Initial revision

git-svn-id: svn://localhost/trunk/ardour2@4 d708f5d6-7413-0410-9779-e7cbd77b26cf

672 files changed, 171972 insertions, 0 deletions

diff --git a/libs/gtkmm2/AUTHORS b/libs/gtkmm2/AUTHORS
new file mode 100644
index 0000000000..35ef03fe26
--- /dev/null
+++ b/libs/gtkmm2/AUTHORS
@@ -0,0 +1,20 @@
+Please use the mailing list (gtkmm-list@gnome.org) instead of emailing developers directly.
+See the ChangeLog for up-to-date information.
+
+Murray Cumming <murrayc@usa.net>
+Daniel Elstner <daniel.elstner@gmx.net>
+
+Some former contributors:
+
+Karl Nelson <kenelson@ece.ucdavis.edu>
+Tero Pulkkinen <terop@modeemi.cs.tut.fi>
+Elliot Lee <sopwith@redhat.com>
+Phil Dawes <P.L.Dawes-CSSE94@cs.bham.ac.uk>
+Erik Andersen <andersee@debian.org>
+Bibek Sahu <scorpio@dodds.net>
+Mirko Streckenbach 
+Havoc Pennington <hp@pobox.com>
+Guillaume Laurent <glaurent@telegraph-road.org>
+Todd Dukes <tdukes@ibmoto.com>
+Peter Lerner <peter.lerner@bnbt.de>
+Herbert Valerio Riedel <hvr@gnu.org>
diff --git a/libs/gtkmm2/CHANGES b/libs/gtkmm2/CHANGES
new file mode 100644
index 0000000000..20c0771eb2
--- /dev/null
+++ b/libs/gtkmm2/CHANGES
@@ -0,0 +1,88 @@
+*** Changes from gtkmm 2.4 to 2.6:
+
+* Added IconView, FileChooserButton, and CellView widgets.
+
+* New API for existing classes:
+  TODO
+
+*** Changes from gtkmm 2.0/2.2 to gtkmm 2.4:
+
+* Useless signals not wrapped.
+
+* Use of libsigc++ 2 instead of libsigc++ 1.2. See the glibmm CHANGES for details of the syntax.
+
+* It is now easier to see which signal you should handle, because there are less of them.
+  Previously we wrapped key-binding signals, but they were quite useless for gtkmm coders.
+
+* Use of Gdk::Device and Gtk::SelectionData instead of C equivalents
+  (Murray Cumming)
+
+* New classes:
+
+  UIManager: Action-based menu and toolbar items. 
+    - Add Actions to an ActionGroup.
+    - Add the ActionGroup to the UIManager.
+    - Layout the Menus and Toolbars, with an XML string. Toolbar items and menu items can share the same Action.
+    - Add the Layout string to the UIManager.
+    - Get a top-level menu or toolbar from the UIManager and put it in a container.
+
+  ComboBox, ComboBoxText, ComboBoxEntry, CellLayout
+
+  EntryCompletion
+
+  ColorButton, FontButton: Buttons that open selection dialogs when clicked, and show the result inside the button.
+
+  Expander: A disclosure triangle, to hide distracting widgets.
+
+  FileChooser: A new File Selection widget.
+    
+  RadioToolButton, SeparatorToolItem, ToggleToolButton, ToolItem, ToolButton
+
+  IconTheme, IconInfo
+  
+* New API for existing classes:
+  Gtk::AccelMap: lock_path(), unlock_path()
+  Gtk::Alignment: get/set_padding(). Useful for indenting Gtk::Frame contents.
+  Gtk::Button: get/set_focus_on_click() get/set_alignment()
+  Gtk::ButtonBox: get_child_secondary().
+  Gtk::Calendar:
+    - display_options() is now set_display_options().
+    - New properties.
+  Gtk::Clipboard: wait_for_targets(), and a simpler request_targets().
+  Gtk::CheckMenuItem: get/set_draw_as_radio()
+  Gtk::Entry: get/set_completion()
+  Gtk::EventBox: get/set_visible_window(), get/set_above_child()
+  Gtk::IconSource: get/set_icon_name()
+  Gtk::Menu: attach(), set_monitor()
+  Gtk::MenuItem: unset_accel_path()
+  Gtk::MenuShell: cancel()
+  Gtk::MessageDialog:
+    - set_markup()
+    - Constructors: Added bool use_markup paramater after message parameter.
+      This is an API change, and I'd leak to hear suggestions for alternatives.
+  Gtk::TextBuffer: select_range()
+  Gtk::TextIter (also known as Gtk::TextBuffer::iterator):
+    Added *_visible_* versions of forwards/backwards methods.
+  Gtk::TextView:
+  - get/set_overwrite(), get/set_accepts_tab()
+  - Added WRAP_WORD_CHAR wrap mode.
+  Gtk::TreeViewColumn (also known as Gtk::TreeView::Column):
+    Added get/set_expand(), get_cell_position()
+  Gtk::Widget:
+  - queue_resize_no_redraw(), get/set__no_show_all()
+  - Added unset_fg(), unset_bg(), unset_font(), unset_text(), unset_base().
+  - Added add_modal_grab(), remove_modal_grab(), get_current_modal_grab().
+    (Ole Laursen)
+  - Added set_window() and set_allocation() for implementing new native widgets.
+    (Detlef Reichl)
+  Gtk::Window: set_default_icon(), set_keep_above(), set_keep_below()
+
+  Gdk::Cursor: new constructor: Cursor(const Glib::RefPtr<Display>& display, const Glib::RefPtr<Pixbuf>& pixbuf, int x, int y)
+  Gdk::Display: flush(), supports_cursor_alpha(), supports_cursor_color(), get_default_cursor_size(),
+    get_maximal_cursor_size(), set_double_click_distance(), get_default_group().
+  Gdk::Pixbuf: get_formats().
+  Gdk::PixbufLoader: create() now has extra bool mime_type parameter.
+  Gdk::Window: set_keep_above(), set_keep_below().
+
+  Pango:LayoutLine: get_length(), get_start_index(), and get_layout().
+
diff --git a/libs/gtkmm2/COPYING b/libs/gtkmm2/COPYING
new file mode 100644
index 0000000000..c4792dd27a
--- /dev/null
+++ b/libs/gtkmm2/COPYING
@@ -0,0 +1,515 @@
+
+                  GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 2.1, February 1999
+
+ Copyright (C) 1991, 1999 Free Software Foundation, Inc.
+     59 Temple Place, Suite 330, Boston, MA  02111-1307  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.
+^L
+  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.
+^L
+                  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.
+
+  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.
+^L
+  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.
+^L
+  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.
+^L
+  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.
+^L
+  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.
+^L
+  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
+^L
+           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 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
+
+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/libs/gtkmm2/ChangeLog b/libs/gtkmm2/ChangeLog
new file mode 100644
index 0000000000..9966e67673
--- /dev/null
+++ b/libs/gtkmm2/ChangeLog
@@ -0,0 +1,2390 @@
+2.6.1:
+
+2005-03-12  Claudio Saavedra <csaavedra@alumnos.utalca.cl>
+ 
+ 	* docs/tutorial/gtkmm-tut.xml: Fixing inconsistences in documentation.
+ 	Bug #170131.
+
+2005-03-13  Murray Cumming <murrayc@murrayc.com>
+
+	* gtk/src/cellrenderercombo.hg:
+	* gtk/src/combo.hg:
+	* gtk/src/fileselection.hg:
+	* gtk/src/optionmenu.hg:
+	* gtk/src/treemodel.hg:
+ 	Doxygen comments: Remove deprecated widgets from 
+	the Widgets and Dialogs groups, so they don't 
+	show up in the lists. 
+
+2005-03-11  Murray Cumming  <murrayc@murrayc.com>
+
+	* gtk/src/cellrenderer.ccg: property_renderable_(): Call the base 
+	class method, not the method itself, to avoid an infinite loop.
+
+2005-03-10  Cedric Gustin <cedric.gustin@swing.be>
+
+	* MSVC_Net2003/Makefile.am: Add blank.cpp to EXTRA_DIST.
+	* MSVC_Net2003/atkmm/atkmm.rc.in,
+	MSVC_Net2003/pangomm/pangomm.rc.in: Use gtkmm @VERSION@ as version
+	string.
+
+2.6.0:
+
+2005-03-04  Murray Cumming  <murrayc@murrayc.com>
+
+	* examples/book/menus_and_toolbars/main_menu/examplewindow.[h|cc]: 
+	Demonstrate radio action items.
+
+2005-03-04  Murray Cumming  <murrayc@murrayc.com>
+
+	* docs/tutorial/gtkmm-tut.xml: Fixed a duplication section id.
+	* docs/tutorial/Makefile: Make the phpwebnotes version build in a 
+	separate directory, to make things simpler.
+
+2005-03-03  Murray Cumming  <murrayc@murrayc.com>
+
+	* gtk/src/scale.hg: format_value signal: Modify the custom conversion 
+	so that this never sends an empty string to GTK+, so we do not stop 
+	C callbacks from using the special meaning that format_value gives to 
+	a null string. This needs an extra signal parameter in C++ in future -
+	see the comment. Bug #154004 from Lars Luthman, who did the 
+	detective work.
+
+2005-03-03 <meissner@suse.de>
+
+	* gtk/src/treeview.ccg: insert_column(): Used (void*)0 instead of 0 
+	for the terminating vararg, to avoid g++ 4.0 warning about  missing 
+	sentinel in function call.
+
+2005-03-03  Albert Chin <thewrittenword.com>
+
+	* configure.in: Check whether funlockfile(), flockfile(), and 
+	getc_unlocked() are really available to the compiler, rather than 
+	just present in a library.
+	* demos/gtk-demo/demo-window.c: Use the new tests.
+
+2005-02-28   Roel Vanhout  <roel.vanhout@gmail.com>
+
+	* docs/tutorial/gtkmm-tut.xml: Add more section ids so that 
+	phpwebnotes would have permanent ids to use.
+
+2.5.7:
+
+2005-02-23  Roel Vanhout  <roel.vanhout@gmail.com>
+
+	* docs/tutorial/: Experimental generation of the html with 
+	phpWebNotes code, to allow online comments. Not used yet.
+
+2005-02-18  Murray Cumming  <murrayc@murrayc.com>
+
+	* gtk/src/gtk_signals.defs: Removed some more quotes from inside 
+	the properties docs strings, because gmmproc can not handle those yet.
+
+2005-02-18  Murray Cumming  <murrayc@murrayc.com>
+
+	* gtk/src/cellrenderer.hg: start_editing(): Add a default value of 0 
+	for the last flags parameter, because this is a valid value.
+	* examples/book/treeview/editable_cells: Added a number_validated 
+	column, which shows how to handle edited cells without the 
+	convenience functions, and how to validate date.
+
+2005-02-15  Murray Cumming  <murrayc@murrayc.com>
+
+	* gtk/src/messagedialog.hg: Deprecate set_markup in favour of 
+	set_message(string, false), which now uses the new 
+	gtk_message_dialog_set_markup() function. We should not have added 
+	this, but we are past API freeze now. Added documentation for 
+	set_message() and set_secondary_text().
+	* examples/book/dialogs/messagedialog/examplewindow.cc: Used 
+	set_secondary_text().
+
+2005-02-13  Murray Cumming  <murrayc@murrayc.com>
+
+	* gtk/src/cellview.hg, comboboxentry.hg, image.hg, main.hg,
+	gkd/src/pixbuf.hg: Corrected some minor doxygen documenation errors.
+
+2005-02-13  Murray Cumming  <murrayc@murrayc.com>
+
+	* atk/src/atk_signals.defs, gdk/src/gdk_signals.defs, 
+	gtk/gtk_signals.defs: Regenerate with latest extra_defs_gen, to get 
+	the property documentation.
+	* docs/reference: Added widget_hierarchy html image map and .dia 
+	original from Marco Scholten in bug 88610.
+	* docs/index.html: Added link to hierarchy.
+	* docs/reference/Makefile.am: Add extra commands to install and 
+	upload the widget_hierarchy files.
+
+2005-02-13  Murray Cumming  <murrayc@murrayc.com>
+
+	* gtk/src/cellrenderertext.hg: Added documentation for the edited() 
+	method. Bug found by Antonio Coralles.
+
+2005-02-13  Murray Cumming  <murrayc@murrayc.com>
+
+	* gdk/src/dragtarget.ccg: get_targets(): Fixed typo to fix the build.
+
+2005-02-07  Ronald Lembcke <es186@fen-net.de>
+
+	* gdk/src/dragcontext.ccg: get_targets(): Actually step through the 
+	list, instead of looping infinitely. Bug #166412.
+
+2005-02-03  Murray Cumming  <murrayc@murrayc.com>
+
+	* gtk/src/targetlist.ccg: Add TargetList:: prefix to the create 
+	method, so that it is actually defined. Bug found by Ronald Lembcke.
+
+2005-02-02  Murray Cumming  <murrayc@murrayc.com>
+
+	* examples/cellrenderercustom/cellrenderertoggle.cc: AppWindow:
+	Move the inner ModelColumns class outside of the AppWindow class, 
+	because the IRIX MipsPro compiler (wrongly) says that its 
+	destructor it was referenced but not defined.
+	* examples/gdk/radar.cc: Added #include of math.h, needed by 
+	IRIX MipsPro compiler.
+
+2005-02-02  Murray Cumming  <murrayc@murrayc.com>
+
+	* gtk/src/treeview.hg: append_column_numeric(), 
+	_connect_auto_store_editable_signal(): Use an intermediate 
+	function pointer, because the IRIX MipsPro compiler needs that. 
+
+2005-02-01  Murray Cumming  <murrayc@murrayc.com>
+
+	* examples/book/clipboard/ideal/examplewindow.cc: 
+	on_clipboard_received_targets(). Use targets = targets_array instead 
+	of targets(targets_array). The IRIX MipsPro compiler needs this, 
+	maybe because of the ustring-std::string conversion. We should 
+	maybe use ustring anyway.
+
+2005-02-01  Murray Cumming  <murrayc@murrayc.com>
+
+	* gtk/gtkmm/comboboxtext.h: Class documentation: Warn about using this 
+	with Glade. Bug #165411,
+
+2005-02-01  Murray Cumming  <murrayc@murrayc.com>
+
+	* configure.in: Check for atk version 1.9 at configure time, 
+	because that is what we use, because it follows the same schedule as 
+	gtkmm.
+
+2005-02-01  Murray Cumming  <murrayc@murrayc.com>
+
+	* gtk/src/treeview.hg, colorselection.ccg: Remove the #ifdefs for AIX, 
+	because sigc::bind now works on AIX.
+
+2.5.6:
+
+2005-01-26  Cedric Gustin <cedric.gustin@swing.be>
+
+	* Makefile.am: Added MSVC_Net2003 directory.
+	* configure.in: Added MSVC_Net2003 entries. AC_SUBST
+	GTKMM_*_VERSION macros (for the MSVC resource files)
+	* gtk/gtkmmconfig.h.in: Added dllimport/dllexport rules. Moved
+	HAVE_FLOCKFILE and HAVE_FUNLOCKFILE #undef's to GLIBMM_CONFIGURE
+	section, as it is not relevant to platforms that do not run
+	configure (MSVC for example). 
+	* examples/stock/stock.cc, examples/tictactoe/tictactoe.cc: Added
+	Gtk namespace to "manage" calls (Gtk::manage) as required by MSVC.
+	* demos/gtk-demo/demo-common.cc: Fixed typo in #ifdef/#endif
+	structure. Uncommented get_democodedir function.
+	* demos/gtk-demo/textwidget.cc: Use default system font on win32.
+	* MSVC_Net2003/*: Initial commit, imported from gtkmm-2-4 branch.
+	* MSVC_Net2003/gtkmm/Makefile.am, MSVC_Net2003/gdkmm/Makefile.am:
+	Rewrote rule for local copy of g[d|t]kmmconfig.h (required for
+	'make distcheck').
+
+2005-01-25  Bryan Forbes  <bryan@reigndropsfall.net>
+
+	* gtk/src/plug.[hg|ccg]: Add a default constructor.
+
+2005-01-25  Murray Cumming  <murrayc@murrayc.com>
+
+	* gtk/src/colorselection.hg: set_change_pallete_hook(): On AIX, #ifdef 
+	out the part that uses sigc::bind, which does not work with the AIX 
+	xlC compiler. This method will be broken of that platform, but it is 
+	rarely used anyway.
+	* demos/gtk-demo/demowindow.cc: SUN Forte, AIX, and Tru64 have the 
+	problem with flockfile and funlockfile - configure finds it but the 
+	compiler can not find it while compiling demowindow.cc. #undef 
+	HAVE_FLOCKFILE and HAVE_FUNLOCKFILE for now, so that it builds on 
+	those platforms.
+
+2005-01-25  Murray Cumming  <murrayc@murrayc.com>
+
+	* configure.in, Makefile.am: Add --disable-demos configure option, 
+	by plors in bug #160756. This is needed because AIX does not support 
+	sigc::bind at all and the demos would be quite unreadable if we 
+	worked around that. This way, at least gtkmm can be installed on AIX.
+
+2005-01-25  Murray Cumming  <murrayc@murrayc.com>
+
+	* examples/book/input/main.cc: Do not use O_NONBLOCK, because the 
+	example is meant to be blocking. As advised by Chris Vine.
+
+2005-01-25  Murray Cumming  <murrayc@murrayc.com>
+
+	* gtk/src/treeview.hg: Use nested sigc::bind<-1>s instead of 
+	sigc::bind(), because the Tru64 compiler needs the extra hint.
+	Added #ifdef GTKMM_HAVE_SIGC_BIND() around some templated convenience 
+	methods, so we can disable these on AIX.
+	* gtk/src/treemodel.[hg|ccg]: Use Gtk::TreeModel::iterator instead of just 
+	iterator, because the Tru64 compiler finds it ambiguous.
+	* demos/example_treeview_editable_cells.cc: Replace use of 
+	TreeView::append_column_editable() with the long-winded workaround,
+	so that the IRIX MipsPro and Tru64 compilers can build this
+
+2005-01-18  Marco Scholten  <mscholtn@xs4all.nl>
+
+	* examples/book/custom/custom_widget/examplewindow.cc:
+	Removed #include <iostream> because it is not used.
+	* examples/book/custom/custom_widget/mywidget.cc:
+	Removed #include <iostream> because it is not used.
+	In on_realize() removed:
+	-set_flags(Gtk::REALIZED); 
+	-set_window( get_parent_window() );
+	-GtkWidget* cWidget = (GtkWidget*)gobj();
+	-cWidget->style = gtk_style_attach(cWidget->style, get_window()->gobj());
+	Added attributes.event_mask = get_events () | Gdk::EXPOSURE_MASK;
+	to make the widget receive expose events.
+	Create GdkWindow and set this as the widgets window
+	Set colors in on_realize() instead of on_expose_event() because this
+	needs to be done only once.
+	Removed colormap in on_expose_event() because of problem with 
+	get_default_colormap() (see Bug 163992). I decided not to wait for a fix
+	on that bug because how we set the color is not essential to this example.
+	Made it draw something nice.
+
+2005-01-18  Murray Cumming  <murrayc@murrayc.com>
+
+	* demos/gtk-demo/demos.h: Use sigc::ptr_fun() instead of the bare 
+	function pointer, because that does not work with the SUN Forte 
+	compiler. on_treeview_row_activated(): Use a const reference of the 
+	slot with operator[] to avoid ambiguity with the SUN Forte compiler - 
+	see the comment in the code.
+
+2005-01-18  Murray Cumming  <murrayc@murrayc.com>
+
+	* examples/book/input/main.cc: Add extra #includes, needed by 
+	the SUN Forte compiler.
+
+2005-01-18  Murray Cumming  <murrayc@murrayc.com>
+ 
+	* demos/demowindow.cc: #ifdef on __SUNPRO_CC instead of 
+	GLIBMM_COMPILER_SUN_FORTE, though we should really find out why 
+	GLIBMM_COMPILER_SUN_FORTE is not defined with the SUN compiler.
+	* demos/example_stockbrowser.cc: Remove some consts that the 
+	SUN compiler does not allow.
+	* gtk/src/radiobutton.hg: Remove duplicate Group typedef, which 
+        SUN Forte complains about.
+        * This should fix the remaining issues in bug #154973.
+	Joel Fredrikson helped with these fixes.
+
+2005-01-11  Murray Cumming  <murrayc@murrayc.com>
+
+	* examples/book/custom/custom_widget/mywidget.cc: Fix from Marco 
+	(mshcoltn) to make this widget actually draw something: on_realize():
+	Use get_window() instead of creating our own Gdk::Window. I am not 
+	sure why this works, but it is simpler.
+
+2.5.5:
+
+2005-01-10  Murray Cumming  <murrayc@murrayc.com>
+
+	* gtk/src/main.[hg|ccg]: Added Main constructor that takes a 
+	Glib::OptionContext(), and added 
+	Main::add_gtk_option_group(option_context) to wrap functionality in 
+	gtk_init_with_args() and gtk_get_option_group(), hopefully.
+	* tests/: Added main_with_option_group to show that it works.
+
+2005-01-10  Murray Cumming  <murrayc@murrayc.com>
+
+	* gtk/src/combobox.hg, comboboxentry.hg, clipboard.hg, cellview.hg, 
+	celllayout.hg, celleditable.hg, cellrenderer*.hg: Added class 
+	documentation, based on the C documentation.
+	* gtk/src/clipboard.hg: Added set_can_store() overload that takes no 
+	arguments.
+	* gtk/src/combobox.hg: Added unset_row_separator_func().
+
+2005-01-09  Murray Cumming  <murrayc@murrayc.com>
+
+	* gtk/src/filechooserbutton.[hg|ccg]: Inherit from the FileChooser 
+	interface. Add constructor which takes no title. Add documentation, 
+	based on the C documentation.
+
+2005-01-09  Murray Cumming  <murrayc@murrayc.com>
+
+	* gtk/examples/book/buttons/: Added filechooserbutton example, 
+	though I see g_warnings.
+
+2005-01-09  Murray Cumming  <murrayc@murrayc.com>
+
+	* gtk/examples/book/treeview/list/examplewindow.[h|cc]: Add an extra 
+	model column, rendered with a CellRendererProgress, to show that it 
+	works.
+
+2005-01-08  Murray Cumming  <murrayc@murrayc.com>
+
+	* gtk/src/aboutdialog.hg: Add logo_icon_name proeprty.
+	* gtk/src/iconview.hg: Wrap the properties.
+
+2005-01-07  Murray Cumming  <murrayc@murrayc.com>
+
+	* Makefile.am: Offline documentation tarball: Do not try to tar up non 
+	existant docs/internals directory. Put 2-4 in the tarball name to 
+	avoid confusion.
+	* docs/index.html: Correct the offline documentation link, so that 
+	people do not download the tarball for the 2.0 documentation instead.
+	Bug #163122.
+
+2005-01-07  Murray Cumming  <murrayc@murrayc.com>
+
+	* gtk/src/modelfilter.hg: Added documentation for set_modify_func().
+	* pango/src/renderer.hg: Added get_color(),
+	* pango/src/color.hg: Added operator bool() so that people can check 
+	for a null Color returned by Renderer::get_color().
+
+2005-01-07  Murray Cumming  <murrayc@murrayc.com>
+
+	* gtk/src/entrycompletion.hg, toolitem.hg: Added //TODO comments 
+	to tell us to add default signal handlers when we can break ABI. Also 
+	remove an extra ; to avoid a warning and fix the build.
+
+2005-01-06  Bryan Forbes  <bryan@reigndropsfall.net>
+
+	* updated .cvsignore files.
+	* gtk/gtkmm/stock.[h|cc]: Added new stock items.
+	* gtk/src/entrycompletion.hg: Changed to use no_default_handler on
+	insert_prefix signal.
+	* gtk/src/filechooserdialog.[hg|ccg]:
+	* gtk/src/filechooserwidget.[hg|ccg]: Added constructors to choose the
+	backend used.
+	* gtk/src/main.[hg|ccg]: Added commented constructors for gtk_init_with_args
+	so we can take a look at it.
+	* gtk/src/toolitem.hg: Changed to use no_default_handler on set_tooltip
+	signal.
+
+2005-01-06  Murray Cumming  <murrayc@murrayc.com>
+
+	* gdk/src/pixbufloader.hg, gtk/src/cellrenderer.hg, gtk/src/range.hg:
+	For the signals that are new in gtkmm 2.5, use the extra 
+	no_default_handler argument with _WRAP_SIGNAL(), to avoid adding new 
+	virtual functions which would break the ABI by increasing the size 
+	of base class objects.
+
+2005-01-06  Murray Cumming  <murrayc@murrayc.com>
+
+	* gtk/src/treeiter.[hg|ccg]: Add forward_search() and 
+	backward_search() overloads without the limit argument.
+	* gtk/src/gtk_docs_override.xml: Correct the documentation for 
+	the full forward_search() and backward_search() methods, so that it 
+	does not suggest 0 for references. Bug found by Rob Page.
+
+2005-01-06  Murray Cumming  <murrayc@murrayc.com>
+
+	* examples/book/dialog/: Added aboutdialog example.
+
+2.5.4:
+
+2005-01-05  Murray Cumming  <murrayc@murrayc.com>
+
+	* atk/src/atk_enums.defs: Regenerated.
+	* atk/src/relation.hg: Added add_target().
+	* atk/src/relationset.hg: Added add_relation_by_type().
+	* atk/src/text.hg: Added get_range_extents(), get_bounded_ranges().
+
+2005-01-05  Murray Cumming  <murrayc@murrayc.com>
+
+	* gdk/src/gdk_pixbuf.defs: Updated with h2defs.py
+	* gdk/src/display.[hg|ccg]: Added supports_selection_notification(), 
+	request_selection_notification(), supports_clipboard_persistance(), 
+	store_clipboard().
+	* gdk/src/pixbuf.[hg|ccg]: Added rotate_simple(), flip(), 
+	save_to_buffer().
+	* gdk/src/pixbuf_format.hg: Added is_scalable(), is_disabled(), 
+	set_disabled(), get_license().
+	* gdk/src/window.hg: Added enable_synchronized_configure(), 
+	configure_finished(), set_focus_on_map().
+
+2005-01-05  Murray Cumming  <murrayc@murrayc.com>
+
+	* gdk/src/gdk_methods.defs: Updated with h2defs.py.
+
+2005-01-04  Murray Cumming  <murrayc@murrayc.com>
+
+	* gdk/src/gdk_enums.defs, gtk/src/gtk_enums.defs, 
+	gtk/src/gtk_signals.defs: Regenerated.
+	* gtk/src/gtk_others.defs: Added get_authors, get_documentors and 
+	get_artists because h2defs.py does not add them to gtk_methods.defs, 
+	for some reason.
+	* gtk/src/action.hg: Added get_accel_path().
+
+2005-01-04  Murray Cumming  <murrayc@murrayc.com>
+
+	* gtk/src/treeview.hg: Added hover_expand and hover_selection 
+	properties.
+
+2005-01-03  Bryan Forbes  <bryan@reigndropsfall.net>
+
+	* gtk/src/cellrenderertext.hg: added properties "language", 
+	"ellipsize", and "ellipsize-set".
+
+2.5.3:
+
+2004-12-19  Murray Cumming  <murraycmurrayc.com>
+
+	* gdk/pixbuf.hg: Added create_from_file() overload that takes 
+	height and width, wrapping gdk_pixbuf_create_from_file_at_scale().
+	Bug #157894.
+
+2004-12-19 Claudio Saavedra <csaavedra@alumnos.utalca.cl>
+ 	
+ 	* example/book/input/main.cc: Improved example to use a 
+ 	Glib::IOChannel. References bug #138259.
+
+2004-12-19  Murray Cumming  <murrayc@murrayc.com>
+
+	* gtk/src/cellrenderer.hg: Added stop_editing() which replaces the 
+	now-deprecated editing_cancelled().
+	* gtk/src/iconview.hg: Added get/set_columns(), get/set_item_width(),
+	get/set_spacing(), get/set_row_spacing(), get/set_column_spacing(), 
+	get/set_margin().
+	* gtk/src/label.hg: Added get/set_max_chars_width(), and property.
+	* gtk/src/textview.hg: Added get_iter_at_position().
+	* gdk/src/gdk_docs.xml, pango/src/pango_docs.xml, 
+	gtk/src/gtk_docs.xml: Regenerated with docextract_to_xm.py, to get 
+	new GTK+ documentation.
+
+2004-12-19  Murray Cumming  <murrayc@murrayc.com>
+
+	* gtk/src/filechooserbutton.hg: Constructors: Added action parameters, 
+	because they have been added to the GTK+ API.
+	* gtk/src/gtk_methods.defs: Regenerated with h2defs.py
+
+2004-12-16  Murray Cumming  <murrayc@murrayc.com>
+ 
+ 	* examples/book/dialogs/messagedialog/examplewindow.cc: The 
+ 	ButtonsType enum is not an ORable flag.
+ 	* docs/tutorial/gtkmm-tut.xml: Fix the text where it says that it is.
+
+2004-12-16  Murray Cumming  <murrayc@murrayc.com>
+
+	* gtk/src/cellview.hg: Remove set_value(), because it has been 
+	removed from GTK+. This fixes the build. Now inherits from the 
+	CellLayout interface. Added text and pixbuf constructors, to match 
+	the C _new conveience functions.
+
+2.5.2:
+	
+2004-12-04  Roger Leigh  <roger@whinlatter.uklinux.net>
+
+	* configure.in: Bug #160244: Ask automake to use the utar format, to 
+	fix the problems with the long filenames of our documentation in the 
+	tarballs.
+
+2004-12-03  Murray Cumming  <murrayc@murrayc.com>
+
+	* gtk/src/treeview.hg: Added append_column_numeric() which allows you 
+	to specify a printf-style format string for the View column, and 
+	append_column_numeric_editable() which does the same, and auto-stores 
+	decimal input. Updated the append_column() documentation to improve 
+	the explanation of supported types, and to suggest use of 
+	append_column_numeric().
+	* examples/book/treeview/list/, editable_cells/: Demonstrate these 
+	new convenience methods.
+
+2004-12-01  Murray Cumming  <murrayc@murrayc.com>
+
+	* gtk/src/label.hg: Added get/set_angle().
+
+2004-12-01  Murray Cumming  <murrayc@murrayc.com>
+
+	* gtk/src/filechooserbutton.hg: GtkFileChooser inherits from HBox, not 
+	Button.
+
+2004-12-01  Murray Cumming  <murrayc@murrayc.com>
+
+	* gtk/src/filechooserbutton.hg: Removed get/set_active(), because they 
+	have been removed from GTK+.
+
+2004-12-01  Murray Cumming  <murrayc@murrayc.com>
+
+	* gtk/src/cellview.hg: Removed set_cell_data() because it has been 
+	removed from GTK+.
+
+2004-12-01  Murray Cumming  <murrayc@murrayc.com>
+
+	* pango/pangomm/: Added types.h, for typedefs of simple structs.
+	* pango/src/: Added renderer.[hg|ccg].
+	* pango/src/context.hg: Add get/set_matrix().
+	* pango/src/fontmetrics.hg: Added get_underline_position(), 
+	get_underline_thickness(), get_strikethrough_position(), 
+	get_strikethrough_thickness().
+	* pango/src/pango_enums.defs: Regenerated.
+	* tools/m4/convert_pango.m4: Added Matrix and Layout conversions.
+
+2004-11-30  Murray Cumming  <murrayc@murrayc.com>
+
+	* tools/m4/convert_gtk.m4: Use _CONVERT_CONST_REFPTR_TO_P_SUN() instead 
+	of _CONVERT_CONST_REFPTR_TO_P(), to hopefully fix the SUN Forte build 
+	problems in bug #154973.
+
+2004-11-30  Murray Cumming  <murrayc@murrayc.com>
+
+	* examples/book/menus_and_toolbars: Applied Fredrik Arnerup's patch 
+	to add a non-stock icon, with some changes.
+
+2004-11-30  Murray Cumming  <murrayc@murrayc.com>
+ 
+ 	* atk/src/hyperlink.hg: get_object(),
+ 	* atk/src/object.hg: get_relation_set(),
+ 	* gdk/src/cursor.hg: get_display(),
+ 	* gdk/src/display.hg: get_default_group(),
+ 	* gdk/src/displaymanager.hg: get_default_display(),
+ 	* gdk/src/drawable.hg: get_screen(), get_display(),
+ 	* gdk/src/event.hg: get_screen(),
+ 	* gdk/src/visual.hg: get_system(), get_best(), get_screen(),
+ 	* gtk/src/widget.hg: get_default_style()
+
+2004-11-25  Chris Vine  <cvine@freeserve.co.uk>
+
+	* example/book/input/: This now works.
+
+2004-11-25  Murray Cumming  <murrayc@murrayc.com>
+
+	* docs/tut/gtkmm-tut.xml: TreeView selection: Use 
+	selected_foreach_iter() instead of selected_foreach(). Error 
+	found by Teus Benschop.
+
+2004-11-24  Murray Cumming  <murrayc@murrayc.com>
+
+	* demos/gtk-demo/: Added missing demo-common.[h|cc] files.
+	* gtk/src/treeview.hg, gdk/src/pixbuf.hg, : Removed extra ; and 
+	unused parameter to fix build for g++ 3.4.
+
+2004-11-21  Murray Cumming  <murrayc@murrayc.com>
+
+	* gtk/src/dialog.[hg|ccg]: Added set_alternative_button_order().
+	* gtk/src/button.[hg|ccg]: Added set/get_image() and property.
+
+2004-11-17  Murray Cumming  <murrayc@murayc.com>
+
+	* gtk/src/iconinfo.[hg|ccg]: Added operator bool(), needed to check 
+	the result of IconTheme::lookup_icon(). Bug #143018.
+
+2004-11-16  Murray Cumming  <murrayc@murrayc.com>
+
+	* docs/tutorial/gtkmm-tut.xml: Mention Gtk::manage() in the Basics/
+	Widgets section, with a link to the Memory Management chapter, so that 
+	people have an explanation of manage() before it is used in examples. 
+	Bug #138248.
+
+2004-11-16 Claudio Saavedra <csaavedra@alumnos.utalca.cl>
+
+	* docs/tutorial/gtkmm-tut.xml: Fixed two typos in Chapter 19 and
+	Appendix A.
+	* examples/book/helloworld/helloworld.cc: Fixed wrong reference
+	to a inexistent method in a comment.
+
+2.5.1:
+
+2004-11-11  Murray Cumming  <murrayc@murrayc.com>
+
+	* gtk/src/filechooser.hg: Wrap GTK_FILE_CHOOSER_ERROR as exception. 
+	Still need to investigate whether GTK_FILE_SYSTEM_ERROR is public API.
+	* gtk/src/icontheme.hg: Wrap GTK_ICON_THEME_ERROR as exception 
+	instead of enum. Luckily, the enum was not used in the API anywhere 
+	so nobody can be using it.
+	* examples/book/: Added input example, based on code that was in the 
+	tutorial inline. This needs to be updated properly - see TODO in the 
+	code.
+	* docs/tutorial/gtkmm-tut.xml: Some minor corrections to the 
+	Idle/Timeout chapter, but it needs to be reviewed properly after we 
+	have finished the example. Get the example from the source, instead of 
+	pasting it inline.
+	* gdk/src/pixbufloader.hg: Wrap size_prepared signal. I am not sure 
+	why this was not wrapped in 2.4.
+	* gtk/src/filefilter.hg: Add add_pixbuf_formats().
+
+2004-11-11  Murray Cumming  <murrayc@murrayc.com>
+
+	* gtk/src/textbuffer.hg: Added ; to fix build.
+
+2004-11-10  Murray Cumming  <murrayc@murrayc.com>
+
+	* gtk/src/gtk_methods.defs: Regenerated with h2defs.py.
+	* gtk/src/selectiondata.hg: Added targets_include_image().
+	* gtk/src/progressbar.hg: Added set/get_ellipsize() and property.
+	* gtk/src/label.hg: Added set/get_single_line_mode() and property.
+	* gtk/src/clipboard.hg: Added set_image(), wait_is_image_available(),
+	wait_for_image(), request_image().
+	* gtk/src/toolitem: Added rebuild_menu().
+
+2004-11-08  Murray Cumming  <murrayc@murrayc.com>
+
+	* examples/book/treeview/combo_renderer/examplewindow.[h|cc]: Use a 
+	combo model from the treeview model, now that it works in GTK+.
+
+2004-11-07  Murray Cumming  <murrayc@murrayc.com>
+
+	* gtk/src/combocellrenderer.hg: The model is a TreeModel, not a 
+	Pixbuf.
+	* gtk/gtkmm/cellrenderer_generation.[h|cc]: Remove the TreeModel/Combo 
+	specialization, because the Combo is not for representing or editing 
+	a TreeModel - it's just to use a TreeModel to present choices for 
+	a text column.
+	* examples/book/treeview/combo_renderer/examplewindow.[h|cc]: This 
+	now works.
+
+2004-11-04  Murray Cumming  <murrayc@murrayc.com>
+
+	* gtk/src/messagedialog.hg: Reverted set_message() implementation 
+	change and added set_secondary_text().
+	* gtk/src/dialog.hg: Added alternative_button_order().
+	* gtk/src/: Added cellrenderercombo.[hg|ccg] and cellrendererprogress.[hg|ccg].
+	* gtk/gtkmm/cellrenderer_generation.[h|cc]: Add template 
+	specializations to create a CellRendererCombo when the model is of 
+	type TreeModel.
+	* pango/src/context.hg: Added get_font_map().
+	* examples/book/treeview/: Added combo_renderer example - does not 
+	actually work yet.
+
+2004-11-03  Murray Cumming  <murrayc@murrayc.com>
+
+	* examples/book/menus/popup/examplewindow.[h|cc]: Use the popup 
+	UIManager node type, so that this example works.
+	* docs/tutorial/gtkmm-tut.xml: Update the popup menu section.
+
+2004-11-03  Murray Cumming  <murrayc@murrayc.com>
+
+	* Removed gtkmm.spec.in and mention of it in configure.in and 
+	Makefile.am, yet again. There is no point in having a broken spec 
+	file that nobody is maintaining. spec files are distro-specific and 
+	belong with distros.
+
+2004-10-31  Murray Cumming  <murrayc@murrayc.com>
+
+	* gtk/src/treemodelfilter.ccg: SignalProxy_Modify::gtk_callback():
+	Do not return before actually copying the value.
+	* examples/book/treeview/: Added filter_modify example, to show the 
+	use of set_modify_func().
+
+2004-10-30  Murray Cumming  <murrayc@murrayc.com>
+
+	* gtk/src/gtk_methods.hg: Regenerated with h2defs.py.
+	* gtk/src/window.hg: Added drag_dest_add_text_targets(), 
+	drag_dest_add_uri_targets(), drag_dest_add_image_targets(), 
+	drag_source_add_text_targets(), drag_source_add_uri_targets(),
+	drag_source_add_image_targets().
+	* gtk/src/aboutdialog: Added get_logo_icon_name(), and 
+	set_logo_icon_name().
+	* gtk/src/clipboard.hg: Added wait_is_target_available(), 
+	set_can_store(), store()
+	* gtk/src/filechooserbutton: Added get/set_width_chars()
+	* gtk/src/image.hg: Added set_from_icon_name(), get/set_pixel_size(), 
+	get_icon_name()
+	* gtk/src/label.hg: Added get/set_width_chars().
+	* gtk/src/messagedialog.[hg|ccg]: Made set_message() public and 
+	reimplemented it with gtk_message_dialog_format_secondary_text() and 
+	gtk_message_dialog_format_secondary_markup() instead of the private 
+	label field.
+	* gtk/src/selectiondata.hg: Added get/set_pixbuf(), get/set_uris().
+
+2004-10-30  Murray Cumming  <murrayc@murrayc.com>
+
+	* gtk/src/treemodelfilter.[hg|ccg]: Added implementations of 
+	set_value_impl() to ouput a warning when it is used instead of 
+	the child model. Added const versions of patch convert methods.
+	* gtk/src/treeview.[hg|ccg]: Added _get_base_model() non-public API 
+	member method to get the child model, if necessary. Used it in the 
+	cell renderer signal handlers instead of get_model().
+	* Added examples/book/treeview/filter, from the gtkmm-2-4 branch.
+
+2004-10-16  Gene Ruebsamen  <gene@erachampion.com>
+ 
+ 	* docs/tutorial/gtkmm-tut.xml: Added a chapter for the new gtk-2.4 
+ 	FileChooserDialog.
+ 	* docs/tutorial/figures/dialogs_filechooser.png: Added a PNG image
+ 	of the new FileChooserDialog.
+
+2004-10-25  Roger Leigh <rleigh@debian.org>
+ 
+ 	* build_shared/Makefile_build.am_fragment: Use PLATFORM_WIN32
+ 	rather than OS_WIN32 so that -no-undefined is used on Cygwin
+ 	as well as MinGW toolchains.
+
+2004-10-25  Murray Cumming  <murrayc@murrayc.com>
+
+	* gtk/gtkmm.h: #include filechooserwidget.h, as suggested in bug 
+	#156170 from Arjan Timmerman.
+
+2004-10-24  Murray Cumming  <murrayc@murrayc.com>
+
+	* docs/tutorial/gtkmm-tut.xml: Updated the menus and toolbars section 
+	about UIManager, though the popup example does not work yet, and I 
+	should mention ui merging and toggle items.
+
+2004-10-22  Murray Cumming  <murrayc@murrayc.com>
+ 
+ 	* gtk/src/treemodelfilter.hg: _WRAP_CTOR: Rename root parameter to 
+ 	virual_root so that it sets the correct property.
+ 
+2004-10-22  Murray Cumming  <murrayc@murrayc.com>
+ 
+ 	* gtk/src/treeiter.hg: In ifdef, use SUN-Forte-style reverse_iterator. 
+ 	Patch from TODO in bug #154973. 
+
+2004-10-22  Murray Cumming  <murrayc@murrayc.com>
+
+	* gtk/src/aboutdialog.hg: Wrap the get and set methods that deal with 
+	char** arrays, using Glib::SArrayHandle. Wrap the callback set 
+	methods with a SignalProxy.
+	* gtk/src/gtk_signals.defs: Add signals and properties for 
+	AboutDialog and MenuToolButton.
+	* tools/extra_defs_gen/generate_defs_gtk.cc: Get defs for 
+	GtkAboutDialog and GtkMenuToolButton.
+	* gtk/src/action_group.hg: Add translate_string(). We probably need to 
+	use iit in the .ccg file.
+	* gtk/src/icontheme.hg: Added get_icon_sizes().
+	* gtk/src/iconview.hg: Added get_selected_items().
+	* tools/m4/convert_gtk.m4: Added conversion for SArrayHandle to char**,
+	and GList* to SListHandle<TreePath>
+
+2004-10-17  Gene Ruebsamen  <gene@erachampion.com>
+
+ 	* docs/tutorial/gtkmm-tut.xml: Updated the Windows installation
+ 	appendix by providing a link to the latest Gtk+ Win32 installer, 
+ 	and updating the installation instructions.
+
+2004-10-12  Murray Cumming  <murrayc@murrayc.com>
+
+	* examples/book/custom/custom_container.cc: Use only C++ methods 
+	instead of the C functions, now that they are public.
+	* docs/tutorial/figures/: Added custom_container.png.
+
+2004-10-10  Murray Cumming  <murrayc@murrayc.com>
+
+	* docs/tutorial/gtkmm-tut.xml: Added Custom Widgets chapter, so far 
+ 	with a Custom Container section and example.
+
+2004-10-10  Murray Cumming  <murrayc@murrayc.com>
+
+	* gtk/src/widget.hg: Made set_parent(), and unparent() public instead 
+	of protected, because they are need by custom Containers. Added 
+	size_request() which is const and actually returns a value, also 
+	needed by custom Containers.
+	* gtk/src/accelgroup,hg: Wrap the new gtk_accelerator_get_label() 
+	function.
+	* gtk/src/comboboxentry.[hg|ccg]: Hand-code get_entry() to fix the 
+	build.
+	* gtk/src/: Added menutoolbutton.[hg|ccg].
+	* gtk/gtkmm/comboboxtext.[h|cc], comboboxentrytext.[h||cc]: Added 
+	set_active_text(), clear(). Reimplemented append() and prepend() 
+	without using the C functions, because they might not work with our 
+	model.
+
+2004-10-09  Murray Cumming  <murrayc@murrayc.com>
+
+	* docs/index.html: Changed cvs links to viewcvs, because lxr and 
+	bonsai are still broken.
+
+2004-10-09  Murray Cumming  <murrayc@murrayc.com>
+
+	* gtk/src/style.hg: Add create() method, as per bug #148012.
+
+2004-10-09  Murray Cumming  <murrayc@murrayc.com>
+
+	* gtk/src/comboboxentry.hg: Added get_entry(), as per bug #142758.
+
+2004-09-04 Jonathan Brandmeyer <jbrandmeyer@earthlink.net>
+ 
+ 	* gdk/src/screen.hg: get_default(): Take an extra reference so that
+ 	the Screen is not deleted too early.
+
+2004-09-17  Murray Cumming  <murrayc@murrayc.com>
+
+	* iconview.hg: Added overrides of set_text_column(), and 
+	set_pixbuf_column() that take ModelColumns instead of ints.
+	Wrapped signals. Added foreach()
+	* cellview.hg: Make get_size_of_row() const.
+	* tools/extra_defs_gen/gtk_extra_defs_gen: Added new types.
+	* gtk/src/gtk_signals.defs: Regenerated (making the usual corrections 
+	for Event* and gpointer parameters.
+	* combobox.[hg|ccg], treeview.[hg|ccg]: Add set_row_separator_func(), 
+	with common implementation in treeview-private.[h|cc].
+	* range.hg: Wrapped change_value signal.
+	* demos/gtk-demo/: Added example_iconview.cc, which demonstrates  the 
+	IconView and is a C++ version of the C original..
+
+2.5.0:
+	
+2004-09-12  Murray Cumming  <murrayc@murrayc.com>
+
+	* gtk/src/: Added cellview.[hg|ccg].
+
+2004-09-10  Murray Cumming  <murrayc@murrayc.com>
+
+	* pango/src/layout: Added set_ellipsize(), get_ellipsize(), and 
+	EllipsizeMode enum.
+	* pango/src/pango_enums.defs: Regenerated.
+	* pango/src/pango_methods.defs: Regenerated.
+	* gtk/src/: Added iconview.[hg|ccg|, filechooserbutton.[hg|ccg].
+	* gtk/src/entry.hg: Added layout_index_to_text_index() and 
+	text_index_to_layout_index()
+	* gtk/src/entrycompletion.hg: Added insert_prefix(), 
+	set_inline_completion(), get_inline_completion(), 
+	set_popup_completion(), get_popup_completion(), get_text_column()
+	* gtk/src/combobox.hg: Added get_wrap_width(), get_row_span_column(),
+	get_column_span_column(), get_add_tearoffs(), set_add_tearoffs(), 
+	get_focus_on_click(), set_focus_on_click(), get_popup_accessible().
+	Wrapped new properties.
+	* gtk/src/action.hg: Wrap new gtk_action_set_sensitive() 
+	instead of writing our own method. Add set_visible() too.
+	* gtk/src/label.hg: Added set_ellipsize(), get_ellipsize().
+	* gtk/src/cellrenderer.hg: Added editing_started signal.
+	* gtk/src/filechooser.hg: Added set_show_hidden(), get_show_hidden().
+	* gtk/src/gtk_methods.defs: Regenerated.
+	* gtk/src/treesortable.hg: Added DEFAULT_UNSORTED_COLUMN_ID constant.
+	* gtk/src/treeview.hg: Added set_fixed_height_mode(), 
+	get_fixed_height_mode(), set_hover_selection(), get_hover_selection(),
+	set_hover_expand(), get_hover_expand()
+
+2004-09-02  Murray Cumming  <murrayc@murrayc.com>
+
+	* This is the HEAD branch, which should wrap new API in GTK+ 2.5/2.6.
+
+2004-08-30  Murray Cumming  <murrayc@murrayc.com>
+
+	* examples/book/dialogs/fileselection/examplewindow.cc: Removed a 
+	misleading include.
+
+2.4.5:
+
+2004-08-07  Murray Cumming  <murrayc@murrayc.com>
+
+	* gtk/src/toolbar.hg: Class documentation: remove mention of 
+	tools() which no longer exists.
+	* examples/book/treeview/drag_and_drop: Correct the implementation 
+	of the vfuncs so that they actually work. In particular they are const 
+	in gtkmm 2.4. 
+
+2004-07-16  Murray Cumming  <murrayc@murrayc.com>
+
+	* gtk/src/settings.ccg: get_default(): Use reference() instead of an 
+	extra parameter, to fix the build.
+
+2004-07-15  Murray Cumming  <murrayc@murrayc.com>
+
+	* gtk/src/settings.ccg: get_default(): Take an extra reference so that 
+	the Settings is not deleted too early. Bug #147592.
+
+2004-07-15  Murray Cumming  <murrayc@murrayc.com>
+
+	* examples/book/treeview/: Added popup example, which was already in 
+	gtkmm 2.0/2.2.
+
+2004-07-08  Murray Cumming  <murrayc@murrayc.com>
+
+	* docs/tutorial/gtk_tut.xml: libglademm chapter: Mention memory 
+	management.
+
+2004-07-08  Murray Cumming  <murrayc@murrayc.com>
+
+	* Patch from Christopher Palm in bug #145594, to change ActionGroup and 
+	EntryCompletion constructors from private to protected. Lets hope 
+	there are no more of these, because this is technically API change in 
+	the stable branch. However, the methods already exist and are  tested 
+	by the create() methods, and are simple and generated, and therefore 
+	unlikely to have errors. Also, this change will only be useful to a 
+	very small number of people, so it does not confuse the API versions.
+
+2004-07-04  Murray Cumming  <murrayc@murrayc.com>
+
+	* docs/tutorial/gtkmm_tut.xml: Tell people to pkg-config for 2.4 
+	instead of 2.0.
+
+2004-07-02  Murray Cumming  <murrayc@murrayc.com>
+
+	* gtk/src/uimanager.hg: Made constructor protected, like in the 
+	previous change.
+	* gtk/src/treesortable.hg: Added docs explaining the return values 
+	for the sort func.
+
+2.4.4:
+
+2004-07-01  Murray Cumming  <murrayc@murrayc.com>
+
+	* gtk/src/action.hg, toggleaction.hg, radioaction.hg, icontheme.hg:
+	Added protected keyword at start of class so that 
+	the constructors can be used by derived classes. This is addition of 
+	API in the stable branch, but it should not affect many people and it 
+	is a little too embarassing to leave as it is.
+
+2004-06-30  Murray Cumming  <murrayc@murrayc.com>
+
+	* gtk/src/container.hg: Add code to the GClass init() function to null 
+	the remove callback if the type is actually GtkContainer rather than 
+	a derived class. The default implementation in GtkContainer complains 
+	about it not being implemented, but that is useless and annoying to us 
+	when deriving directly from Gtk::Container.
+
+2004-06-20  Daniel Elstner  <daniel.elstner@gmx.net>
+
+	* gtk/src/stockitem.ccg (StockItem::StockItem): Pass a 0 pointer
+	to GTK+ if translation_domain is the empty string, so that the
+	application's global translation domain will be used by default.
+
+2004-06-20  Daniel Elstner  <daniel.elstner@gmx.net>
+
+	* gtk/src/widget.ccg (Widget::unset_fg): First cast Gtk::StateType
+	to int and then to GtkStateType, because direct static_cast<> from
+	one enum type to another is invalid C++.  Why g++ 3.3 accepts this
+	is a mystery to me though...
+	(Widget::unset_bg): ditto
+	(Widget::unset_text): ditto
+	(Widget::unset_base): ditto.
+
+2.4.3:
+
+2004-06-16  Daniel Elstner  <daniel.elstner@gmx.net>
+
+	* gtk/src/treeiter.ccg (TreeIter::operator--): Correctly decrement
+	the end iterator.  Also assert that the iterator is not already at
+	the begin of the sequence.
+
+	* gtk/src/treeiter.hg (TreeIter::operator--): s/slow/very slow/
+
+2004-06-15  Murray Cumming  <murrayc@murrayc.com>
+
+	* gtk/gtkmm/comboboxentrytext.h: Correct the header guard so that it 
+	can be used at the same time as comboboxentry.h.
+	* gtk/gtkmm/comboboxentrytext.cc, comboboxtext.cc: Implement the 
+	GObject* castitem constructors.
+
+2004-06-08  Cedric Gustin  <cedric.gustin@swing.be>
+  
+	* gdk/gdkmm/Makefile.am: link against libpangomm-1.4 instead of
+	1.6 on win32 (sublib_win32_dlls_libs variable).
+
+2.4.2:
+
+2004-06-04  Daniel Elstner  <daniel.elstner@gmx.net>
+
+	* gtk/src/filechooser.hg (FileChooser): Copy the class docs from
+	GTK+.  Also explain the fact that the API is broken and how to use
+	it correctly despite this problem (bug #142138).
+
+2004-06-03  Murray Cumming  <murrayc@murrayc.com>
+
+	* gtk/src/treeview.ccg: get_path_at_pos(): Correct memory management
+	of the path. Bug #142970 from david@thepriorities.com.
+
+2004-05-28  Murray Cumming  <murrayc@murrayc.com>
+
+	* docs/FAQ/gtkmm_faq.xml: Mentioned gtkmm 2.4.
+
+2004-05-28  Murray Cumming  <murrayc@murrayc.com>
+
+	* gtk/src/combobox.ccg: get_active(): Instantiate a 
+	Gtk::TreeModel::iterator instead of the GtkTreeIter, so that the 
+	underlying GtkTreeIter is properly initialized.
+
+2004-05-25  Daniel Elstner  <daniel.elstner@gmx.net>
+
+	* demos/pixbuf-demo.cc: More micro tweaking.
+
+2004-05-25  Daniel Elstner  <daniel.elstner@gmx.net>
+
+	* demos/pixbuf-demo.cc: Minor cleanups: use const double rather
+	than a macro for pi, no need to explicitly maintain the timeout
+	signal connection, and some other stuff.
+
+2004-05-23  Murray Cumming  <murrayc@murrayc.com>
+
+	* gtk/gtkmm/comboboxentrytext.cc: Patch from Teemu Tervo to prevent 
+	the text column from being added twice, in bug #142956.
+
+2004-05-22  Daniel Elstner  <daniel.elstner@gmx.net>
+
+	* configure.in: Check for gthread-2.0 and if it exists, substitute
+	the required compiler flags into GTHREAD_CFLAGS.  This is necessary
+	to make the library code work correctly in a threaded application.
+	For instance, on glibc systems errno is replaced by a macro which
+	expands into a function call.  Actually this stuff was already in
+	place, but apparently got lost when glibmm was split off.
+
+	* build_shared/Makefile_build.am_fragment (all_includes): Append
+	$(GTHREAD_CFLAGS).
+
+2004-05-19  Daniel Elstner  <daniel.elstner@gmx.net>
+
+	* gtk/gtkmm.h: Remove duplicated combobox.h include.  Add missing
+	includes of comboboxentry.h and comboboxentrytext.h.
+
+2004-05-18  Daniel Elstner  <daniel.elstner@gmx.net>
+
+	* gtk/src/treeiter.ccg (TreeIter::operator bool): Put the original
+	test for gobject_.stamp != 0 back in place.  The iter_is_valid()
+	method provided by model implementations is intended for debugging
+	purposes only, and thus should not be used here (bug #142599).
+
+	* gtk/src/treemodel.hg (TreeModel::iter_is_valid): Document that
+	the usage of this method as abstract interface is deprecated, and
+	that the implementation's iter_is_valid() should be used directly.
+
+2004-05-14  Murray Cumming  <murrayc@murrayc.com>
+
+	* gtk/gtkmm/comboboxtext.cc, comboboxentrytext.cc: get_active_text():
+	The iterator was being used in ways that probably should not compile.
+	This leads to strange results in other situations, so it is best to fix
+	it.
+
+2.4.1:
+
+2004-04-25  Murray Cumming  <murrayc@murrayc.com>
+
+	* gdk/Makefile.am: install gdkmmconfig.h in a gdkmm-2.6 directory,
+	instead of a gtkmm-2.6 directory. Bug #141045.
+
+2004-04-23  Murray Cumming  <murrayc@murrayc.com>
+
+	* gtk/src/uimanager.[hg|ccg]: add_ui_from_string now returns a 
+	ui_merge_id instead of a guint, to make the API clearer. This is 
+	technically an API change, but it's not a breaking one, and it's not
+	an ABI change.
+
+2004-04-22  Alexander Nedotsukov <bland@FreeBSD.org>
+
+ 	* atk/atkmm: Fixed private/ includes installation directory.
+
+2004-04-17  Murray Cumming  <murrayc@murrayc.com>
+
+	* gtk/src/optionmenu.hg, fileselection.hg, combo.hg: Mark them as 
+	deprecated in the docs, by using the Doxygen @deprecated command.
+
+2004-04-17  Murray Cumming  <murrayc@murrayc.com>
+
+	* Removed some extra semi-colons detected by gcc 3.4 from cvs.
+
+2.4.0:
+
+2004-04-11  Murray Cumming  <murrayc@murrayc.com>
+
+	* atk/src/: Added implementor.[hg|ccg] to wrap the AtkImplementorIface.
+	* gtk/src/widget.hg: Widget inherits from the Implementor interface
+	as well as Gtk::Object.
+
+2004-04-10  Murray Cumming  <murrayc@murrayc.com>
+
+	* gtk/gtkmm.h: #include treemodelsort.h and treemodelfilter.h
+	* gtk/src/menu.hg: popup(): Wrap the C callback as a Slot, so we do
+	not need to include gtkmenu.h.
+	* gtk/src/iconinfo.hg: Do not include gtkiconinfo.h.
+	* gtk/src/notebook.hg: Do not include gtknotebook.h
+	* gtk/src/stockitem.hg: Do not include gtkstockitem.h
+	* gtk/src/texttag.hg: Do not include gtktexttag.h
+
+2004-04-09  Murray Cumming  <murrayc@murrayc.com>
+
+	* toolbar.hg: Added get_tooltips_object() accessor, which should let
+	us set tooltips on toolbar objects.
+
+2004-04-09  Murray Cumming  <murrayc@murrayc.com>
+
+	* filefilter.hg: Create a FileFilter::Info class to use in place of
+	GtkFileFilterInfo, in the add_custom() callbak . Removed filter(), 
+	because it is not needed and because it is difficult to wrap.
+
+2004-04-08  Bryan Forbes  <bryan@reigndropsfall.net>
+
+	* gtk/gtkmm.h: include gtkmm/settings.h.
+
+2.3.8
+
+2004-04-09  Murray Cumming  <murrayc@murrayc.com>
+
+	* gtk/src/action.hg: Added set_tooltip().
+
+2004-04-07  Bryan Forbes  <bryan@reigndropsfall.net>
+
+	* gtk/src/icontheme.hg: added refreturns for get_default and get_for_screen.
+	* gtk/src/settings.hg: added unwrapped properties.
+	* gtk/src/targetlist.[hg|ccg]: added a create method that wraps
+	gtk_target_list_new.
+
+2004-04-07  Murray Cumming  <murrayc@murrayc.com>
+
+	* Removed some TODO comments that are no longer relevant.
+
+2004-04-03  Murray Cumming  <murrayc@murrayc.com>
+
+	* gtk/src/treemodel.[hg|ccg]: Rename 2 of the 3 foreach() overloads
+	to foreach_iter() and foreach_path(), because they are ambiguous with
+	libsigc++ 2.
+
+2004-04-03  Murray Cumming  <murrayc@murrayc.com>
+
+	* gtk/src/liststore.[hg|ccg], treestore.[hg|ccg]: Added insert_after(),
+	because it is apparently faster with many rows. Bug #131019.
+
+2004-04-01  Murray Cumming  <murrayc@murrayc.com>
+
+	* gtk/src/action.[hg|ccg]: Added set_sensitive(), even though
+	it does not exist in GTK+ itself yet. Spotted by Matthew Walton.
+
+2.3.7:
+
+2004-03-28  Bryan Forbes  <bryan@reigndropsfall.net>
+
+	* gtk/src/action.[hg|ccg]:
+	* tools/m4/convert_gtk.m4: changed Action::create_menu_item(), 
+	create_tool_item(), and create_icon() to return Gtk::MenuItem*, 
+	Gtk::ToolItem*, and Gtk::Image respectively, rather than Gtk::Widget*.
+
+2004-03-28  Murray Cumming  <murrayc@murrayc.com>
+
+	* gtk/src/uimanager.ccg: Fix typo to fix the build.
+	* */src/*_methods.defs: Regenerated with h2defs.py.
+
+2004-03-28  Murray Cumming  <murrayc@murrayc.com>
+
+	* *_docs_override.xml: Added several overrides to remove references to
+	0 parameters and freeing of strings.
+	* atk/src/table.hg: Added const versions of some get_*() methods.
+
+2004-03-25  Andrew E. Makeev  <andrew@solvo.ru>
+
+	* gtk/src/treeview.hg, gtk/src/treeview.ccg: Added 
+	move_column_to_start(), which uses gtk_tree_view_move_column_after() 
+	with a 0 parameter.
+
+2004-03-26  Elijah Newren  <newren@math.utah.edu>
+ 
+ 	* docs/tutorial/gtkmm-tut.xml: Several simple fixes. 
+
+2004-03-27  Murray Cumming  <murrayc@murrayc.com>
+
+	* example/book/: Added menus_and_toolbars example that uses UIManager.
+	The book should probably stop using the other menu and toolbar examples
+	and they should be moved away.
+
+2004-03-27  Murray Cumming  <murrayc@murrayc.com>
+
+	* gtk/src/action.ccg, toggleaction.ccg, radioaction.ccg: 
+	Constructor: Give GTK+ 0 instead of "" for default labels and tooltips,
+	so that the stock ones are used.
+
+2004-03-25  Murray Cumming  <murrayc@murrayc.com>
+
+	* gtk/src/filefilter.[hg|ccg]: Wrapped filefilter as a GtkObject 
+	instead of a GObject, because it is a GtkObject.
+	* examples/book/dialogs/filechooserdialog/: Used filefilter.
+
+2004-03-25  Bryan Forbes  <bryan@reigndropsfall.net>
+
+	* gtk/src/messagedialog.[hg|ccg]: removed use_separator parameter from
+	constructor as GtkMessageDialog gets its separator setting from the style
+	now.
+
+2004-03-24  Bryan Forbes  <bryan@reigndropsfall.net>
+
+	* gtk/src/uimanager.hg: fixed typo in disconnect_proxy signal.
+
+2004-03-21 Elijah Newren  <newren@math.utah.edu>
+
+	* doc/FAQ/gtkmm-faq.xml: Updated to mention gtkmm2 more than gtkmm 1.2.
+
+2004-03-20  Murray Cumming  <murrayc@murrayc.com>
+
+	* demos/gtk-demo/demowindow.cc: Use sigc::ptr_fun() instead of giving
+	the set_select_function function pointer directly to connect.
+
+2004-03-20  Murray Cumming  <murrayc@murrayc.com>
+
+	* ActionGroup::get_action(), Clipboard::get_owner(), 
+	ComboBox::get_model(), Entry::get_layout(), get_completion(),
+	EntryCompletion::get_model(), FileChooser::get_filter(), 
+	IconInfo::get_builtin_pixbuf(), IconSource::get_pixbuf(), 
+	Image::get_pixbuf(), get_animation(), Menu::get_accel_group(), 
+	Scale::get_layout(), TreeModelFilter::get_model(),
+	UIManager::get_accel_group(), get_action(), 
+	Widget::drag_begin(): Use refreturn.
+	* Entry::get_layout(), IconInfo::get_builtin_pixbuf(): 
+	IconSource::get_pixbuf(), Image::get_pixbuf(), 
+	Menu::get_accel_group(): Added const versions.
+        (Thanks to Bryan Forbes for finding the missing refreturns.)
+
+2004-03-18  Murray Cumming  <murrayc@murrayc.com>
+
+	* gtk/src/icontheme.hg: Wrapped changed signal.
+
+2004-03-14  Murray Cumming  <murrayc@murrayc.com>
+      
+	* gtk/src/bin.ccg remove(),
+	  gtk/src/container.[hg|ccg]: If the child widget is managed, do 
+	a reference on the child widget before removing it, so that it 
+	is not destroyed, and is ready for a new container, just like 
+	when it was first instantiated.
+
+2.3.6:
+
+2004-03-14  Murray Cumming  <murrayc@murrayc.com>
+      
+	* demos/demowindow.cc: Do not use flockfile if we are using the SUN
+ 	compiler, even though it passes the configure test, because it does
+ 	not seem to work here.
+
+2004-03-13  Murray Cumming  <murrayc@murrayc.com>
+
+	* gtk/src/toolbar, treestore: Removed extra semicolon to remove
+	g++ 3.4 warning.
+
+2004-03-13  Murray Cumming  <murrayc@murrayc.com>
+
+	* atk/src/hypertext.hg, 
+	Removed extra semicolon to remove g++ 3.4 warning.	
+
+2004-03-12  Cedric Gustin  <cedric.gustin@swing.be>
+  
+ 	* README.win32: Updated file for upcoming gtkmm-2.4.  
+ 	* atk/src/action.hg, atk/src/component.hg, atk/src/object.hg,
+ 	gtk/gtkmm/accelmap.cc, gtk/gtkmm/accelmap.h,
+ 	gtk/gtkmm/comboboxtext.cc, gtk/gtkmm/comboboxtext.h,
+ 	gtk/src/main.ccg : Removed many #ifndef WIN32 as all methods are
+ 	now available/dllexported on win32, with the exceptions og Plug
+ 	and Socket.
+ 	* atk/atkmm/Makefile.am, atk/atkmm/private/Makefile.am,
+ 	atk/src/Makefile_list_of_hg.am_fragment,
+ 	build_shared/Makefile_build.am_fragment,
+ 	build_shared/Makefile_build_gensrc.am_fragment,
+ 	build_shared/Makefile_conditional.am_fragment,
+ 	build_shared/Makefile_gensrc.am_fragment, gdk/gdkmm/Makefile.am,
+ 	gdk/gdkmm/private/Makefile.am,
+ 	gdk/src/Makefile_list_of_hg.am_fragment, gtk/gtkmm/Makefile.am,
+ 	gtk/gtkmm/private/Makefile.am,
+ 	gtk/src/Makefile_list_of_hg.am_fragment,
+ 	pango/pangomm/Makefile.am, pango/pangomm/private/Makefile.am,
+ 	pango/src/Makefile_list_of_hg.am_fragment: Revamped the
+ 	Makefile.am helpers to accomodate multiple platforms (general,
+ 	posix, win32) and files sections (regular and deprecated files). 
+
+2004-03-12  Murray Cumming  <murrayc@murrayc.com>
+
+	* docs/reference/Makefile.am: remove the make dependency of 
+	html/index.html on the generated installed beautify_docs.pl script, so
+	that docs are not rebuilt when building from a tarball.
+	Bug #136597 from dalgoda.
+
+2004-03-12  Murray Cumming  <murrayc@murrayc.com>
+
+	* examples/cellrenderercustom/cellrendererpopup.cc: Removed some 
+	accidentally pasted text that breaks the build.
+
+2004-03-11  Murray Cumming  <murrayc@murrayc.com>
+
+	* demos/gtk-demo/demowindow.cc: Added #ifdef GLIBMM_COMPILER_SUN_FORTE
+	around the strange flockfile and funlockfile function prototypes, to 
+	avoid problems on platforms which declare them differently.
+
+2004-03-09  Murray Cumming  <murrayc@murrayc.com>
+ 
+ 	* Some, but not all, SUN Forte build fixes:
+ 	* demos/gtk-demo/demowindow.cc: Added prototypes for flockfile()
+ 	and funlockfile() because it does not seem to get them from
+	stdio.h - very strange. Commented-out the g_assert() lines that it
+ 	says as badly formed.
+ 	* demos/gtk-demo/textwidget.cc: Made the next_token char* const.
+	* examples/book/clipboard/ideal/examplewindow.cc: 
+ 	on_clipboard_received_targets: Remove the useless const from the
+ 	std::list variable because it confused the compiler.
+ 	* examples/cellrenderercustom/cellrendererpopup.cc:
+ 	on_show_popup(): Use namespaced class name when specifying a
+ 	particular version of gobj().
+ 	* gdk/src/display.hg: Removed lots of extra ;s that caused
+ 	warnings.
+ 	* gdk/src/pixmap.ccg: Use unwrap<Drawable> instead of 
+ 	unwrap<const Drawable> - this is the same as the sun-specific
+ 	stuff in tools/m4/convert_*.m4.
+ 	* gdk/src/pixmap.hg: Removed extra ;s that cause warnings.
+ 	* gtk/src/textbuffer.ccg: insert_(): Some const changes - see the 
+ 	comments. 
+ 	* tools/m4/convert_gdk.m4, convert_glib.m4: Use existing
+ 	sun-specific conversion when converting from any 
+ 	RefPtr<const Something> to *Something.
+
+2004-03-09  Murray Cumming  <murrayc@murrayc.com>
+
+	* Regenerated gtk/src/gtk_docs.xml, and gdk/src/gdk_docs.xml with
+	docextract_to_xml.py.
+	* docs/reference/Makefile.am: Upload doxygen-warnings.txt and 
+	doxygen-output.txt every time, so everybody sees them.
+
+2004-03-09  Hagen Moebius  <hagen.moebius@starschiffchen.de>
+
+        * Recent efforts cumulated in a massive documentation patch, which
+        eliminates almost all doxygen warnings/errors.
+        Files: atk/atkmm/init.h, gdk/src/display.hg, drawable.hg,
+        gdk_docs_override.xml, pixbuf.hg, window.ccg, window.hg,
+        gtk/gtkmm/accelkey.h, gtk/src/accellabel.hg, alignment.hg, box.hg
+        button.hg, cellrenderer.hg, filechooser.hg, gtk_docs_override.xml,
+        image.hg, layout.hg, main.hg, notebook.hg, rc.hg, textbuffer.hg,
+        treedragdest.hg, treemodelfilter.hg, treemodel.hg, treepath.hg,
+        treeview.hg, widget.hg, window.hg, pango/src/attributes.hg,
+        pango_docs_override.xml
+
+2004-03-07  Murray Cumming  <murrayc@murrayc.com>
+
+	* Regenerated *_docs.xml files for atk, gdk, pango, and gtkmm, 
+	because Hagen Moebius improved the docextract_to_xml.py script.
+
+2004-04-07  Hagen Moebius  <hagen.moebius@starschiffchen.de>
+
+	* added documentation to gtk/src/viewport.hg, gtk/src/toolbutton.hg,
+        gtk/src/toggletoolbutton.hg, gtk/src/separatortoolitem.hg and
+        gtk/src/range.hg. Fixed a spelling error in gtk/src/radiotoolbutton.hg.
+        All documentation copy/pasted from Gtk+, so still room for imrovement.
+
+2004-04-06  Hagen Moebius  <hagen.moebius@starschiffchen.de>
+
+	* modified docs/reference/Makefile.am to support a more general output
+	of doxygen warnings/errors.
+
+2004-03-06  Murray Cumming  <murrayc@murrayc.com>
+
+	* gtk/src/gtk_signals.defs: Added the new RadioMenuItem::group_changed
+	signal.
+
+2004-03-06  Murray Cumming  <murrayc@murrayc.com>
+
+	* gtk/src/filechooser.hg: set_current_folder(), 
+	set_current_folder_uri(), select_filename(), select_uri(), 
+	set_filename(), and set_uri() now return bools, because GTK+ now
+	does this.
+
+2004-03-06  Murray Cumming  <murrayc@murrayc.com>
+
+	* gtk/src/gtk_methods.defs: regenerated.
+	* gtk/src/gtk_docs.xml: regenerated.
+
+2004-03-05  Hagen Moebius  <hagen.moebius@starschiffchen.de>
+ 
+ 	* added missing documentation to gtk/src/expander.hg,
+ 	gtk/src/filechooserwidget.hg, gtk/src/fontbutton.hg,
+ 	gtk/src/imagemenuitem.hg, gtk/src/radiotoolbutton.hg. Mainly
+ 	class documentation, some non-Gtk+ function and some constructors.
+ 
+2004-03-05  Hagen Moebius  <hagen.moebius@starschiffchen.de>
+ 
+ 	* gtk/src/colorbutton.hg: added missing documentation to some functions.
+
+2004-03-05  Murray Cumming  <murrayc@murrayc.com>
+
+	* gtk/src/radiobutton.hg, radiomenuitem.hg: Wrap the group_changed
+	signals now that they are corrected in GTK+.
+	* gtk/src/filechooser.hg: Correct the set_local_only() parameter name
+	to match the one in GTK+, as spotted by Matthew Walton.
+
+2.3.5:
+
+2004-03-03  Bryan Forbes  <mxpxfifws@yahoo.com>
+
+	* gtk/src/toolbar.[hg|ccg]: added methods to append, prepend, and 
+	insert with a sigc::slot.
+	* examples/stock/stock.cc: use new append method to append with a slot;
+	added a toggle button to prove that there are no ambiguity problems 
+	with the new methods.
+
+2004-03-02  Bryan Forbes  <mxpxfifws@yahoo.com>
+
+	* gtk/src/toolbar.[hg|ccg]: removed old STL-stlye API (deprecated and 
+	can't co-exist with new API).
+	* gtk/gtkmm/toolbar_elements.[h|cc]: removed these files to get rid of 
+	all old API for Gtk::Toolbar.
+	* gtk/gtkmm/Makefile.am: removed toolbar_elements.[h|cc] from list of 
+	files to build, because it is only needed by the old STL-style Toolbar
+	API.
+
+2004-03-03  Murray Cumming  <murrayc@murrayc.com>
+
+	* gtk/src/radiobutton.hg, radiomenuitem.hg: Commented-out
+	the new group_changed signals until their declarations
+	are fixed in GTK+ - patch submitted.
+
+2004-03-03  Murray Cumming  <murrayc@murrayc.com>
+
+	* pango/src/pango_methods.defs: Updated with h2defs.py.
+	* pango/fontface.[hg|ccg]: Added list_sizes().
+	* pango/attriter.[hg|ccg]: Added get_attrs().
+	* pango/fontfamily.hg: Added is_monospace().
+	* pango/fontset.[hg|ccg]: Added foreach().
+	* pango/language.hg: Added includes_script().
+	* pango/layout: Added set/get_auto_dir().
+
+2004-03-02  Murray Cumming  <murrayc@murrayc.com>
+
+	* Updated gtk/src/gtk_signals.defs with tools/extra_defs_gen.
+	* gtk/src/cellrendererpixbuf.hg: Wrapped several new properties.
+
+2004-03-02  Murray Cumming  <murrayc@murrayc.com>
+
+	* New GTK+ API wrapped:
+	* FileChooser: Added set/get_use_preview_label() and use_preview_label
+	property.
+	* Entry: Added set/get_alignment().
+	* ComboBox: Added popup() and popdown().
+	* Scale: Added get_layout() and get_layout_offsets().
+	* Widget: Added add_mnemonic_labels(), remove_mnemonic_label(), and
+	list_mnemonic_labels().
+	* ComboBoxEntry: Added a set_text_column() overload that takes a
+	ModelColumnBase instead of an int.
+	* Added ComboBoxEntryText, like ComboBoxText, as an equivalent for
+	gtk_combo_box_entry_new_text().
+	* RadioButton, RadioMenuItem: Added group_changed signals.
+	* Widget: Added draw_insertion_cursor() as wrapper for 
+	gtk_draw_insertion_cursor, which has a GtkWidget as the first 
+	parameter.
+	* Updated gtk/src/gtk_methods.defs with h2defs.py
+
+2004-03-01  Murray Cumming  <murrayc@murrayc.com>
+
+	* gtk/src/treeview.ccg: Corrected the implementation of 
+	unset_expander_column() to reset_expander_column(), to fix the build.
+
+2004-02-29  Billy O'Connor  <billyoc@gnuyork.org>
+ 
+ 	* gtk/src/treeview.hg: Added documentation for Gtk::TreeView.
+
+2004-02-29  Murray Cumming  <murrayc@murrayc.com>
+
+	* gtk/src/treeiter.[hg|ccg]: begins_tag(), ends_tag(), toggles_tag(), 
+	has_tag(): Use a const parameter, and added method overloads with no 
+	parameter, because the C functions can take a NULL.
+	* gtk/src/treemodel.[hg|ccg]: rows_reordered() now takes a
+	Glib::ArrayHandle<int> instead of a int* array of unknown size.
+	* gtk/src/entrycompletion.hg: Added prepend_*() methods instead of 
+	using a default arg for insert().
+	* examples/book/entry: Moved the existing example into a simple
+	sub-directory, and added a completion sub-directory, demonstrating
+	Gtk::EntryCompletion.
+
+2004-02-29  Murray Cumming  <murrayc@murrayc.com>
+
+	* gtk/src/treeselection.[hg|ccg]: Made selected_foreach() methods 
+	const, because the slots are not allowed to change the model. But we
+	really need a TreeModel::const_iterator for this, and other things.
+
+2004-02-27  Bryan Forbes  <mxpxfifws@yahoo.com>
+
+	* gtk/src/filechooser.hg: removed the inclusion of gtk/gtkfilechooser.h
+	since it's included in the ccg.
+
+2004-02-27  Bryan Forbes  <mxpxfifws@yahoo.com>
+
+	* gtk/src/gtk_methods.defs: removed the set_folder_mode and get_folder_mode
+	methods as they are no longer in gtk+.
+
+2004-02-27  Murray Cumming  <murrayc@murrayc.com>
+
+	* gtk/src/gtk_enums.defs: Added new FileChooser enum values, so that
+	set_action() is now a real replacement for set_folder_mode().
+	* examples/book/dialogs/filechooser/: Updated to use set_action()
+	instead of set_folder_mode(), really fixin build.
+
+2004-02-27  Murray Cumming  <murrayc@murray.com>
+
+	* gtk/src/filechooser.hg: Removed set_folder_mode() and 
+	get_folder_mode() because they have been removed from GTK+. This fixes
+	the cvs build.
+
+2004-02-27  Murray Cumming  <murrayc@murrayc.com>
+
+	* gtk/src/treepath.hg: append<>(): Corrected a typo that is detected by
+	gtk++ 3.4 prereleases and would have been detected before if this 
+	template method had been used. Bug #131928 by Matthew Tuck.  
+
+2004-02-26  Martin Schulze <martin-ml@hippogriff.de>
+
+	* More libsigc++ 2 changes: Some documentation fixes, updates in the 
+	tutorial and tries to solve some issues in GtkMainConnectionNode. With 
+	fixes from Bryan Forbes.
+
+2004-02-26  Bryan Forbes  <mxpxfifws@yahoo.com>
+
+	* configure.in:
+	* Makefile.am: added --enable-examples to configure to enable/disable the
+	building of the examples.
+
+2004-02-26  Murray Cumming  <murrayc@murrayc.com>
+
+	* examples/book/treeview/tree/examplewindow.[h|cc]: Handle the TreeView
+	row_activated signal.
+	* gdk/src/display.hg: Add const overloads get_screen(), 
+	get_default_screen(), list_devices(), get_event(), and peek_event().
+	* gdk/src/iconinfo.ccg: Actually implement get_attach_points(), though 
+	the implementation is incomplete - see the TODO in the code.
+	* gdk/src/iconinfo.hg: Add default parameter values for 
+	set_raw_coordinates(). Make get_embedded_rect() and get_attach_points()
+	const.
+	* gdk/src/icontheme.hg: Add parameter names in get_for_screen() and
+	set_screen(). Made load_icon() and list_icons() const.
+	* gtk/src/widget.[hg|ccg]: Made drag_dest_find_target() const.
+	* gdk/src/treeiter: Added reverse_iterator and const_reverse_iterator, 
+	though const_iterator and const_reverse_iterator are not really const 
+	yet. Added suitable overloads of begin() and end(), and added rbegin()
+	and rend().
+	* tools/m4/convert_gtk.m4: Added conversion needed by the above.
+
+2004-02-26  Bryan Forbes  <mxpxfifws@yahoo.com>
+
+	* examples/stock/stock.cc: fixed to use the new Toolbar API.
+
+2.5.4:
+
+2004-02-14  Murray Cumming  <murrayc@murrayc.com>
+
+	* gtk/src/gtk_methods.defs: Updated with h2defs.py
+	* gtk/src/gtk_signals.defs: Updated with generate_extra_defs, keeping
+	hand-coded changes for the Widget _event signals.
+	* gtk/src/gtk_enums.defs: Updated with glibmm/tools/enums.pl.
+	* gdk/src/pixbufloader.hg: Added set_size() as wrapper for 
+	gdk_pixbuf_loader_set_size().
+	* gtk/src/cellrenderer.hg: Wrapped editing_cancelled() and the
+	editing_cancelled signal, for use by CellRenderer implementations.
+	* gtk/src/action.hg: Added get_visible(), get_sensitive(), 
+	is_visible(), is_sensitive().
+	* gtk/src/actiongroup.hg: Added set_sensitive(), set_visible(), 
+	get_visible(), get_sensitive().
+	* gtk/src/uimanager.hg: Wrapped the proxy_connected, 
+	proxy_disconnected, pre_activate, and post_activate signals.
+	* gtk/src/widget.hg: Wrapped event_after signal.
+
+2004-02-11  Bryan Forbes  <mxpxfifws@yahoo.com>
+
+	* examples/cellrenderercustom/popupentry.cc: change to use Gtk::Requisition.
+	* examples/dnd/dndwindow.cc: change to use Gtk::AtomString::to_cpp_type.
+	* gdk/src/drawable.hg: changed the PangoGlyphString* arg to
+	Pango::GlyphString& since that argument is not an array. closes bug #97036
+	* gdk/src/window.[ccg|hg]: changed methods that use GList* to a
+	Glib::ListHandle<>; wrote get_internal_paint_info by hand because we need a
+	temporary variable.
+	* gtk/gtkmm/stock.[cc|h]: added the new Authentication dialog stock icon.
+	* gtk/src/Makefile_list_of_hg.am_fragment: added new iconinfo.hg.
+	* gtk/src/filechooser.hg: changed the GSList* returned by get_uris() to a
+	Glib::SListHandle<Glib::ustring>.
+	* gtk/src/iconinfo.[ccg|hg]: added new class to deal with GtkIconInfo.
+	* gtk/src/icontheme.[ccg|hg]: changed to use new IconInfo class; hand coded
+	get|set_search_path.
+	* gtk/src/window.hg: added property "role".
+	* tools/m4/convert_gtk.m4: added conversion for GtkIconInfo*->IconInfo.
+
+2.3.4:
+
+2004-02-13  Murray Cumming  <murrayc@usa.net>
+
+	* examples/cellrendercustom/popup.cc: Get and use a string for the
+	target, to fix the build.
+	* gdk/src/dragcontext.hg: get_selection() is now const.
+
+2004-02-11  Matthew Walton  <matthew@alledora.co.uk>
+
+	* examples/book/dialogs/filechooserdialog/examplewindow.cc:
+	Add buttons, as you would need in a real example.
+
+2004-02-10  Bryan Forbes  <mxpxfifws@yahoo.com>
+
+	* tools/m4/convert_gtk.m4: added TargetFlags<->GtkTargetFlags,
+	IconLookupFlags<->GtkIconLookupFlags, and
+	IconThemeError<->GtkIconThemeError; added conversions for
+	IconTheme<->GtkIconTheme and TargetList<->GtkTargetList.
+	* gtk/gtkmm/targetentry.[cc|h]: use the TargetFlags enum.
+	* gtk/src/Makefile_list_of_hg.am_fragment: added icontheme.hg and
+	targetlist.hg.
+	* gtk/src/enums.hg: added TargetFlags enum.
+	* gtk/src/frame.hg: use Allocation instead of GtkAllocation.
+	* gtk/src/icontheme.[ccg|hg]: added IconTheme class.
+	* gtk/src/socket.hg: use Gdk::NativeWindow instead of GdkNativeWindow.
+	* gtk/src/targetlist.[ccg|hg]: added TargetList class.
+	* gtk/src/widget.[ccg|hg]: use the new TargetList class; typedef Requisition
+	and Allocation and convert methods to use them; use Glib::ustring instead of
+	GdkAtom where necessary;
+	* demos/gtk-demo/example_drawingarea.cc:
+	* examples/cellrenderercustom/cellrendererpopup.cc: changed to use new
+	Allocation API.
+	* examples/dnd/dndwindow.c: changed to use the new TargetFlag enum.
+	* fixed up as per murrayc's requests; closes bug #133936.
+
+2004-02-10  Bryan Forbes  <mxpxfifws@yahoo.com>
+
+	* tools/m4/convert_gdk.m4: added InputSource<->GdkInputSource,
+	Glib::ustring<->GdkAtom, and NativeWindow<->GdkNativeWindow.
+	* gdk/src/colormap.hg: Used Gdk::Color instead of GdkColor.
+	* gdk/src/device.hg: Wrapped GdkInputSource and used the new enum in
+	corresponding methods.
+	* gdk/src/display.[hg|ccg]: Used Glib::ustring instead of GdkAtom and
+	NativeWindow instead of GdkNativeWindow.
+	* gdk/src/dragcontext.[ccg|hg]: Used DragProtocol instead of
+	GdkDragProtocol; GdkAtom->Glib::ustring.
+	* gdk/src/event.[ccg|hg]: 
+	* gdk/src/pixmap.[ccg|hg]: GdkNativeWindow->NativeWindow.
+	* gdk/src/types.[ccg|hg]: Added Gdk::AtomStringTraits struct back and
+	typedef'd it as AtomString; typedef'd	GdkNativeWindow as Gdk::NativeWindow.
+	* gdk/src/window.hg: GdkGeometry->Geometry.
+	* fixed up as per murrayc's requests; closes bug #133933.
+
+2004-02-10  Murray Cumming  <murrayc@usa.net>
+
+	* gtkmm now uses libsigc++ 2 as like glibmm, with slightly different
+	API. See bug #125061. We need to update CHANGES later.
+
+2.3.3:
+
+2004-01-31  Murray Cumming  <murrayc@usa.net>
+
+	* gdk/src/window.hg, gtk/src/widget.hg: Used C++ Region type instead of
+	GdkRegion. Make Region& args const where appropriate.
+	* gtk/src/treedragsource.[hg|ccg]: Hand-coded the drag_get_data vfunc
+	so that it can use a C++ SelectionData& output parameter.
+	* gtk/src/selectiondata.[hg|ccg]: Added set() method with fewer 
+	parameters, that calls get_target() to get the type(), like the 
+	examples do. Hopefully that is sensible.
+	* gtk/src/celllayout.hg: Use C++ CellRenderer* instead of C 
+	GtkCellRenderer for vfunc paramters.
+	* gtk/src/treeiter.[hg|ccg]: Added TreeIter::operator--(), which is 
+	slow and which has no direct equivalent in GTK+ itself yet.
+	* Added lots of const ListHandle and SListHandle get methods, with 
+	const elements. Fixes bug 126721.
+	
+
+2004-01-29  Murray Cumming  <murrayc@usa.net>
+
+	* gtk/src/widget: The drag_data_get and selection_get signals now have 
+	Gtk::SelectionData& return parameters instead of GtkSelectionData*. 
+	This requires the latest glibmm, which has added the optional 
+	custom_c_callback parameter for _WRAP_SIGNAL(). This required some 
+	copy/paste/changed code in the .ccg files.
+
+2.3.2:
+
+2004-01-21  Murray Cumming  <murrayc@usa.net>
+
+	* examples/book/treemodelcustom/exampletreemodel.[h|cc]: Wrote and
+	used some GlueItem and GlueList classes to better manage the 
+	GtkTreeIter data. But at the moment, the old iters are never 
+	invalidatated so this concept is not fully tested.
+	* gtk/src/treemodelfilter: Wrapped set_modify_func() after talking
+	to Kris about what it does.
+
+2004-01-19  Murray Cumming  <murrayc@usa.net>
+
+	* gtk/src/liststore.[hg|ccg], gtk/src/treestore.[hg|ccg]: Added
+	set_model_columns() methods, as wrappers for 
+	gtk_list_store_set_model_columns() and 
+	gtk_tree_store_set_model_columns().
+	* examples/book/treeview/drag_and_drop/dnd_treemodel.[h|cc]: Used
+	these methods with a non-static member ModelColumnRecord, so that
+	the ModelColumnRecord can be instantiated after the gtkmm type system.
+	Thanks to Bryan Forbes for pointing this out.
+
+2004-01-19  Takashi Takekawa <takekawa@users.sourceforge.jp>
+ 
+ 	* atk/src/text.hg, gtk/src/enums.hg: deleted unnecessary namespace
+	qualification, for the Intel compiler. Bug #131172.
+
+2004-01-19  Murray Cumming  <murrayc@usa.net>
+
+	* gdk/src/drawable.[hg|ccg]: Added copy_to_image() as wrapper for
+	gdk_drawable_copy_to_image().
+	* gtk/src/cellrenderertext.hg: Add a custom m4 conversion for the
+	Gdk::Drawable paramter of the render() vfunc, so that it takes
+	an extra reference.
+
+2004-01-16  Murray Cumming  <murrayc@usa.net>
+
+	* */*.hg: All _WRAP_VFUNCS are now in protected sections, because
+	gmmproc no longer puts them in a separated protected section 
+	automatically. Note also, that gmmproc now generates correct const
+	_vfuncs, so some of your overrides might no longer be overrides. Also,
+	you can add doxygen documentation before the _WRAP_VFUNC() macro now,
+	and it will be read by doxygen.
+
+2004-01-14  Murray Cumming  <murrayc@usa.net>
+
+	* gtk/src/treeiter.[hg}ccg]: Added TreeIter::set_stamp() and 
+	get_stamp(), with documentation, for use when implementing a 
+	custom TreeModel.
+	* gtk/src/treemodel.[hg|ccg]: 
+	- Hand-coded several vfuncs and their C callbacks, so that we can have 
+	C++ iterators instead of GtkTreeIter*s in the API, and to reorder some 
+	parameters.
+	- Added 2 extra vfuncs for information about root nodes. The C 
+	versions of these vfuncs provide root node information when the iter 
+	is NULL, but it is nicer in C++ to just have an extra vfunc without 
+	that parameter. This requires an extra if() in the _vfunc_callback() 
+	implementation.
+	- Added documentation for the vfuncs but gmmproc does not yet put the
+	documentation in the right place for the generated vfuncs. 
+	* gtk/src/cellrenderer.hg: Added docuemntation for the vfuncs, but
+	gmmproc does not put this documentation in the right place yet.
+	* examples/: Added treemodelcustom to show a derived TreeModel, which
+	overrides those vfuncs, based on the example by Christof Pettig.
+
+2004-01-12  Murray Cumming  <murrayc@usa.net>
+
+	* demos/gtk-demo/example_uimanager.cc: Removed extra comma to fix 
+	build - patch by Billy O'Connor.
+
+2004-01-09  Murray Cumming  <murrayc@usa.net>
+
+	* gtk/src/main.[hg|ccg]: Added docs, based on the C docs. Added bool
+	return value to iteration().
+	* gtk/src/uimanager.hg: Added wrapper for get_toplevels(), as wrapper
+	for gtk_ui_manager_get_toplevels().
+	* gtk/src/action.hg: add(): Use the new 
+	gtk_action_group_add_action_with_accels() instead of
+	gtk_action_group_add_action() so that it tries to use the stock 
+	accelerator if the action has a stock_id.
+
+2004-01-05  Murray Cumming  <murrayc@usa.net>
+
+	* gdk/src/image.hg: Added accessors for public struct fields.
+
+2003-01-05  Eric Bourque <ericb@computer.org>
+
+ 	* gtkmm.spec.in: added an unpackaged file (.devhelp) to the %files 
+	section. 
+
+2004-01-03  Murray Cumming  <murrayc@usa.net>
+
+	* gdk/src/*.[hg|ccg]: Added class documentation, by copying it from the
+	C documentation.
+	* gdk/gdkmm/: Added rgb.[h|cc] with some global functions, wrapping
+	gdk_rgb_get_colormap(), gdk_rgb_get_visual() and gdk_rgb_ditherable().
+	* gdk/src/color.hg: Documented all methods, apart from the hsv and hsl 
+	stuff that is a mystery to me.
+	* gdk/src/colormap.hg: Added get_system() as a wrapper for 
+	gdk_colormap_get_system().
+	* gdk/src/device.hg: Added get_name(), get_source(), get_mode() and
+	get_has_cursor() as accessors for read-only struct fields.
+	* gdk/src/dragcontext.[hg|ccg]: Added get_targets() and documented it
+	and other accessors.
+	* gtk/src/liststore.hg, treestore.hg: Documented all methods.
+	* gtk/src/tree*.hg: Added lots of class and method documentation.
+
+2003-12-31  Murray Cumming  <murrayc@usa.net>
+
+	* docs/reference/Makefile.am: Corrected generated .devhelp filename
+	so that it matches the pattern that devhelp looks for.
+	* docs/reference/doxygen_to_devhelp.xsl: Correct link prefix, so that
+	it links to the installed html documentation.
+	* gtk/gtkmm/accelmap.[h|cc]: Added lock_path() and unlock_path() as 
+	wrappers for new GTK+ functions. Added documentation for all AccelMap
+	methods, based on the GTK+ docs.
+	* gtk/src/clipboard.[hg|ccg]: Added documentation, based on the C docs.
+	Added wait_for_targets(), as a wrapper for 
+	gtk_clipboard_wait_for_targets(). Added a version of request_targets()
+	with a callback that takes a list of strings, as a wrapper for 
+	gtk_clipboard_request_targets(), and deprecated the hacky one
+	with a callback that takes a SelectionData.
+	* atk/src/: Added Hyperlink, Hypertext, Document, and StreamableContent
+	* atk/src/atkobject.hg: Now inherits from the Hypertext interfaces as
+	well as the others.
+	* gtk/src/gtk_methods.defs: Updated from gtk+ with h2defs.py
+
+2003-12-30  Murray Cumming  <murrayc@usa.net>
+
+	* docs/reference/Makefile.am: Use installed beautify_docs, instead
+	of a copy.
+	* configure.in: Use installed glibmm_check_perl() instead of a copy.
+
+2003-12-21  Murray Cumming  <murrayc@usa.net>
+
+	* gtk/src/menushell.hg: Added cancel() as wrapper for 
+	gtk_menu_shell_cancel().
+
+2003-12-20  Murray Cumming  <murrayc@usa.net>
+
+	* gtk/src/celllayout.hg: Wrapped reorder() method and vfunc.
+	* gtk/src/gtk_methods.defs and gdk/src/gdk_methods.defs: regenerated
+	with h2defs.pyt.
+
+2003-12-18  Murray Cumming  <murrayc@usa.net>
+
+	* gdk/src/display.hg: Added set_double_click_distance() as wrapper
+	for gdk_display_set_double_click_distance(), though the .defs for
+	it are not there yet.
+	* gtk/src/settings.hg: Added double-click-distance property.
+	* gtk/src/button.hg: Added get/set_alignment() as wrapper for
+	gtk_button_get/set_alignment(), though the .defs are not there yet.
+	* pango/src/pangoline.hg: Added get_length(), get_start_index(), and
+	get_layout() as accessors for the public struct fields.
+	* gtk/src/cellrenderertext.hg: Wrapped the new single-paragraph-mode
+	property.
+
+2003-12-13  Murray Cumming  <murrayc@usa.net>
+
+	* docs/reference/Makefile.am: Make sure that gtkmm2.devhelp is
+	generated before trying to install it. Added a doxygen-warnings
+	target that outputs the doxygen log to doyxgen_warnings.txt.
+	* gdk/src/window.hg: Added get_group(), as a wrapper for 
+	gdk_window_get_group(), and set_accept_focus() as wrapper for
+	gdk_window_set_accept_focus().
+	* gdk/src/display.hg: Added get_default_group(), as wrapper for 
+	gdk_display_get_default_group().
+
+2.3.1:
+
+2003-12-08  Murray Cumming  <murrayc@usa.net>
+	
+	* gtk/src/gtk_methods.defs: Regenerated with h2defs.py.
+	* gtk/src/combobox.hg: Corrected C function name in _WRAP_CONSTRUCT,
+	so that the constructor is actually generated.
+	* gtk/src/comboboxentry.hg: Added set_text_column() as wrapper
+	for gtk_combo_box_entry_set_text_column().
+	* gtk/src/entrycompletion.[hg|ccg]: Wrapped match_selected signal,
+	unpleasantly, by hand-coding everything.
+	* gtk/src/filefilter.[hg|ccg]: Added add_custom() as wrapper for
+	gtk_file_filter_add_custom(), using a SignalProxy.
+	* gtk/src/menu: Added set_monitor() as wrapper for 
+	gtk_menu_set_monitor().
+	* gtk/src/treeviewcolumn.hg: Added get_cell_position() as a 
+	wrapper for gtk_tree_view_column_cell_get_position().
+
+2003-12-08  Murray Cumming  <murrayc@usa.net>
+
+	* atk/atkmm/, pango/pangomm: Added init.[h|cc] so you can use
+	these libraries without using all of gtkmm.
+
+2003-12-06  Murray Cumming  <murrayc@usa.net>
+
+	* gtk/src/radiotoolbutton.[hg|ccg]: Removed the constructor that
+	takes a RadioToolButton& group, because it looks like a copy
+	constructor. Added a constructor that takes a Widget& icon_group,
+	for consistency with the other ToolButton classes.
+	Bug 128484 (Billy O'Connor).
+
+2003-12-03  Murray Cumming  <murrayc@usa.net>
+
+	* gtk/src/widget.hg: Wrapped get_accessible, screen_changed, and 
+	can_activate_accel signals, though the .defs are not there for them 
+	yet.
+
+2003-11-27  Murray Cumming  <murrayc@usa.net>
+
+	* gtk/src/treemodel.hg: Added iter_is_valid(). Use the old TreeIter::
+	operator bool() as a default implementation, but this is already 
+	reimplemented in ListStore and TreeStore, using GTK+ functions.
+	* gtk/src/treeiter.hg: operator bool(): Use iter_is_valid() instead
+	of our hack.
+
+2003-11-23  Murray Cumming  <murrayc@usa.net>
+
+	* gtk/src/radiotoolbutton.[hg|ccg]: Manually-implement constructors,
+	because the group is not a property.
+	* examples/book/toolbar: Use the new Toolbar API, to test it, though
+	this example should probably use the UIManager in future.
+	* gtk/gtkmm.h: Added the toolitem headers.
+
+2003-11-22  Murray Cumming  <murrayc@usa.net>
+
+	* gtk/src/toolbar.[hg|ccg]: Deprecated ToolList.
+	* examples/Makefile.am_fragment: Added GTKMM_DISABLE_DEPRECATED to
+	examples build.
+	* gdk/src/pixbuf.[hg|ccg]: Wrapped get_formats().
+
+2003-11-19  Murray Cumming  <murrayc@usa.net>
+
+	* docs/reference/Makefile.am: Fix the distcheck for the .devhelp file.
+	* gtk/src/expander.hg: Add the get/set_markup methods, though there
+	are no .defs for them yet.
+
+2003-11-17  Murray Cumming  <murrayc@usa.net>
+
+	* gtk/src/combobox.hg: Changed constructors, and added set_model(),
+	because the model is now a non-construct-only property in GTK+.
+	* gtk/gtkmm/comboboxtext.[h|cc]: Used changed API to implement this.
+	examples/book/combobox/text now works.
+
+2003-11-16  Murray Cumming  <murrayc@usa.net>
+
+	* gtk/src/toolbar.[hg|cc]: Wrapped new functions, including the 
+	ToolItem-based insert, append, and prepend, and deprecated our
+	equivalents of the deprecated C functions.
+	Moved deprecated Elements API into toolbar_elements.[h|cc].
+	* gtk/src/gtk_docs.xml: Replaced with freshly generated output
+	from docextract_to_xml.py from pygtk.
+	* Added gdk/src/pixbufformat.[hg|ccg] as wrapper for GdkPixbufFormat.
+
+2003-11-14  Murray Cumming  <murrayc@usa.net>
+ 
+ 	* gdk/src/gdk_docs_override.xml, gtk/src/gtk_docs_override.xm,
+ 	pango/src/pango_docs_override.xml. Added overrides for 4 or 5 methods
+ 	that mention Glib::Free, though I feel sure that I did this once
+ 	before. Bug #126870.
+
+2003-11-05  Murray Cumming  <murrayc@usa.net>
+
+	* gtk/src/widget.hg, gdk/src/window.hg: Fixed typos to fix build.
+
+2003-11-03  Murray Cumming  <murrayc@usa.net>
+
+	* gtk/src/action.[hg|ccg]: Renamed add_action() to add(), to reduce
+	the amount of client code slightly.
+	* gtk/src/celllayout.[hg|ccg]: Added set_cell_data_func(), using
+	SignalProxy.
+	* gtk/src/treemodelfilter.[hg|ccg]: 
+	Added set_visible_func(), using SignalProxy.
+	Added convert methods.
+
+
+2003-11-02  Murray Cumming  <murrayc@usa.net>
+
+	* gtk/src/*action.[hg|ccg]: renamed create_from_stock() to
+	create() because I think we can overload the methods, because the
+	parameters are distinguishable.
+	* examples/book/dialogs/: Added filechooserdialog, by copying and
+	modifying the fileselectiondialog example.
+	* gtk/src/entrycompletion.[hg|ccg]: wrap set_match_func() using
+	SignalProxy.
+
+2003-11-01  Murray Cumming  <murrayc@usa.net>
+
+	* gtk/src/: Added wrappers for FileChooser, FileChooserWidget,
+	FileChooserDialog and FileFilter. FileChooser is an interface
+	but I see no way to override it.
+	* Wrapped some more signals and vfuncs.
+
+2003-10-31  Murray Cumming  <murrayc@usa.net>
+
+	* docs/index.html: Corrected links to glibmm docs, using relative 
+	links.
+
+2003-10-30  Murray Cumming  <murrayc@usa.net>
+
+	* gtk/src/toolitem.hg: Removed get/set_pack_end() now that they are
+	removed from GTK+, to fix the CVS build.
+	* docs/Makefile.am_fragment: Install docs to gtkmm-2.4 directory
+	instead of gtkmm-2.3.
+	* docs/reference/Makefile.am: Add installdox rule to make the 
+	reference html link to the glibmm docs when they are installed.
+
+2003-10-26  Murray Cumming  <murrayc@usa.net>
+
+	* Dealt with several //TODO comments, adding several unset_*() methods
+	* *Action: Changed create() to create_from_stock() and create.
+	* ToggleAction: create() methods: Added bool is_active parameter.
+	* RadioAction: create() methods: Added group parameter.
+	* Added gtk/gtkmm/radiobuttongroup.[h|cc] containing 
+	Gtk::RadioButtonGroup. This was previously in the Gtk::Menu_Helpers
+	namespace. It now works with RadioActions as well as the 3 other
+	Radio item classes.
+	* Added examples/combobox/complex, showing a custom tree model,
+
+2.3.0:
+
+2003-10-24  Murray Cumming  <murrayc@usa.net>
+
+	* gtk/src/gtk_signals.defs: regenerated, keeping hand-coded changes,
+	after adding some extra GTypes to tools/extra_defs_gen.
+	* gkt/gtkmm: Added cellrenderer_generation.[h|cc], with some of the 
+	templates and template specialisations previously in 
+	treeviewcolumn.[hg|ccg]. This allowed them to be reused in
+	gtk/src/celllayout.hg for a pack_start(model column) template.
+	* demos/gtk-demo/: Added example_ui_manager.cc - a C++ version of
+	the C one.  
+
+2003-10-22  Murray Cumming  <murrayc@usa.net>
+
+	* Added wrappers for GtkToolItem, ToolButton, ToggleButton,
+	RadioToolButton.
+
+2003-10-17  Murray Cumming  <murrayc@usa.net>
+
+	* gtk/src/combobox.hg: Updated for latest API.
+	* Added gtk/gtkmm/comboboxtext.[h|cc], putting text-based stuff
+	in a sub class.
+	* gtk/src/treemodel.[hg|ccg]: Added const overload of children(),
+	but it's a bad hack that needs more attention.
+	* Added examples/book/combobox, which uses ComboBoxText and should use
+	ComboBox also in future. It segfaults at the moment.
+	* Added gtk/src/toggleaction.[hg|ccg] and gtk/src/radioaction.hg.
+	* Wrapped GList* and GSList*-using methods.
+	* UIManager: Wrapped Error-using methods, with optional errthrow
+	  parameter of _WRAP_METHOD().
+	* gtk/src/gtk_signals.defs: Updated with newly-generated defs from
+	extra_defs_gen, redoing the by-hand corrections.
+	* examples/book/dialogs/colorselection, fontselection: Used
+	the buttons instead. This will be moved into the buttons folder
+	later.
+	* examples/book/dialogs/messagedialog: Updated for new constructor
+	API.
+
+2003-10-12  Murray Cumming  <murrayc@usa.net>
+
+	* gtk/src/treemodel.hg: Comment-out wrapper for row-inserted
+	signal, until gtk+ bug 123923 has been dealt with, to prevent
+	treeview crash with GTK+ 2.3
+
+2003-10-12  Murray Cumming  <murrayc@usa.net>
+
+	* Added wrappers for new GTK+  classes: Action, ActionGroup, 
+        CellLayout, ComboBox, ComboBoxEntry, ColorButton, EntryCompletion,
+        Expander, FontButton, UIManager, and a few extra methods and
+        properties. More API details in NEWS.
+
+2003-10-01  Murray Cumming  <murrayc@usa.net>
+
+	* tools/m4/convert_gdk.m4: Correct the GdkDrawable conversion to
+	fix the build.
+
+2003-09-30  Murray Cumming  <murrayc@usa.net>
+
+	* gtk/src/cellrenderer.hg, gtk/src/gtk_vfuncs.defs, 
+	tools/m4/convert_gdk.m4: The CellRenderer render vfunc now takes a 
+	Gdk::Drawable instead of a Gdk::Window, as per my recent change 
+	in GTK+ in CVS. See bug #102405.
+
+2003-09-30  Murray Cumming  <murrayc@usa.net>
+
+	* gtk/src/gtk_methods.defs: Updated with h2defs.py from GTK+ in cvs.
+
+2003-09-30  Murray Cumming  <murrayc@usa.net>
+
+	* gtk/src/cellrenderer.hg, gtk/src/gtk_signals.defs:
+	Wrapped the CellRenderer::background-cell-* properties that seem
+	to have been added in GTK+ 2.2, but that we had not wrapped yet.
+	Bug #116803.
+
+2003-09-30  Murray Cumming  <murrayc@usa.net>
+
+	* gtk/src/textbuffer.hg: get_selection_bounds() returns a bool
+	to say whether anything is selected. Bug #118459
+	* gtk/src/widget.hg: get_style_property(): Parameter renamed to
+	avoid rare warning. Part of bug #117740.
+
+2003-09-28  Bradley Bell  <btb@debian.org>
+ 
+ 	* gtk/src/notebook.hg, gtk/src/treeiter.ccg, gtk/src/treeiter.hg:
+ 	workarounds for inaccessible base bugs with latest gcc.
+
+2003-09-11  Cedric Gustin  <cedric.gustin@swing.be>
+
+	* atk/src/text.hg, gdk/src/display.hg, gdk/src/displaymanager.hg,
+	gdk/src/screen.hg, glib/glibmm/threadpool.cc,
+	gtk/src/clipboard.hg, gtk/src/treerowreference.hg,
+	gtk/src/widget.hg, gtk/src/window.hg : Removed a bunch of
+	_GTKMMPROC_SIGNAL_H_AND_CC(#ifndef G_OS_WIN32) restrictions. These
+	functions are now implemented in the latest (2.2.4) GTK+ on win32.
+	* gdk/src/Makefile_list_of_hg.am_fragment,
+	gtk/src/Makefile_list_of_hg.am_fragment : Adapted Makefile.am's
+	accordingly. In particular, Gtk::Clipboard is now supported on
+	win32.
+	* README.win32 : Updated list of unsupported functions. 
+
+2003-09-04  Bradley Bell  <btb@debian.org>
+ 
+ 	* docs/reference/Makefile.am: Distribute doxygen tags 
+
+2003-08-20  Murray Cumming  <murrayc@usa.net>
+  
+ 	* gdk/src/display.hg: Add refreturn WRAP_METHOD() parameter to
+ 	open() and open_default_libgtk_only(), because these seem to return
+ 	an existing instance rather than a new one. Should fix bug #119049.
+
+2003-08-20  Frank Naumann  <fnaumann@freemint.de>
+ 
+ 	* demos/gtk-demo/example_treeview_editable_cells.cc,
+  	  examples/book/treeview/editable_cells/examplewindow.cc,
+  	  gtk/src/treeview.hg: Added workaround for MSVC++.
+  	The MSVC++ now compile Gtk::TreeView::append_column_editable
+  	and the result work as expected. An exact description
+  	can be found in the treeview.h as comment. Removed
+  	the no longer required MSVC++ workarounds from the
+  	examples too.
+
+2003-08-11  Martin Schulze  <teebaum@cvs.gnome.org>
+
+	* gtk/src/treeview.hg, docs/tutorial/gtkmm-tut.xml:
+	Add information about what to do when the column type is not
+	supported and TreeView::append_column() sets up the CellRenderer
+	incompletely (bug #118922).
+
+2003-07-21  Murray Cumming  <murrayc@usa.net>
+ 
+ 	* src/gtk/buttonbox.hg: Documentation: Corrected the switched 
+ 	vertical/horizonal descriptions of VButtonBox and HButtonBox.
+ 	Bug #117883.
+
+2003-07-05  Murray Cumming  <murrayc@usa.net>
+ 
+ 	* gtk/src/object.ccg Object::_init_unmanage(): 
+ 	Don't g_object_ref() objects that are already not managed, such as 
+ 	stuff used with Glib::Wrap() which is already in a container 
+ 	(Containers sink (unfloat) child widgets after they are added). Also, 
+ 	don't mark it as not manage()d, (!referenced_) of course. This was 
+ 	doing one-too-many refs, so sometimes the objects would not be 
+ 	finalized even if they were destroyed. Daniel Elstner found this 
+ 	potential problem months ago and I should have listened to him.
+ 	This seems to fix the lifetime bug shown in tests/wrap_existing. I think this
+   fixes the get_toplevel_windows() leak shown in tests/refcount_dialog also.
+   Thanks to Harold Hopfes for doing _lots_ of investigation work on this bug.
+ 	* gtk/src/window.ccg: Window::_destroy_c_instance():
+ 	Remove the g_object_unref() that was a window-specific fix for the
+ 	extra g_object_ref() in gtk/src/object.ccg above.
+
+2003-07-12  Murray Cumming  <murrayc@usa.net>
+
+	* pango/src/pango_docs_override.xml,
+	  gdk/src/gdk_docs_override.xml,
+	  gtk/src/gtk_docs_override.xml: Added overrides for documentation 
+	that talks about null pointer values where we use references. Added 
+	TODOs in the .hg files to add unset() methods in 2.4 to support this
+	functionality.
+
+2003-07-03  Murray Cumming  <murrayc@usa.net>
+
+	* Used %p and (void*) cast to various g_warning()s used when
+	--enable-debug-refcounting is used, avoiding compiler warnings.
+	* Added tests/wrap_existing, which shows a memory leak that we are
+	currently working on.
+
+2003-06-17  Murray Cumming  <murrayc@usa.net>
+ 
+ 	* docs/FAQ/gtkmm_faq.xml: Applied patch from Andreas Rottman 
+ 	mentioning libsigcx extension library.
+
+2003-06-13  Cedric Gustin  <cedric.gustin@swing.be>
+ 
+         * gtk/src/treeviewcolumn.hg: Added declaration of
+ 	generate_cellrenderer full class specialization for types bool and
+ 	Gdk::Pixbuf. This solves a long-standing bug with treeviews on
+ 	win32. Hopefully, it will also solve bug #113688 on Debian.
+ 	* demos/gtk-demo/example_stockbrowser.cc: Removed GTKMM_WIN32
+ 	compiler directive. On win32, stock icons are not displayed as
+ 	expected in the first column of the treeview.
+	
+2003-05-31  Murray Cumming  <murrayc@usa.net>
+
+	* configure.in: Depends on GTK+ 2.3.0 now that GTK+ has branched, with
+	GTK+ 2.4 in HEAD.
+	* configure.in: gmmproc is now installed in a glibmm-2.3 folder
+	rather than a glibmm-2.4 folder.
+	* gtk/src/alignment.hg: Wrapped new padding functions and properties. 
+	Wrote New in GTK+ 2.4 next to them. They need regenerated .defs files,
+	but we can do that later.
+
+2003-05-18  Murray Cumming  <murrayc@usa.net>
+ 
+ 	* docs/tutorial/gtkmm-tut.xml: TreeView chapter: Replaced some TODOs
+ 	with short paragraphs. Added copies of the example screenshots to
+ 	show the list and tree models.
+
+2003-05-14  Murray Cumming  <murrayc@usa.net>
+
+	* Applied some of MSVC++ .NET 2003 changes from jburris. For instance,
+	use of Gtk:: prefix with manage, because MSVC++ can not guess it. Also
+	corrected the out-of-sync protected/private modifiers in the private
+	gtype classes and their prototypes.
+
+2003-05-09  Murray Cumming  <murrayc@usa.net>
+ 
+ 	* gtk/src/menushell.[hg|ccg] replace GP_LIST_CONTAINER_REMOVE() with
+ 	custom-written remove() and erase() MenuList methods, to ensure that
+ 	we unset the accel widget that we might have set in the MenuItem() 
+ 	constructor. This avoids a memory leak due to the extra reference.
+	* gtk/src/accel_label.[hg|ccg]: Added unset_accel_widget().
+
+2003-05-06  Enrico Costanza  <ec142@york.ac.uk>
+ 
+ 	* gtk/src/image.hg: Added "refreturn" to _METHOD_WRAP for get_pixbuf
+ 	This fixes a bug that caused "(g_object_unref): assertion `G_IS_OBJECT
+ 	(object)' failed"
+
+2003-05-06  Murray Cumming  <murrayc@usa.net>
+
+	* gtk/src/optionmenu.[hg|ccg]: Implemented a custom destructor which
+	calls remove_menu(), to prevent the menu (set with set_menu()), from
+	remembering a dead OptionMenu. See the comment in the destructor for
+	more details.
+	
+2003-05-02  Murray Cumming  <murrayc@usa.net>
+
+	* *.hg: Added namespace prefix to all StateType parameter types, 
+	because there is one in Atk and in Gtk and that confuses Doxygen.
+	* demos/gtk-demo/example_change_display.cc: Commented-out some unused
+	method parameters, to avoid warnings.
+
+2003-04-26  Gene Ruebsamen <gene@erachampion.com>
+	
+ 	* docs/tutorial/gtkmm-tut.xml: Added a new appendix for win32
+ 	with the cygwin/command-line portion contributed by Cedric Gustin.
+ 	Created a new link from the Installation section to point to the new appendix.
+ 	Also fixed the filename of the tutorial in the "Contributing" section.
+ 	* docs/tutorial/figures/devcpp_project_options.png: Added new image for the new win32 appendix described above.
+	
+2003-04-22  Murray Cumming  <murrayc@usa.net>
+
+	* Install headers in x.3 directories instead of .4 because I noticed
+	that some are already there so it needed to be fixed, and, given the
+	current build files, it was easier to choose .3 than .4 (it is based
+	on the library names), and because it does not seem like such a bad
+	idea.
+
+2003-04-21  Murray Cumming  <murrayc@usa.net>
+
+	* gtk/src/menushell.ccg: Added 
+	GP_LIST_ITER(Glib::List_Cpp_Iterator<GtkListItem, ComboDropDownItem> 
+	because the standard GP_LIST iterator seems to be useless. See bug
+	#110206.
+	
+2003-04-21  Murray Cumming  <murrayc@usa.net>
+
+	* examples/book/Makefile.am: Added idle directory.
+	* configure.in: Added examples/book/idle/Makefile.
+
+2003-03-30  Gene Ruebsamen <gene@erachampion.com>
+
+	* examples/book/timeout/timerexample.[cc,h]: update examples to
+	work with Gtkmm2.
+	* examples/book/idle/idleexample.[cc,h]: create new idle directory and
+	examples for Gtkmm2.
+	* docs/tutorial/gtkmm-tut.xml: update the idle/timeout chapter for
+	Gtkmm2 and modify to use the program listings in the examples/book/
+	directories.
+	
+2003-04-21 Oli Kessler <ok@tor.ch>
+       
+         * gtk/gtk_docs_override.xml, fixed docu bug in the function
+         gtk_window_set_default
+	
+2003-04-15  Ole Laursen  <olau@hardworking.dk>
+
+	* gtk/src/widget.{cc,h}g: Added unset_fg/bg/font/text/base to
+	support unwrapped null pointer parameter to modify_fg/bg/....
+
+2003-04-13  Ole Laursen  <olau@hardworking.dk>
+
+	* examples/cellrenderercustom/cellrendererpopup.cc: Switched to
+	using wrappers of grab_add and friends instead of using the C
+	functions.
+
+	* gtk/src/main.ccg, gtk/src/main.hg: Removed commented wrapper of
+	grab_add and friends.
+
+	* gtk/src/widget.ccg, gtk/src/widget.hg: Wrapped
+	gtk_grab_add()/remove()/get_current().
+
+2003-03-30  Murray Cumming  <murrayc@usa.net>
+
+        * gtk/gtk_docs_override.xml, likewise atk, pango: Added overrides for
+ 	docs that mention *_free() functions.
+	
+2003-03-26  Martin Schulze  <MHL.Schulze@t-online.de>
+
+	* pango/src/attrlist.{ccg,hg}: AttrList::insert,
+	AttrList::insert_before, AttrList::change must pass a copy of
+	the attribute parameter into the c functions (should fix #109334).
+
+2003-03-22  Enrico Scholz  <enrico.scholz@informatik.tu-chemnitz.de>
+ 
+	* examples/Makefile.am_fragment:  Added DESTDIR-support. 
+
+2003-03-20  Ole Laursen  <olau@hardworking.dk>
+
+	* gtk/src/widget.hg: Applied patch from Detlef Reichl to add
+	protected set_window and set_allocation (#108484).	
+
+2003-03-18  Cedric Gustin  <cgustin@ibelgique.com>
+
+	* Makefile.am : removed examples from DIST_SUBDIRS.
+
+2003-03-13  Sebastian Rittau  <srittau@jroger.in-berlin.de>
+
+	* gdk/src/gc.hg: Added refreturn flag to both GC::get_screen() flavors.
+	Closes bug #108233. (With help by Sven Grottke.)
+
+2003-02-14  Bryan Forbes  <mxpxfifws@yahoo.com>
+
+	* gtk/src/accelgroup.hg:
+	* gtk/src/accellabel.hg:
+	* gtk/src/adjustment.hg:
+	* gtk/src/alignment.hg:
+	* gtk/src/arrow.hg:
+	* gtk/src/aspectframe.hg:
+	* gtk/src/bin.hg: Added documentation for constructors and
+	_MEMBER_GET() wrappers.
+	* gtk/src/box.hg: Added the PackOptions enum into the gtkmmEnums
+	group so it is now on the correct documentation page.
+	* gtk/src/enums.hg: Allow Doxygen to grab Gtk::AlignmentEnum (used in
+	alignment.hg and others) and added it to the gtkmmEnums group.
+	* gtk/src/gtk_docs_override.xml: Added documentation for methods
+	in accelgroup.hg, accellabel.hg, adjusment.hg, and arrow.hg.
+	
+2003-01-27  Murray Cumming  <murrayc@usa.net>
+ 
+ 	* gdk/src/display.hg: Used refreturn on  get_default() and
+ 	get_core_pointer(), preventing segfaults.
+	
+2003-01-27  Murray Cumming  <murrayc@usa.net>
+
+	* Replaced use of RefPtr::is_null() with use of operator bool().
+
+2003-01-24  Murray Cumming  <murrayc@usa.net>
+
+	* gtk/gtkmm/menu_elems.cc: Element::Element(MenuItem): Use the
+	Glib::RefPtr<> constructor explicitly, for clarity, and do the
+	necessary extra ref - fixes lifetime bug 104194
+
+2003-01-23  Murray Cumming  <murrayc@usa.net>
+
+	* More TODOs:
+	  - Gtk::Container: Removed const set_focus_chain(), added const 
+	    get_focus_chain().
+          - Gtk::TreeDragSource::drag_data_get() and 
+	    Gtk::TreeDragDest::row_drag_possible() now use SelectionData 
+	    instead of GtkSelectionData.
+
+2003-01-23  Murray Cumming  <murrayc@usa.net>
+
+	* Updated dnd examples for new signal signatures.
+
+2003-01-23  Murray Cumming  <murrayc@usa.net>
+
+	* More use of Gdk::Device and Gtk::SelectionData.
+
+2003-01-22  Murray Cumming  <murrayc@usa.net>
+
+	* Used _IGNORE_SIGNAL() on keybinding signals, though gmmproc still
+	complains about them. I founds these signals by grepping for
+	binding_entry_add_signal in the gtk+ source code.
+	* Dealt with various minor TODOs, adding const and using C++ types.
+
+2003-01-22  Murray Cumming  <murrayc@usa.net>
+
+	* Rename GTKMM_ macros to GLIBMM_.
+
+2003-01-22  Murray Cumming  <murrayc@usa.net>
+
+	* build_shared: Used the general/win32/posix variables used in
+	the gtkmm Makefile.ams, so that the libraries actually build.
+	* gtk/src/treepath.[hg|ccg]: Removed the TreePath(bool) override, as 
+	suggested, because it broke the build, because we don't seem to set 
+	gtkmm_COMPILATION.
+	* gtk/gtkmm/menu_elem.[h|cc]: It used the RefPtr::operator=() that we
+	removed because that operator=() shouldn't be used. Faked the behaviour
+	with an explict use of the constructor and a reference() for now, with 
+	a TODO.
+
+2003-01-21  Murray Cumming  <murrayc@usa.net>
+
+	* Changed library names: 1.4 -> 1.3 and 2.4 -> 2.3 so that they
+	can be unstable.
+
+2003-01-21  Murray Cumming  <murrayc@usa.net>
+
+	* Copied and modified slightly the build_shared files from libgdamm,
+	to use the gmmproc from glibmm-2.4.
+
+2003-01-21  Murray Cumming  <murrayc@usa.net>
+
+	* Changed library names: 1.0 -> 1.4 and 2.0 -> 2.4
+
+See gtkmm 2.2 for previous ChangeLog entries.
diff --git a/libs/gtkmm2/atk/SConscript b/libs/gtkmm2/atk/SConscript
new file mode 100644
index 0000000000..f0f18d4d12
--- /dev/null
+++ b/libs/gtkmm2/atk/SConscript
@@ -0,0 +1,10 @@
+import glob
+
+atkmm_files = glob.glob('atkmm/*.cc')
+
+Import('env libraries')
+atkmm = env.Copy()
+atkmm.Merge([libraries['glibmm2'], libraries['gtk2'], libraries['sigc2'] ])
+
+libatkmm = atkmm.StaticLibrary('atkmm', atkmm_files)
+Default(libatkmm)
diff --git a/libs/gtkmm2/atk/atkmm.h b/libs/gtkmm2/atk/atkmm.h
new file mode 100644
index 0000000000..712664344f
--- /dev/null
+++ b/libs/gtkmm2/atk/atkmm.h
@@ -0,0 +1,42 @@
+/* $Id$ */
+
+/* atkmm - a C++ wrapper for the GLib toolkit
+ *
+ * Copyright 2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#ifndef _ATKMM_H
+#define _ATKMM_H
+
+#include <atkmm/action.h>
+#include <atkmm/component.h>
+#include <atkmm/document.h>
+#include <atkmm/editabletext.h>
+#include <atkmm/image.h>
+#include <atkmm/implementor.h>
+#include <atkmm/object.h>
+#include <atkmm/objectaccessible.h>
+#include <atkmm/relation.h>
+#include <atkmm/relationset.h>
+#include <atkmm/selection.h>
+#include <atkmm/stateset.h>
+#include <atkmm/table.h>
+#include <atkmm/text.h>
+#include <atkmm/value.h>
+
+#endif /* _ATKMM_H */
+
diff --git a/libs/gtkmm2/atk/atkmm/action.cc b/libs/gtkmm2/atk/atkmm/action.cc
new file mode 100644
index 0000000000..69a260463c
--- /dev/null
+++ b/libs/gtkmm2/atk/atkmm/action.cc
@@ -0,0 +1,481 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <atkmm/action.h>
+#include <atkmm/private/action_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <atk/atkaction.h>
+
+
+namespace
+{
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Glib::RefPtr<Atk::Action> wrap(AtkAction* object, bool take_copy)
+{
+  return Glib::RefPtr<Atk::Action>( dynamic_cast<Atk::Action*> (Glib::wrap_auto ((GObject*)(object), take_copy)) );
+  //We use dynamic_cast<> in case of multiple inheritance.
+}
+
+} // namespace Glib
+
+
+namespace Atk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Interface_Class& Action_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Interface_Class has to know the interface init function
+    // in order to add interfaces to implementing types.
+    class_init_func_ = &Action_Class::iface_init_function;
+
+    // We can not derive from another interface, and it is not necessary anyway.
+    gtype_ = atk_action_get_type();
+  }
+
+  return *this;
+}
+
+void Action_Class::iface_init_function(void* g_iface, void*)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_iface);
+
+  //This is just to avoid an "unused variable" warning when there are no vfuncs or signal handlers to connect.
+  //This is a temporary fix until I find out why I can not seem to derive a GtkFileChooser interface. murrayc
+  g_assert(klass != 0); 
+
+  klass->do_action = &do_action_vfunc_callback;
+  klass->get_n_actions = &get_n_actions_vfunc_callback;
+  klass->get_description = &get_description_vfunc_callback;
+  klass->get_name = &get_name_vfunc_callback;
+  klass->get_keybinding = &get_keybinding_vfunc_callback;
+  klass->set_description = &set_description_vfunc_callback;
+}
+
+gboolean Action_Class::do_action_vfunc_callback(AtkAction* self, gint i)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return static_cast<int>(obj->do_action_vfunc(i
+));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->do_action)
+      return (*base->do_action)(self, i);
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+gint Action_Class::get_n_actions_vfunc_callback(AtkAction* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return obj->get_n_actions_vfunc();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->get_n_actions)
+      return (*base->get_n_actions)(self);
+  }
+
+  typedef gint RType;
+  return RType();
+}
+
+const gchar* Action_Class::get_description_vfunc_callback(AtkAction* self, gint i)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return obj->get_description_vfunc(i
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->get_description)
+      return (*base->get_description)(self, i);
+  }
+
+  typedef const gchar* RType;
+  return RType();
+}
+
+const gchar* Action_Class::get_name_vfunc_callback(AtkAction* self, gint i)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return obj->get_name_vfunc(i
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->get_name)
+      return (*base->get_name)(self, i);
+  }
+
+  typedef const gchar* RType;
+  return RType();
+}
+
+const gchar* Action_Class::get_keybinding_vfunc_callback(AtkAction* self, gint i)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return obj->get_keybinding_vfunc(i
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->get_keybinding)
+      return (*base->get_keybinding)(self, i);
+  }
+
+  typedef const gchar* RType;
+  return RType();
+}
+
+gboolean Action_Class::set_description_vfunc_callback(AtkAction* self, gint i, const gchar* desc)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return static_cast<int>(obj->set_description_vfunc(i
+, Glib::convert_const_gchar_ptr_to_ustring(desc)
+));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->set_description)
+      return (*base->set_description)(self, i, desc);
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+
+Glib::ObjectBase* Action_Class::wrap_new(GObject* object)
+{
+  return new Action((AtkAction*)(object));
+}
+
+
+/* The implementation: */
+
+Action::Action()
+:
+  Glib::Interface(action_class_.init())
+{}
+
+Action::Action(AtkAction* castitem)
+:
+  Glib::Interface((GObject*)(castitem))
+{}
+
+Action::~Action()
+{}
+
+// static
+void Action::add_interface(GType gtype_implementer)
+{
+  action_class_.init().add_interface(gtype_implementer);
+}
+
+Action::CppClassType Action::action_class_; // initialize static member
+
+GType Action::get_type()
+{
+  return action_class_.init().get_type();
+}
+
+GType Action::get_base_type()
+{
+  return atk_action_get_type();
+}
+
+
+bool Action::do_action(int i)
+{
+  return atk_action_do_action(gobj(), i);
+}
+
+int Action::get_n_actions() const
+{
+  return atk_action_get_n_actions(const_cast<AtkAction*>(gobj()));
+}
+
+Glib::ustring Action::get_description(int i) const
+{
+  return Glib::convert_const_gchar_ptr_to_ustring(atk_action_get_description(const_cast<AtkAction*>(gobj()), i));
+}
+
+Glib::ustring Action::get_name(int i) const
+{
+  return Glib::convert_const_gchar_ptr_to_ustring(atk_action_get_name(const_cast<AtkAction*>(gobj()), i));
+}
+
+Glib::ustring Action::get_keybinding(int i)
+{
+  return Glib::convert_const_gchar_ptr_to_ustring(atk_action_get_keybinding(gobj(), i));
+}
+
+bool Action::set_description(int i, const Glib::ustring& desc)
+{
+  return atk_action_set_description(gobj(), i, desc.c_str());
+}
+
+Glib::ustring Action::get_localized_name(int i)
+{
+  return Glib::convert_const_gchar_ptr_to_ustring(atk_action_get_localized_name(gobj(), i));
+}
+
+
+bool Atk::Action::do_action_vfunc(int i) 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->do_action)
+    return (*base->do_action)(gobj(),i);
+
+  typedef bool RType;
+  return RType();
+}
+
+int Atk::Action::get_n_actions_vfunc() const
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->get_n_actions)
+    return (*base->get_n_actions)(const_cast<AtkAction*>(gobj()));
+
+  typedef int RType;
+  return RType();
+}
+
+const char* Atk::Action::get_description_vfunc(int i) const
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->get_description)
+    return (*base->get_description)(const_cast<AtkAction*>(gobj()),i);
+
+  typedef const char* RType;
+  return RType();
+}
+
+const char* Atk::Action::get_name_vfunc(int i) const
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->get_name)
+    return (*base->get_name)(const_cast<AtkAction*>(gobj()),i);
+
+  typedef const char* RType;
+  return RType();
+}
+
+const char* Atk::Action::get_keybinding_vfunc(int i) const
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->get_keybinding)
+    return (*base->get_keybinding)(const_cast<AtkAction*>(gobj()),i);
+
+  typedef const char* RType;
+  return RType();
+}
+
+bool Atk::Action::set_description_vfunc(int i, const Glib::ustring& desc) 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->set_description)
+    return (*base->set_description)(gobj(),i,desc.c_str());
+
+  typedef bool RType;
+  return RType();
+}
+
+
+} // namespace Atk
+
+
diff --git a/libs/gtkmm2/atk/atkmm/action.h b/libs/gtkmm2/atk/atkmm/action.h
new file mode 100644
index 0000000000..af8a131378
--- /dev/null
+++ b/libs/gtkmm2/atk/atkmm/action.h
@@ -0,0 +1,193 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _ATKMM_ACTION_H
+#define _ATKMM_ACTION_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* Copyright (C) 2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+extern "C" { typedef struct _AtkActionIface AtkActionIface; }
+#endif
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _AtkAction AtkAction;
+typedef struct _AtkActionClass AtkActionClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Atk
+{ class Action_Class; } // namespace Atk
+namespace Atk
+{
+
+/** The ATK interface provided by UI components which the user can activate/interact with,
+ * This should be implemented by instances of Atk::Object classes with which the user can interact directly, i.e. buttons,
+ * checkboxes, scrollbars, e.g. components which are not "passive" providers of UI information.
+ *
+ * Exceptions: when the user interaction is already covered by another appropriate interface such as Atk::EditableText
+ * (insert/delete test, etc.) or Atk::Value (set value) then these actions should not be exposed by Atk::Action as well.
+ * 
+ * Also note that the Atk::Action API is limited in that parameters may not be passed to the object being activated;
+ * thus the action must be self-contained and specifiable via only a single "verb". Concrete examples include "press",
+ * "release", "click" for buttons, "drag" (meaning initiate drag) and "drop" for drag sources and drop targets, etc.
+ * 
+ * Though most UI interactions on components should be invocable via keyboard as well as mouse, there will generally be
+ * a close mapping between "mouse actions" that are possible on a component and the Atk::Actions. Where mouse and keyboard
+ * actions are redundant in effect, Atk::Action should expose only one action rather than exposing redundant actions if
+ * possible. By convention we have been using "mouse centric" terminology for Atk::Action names. 
+ */
+
+class Action : public Glib::Interface
+{
+  
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+public:
+  typedef Action CppObjectType;
+  typedef Action_Class CppClassType;
+  typedef AtkAction BaseObjectType;
+  typedef AtkActionIface BaseClassType;
+
+private:
+  friend class Action_Class;
+  static CppClassType action_class_;
+
+  // noncopyable
+  Action(const Action&);
+  Action& operator=(const Action&);
+
+protected:
+  Action(); // you must derive from this class
+  explicit Action(AtkAction* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+  virtual ~Action();
+
+  static void add_interface(GType gtype_implementer);
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GObject.
+  AtkAction*       gobj()       { return reinterpret_cast<AtkAction*>(gobject_); }
+
+  ///Provides access to the underlying C GObject.  
+  const AtkAction* gobj() const { return reinterpret_cast<AtkAction*>(gobject_); }
+
+private:
+
+
+public:
+
+  
+  /** Perform the specified action on the object.
+   * @param i The action index corresponding to the action to be performed.
+   * @return <tt>true</tt> if success, <tt>false</tt> otherwise.
+   */
+  bool do_action(int i);
+  
+  /** Gets the number of accessible actions available on the object.
+   * If there are more than one, the first one is considered the
+   * "default" action of the object.
+   * @return A the number of actions, or 0 if @a action  does not
+   * implement this interface.
+   */
+  int get_n_actions() const;
+  
+  /** Returns a description of the specified action of the object.
+   * @param i The action index corresponding to the action to be performed.
+   * @return A description string, or <tt>0</tt>
+   * if @a action  does not implement this interface.
+   */
+  Glib::ustring get_description(int i) const;
+  
+  /** Returns the name of the specified action of the object.
+   * @param i The action index corresponding to the action to be performed.
+   * @return A name string, or an empty string if @a action  does not implement this interface.
+   */
+  Glib::ustring get_name(int i) const;
+  
+  /** Returns a keybinding associated with this action, if one exists.
+   * @param i The action index corresponding to the action to be performed.
+   * @return A string representing the keybinding, or an empty string
+   * if there is no keybinding for this action.
+   */
+  Glib::ustring get_keybinding(int i);
+  
+  /** Sets a description of the specified action of the object.
+   * @param i The action index corresponding to the action to be performed.
+   * @param desc The description to be assigned to this action.
+   * @return A <tt>bool</tt> representing if the description was successfully set;.
+   */
+  bool set_description(int i, const Glib::ustring& desc);
+  
+  /** Returns the localized name of the specified action of the object.
+   * @param i The action index corresponding to the action to be performed.
+   * @return A name string, or an empty string
+   * if @a action  does not implement this interface.
+   */
+  Glib::ustring get_localized_name(int i);
+
+protected:
+    virtual bool do_action_vfunc(int i);
+    virtual int get_n_actions_vfunc() const;
+    virtual const char* get_description_vfunc(int i) const;
+    virtual const char* get_name_vfunc(int i) const;
+    virtual const char* get_keybinding_vfunc(int i) const;
+    virtual bool set_description_vfunc(int i, const Glib::ustring& desc);
+
+
+public:
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+};
+
+} // namespace Atk
+
+
+namespace Glib
+{
+  /** @relates Atk::Action
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Glib::RefPtr<Atk::Action> wrap(AtkAction* object, bool take_copy = false);
+
+} // namespace Glib
+
+#endif /* _ATKMM_ACTION_H */
+
diff --git a/libs/gtkmm2/atk/atkmm/component.cc b/libs/gtkmm2/atk/atkmm/component.cc
new file mode 100644
index 0000000000..c4256e7699
--- /dev/null
+++ b/libs/gtkmm2/atk/atkmm/component.cc
@@ -0,0 +1,892 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <atkmm/component.h>
+#include <atkmm/private/component_p.h>
+
+#include <atk/atk-enum-types.h>
+// -*- c++ -*-
+/* $Id$ */
+
+/* Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <atkmm/object.h>
+#include <atk/atkcomponent.h>
+
+
+namespace
+{
+} // anonymous namespace
+
+// static
+GType Glib::Value<Atk::CoordType>::value_type()
+{
+  return atk_coord_type_get_type();
+}
+
+// static
+GType Glib::Value<Atk::Layer>::value_type()
+{
+  return atk_layer_get_type();
+}
+
+
+namespace Glib
+{
+
+Glib::RefPtr<Atk::Component> wrap(AtkComponent* object, bool take_copy)
+{
+  return Glib::RefPtr<Atk::Component>( dynamic_cast<Atk::Component*> (Glib::wrap_auto ((GObject*)(object), take_copy)) );
+  //We use dynamic_cast<> in case of multiple inheritance.
+}
+
+} // namespace Glib
+
+
+namespace Atk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Interface_Class& Component_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Interface_Class has to know the interface init function
+    // in order to add interfaces to implementing types.
+    class_init_func_ = &Component_Class::iface_init_function;
+
+    // We can not derive from another interface, and it is not necessary anyway.
+    gtype_ = atk_component_get_type();
+  }
+
+  return *this;
+}
+
+void Component_Class::iface_init_function(void* g_iface, void*)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_iface);
+
+  //This is just to avoid an "unused variable" warning when there are no vfuncs or signal handlers to connect.
+  //This is a temporary fix until I find out why I can not seem to derive a GtkFileChooser interface. murrayc
+  g_assert(klass != 0); 
+
+  klass->add_focus_handler = &add_focus_handler_vfunc_callback;
+  klass->contains = &contains_vfunc_callback;
+  klass->ref_accessible_at_point = &ref_accessible_at_point_vfunc_callback;
+  klass->get_extents = &get_extents_vfunc_callback;
+  klass->get_position = &get_position_vfunc_callback;
+  klass->get_size = &get_size_vfunc_callback;
+  klass->get_layer = &get_layer_vfunc_callback;
+  klass->get_mdi_zorder = &get_mdi_zorder_vfunc_callback;
+  klass->grab_focus = &grab_focus_vfunc_callback;
+  klass->remove_focus_handler = &remove_focus_handler_vfunc_callback;
+  klass->set_extents = &set_extents_vfunc_callback;
+  klass->set_position = &set_position_vfunc_callback;
+  klass->set_size = &set_size_vfunc_callback;
+}
+
+guint Component_Class::add_focus_handler_vfunc_callback(AtkComponent* self, AtkFocusHandler handler)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return obj->add_focus_handler_vfunc(handler);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->add_focus_handler)
+      return (*base->add_focus_handler)(self, handler);
+  }
+
+  typedef guint RType;
+  return RType();
+}
+
+gboolean Component_Class::contains_vfunc_callback(AtkComponent* self, gint x, gint y, AtkCoordType coord_type)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return static_cast<int>(obj->contains_vfunc(x
+, y
+, ((CoordType)(coord_type))
+));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->contains)
+      return (*base->contains)(self, x, y, coord_type);
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+AtkObject* Component_Class::ref_accessible_at_point_vfunc_callback(AtkComponent* self, gint x, gint y, AtkCoordType coord_type)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return Glib::unwrap_copy(obj->get_accessible_at_point_vfunc(x
+, y
+, ((CoordType)(coord_type))
+));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->ref_accessible_at_point)
+      return (*base->ref_accessible_at_point)(self, x, y, coord_type);
+  }
+
+  typedef AtkObject* RType;
+  return RType();
+}
+
+void Component_Class::get_extents_vfunc_callback(AtkComponent* self, gint* x, gint* y, gint* width, gint* height, AtkCoordType coord_type)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->get_extents_vfunc(*(x)
+, *(y)
+, *(width)
+, *(height)
+, ((CoordType)(coord_type))
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->get_extents)
+      (*base->get_extents)(self, x, y, width, height, coord_type);
+  }
+}
+
+void Component_Class::get_position_vfunc_callback(AtkComponent* self, gint* x, gint* y, AtkCoordType coord_type)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->get_position_vfunc(*(x)
+, *(y)
+, ((CoordType)(coord_type))
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->get_position)
+      (*base->get_position)(self, x, y, coord_type);
+  }
+}
+
+void Component_Class::get_size_vfunc_callback(AtkComponent* self, gint* width, gint* height)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->get_size_vfunc(*(width)
+, *(height)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->get_size)
+      (*base->get_size)(self, width, height);
+  }
+}
+
+AtkLayer Component_Class::get_layer_vfunc_callback(AtkComponent* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return ((AtkLayer)(obj->get_layer_vfunc()));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->get_layer)
+      return (*base->get_layer)(self);
+  }
+
+  typedef AtkLayer RType;
+  return RType();
+}
+
+gint Component_Class::get_mdi_zorder_vfunc_callback(AtkComponent* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return obj->get_mdi_zorder_vfunc();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->get_mdi_zorder)
+      return (*base->get_mdi_zorder)(self);
+  }
+
+  typedef gint RType;
+  return RType();
+}
+
+gboolean Component_Class::grab_focus_vfunc_callback(AtkComponent* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return static_cast<int>(obj->grab_focus_vfunc());
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->grab_focus)
+      return (*base->grab_focus)(self);
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+void Component_Class::remove_focus_handler_vfunc_callback(AtkComponent* self, guint handler_id)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->remove_focus_handler_vfunc(handler_id);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->remove_focus_handler)
+      (*base->remove_focus_handler)(self, handler_id);
+  }
+}
+
+gboolean Component_Class::set_extents_vfunc_callback(AtkComponent* self, gint x, gint y, gint width, gint height, AtkCoordType coord_type)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return static_cast<int>(obj->set_extents_vfunc(x
+, y
+, width
+, height
+, ((CoordType)(coord_type))
+));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->set_extents)
+      return (*base->set_extents)(self, x, y, width, height, coord_type);
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+gboolean Component_Class::set_position_vfunc_callback(AtkComponent* self, gint x, gint y, AtkCoordType coord_type)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return static_cast<int>(obj->set_position_vfunc(x
+, y
+, ((CoordType)(coord_type))
+));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->set_position)
+      return (*base->set_position)(self, x, y, coord_type);
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+gboolean Component_Class::set_size_vfunc_callback(AtkComponent* self, gint width, gint height)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return static_cast<int>(obj->set_size_vfunc(width
+, height
+));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->set_size)
+      return (*base->set_size)(self, width, height);
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+
+Glib::ObjectBase* Component_Class::wrap_new(GObject* object)
+{
+  return new Component((AtkComponent*)(object));
+}
+
+
+/* The implementation: */
+
+Component::Component()
+:
+  Glib::Interface(component_class_.init())
+{}
+
+Component::Component(AtkComponent* castitem)
+:
+  Glib::Interface((GObject*)(castitem))
+{}
+
+Component::~Component()
+{}
+
+// static
+void Component::add_interface(GType gtype_implementer)
+{
+  component_class_.init().add_interface(gtype_implementer);
+}
+
+Component::CppClassType Component::component_class_; // initialize static member
+
+GType Component::get_type()
+{
+  return component_class_.init().get_type();
+}
+
+GType Component::get_base_type()
+{
+  return atk_component_get_type();
+}
+
+
+guint Component::add_focus_handler(AtkFocusHandler handler)
+{
+  return atk_component_add_focus_handler(gobj(), handler);
+}
+
+bool Component::contains(int x, int y, CoordType coord_type) const
+{
+  return atk_component_contains(const_cast<AtkComponent*>(gobj()), x, y, ((AtkCoordType)(coord_type)));
+}
+
+Glib::RefPtr<Atk::Object> Component::get_accessible_at_point(int x, int y, CoordType coord_type)
+{
+  return Glib::wrap(atk_component_ref_accessible_at_point(gobj(), x, y, ((AtkCoordType)(coord_type))));
+}
+
+void Component::get_extents(int& x, int& y, int& width, int& height, CoordType coord_type) const
+{
+  atk_component_get_extents(const_cast<AtkComponent*>(gobj()), &x, &y, &width, &height, ((AtkCoordType)(coord_type)));
+}
+
+void Component::get_position(int& x, int& y, CoordType coord_type) const
+{
+  atk_component_get_position(const_cast<AtkComponent*>(gobj()), &x, &y, ((AtkCoordType)(coord_type)));
+}
+
+void Component::get_size(int& width, int& height) const
+{
+  atk_component_get_size(const_cast<AtkComponent*>(gobj()), &width, &height);
+}
+
+Layer Component::get_layer() const
+{
+  return ((Layer)(atk_component_get_layer(const_cast<AtkComponent*>(gobj()))));
+}
+
+int Component::get_mdi_zorder() const
+{
+  return atk_component_get_mdi_zorder(const_cast<AtkComponent*>(gobj()));
+}
+
+bool Component::grab_focus()
+{
+  return atk_component_grab_focus(gobj());
+}
+
+void Component::remove_focus_handler(guint handler_id)
+{
+  atk_component_remove_focus_handler(gobj(), handler_id);
+}
+
+bool Component::set_extents(int x, int y, int width, int height, CoordType coord_type)
+{
+  return atk_component_set_extents(gobj(), x, y, width, height, ((AtkCoordType)(coord_type)));
+}
+
+bool Component::set_position(int x, int y, CoordType coord_type)
+{
+  return atk_component_set_position(gobj(), x, y, ((AtkCoordType)(coord_type)));
+}
+
+bool Component::set_size(int width, int height)
+{
+  return atk_component_set_size(gobj(), width, height);
+}
+
+
+guint Atk::Component::add_focus_handler_vfunc(AtkFocusHandler handler) 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->add_focus_handler)
+    return (*base->add_focus_handler)(gobj(),handler);
+
+  typedef guint RType;
+  return RType();
+}
+
+bool Atk::Component::contains_vfunc(int x, int y, CoordType coord_type) const
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->contains)
+    return (*base->contains)(const_cast<AtkComponent*>(gobj()),x,y,((AtkCoordType)(coord_type)));
+
+  typedef bool RType;
+  return RType();
+}
+
+Glib::RefPtr<Atk::Object> Atk::Component::get_accessible_at_point_vfunc(int x, int y, CoordType coord_type) 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->ref_accessible_at_point)
+    return Glib::wrap((*base->ref_accessible_at_point)(gobj(),x,y,((AtkCoordType)(coord_type))));
+
+  typedef Glib::RefPtr<Atk::Object> RType;
+  return RType();
+}
+
+void Atk::Component::get_extents_vfunc(int& x, int& y, int& width, int& height, CoordType coord_type) const
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->get_extents)
+    (*base->get_extents)(const_cast<AtkComponent*>(gobj()),&x,&y,&width,&height,((AtkCoordType)(coord_type)));
+}
+
+void Atk::Component::get_position_vfunc(int& x, int& y, CoordType coord_type) const
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->get_position)
+    (*base->get_position)(const_cast<AtkComponent*>(gobj()),&x,&y,((AtkCoordType)(coord_type)));
+}
+
+void Atk::Component::get_size_vfunc(int& width, int& height) const
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->get_size)
+    (*base->get_size)(const_cast<AtkComponent*>(gobj()),&width,&height);
+}
+
+Layer Atk::Component::get_layer_vfunc() const
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->get_layer)
+    return ((Layer)((*base->get_layer)(const_cast<AtkComponent*>(gobj()))));
+
+  typedef Layer RType;
+  return RType();
+}
+
+int Atk::Component::get_mdi_zorder_vfunc() const
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->get_mdi_zorder)
+    return (*base->get_mdi_zorder)(const_cast<AtkComponent*>(gobj()));
+
+  typedef int RType;
+  return RType();
+}
+
+bool Atk::Component::grab_focus_vfunc() 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->grab_focus)
+    return (*base->grab_focus)(gobj());
+
+  typedef bool RType;
+  return RType();
+}
+
+void Atk::Component::remove_focus_handler_vfunc(guint handler_id) 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->remove_focus_handler)
+    (*base->remove_focus_handler)(gobj(),handler_id);
+}
+
+bool Atk::Component::set_extents_vfunc(int x, int y, int width, int height, CoordType coord_type) 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->set_extents)
+    return (*base->set_extents)(gobj(),x,y,width,height,((AtkCoordType)(coord_type)));
+
+  typedef bool RType;
+  return RType();
+}
+
+bool Atk::Component::set_position_vfunc(int x, int y, CoordType coord_type) 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->set_position)
+    return (*base->set_position)(gobj(),x,y,((AtkCoordType)(coord_type)));
+
+  typedef bool RType;
+  return RType();
+}
+
+bool Atk::Component::set_size_vfunc(int width, int height) 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->set_size)
+    return (*base->set_size)(gobj(),width,height);
+
+  typedef bool RType;
+  return RType();
+}
+
+
+} // namespace Atk
+
+
diff --git a/libs/gtkmm2/atk/atkmm/component.h b/libs/gtkmm2/atk/atkmm/component.h
new file mode 100644
index 0000000000..889d626dae
--- /dev/null
+++ b/libs/gtkmm2/atk/atkmm/component.h
@@ -0,0 +1,331 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _ATKMM_COMPONENT_H
+#define _ATKMM_COMPONENT_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* Copyright (C) 2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+extern "C"
+{
+  typedef struct _AtkComponentIface AtkComponentIface;
+  typedef struct _AtkObject         AtkObject;
+  typedef void (* AtkFocusHandler) (AtkObject*, gboolean);
+}
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _AtkComponent AtkComponent;
+typedef struct _AtkComponentClass AtkComponentClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Atk
+{ class Component_Class; } // namespace Atk
+namespace Atk
+{
+
+
+/** @addtogroup atkmmEnums Enums and Flags */
+
+/**
+ * @ingroup atkmmEnums
+ */
+enum CoordType
+{
+  XY_SCREEN,
+  XY_WINDOW
+};
+
+} // namespace Atk
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Atk::CoordType> : public Glib::Value_Enum<Atk::CoordType>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Atk
+{
+
+/**
+ * @ingroup atkmmEnums
+ */
+enum Layer
+{
+  LAYER_INVALID,
+  LAYER_BACKGROUND,
+  LAYER_CANVAS,
+  LAYER_WIDGET,
+  LAYER_MDI,
+  LAYER_POPUP,
+  LAYER_OVERLAY,
+  LAYER_WINDOW
+};
+
+} // namespace Atk
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Atk::Layer> : public Glib::Value_Enum<Atk::Layer>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Atk
+{
+
+
+class Object;
+
+
+/** The ATK interface provided by UI components which occupy a physical area on the screen.
+ * This should be implemented by most if not all UI elements with an actual on-screen presence, i.e. components which
+ * can be said to have a screen-coordinate bounding box. Virtually all widgets will need to have Atk::Component
+ * implementations provided for their corresponding Atk::Object class. In short, only UI elements which are *not* GUI
+ * elements will omit this ATK interface.
+ * 
+ * A possible exception might be textual information with a transparent background, in which case text glyph bounding
+ * box information is provided by Atk::Text.
+ */
+
+class Component : public Glib::Interface
+{
+  
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+public:
+  typedef Component CppObjectType;
+  typedef Component_Class CppClassType;
+  typedef AtkComponent BaseObjectType;
+  typedef AtkComponentIface BaseClassType;
+
+private:
+  friend class Component_Class;
+  static CppClassType component_class_;
+
+  // noncopyable
+  Component(const Component&);
+  Component& operator=(const Component&);
+
+protected:
+  Component(); // you must derive from this class
+  explicit Component(AtkComponent* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+  virtual ~Component();
+
+  static void add_interface(GType gtype_implementer);
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GObject.
+  AtkComponent*       gobj()       { return reinterpret_cast<AtkComponent*>(gobject_); }
+
+  ///Provides access to the underlying C GObject.  
+  const AtkComponent* gobj() const { return reinterpret_cast<AtkComponent*>(gobject_); }
+
+private:
+
+  
+public:
+  
+  /** Add the specified handler to the set of functions to be called 
+   * when this object receives focus events (in or out). If the handler is
+   * already added it is not added again
+   * @param handler The Atk::FocusHandler to be attached to @a component .
+   * @return A handler id which can be used in atk_component_remove_focus_handler
+   * or zero if the handler was already added.
+   */
+  guint add_focus_handler(AtkFocusHandler handler);
+  
+  /** Checks whether the specified point is within the extent of the @a component .
+   * @param x X coordinate.
+   * @param y Y coordinate.
+   * @param coord_type Specifies whether the coordinates are relative to the screen
+   * or to the components top level window.
+   * @return <tt>true</tt> or <tt>false</tt> indicating whether the specified point is within
+   * the extent of the @a component  or not.
+   */
+  bool contains(int x, int y, CoordType coord_type) const;
+  
+  /** Gets a reference to the accessible child, if one exists, at the
+   * coordinate point specified by @a x  and @a y .
+   * @param x X coordinate.
+   * @param y Y coordinate.
+   * @param coord_type Specifies whether the coordinates are relative to the screen
+   * or to the components top level window.
+   * @return A reference to the accessible child, if one exists.
+   */
+  Glib::RefPtr<Atk::Object> get_accessible_at_point(int x, int y, CoordType coord_type);
+  
+  /** Gets the rectangle which gives the extent of the @a component .
+   * @param x Address of <tt>int</tt> to put x coordinate.
+   * @param y Address of <tt>int</tt> to put y coordinate.
+   * @param width Address of <tt>int</tt> to put width.
+   * @param height Address of <tt>int</tt> to put height.
+   * @param coord_type Specifies whether the coordinates are relative to the screen
+   * or to the components top level window.
+   */
+  void get_extents(int& x, int& y, int& width, int& height, CoordType coord_type) const;
+  
+  /** Gets the position of @a component  in the form of 
+   * a point specifying @a component 's top-left corner.
+   * @param x Address of <tt>int</tt> to put x coordinate position.
+   * @param y Address of <tt>int</tt> to put y coordinate position.
+   * @param coord_type Specifies whether the coordinates are relative to the screen
+   * or to the components top level window.
+   */
+  void get_position(int& x, int& y, CoordType coord_type) const;
+  
+  /** Gets the size of the @a component  in terms of width and height.
+   * @param width Address of <tt>int</tt> to put width of @a component .
+   * @param height Address of <tt>int</tt> to put height of @a component .
+   */
+  void get_size(int& width, int& height) const;
+  
+  /** Gets the layer of the component.
+   * @return An Atk::Layer which is the layer of the component.
+   */
+  Layer get_layer() const;
+  
+  /** Gets the zorder of the component. The value G_MININT will be returned 
+   * if the layer of the component is not ATK_LAYER_MDI or ATK_LAYER_WINDOW.
+   * @return A <tt>int</tt> which is the zorder of the component, i.e. the depth at 
+   * which the component is shown in relation to other components in the same 
+   * container.
+   */
+  int get_mdi_zorder() const;
+  
+  /** Grabs focus for this @a component .
+   * @return <tt>true</tt> if successful, <tt>false</tt> otherwise.
+   */
+  bool grab_focus();
+  
+  /** Remove the handler specified by @a handler_id  from the list of
+   * functions to be executed when this object receives focus events 
+   * (in or out).
+   * @param handler_id The handler id of the focus handler to be removed
+   * from @a component .
+   */
+  void remove_focus_handler(guint handler_id);
+  
+  /** Sets the extents of @a component .
+   * @param x X coordinate.
+   * @param y Y coordinate.
+   * @param width Width to set for @a component .
+   * @param height Height to set for @a component .
+   * @param coord_type Specifies whether the coordinates are relative to the screen
+   * or to the components top level window.
+   * @return <tt>true</tt> or <tt>false</tt> whether the extents were set or not.
+   */
+  bool set_extents(int x, int y, int width, int height, CoordType coord_type);
+  
+  /** Sets the postition of @a component .
+   * @param x X coordinate.
+   * @param y Y coordinate.
+   * @param coord_type Specifies whether the coordinates are relative to the screen
+   * or to the components top level window.
+   * @return <tt>true</tt> or <tt>false</tt> whether or not the position was set or not.
+   */
+  bool set_position(int x, int y, CoordType coord_type);
+  
+  /** Set the size of the @a component  in terms of width and height.
+   * @param width Width to set for @a component .
+   * @param height Height to set for @a component .
+   * @return <tt>true</tt> or <tt>false</tt> whether the size was set or not.
+   */
+  bool set_size(int width, int height);
+
+protected:
+    virtual guint add_focus_handler_vfunc(AtkFocusHandler handler);
+    virtual bool contains_vfunc(int x, int y, CoordType coord_type) const;
+
+    virtual Glib::RefPtr<Atk::Object> get_accessible_at_point_vfunc(int x, int y, CoordType coord_type);
+
+    virtual void get_extents_vfunc(int& x, int& y, int& width, int& height, CoordType coord_type) const;
+    virtual void get_position_vfunc(int& x, int& y, CoordType coord_type) const;
+    virtual void get_size_vfunc(int& width, int& height) const;
+    virtual Layer get_layer_vfunc() const;
+    virtual int get_mdi_zorder_vfunc() const;
+    virtual bool grab_focus_vfunc();
+    virtual void remove_focus_handler_vfunc(guint handler_id);
+    virtual bool set_extents_vfunc(int x, int y, int width, int height, CoordType coord_type);
+    virtual bool set_position_vfunc(int x, int y, CoordType coord_type);
+    virtual bool set_size_vfunc(int width, int height);
+
+
+public:
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+};
+
+} // namespace Atk
+
+
+namespace Glib
+{
+  /** @relates Atk::Component
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Glib::RefPtr<Atk::Component> wrap(AtkComponent* object, bool take_copy = false);
+
+} // namespace Glib
+
+#endif /* _ATKMM_COMPONENT_H */
+
diff --git a/libs/gtkmm2/atk/atkmm/document.cc b/libs/gtkmm2/atk/atkmm/document.cc
new file mode 100644
index 0000000000..64946c6f84
--- /dev/null
+++ b/libs/gtkmm2/atk/atkmm/document.cc
@@ -0,0 +1,246 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <atkmm/document.h>
+#include <atkmm/private/document_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* Copyright 2003 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <atkmm/object.h>
+#include <atk/atkdocument.h>
+
+
+namespace Atk
+{
+
+
+} // namespace Atk
+
+
+namespace
+{
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Glib::RefPtr<Atk::Document> wrap(AtkDocument* object, bool take_copy)
+{
+  return Glib::RefPtr<Atk::Document>( dynamic_cast<Atk::Document*> (Glib::wrap_auto ((GObject*)(object), take_copy)) );
+  //We use dynamic_cast<> in case of multiple inheritance.
+}
+
+} // namespace Glib
+
+
+namespace Atk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Interface_Class& Document_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Interface_Class has to know the interface init function
+    // in order to add interfaces to implementing types.
+    class_init_func_ = &Document_Class::iface_init_function;
+
+    // We can not derive from another interface, and it is not necessary anyway.
+    gtype_ = atk_document_get_type();
+  }
+
+  return *this;
+}
+
+void Document_Class::iface_init_function(void* g_iface, void*)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_iface);
+
+  //This is just to avoid an "unused variable" warning when there are no vfuncs or signal handlers to connect.
+  //This is a temporary fix until I find out why I can not seem to derive a GtkFileChooser interface. murrayc
+  g_assert(klass != 0); 
+
+  klass->get_document_type = &get_document_type_vfunc_callback;
+  klass->get_document = &get_document_vfunc_callback;
+}
+
+const gchar* Document_Class::get_document_type_vfunc_callback(AtkDocument* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return obj->get_document_type_vfunc();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->get_document_type)
+      return (*base->get_document_type)(self);
+  }
+
+  typedef const gchar* RType;
+  return RType();
+}
+
+gpointer Document_Class::get_document_vfunc_callback(AtkDocument* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return obj->get_document_vfunc();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->get_document)
+      return (*base->get_document)(self);
+  }
+
+  typedef gpointer RType;
+  return RType();
+}
+
+
+Glib::ObjectBase* Document_Class::wrap_new(GObject* object)
+{
+  return new Document((AtkDocument*)(object));
+}
+
+
+/* The implementation: */
+
+Document::Document()
+:
+  Glib::Interface(document_class_.init())
+{}
+
+Document::Document(AtkDocument* castitem)
+:
+  Glib::Interface((GObject*)(castitem))
+{}
+
+Document::~Document()
+{}
+
+// static
+void Document::add_interface(GType gtype_implementer)
+{
+  document_class_.init().add_interface(gtype_implementer);
+}
+
+Document::CppClassType Document::document_class_; // initialize static member
+
+GType Document::get_type()
+{
+  return document_class_.init().get_type();
+}
+
+GType Document::get_base_type()
+{
+  return atk_document_get_type();
+}
+
+
+Glib::ustring Document::get_document_type() const
+{
+  return Glib::convert_const_gchar_ptr_to_ustring(atk_document_get_document_type(const_cast<AtkDocument*>(gobj())));
+}
+
+gpointer Document::get_document()
+{
+  return atk_document_get_document(gobj());
+}
+
+
+const gchar* Atk::Document::get_document_type_vfunc() 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->get_document_type)
+    return (*base->get_document_type)(gobj());
+
+  typedef const gchar* RType;
+  return RType();
+}
+
+gpointer Atk::Document::get_document_vfunc() const
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->get_document)
+    return (*base->get_document)(const_cast<AtkDocument*>(gobj()));
+
+  typedef gpointer RType;
+  return RType();
+}
+
+
+} // namespace Atk
+
+
diff --git a/libs/gtkmm2/atk/atkmm/document.h b/libs/gtkmm2/atk/atkmm/document.h
new file mode 100644
index 0000000000..71808475c3
--- /dev/null
+++ b/libs/gtkmm2/atk/atkmm/document.h
@@ -0,0 +1,145 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _ATKMM_DOCUMENT_H
+#define _ATKMM_DOCUMENT_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* Copyright (C) 2003 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+extern "C"
+{
+  typedef struct _AtkDocumentIface AtkDocumentIface;
+  typedef struct _AtkDocument      AtkDocument;
+}
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _AtkDocument AtkDocument;
+typedef struct _AtkDocumentClass AtkDocumentClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Atk
+{ class Document_Class; } // namespace Atk
+namespace Atk
+{
+
+class Object;
+
+/** The ATK interface which allows access to a DOM associated with on object.
+ * This interface should be supported by any object that has an associated document object model (DOM). This interface
+ * provides the standard mechanism allowing an assistive technology access to the DOM.
+ */
+
+class Document : public Glib::Interface
+{
+  
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+public:
+  typedef Document CppObjectType;
+  typedef Document_Class CppClassType;
+  typedef AtkDocument BaseObjectType;
+  typedef AtkDocumentIface BaseClassType;
+
+private:
+  friend class Document_Class;
+  static CppClassType document_class_;
+
+  // noncopyable
+  Document(const Document&);
+  Document& operator=(const Document&);
+
+protected:
+  Document(); // you must derive from this class
+  explicit Document(AtkDocument* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+  virtual ~Document();
+
+  static void add_interface(GType gtype_implementer);
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GObject.
+  AtkDocument*       gobj()       { return reinterpret_cast<AtkDocument*>(gobject_); }
+
+  ///Provides access to the underlying C GObject.  
+  const AtkDocument* gobj() const { return reinterpret_cast<AtkDocument*>(gobject_); }
+
+private:
+
+public:
+
+  
+  /** Gets a string indicating the document type.
+   * @return A string indicating the document type.
+   */
+  Glib::ustring get_document_type() const;
+  
+  /** Gets a %gpointer that points to an instance of the DOM.  It is
+   * up to the caller to check atk_document_get_type to determine
+   * how to cast this pointer.
+   * @return A %gpointer that points to an instance of the DOM.
+   */
+  gpointer get_document();
+
+protected:
+    virtual const gchar* get_document_type_vfunc();
+    virtual gpointer get_document_vfunc() const;
+
+
+public:
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+};
+
+} // namespace Atk
+
+
+namespace Glib
+{
+  /** @relates Atk::Document
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Glib::RefPtr<Atk::Document> wrap(AtkDocument* object, bool take_copy = false);
+
+} // namespace Glib
+
+#endif /* _ATKMM_DOCUMENT_H */
+
diff --git a/libs/gtkmm2/atk/atkmm/editabletext.cc b/libs/gtkmm2/atk/atkmm/editabletext.cc
new file mode 100644
index 0000000000..10e58003b7
--- /dev/null
+++ b/libs/gtkmm2/atk/atkmm/editabletext.cc
@@ -0,0 +1,506 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <atkmm/editabletext.h>
+#include <atkmm/private/editabletext_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <atkmm/object.h>
+#include <atk/atkeditabletext.h>
+
+
+namespace
+{
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Glib::RefPtr<Atk::EditableText> wrap(AtkEditableText* object, bool take_copy)
+{
+  return Glib::RefPtr<Atk::EditableText>( dynamic_cast<Atk::EditableText*> (Glib::wrap_auto ((GObject*)(object), take_copy)) );
+  //We use dynamic_cast<> in case of multiple inheritance.
+}
+
+} // namespace Glib
+
+
+namespace Atk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Interface_Class& EditableText_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Interface_Class has to know the interface init function
+    // in order to add interfaces to implementing types.
+    class_init_func_ = &EditableText_Class::iface_init_function;
+
+    // We can not derive from another interface, and it is not necessary anyway.
+    gtype_ = atk_editable_text_get_type();
+  }
+
+  return *this;
+}
+
+void EditableText_Class::iface_init_function(void* g_iface, void*)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_iface);
+
+  //This is just to avoid an "unused variable" warning when there are no vfuncs or signal handlers to connect.
+  //This is a temporary fix until I find out why I can not seem to derive a GtkFileChooser interface. murrayc
+  g_assert(klass != 0); 
+
+  klass->set_run_attributes = &set_run_attributes_vfunc_callback;
+  klass->set_text_contents = &set_text_contents_vfunc_callback;
+  klass->insert_text = &insert_text_vfunc_callback;
+  klass->copy_text = &copy_text_vfunc_callback;
+  klass->cut_text = &cut_text_vfunc_callback;
+  klass->delete_text = &delete_text_vfunc_callback;
+  klass->paste_text = &paste_text_vfunc_callback;
+}
+
+gboolean EditableText_Class::set_run_attributes_vfunc_callback(AtkEditableText* self, AtkAttributeSet* attrib_set, gint start_offset, gint end_offset)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return static_cast<int>(obj->set_run_attributes_vfunc(attrib_set, start_offset
+, end_offset
+));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->set_run_attributes)
+      return (*base->set_run_attributes)(self, attrib_set, start_offset, end_offset);
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+void EditableText_Class::set_text_contents_vfunc_callback(AtkEditableText* self, const gchar* string)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->set_text_contents_vfunc(Glib::convert_const_gchar_ptr_to_ustring(string)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->set_text_contents)
+      (*base->set_text_contents)(self, string);
+  }
+}
+
+void EditableText_Class::insert_text_vfunc_callback(AtkEditableText* self, const gchar* string, gint length, gint* position)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->insert_text_vfunc(Glib::convert_const_gchar_ptr_to_ustring(string)
+, length
+, *(position)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->insert_text)
+      (*base->insert_text)(self, string, length, position);
+  }
+}
+
+void EditableText_Class::copy_text_vfunc_callback(AtkEditableText* self, gint start_pos, gint end_pos)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->copy_text_vfunc(start_pos
+, end_pos
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->copy_text)
+      (*base->copy_text)(self, start_pos, end_pos);
+  }
+}
+
+void EditableText_Class::cut_text_vfunc_callback(AtkEditableText* self, gint start_pos, gint end_pos)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->cut_text_vfunc(start_pos
+, end_pos
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->cut_text)
+      (*base->cut_text)(self, start_pos, end_pos);
+  }
+}
+
+void EditableText_Class::delete_text_vfunc_callback(AtkEditableText* self, gint start_pos, gint end_pos)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->delete_text_vfunc(start_pos
+, end_pos
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->delete_text)
+      (*base->delete_text)(self, start_pos, end_pos);
+  }
+}
+
+void EditableText_Class::paste_text_vfunc_callback(AtkEditableText* self, gint position)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->paste_text_vfunc(position
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->paste_text)
+      (*base->paste_text)(self, position);
+  }
+}
+
+
+Glib::ObjectBase* EditableText_Class::wrap_new(GObject* object)
+{
+  return new EditableText((AtkEditableText*)(object));
+}
+
+
+/* The implementation: */
+
+EditableText::EditableText()
+:
+  Glib::Interface(editabletext_class_.init())
+{}
+
+EditableText::EditableText(AtkEditableText* castitem)
+:
+  Glib::Interface((GObject*)(castitem))
+{}
+
+EditableText::~EditableText()
+{}
+
+// static
+void EditableText::add_interface(GType gtype_implementer)
+{
+  editabletext_class_.init().add_interface(gtype_implementer);
+}
+
+EditableText::CppClassType EditableText::editabletext_class_; // initialize static member
+
+GType EditableText::get_type()
+{
+  return editabletext_class_.init().get_type();
+}
+
+GType EditableText::get_base_type()
+{
+  return atk_editable_text_get_type();
+}
+
+
+bool EditableText::set_run_attributes(const AttributeSet& attrib_set, int start_offset, int end_offset)
+{
+  return atk_editable_text_set_run_attributes(gobj(), (attrib_set).data(), start_offset, end_offset);
+}
+
+void EditableText::set_text_contents(const Glib::ustring& string)
+{
+  atk_editable_text_set_text_contents(gobj(), string.c_str());
+}
+
+void EditableText::insert_text(const Glib::ustring& string, int length, int& position)
+{
+  atk_editable_text_insert_text(gobj(), string.c_str(), length, &position);
+}
+
+void EditableText::copy_text(int start_pos, int end_pos)
+{
+  atk_editable_text_copy_text(gobj(), start_pos, end_pos);
+}
+
+void EditableText::cut_text(int start_pos, int end_pos)
+{
+  atk_editable_text_cut_text(gobj(), start_pos, end_pos);
+}
+
+void EditableText::delete_text(int start_pos, int end_pos)
+{
+  atk_editable_text_delete_text(gobj(), start_pos, end_pos);
+}
+
+void EditableText::paste_text(int position)
+{
+  atk_editable_text_paste_text(gobj(), position);
+}
+
+
+bool Atk::EditableText::set_run_attributes_vfunc(AtkAttributeSet* attrib_set, int start_offset, int end_offset) 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->set_run_attributes)
+    return (*base->set_run_attributes)(gobj(),attrib_set,start_offset,end_offset);
+
+  typedef bool RType;
+  return RType();
+}
+
+void Atk::EditableText::set_text_contents_vfunc(const Glib::ustring& string) 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->set_text_contents)
+    (*base->set_text_contents)(gobj(),string.c_str());
+}
+
+void Atk::EditableText::insert_text_vfunc(const Glib::ustring& string, int length, int& position) 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->insert_text)
+    (*base->insert_text)(gobj(),string.c_str(),length,&position);
+}
+
+void Atk::EditableText::copy_text_vfunc(int start_pos, int end_pos) 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->copy_text)
+    (*base->copy_text)(gobj(),start_pos,end_pos);
+}
+
+void Atk::EditableText::cut_text_vfunc(int start_pos, int end_pos) 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->cut_text)
+    (*base->cut_text)(gobj(),start_pos,end_pos);
+}
+
+void Atk::EditableText::delete_text_vfunc(int start_pos, int end_pos) 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->delete_text)
+    (*base->delete_text)(gobj(),start_pos,end_pos);
+}
+
+void Atk::EditableText::paste_text_vfunc(int position) 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->paste_text)
+    (*base->paste_text)(gobj(),position);
+}
+
+
+} // namespace Atk
+
+
diff --git a/libs/gtkmm2/atk/atkmm/editabletext.h b/libs/gtkmm2/atk/atkmm/editabletext.h
new file mode 100644
index 0000000000..233aa9e892
--- /dev/null
+++ b/libs/gtkmm2/atk/atkmm/editabletext.h
@@ -0,0 +1,193 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _ATKMM_EDITABLETEXT_H
+#define _ATKMM_EDITABLETEXT_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* Copyright (C) 2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+
+#include <atkmm/text.h>
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+extern "C"
+{
+  typedef struct _AtkEditableTextIface AtkEditableTextIface;
+  typedef struct _AtkEditableText      AtkEditableText;
+}
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _AtkEditableText AtkEditableText;
+typedef struct _AtkEditableTextClass AtkEditableTextClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Atk
+{ class EditableText_Class; } // namespace Atk
+namespace Atk
+{
+
+//TODO: I see no evidence that AtkEditableText is actually a subclass of AtkText, as the C docs say. murrayc.
+/* The ATK interface implemented by components containing user-editable text content.
+ * This should be implemented by UI components which contain text which the user can edit, via the Atk::Object
+ * corresponding to that component (see Atk::Object).
+ * EditableText is a subclass of AtkText, and as such, an object which implements EditableText is by definition
+ * an Atk::Text implementor as well. 
+ */
+
+class EditableText : public Glib::Interface
+{
+  
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+public:
+  typedef EditableText CppObjectType;
+  typedef EditableText_Class CppClassType;
+  typedef AtkEditableText BaseObjectType;
+  typedef AtkEditableTextIface BaseClassType;
+
+private:
+  friend class EditableText_Class;
+  static CppClassType editabletext_class_;
+
+  // noncopyable
+  EditableText(const EditableText&);
+  EditableText& operator=(const EditableText&);
+
+protected:
+  EditableText(); // you must derive from this class
+  explicit EditableText(AtkEditableText* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+  virtual ~EditableText();
+
+  static void add_interface(GType gtype_implementer);
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GObject.
+  AtkEditableText*       gobj()       { return reinterpret_cast<AtkEditableText*>(gobject_); }
+
+  ///Provides access to the underlying C GObject.  
+  const AtkEditableText* gobj() const { return reinterpret_cast<AtkEditableText*>(gobject_); }
+
+private:
+
+
+public:
+  
+  /** Sets the attributes for a specified range. See the ATK_ATTRIBUTE
+   * macros (such as Atk::ATTRIBUTE_LEFT_MARGIN) for examples of attributes 
+   * that can be set. Note that other attributes that do not have corresponding
+   * ATK_ATTRIBUTE macros may also be set for certain text widgets.
+   * @param attrib_set An Atk::AttributeSet.
+   * @param start_offset Start of range in which to set attributes.
+   * @param end_offset End of range in which to set attributes.
+   * @return <tt>true</tt> if attributes successfully set for the specified
+   * range, otherwise <tt>false</tt>.
+   */
+  bool set_run_attributes(const AttributeSet& attrib_set, int start_offset, int end_offset);
+  
+  /** Set text contents of @a text .
+   * @param string String to set for text contents of @a text .
+   */
+  void set_text_contents(const Glib::ustring& string);
+  
+  /** Insert text at a given position.
+   * @param string The text to insert.
+   * @param length The length of text to insert, in bytes.
+   * @param position The caller initializes this to 
+   * the position at which to insert the text. After the call it
+   * points at the position after the newly inserted text.
+   */
+  void insert_text(const Glib::ustring& string, int length, int& position);
+  
+  /** Copy text from @a start_pos  up to, but not including @a end_pos  
+   * to the clipboard.
+   * @param start_pos Start position.
+   * @param end_pos End position.
+   */
+  void copy_text(int start_pos, int end_pos);
+  
+  /** Copy text from @a start_pos  up to, but not including @a end_pos 
+   * to the clipboard and then delete from the widget.
+   * @param start_pos Start position.
+   * @param end_pos End position.
+   */
+  void cut_text(int start_pos, int end_pos);
+  
+  /** Delete text @a start_pos  up to, but not including @a end_pos .
+   * @param start_pos Start position.
+   * @param end_pos End position.
+   */
+  void delete_text(int start_pos, int end_pos);
+  
+  /** Paste text from clipboard to specified @a position .
+   * @param position Position to paste.
+   */
+  void paste_text(int position);
+
+protected:
+    virtual bool set_run_attributes_vfunc(AtkAttributeSet* attrib_set, int start_offset, int end_offset);
+    virtual void set_text_contents_vfunc(const Glib::ustring& string);
+    virtual void insert_text_vfunc(const Glib::ustring& string, int length, int& position);
+    virtual void copy_text_vfunc(int start_pos, int end_pos);
+    virtual void cut_text_vfunc(int start_pos, int end_pos);
+    virtual void delete_text_vfunc(int start_pos, int end_pos);
+    virtual void paste_text_vfunc(int position);
+
+
+public:
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+};
+
+} // namespace Atk
+
+
+namespace Glib
+{
+  /** @relates Atk::EditableText
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Glib::RefPtr<Atk::EditableText> wrap(AtkEditableText* object, bool take_copy = false);
+
+} // namespace Glib
+
+#endif /* _ATKMM_EDITABLETEXT_H */
+
diff --git a/libs/gtkmm2/atk/atkmm/hyperlink.cc b/libs/gtkmm2/atk/atkmm/hyperlink.cc
new file mode 100644
index 0000000000..d9e1050a7b
--- /dev/null
+++ b/libs/gtkmm2/atk/atkmm/hyperlink.cc
@@ -0,0 +1,681 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <atkmm/hyperlink.h>
+#include <atkmm/private/hyperlink_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* Copyright 2003 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <atkmm/object.h>
+#include <atk/atkobject.h>
+#include <atk/atkhyperlink.h>
+
+
+namespace Atk
+{
+
+} // namespace Atk
+
+
+namespace
+{
+
+const Glib::SignalProxyInfo Hyperlink_signal_link_activated_info =
+{
+  "link_activated",
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
+};
+
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Glib::RefPtr<Atk::Hyperlink> wrap(AtkHyperlink* object, bool take_copy)
+{
+  return Glib::RefPtr<Atk::Hyperlink>( dynamic_cast<Atk::Hyperlink*> (Glib::wrap_auto ((GObject*)(object), take_copy)) );
+  //We use dynamic_cast<> in case of multiple inheritance.
+}
+
+} /* namespace Glib */
+
+
+namespace Atk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& Hyperlink_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &Hyperlink_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(atk_hyperlink_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  Action::add_interface(get_type());
+  }
+
+  return *this;
+}
+
+void Hyperlink_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+  klass->get_uri = &get_uri_vfunc_callback;
+  klass->get_object = &get_object_vfunc_callback;
+  klass->get_end_index = &get_end_index_vfunc_callback;
+  klass->get_start_index = &get_start_index_vfunc_callback;
+  klass->is_valid = &is_valid_vfunc_callback;
+  klass->get_n_anchors = &get_n_anchors_vfunc_callback;
+  klass->link_state = &link_state_vfunc_callback;
+  klass->is_selected_link = &is_selected_link_vfunc_callback;
+  klass->link_activated = &link_activated_callback;
+}
+
+gchar* Hyperlink_Class::get_uri_vfunc_callback(AtkHyperlink* self, gint i)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return obj->get_uri_vfunc(i
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->get_uri)
+      return (*base->get_uri)(self, i);
+  }
+
+  typedef gchar* RType;
+  return RType();
+}
+
+AtkObject* Hyperlink_Class::get_object_vfunc_callback(AtkHyperlink* self, gint i)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return Glib::unwrap(obj->get_object_vfunc(i
+));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->get_object)
+      return (*base->get_object)(self, i);
+  }
+
+  typedef AtkObject* RType;
+  return RType();
+}
+
+gint Hyperlink_Class::get_end_index_vfunc_callback(AtkHyperlink* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return obj->get_end_index_vfunc();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->get_end_index)
+      return (*base->get_end_index)(self);
+  }
+
+  typedef gint RType;
+  return RType();
+}
+
+gint Hyperlink_Class::get_start_index_vfunc_callback(AtkHyperlink* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return obj->get_start_index_vfunc();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->get_start_index)
+      return (*base->get_start_index)(self);
+  }
+
+  typedef gint RType;
+  return RType();
+}
+
+gboolean Hyperlink_Class::is_valid_vfunc_callback(AtkHyperlink* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return static_cast<int>(obj->is_valid_vfunc());
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->is_valid)
+      return (*base->is_valid)(self);
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+gint Hyperlink_Class::get_n_anchors_vfunc_callback(AtkHyperlink* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return obj->get_n_anchors_vfunc();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->get_n_anchors)
+      return (*base->get_n_anchors)(self);
+  }
+
+  typedef gint RType;
+  return RType();
+}
+
+guint Hyperlink_Class::link_state_vfunc_callback(AtkHyperlink* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return obj->link_state_vfunc();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->link_state)
+      return (*base->link_state)(self);
+  }
+
+  typedef guint RType;
+  return RType();
+}
+
+gboolean Hyperlink_Class::is_selected_link_vfunc_callback(AtkHyperlink* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return static_cast<int>(obj->is_selected_link_vfunc());
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->is_selected_link)
+      return (*base->is_selected_link)(self);
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+
+void Hyperlink_Class::link_activated_callback(AtkHyperlink* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_link_activated();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->link_activated)
+      (*base->link_activated)(self);
+  }
+}
+
+
+Glib::ObjectBase* Hyperlink_Class::wrap_new(GObject* object)
+{
+  return new Hyperlink((AtkHyperlink*)object);
+}
+
+
+/* The implementation: */
+
+AtkHyperlink* Hyperlink::gobj_copy()
+{
+  reference();
+  return gobj();
+}
+
+Hyperlink::Hyperlink(const Glib::ConstructParams& construct_params)
+:
+  Glib::Object(construct_params)
+{}
+
+Hyperlink::Hyperlink(AtkHyperlink* castitem)
+:
+  Glib::Object((GObject*)(castitem))
+{}
+
+Hyperlink::~Hyperlink()
+{}
+
+
+Hyperlink::CppClassType Hyperlink::hyperlink_class_; // initialize static member
+
+GType Hyperlink::get_type()
+{
+  return hyperlink_class_.init().get_type();
+}
+
+GType Hyperlink::get_base_type()
+{
+  return atk_hyperlink_get_type();
+}
+
+
+Glib::ustring Hyperlink::get_uri(int i) const
+{
+  return Glib::convert_return_gchar_ptr_to_ustring(atk_hyperlink_get_uri(const_cast<AtkHyperlink*>(gobj()), i));
+}
+
+Glib::RefPtr<Atk::Object> Hyperlink::get_object(int i)
+{
+
+  Glib::RefPtr<Atk::Object> retvalue = Glib::wrap(atk_hyperlink_get_object(gobj(), i));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::RefPtr<const Atk::Object> Hyperlink::get_object(int i) const
+{
+
+  Glib::RefPtr<const Atk::Object> retvalue = Glib::wrap(atk_hyperlink_get_object(const_cast<AtkHyperlink*>(gobj()), i));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+int Hyperlink::get_end_index() const
+{
+  return atk_hyperlink_get_end_index(const_cast<AtkHyperlink*>(gobj()));
+}
+
+int Hyperlink::get_start_index() const
+{
+  return atk_hyperlink_get_start_index(const_cast<AtkHyperlink*>(gobj()));
+}
+
+bool Hyperlink::is_valid() const
+{
+  return atk_hyperlink_is_valid(const_cast<AtkHyperlink*>(gobj()));
+}
+
+bool Hyperlink::is_inline() const
+{
+  return atk_hyperlink_is_inline(const_cast<AtkHyperlink*>(gobj()));
+}
+
+int Hyperlink::get_n_anchors() const
+{
+  return atk_hyperlink_get_n_anchors(const_cast<AtkHyperlink*>(gobj()));
+}
+
+bool Hyperlink::is_selected_link() const
+{
+  return atk_hyperlink_is_selected_link(const_cast<AtkHyperlink*>(gobj()));
+}
+
+
+Glib::SignalProxy0< void > Hyperlink::signal_link_activated()
+{
+  return Glib::SignalProxy0< void >(this, &Hyperlink_signal_link_activated_info);
+}
+
+
+Glib::PropertyProxy_ReadOnly<bool> Hyperlink::property_selected_link() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "selected-link");
+}
+
+Glib::PropertyProxy_ReadOnly<int> Hyperlink::property_number_of_anchors() const
+{
+  return Glib::PropertyProxy_ReadOnly<int>(this, "number-of-anchors");
+}
+
+Glib::PropertyProxy_ReadOnly<int> Hyperlink::property_end_index() const
+{
+  return Glib::PropertyProxy_ReadOnly<int>(this, "end-index");
+}
+
+Glib::PropertyProxy_ReadOnly<int> Hyperlink::property_start_index() const
+{
+  return Glib::PropertyProxy_ReadOnly<int>(this, "start-index");
+}
+
+
+void Atk::Hyperlink::on_link_activated()
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->link_activated)
+    (*base->link_activated)(gobj());
+}
+
+
+gchar* Atk::Hyperlink::get_uri_vfunc(int i) const
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->get_uri)
+    return (*base->get_uri)(const_cast<AtkHyperlink*>(gobj()),i);
+
+  typedef gchar* RType;
+  return RType();
+}
+
+Glib::RefPtr<Atk::Object> Atk::Hyperlink::get_object_vfunc(int i) 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->get_object)
+    return Glib::wrap((*base->get_object)(gobj(),i));
+
+  typedef Glib::RefPtr<Atk::Object> RType;
+  return RType();
+}
+
+int Atk::Hyperlink::get_end_index_vfunc() const
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->get_end_index)
+    return (*base->get_end_index)(const_cast<AtkHyperlink*>(gobj()));
+
+  typedef int RType;
+  return RType();
+}
+
+int Atk::Hyperlink::get_start_index_vfunc() const
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->get_start_index)
+    return (*base->get_start_index)(const_cast<AtkHyperlink*>(gobj()));
+
+  typedef int RType;
+  return RType();
+}
+
+bool Atk::Hyperlink::is_valid_vfunc() const
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->is_valid)
+    return (*base->is_valid)(const_cast<AtkHyperlink*>(gobj()));
+
+  typedef bool RType;
+  return RType();
+}
+
+int Atk::Hyperlink::get_n_anchors_vfunc() const
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->get_n_anchors)
+    return (*base->get_n_anchors)(const_cast<AtkHyperlink*>(gobj()));
+
+  typedef int RType;
+  return RType();
+}
+
+guint Atk::Hyperlink::link_state_vfunc() const
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->link_state)
+    return (*base->link_state)(const_cast<AtkHyperlink*>(gobj()));
+
+  typedef guint RType;
+  return RType();
+}
+
+bool Atk::Hyperlink::is_selected_link_vfunc() const
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->is_selected_link)
+    return (*base->is_selected_link)(const_cast<AtkHyperlink*>(gobj()));
+
+  typedef bool RType;
+  return RType();
+}
+
+
+} // namespace Atk
+
+
diff --git a/libs/gtkmm2/atk/atkmm/hyperlink.h b/libs/gtkmm2/atk/atkmm/hyperlink.h
new file mode 100644
index 0000000000..293137afb0
--- /dev/null
+++ b/libs/gtkmm2/atk/atkmm/hyperlink.h
@@ -0,0 +1,252 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _ATKMM_HYPERLINK_H
+#define _ATKMM_HYPERLINK_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* Copyright (C) 2003 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <atkmm/action.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _AtkHyperlink AtkHyperlink;
+typedef struct _AtkHyperlinkClass AtkHyperlinkClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Atk
+{ class Hyperlink_Class; } // namespace Atk
+namespace Atk
+{
+
+class Object;
+
+/* An ATK object which encapsulates a link or set of links in a hypertext document.
+ * It implements the AtkAction interface.
+ */
+
+class Hyperlink
+  : public Glib::Object,
+    public Atk::Action
+{
+  
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+public:
+  typedef Hyperlink CppObjectType;
+  typedef Hyperlink_Class CppClassType;
+  typedef AtkHyperlink BaseObjectType;
+  typedef AtkHyperlinkClass BaseClassType;
+
+private:  friend class Hyperlink_Class;
+  static CppClassType hyperlink_class_;
+
+private:
+  // noncopyable
+  Hyperlink(const Hyperlink&);
+  Hyperlink& operator=(const Hyperlink&);
+
+protected:
+  explicit Hyperlink(const Glib::ConstructParams& construct_params);
+  explicit Hyperlink(AtkHyperlink* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+  virtual ~Hyperlink();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GObject.
+  AtkHyperlink*       gobj()       { return reinterpret_cast<AtkHyperlink*>(gobject_); }
+
+  ///Provides access to the underlying C GObject.
+  const AtkHyperlink* gobj() const { return reinterpret_cast<AtkHyperlink*>(gobject_); }
+
+  ///Provides access to the underlying C instance. The caller is responsible for unrefing it. Use when directly setting fields in structs.
+  AtkHyperlink* gobj_copy();
+
+private:
+
+  
+protected:
+
+public:
+
+  
+  /** Get a the URI associated with the anchor specified 
+   * by @a i  of @a link . 
+   * 
+   * Multiple anchors are primarily used by client-side image maps.
+   * @param i A (zero-index) integer specifying the desired anchor.
+   * @return A string specifying the URI.
+   */
+  Glib::ustring get_uri(int i) const;
+
+  
+  /** Returns the item associated with this hyperlinks nth anchor.
+   * For instance, the returned Atk::Object will implement Atk::Text
+   * if @a link  is a text hyperlink, Atk::Image if @a link  is an image
+   * hyperlink etc. 
+   * 
+   * Multiple anchors are primarily used by client-side image maps.
+   * @param i A (zero-index) integer specifying the desired anchor.
+   * @return An Atk::Object associated with this hyperlinks i-th anchor.
+   */
+  Glib::RefPtr<Atk::Object> get_object(int i);
+  
+  /** Returns the item associated with this hyperlinks nth anchor.
+   * For instance, the returned Atk::Object will implement Atk::Text
+   * if @a link  is a text hyperlink, Atk::Image if @a link  is an image
+   * hyperlink etc. 
+   * 
+   * Multiple anchors are primarily used by client-side image maps.
+   * @param i A (zero-index) integer specifying the desired anchor.
+   * @return An Atk::Object associated with this hyperlinks i-th anchor.
+   */
+  Glib::RefPtr<const Atk::Object> get_object(int i) const;
+  
+  
+  /** Gets the index with the hypertext document at which this link ends.
+   * @return The index with the hypertext document at which this link ends.
+   */
+  int get_end_index() const;
+
+  
+  /** Gets the index with the hypertext document at which this link begins.
+   * @return The index with the hypertext document at which this link begins.
+   */
+  int get_start_index() const;
+
+  
+  /** Since the document that a link is associated with may have changed
+   * this method returns <tt>true</tt> if the link is still valid (with
+   * respect to the document it references) and <tt>false</tt> otherwise.
+   * @return Whether or not this link is still valid.
+   */
+  bool is_valid() const;
+
+  
+  /** Indicates whether the link currently displays some or all of its
+   * content inline.  Ordinary HTML links will usually return
+   * <tt>false</tt>, but an inline &lt;src&gt; HTML element will return
+   * <tt>true</tt>.
+   * a *
+   * @return Whether or not this link displays its content inline.
+   */
+  bool is_inline() const;
+
+  
+  /** Gets the number of anchors associated with this hyperlink.
+   * @return The number of anchors associated with this hyperlink.
+   */
+  int get_n_anchors() const;
+  
+  /** Determines whether this AtkHyperlink is selected
+   * @return True is the AtkHyperlink is selected, False otherwise.
+   */
+  bool is_selected_link() const;
+
+  
+  Glib::SignalProxy0< void > signal_link_activated();
+
+
+  /** Specifies whether the AtkHyperlink object is selected.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_selected_link() const;
+
+
+  /** The number of anchors associated with the AtkHyperlink object.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<int> property_number_of_anchors() const;
+
+
+  /** The end index of the AtkHyperlink object.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<int> property_end_index() const;
+
+
+  /** The start index of the AtkHyperlink object.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<int> property_start_index() const;
+
+
+protected:
+    virtual gchar* get_uri_vfunc(int i) const;
+    virtual Glib::RefPtr<Atk::Object> get_object_vfunc(int i);
+    virtual int get_end_index_vfunc() const;
+    virtual int get_start_index_vfunc() const;
+    virtual bool is_valid_vfunc() const;
+    virtual int get_n_anchors_vfunc() const;
+    virtual guint link_state_vfunc() const;
+    virtual bool is_selected_link_vfunc() const; 
+
+
+public:
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+  virtual void on_link_activated();
+
+
+};
+
+} // namespace Atk
+
+
+namespace Glib
+{
+  /** @relates Atk::Hyperlink
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Glib::RefPtr<Atk::Hyperlink> wrap(AtkHyperlink* object, bool take_copy = false);
+}
+
+
+#endif /* _ATKMM_HYPERLINK_H */
+
diff --git a/libs/gtkmm2/atk/atkmm/hypertext.cc b/libs/gtkmm2/atk/atkmm/hypertext.cc
new file mode 100644
index 0000000000..f383ba5e74
--- /dev/null
+++ b/libs/gtkmm2/atk/atkmm/hypertext.cc
@@ -0,0 +1,396 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <atkmm/hypertext.h>
+#include <atkmm/private/hypertext_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* Copyright 2003 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <atkmm/object.h>
+#include <atk/atkhypertext.h>
+
+
+namespace Atk
+{
+
+
+} // namespace Atk
+
+
+namespace
+{
+
+void Hypertext_signal_link_selected_callback(AtkHypertext* self, gint p0,void* data)
+{
+  using namespace Atk;
+  typedef sigc::slot< void,int > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(p0
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+}
+
+const Glib::SignalProxyInfo Hypertext_signal_link_selected_info =
+{
+  "link_selected",
+  (GCallback) &Hypertext_signal_link_selected_callback,
+  (GCallback) &Hypertext_signal_link_selected_callback
+};
+
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Glib::RefPtr<Atk::Hypertext> wrap(AtkHypertext* object, bool take_copy)
+{
+  return Glib::RefPtr<Atk::Hypertext>( dynamic_cast<Atk::Hypertext*> (Glib::wrap_auto ((GObject*)(object), take_copy)) );
+  //We use dynamic_cast<> in case of multiple inheritance.
+}
+
+} // namespace Glib
+
+
+namespace Atk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Interface_Class& Hypertext_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Interface_Class has to know the interface init function
+    // in order to add interfaces to implementing types.
+    class_init_func_ = &Hypertext_Class::iface_init_function;
+
+    // We can not derive from another interface, and it is not necessary anyway.
+    gtype_ = atk_hypertext_get_type();
+  }
+
+  return *this;
+}
+
+void Hypertext_Class::iface_init_function(void* g_iface, void*)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_iface);
+
+  //This is just to avoid an "unused variable" warning when there are no vfuncs or signal handlers to connect.
+  //This is a temporary fix until I find out why I can not seem to derive a GtkFileChooser interface. murrayc
+  g_assert(klass != 0); 
+
+  klass->get_link = &get_link_vfunc_callback;
+  klass->get_n_links = &get_n_links_vfunc_callback;
+  klass->get_link_index = &get_link_index_vfunc_callback;
+  klass->link_selected = &link_selected_callback;
+}
+
+AtkHyperlink* Hypertext_Class::get_link_vfunc_callback(AtkHypertext* self, gint link_index)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return Glib::unwrap(obj->get_link_vfunc(link_index
+));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->get_link)
+      return (*base->get_link)(self, link_index);
+  }
+
+  typedef AtkHyperlink* RType;
+  return RType();
+}
+
+gint Hypertext_Class::get_n_links_vfunc_callback(AtkHypertext* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return obj->get_n_links_vfunc();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->get_n_links)
+      return (*base->get_n_links)(self);
+  }
+
+  typedef gint RType;
+  return RType();
+}
+
+gint Hypertext_Class::get_link_index_vfunc_callback(AtkHypertext* self, gint char_index)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return obj->get_link_index_vfunc(char_index
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->get_link_index)
+      return (*base->get_link_index)(self, char_index);
+  }
+
+  typedef gint RType;
+  return RType();
+}
+
+
+void Hypertext_Class::link_selected_callback(AtkHypertext* self, gint p0)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_link_selected(p0
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->link_selected)
+      (*base->link_selected)(self, p0);
+  }
+}
+
+
+Glib::ObjectBase* Hypertext_Class::wrap_new(GObject* object)
+{
+  return new Hypertext((AtkHypertext*)(object));
+}
+
+
+/* The implementation: */
+
+Hypertext::Hypertext()
+:
+  Glib::Interface(hypertext_class_.init())
+{}
+
+Hypertext::Hypertext(AtkHypertext* castitem)
+:
+  Glib::Interface((GObject*)(castitem))
+{}
+
+Hypertext::~Hypertext()
+{}
+
+// static
+void Hypertext::add_interface(GType gtype_implementer)
+{
+  hypertext_class_.init().add_interface(gtype_implementer);
+}
+
+Hypertext::CppClassType Hypertext::hypertext_class_; // initialize static member
+
+GType Hypertext::get_type()
+{
+  return hypertext_class_.init().get_type();
+}
+
+GType Hypertext::get_base_type()
+{
+  return atk_hypertext_get_type();
+}
+
+
+Glib::RefPtr<Hyperlink> Hypertext::get_link(int link_index)
+{
+  return Glib::wrap(atk_hypertext_get_link(gobj(), link_index));
+}
+
+Glib::RefPtr<const Hyperlink> Hypertext::get_link(int link_index) const
+{
+  return Glib::wrap(atk_hypertext_get_link(const_cast<AtkHypertext*>(gobj()), link_index));
+}
+
+int Hypertext::get_n_links() const
+{
+  return atk_hypertext_get_n_links(const_cast<AtkHypertext*>(gobj()));
+}
+
+int Hypertext::get_link_index(int char_index) const
+{
+  return atk_hypertext_get_link_index(const_cast<AtkHypertext*>(gobj()), char_index);
+}
+
+
+Glib::SignalProxy1< void,int > Hypertext::signal_link_selected()
+{
+  return Glib::SignalProxy1< void,int >(this, &Hypertext_signal_link_selected_info);
+}
+
+
+void Atk::Hypertext::on_link_selected(int link_index)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->link_selected)
+    (*base->link_selected)(gobj(),link_index);
+}
+
+
+Glib::RefPtr<Hyperlink> Atk::Hypertext::get_link_vfunc(int link_index) 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->get_link)
+    return Glib::wrap((*base->get_link)(gobj(),link_index));
+
+  typedef Glib::RefPtr<Hyperlink> RType;
+  return RType();
+}
+
+int Atk::Hypertext::get_n_links_vfunc() const
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->get_n_links)
+    return (*base->get_n_links)(const_cast<AtkHypertext*>(gobj()));
+
+  typedef int RType;
+  return RType();
+}
+
+int Atk::Hypertext::get_link_index_vfunc(int char_index) const
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->get_link_index)
+    return (*base->get_link_index)(const_cast<AtkHypertext*>(gobj()),char_index);
+
+  typedef int RType;
+  return RType();
+}
+
+
+} // namespace Atk
+
+
diff --git a/libs/gtkmm2/atk/atkmm/hypertext.h b/libs/gtkmm2/atk/atkmm/hypertext.h
new file mode 100644
index 0000000000..090827662a
--- /dev/null
+++ b/libs/gtkmm2/atk/atkmm/hypertext.h
@@ -0,0 +1,167 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _ATKMM_HYPERTEXT_H
+#define _ATKMM_HYPERTEXT_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* Copyright (C) 2003 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+
+#include <atkmm/hyperlink.h>
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+extern "C"
+{
+  typedef struct _AtkHypertextIface AtkHypertextIface;
+  typedef struct _AtkHypertext      AtkHypertext;
+}
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+/** The ATK interface which provides standard mechanism for manipulating hyperlinks.
+ */
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _AtkHypertext AtkHypertext;
+typedef struct _AtkHypertextClass AtkHypertextClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Atk
+{ class Hypertext_Class; } // namespace Atk
+namespace Atk
+{
+
+class Object;
+
+
+class Hypertext : public Glib::Interface
+{
+  
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+public:
+  typedef Hypertext CppObjectType;
+  typedef Hypertext_Class CppClassType;
+  typedef AtkHypertext BaseObjectType;
+  typedef AtkHypertextIface BaseClassType;
+
+private:
+  friend class Hypertext_Class;
+  static CppClassType hypertext_class_;
+
+  // noncopyable
+  Hypertext(const Hypertext&);
+  Hypertext& operator=(const Hypertext&);
+
+protected:
+  Hypertext(); // you must derive from this class
+  explicit Hypertext(AtkHypertext* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+  virtual ~Hypertext();
+
+  static void add_interface(GType gtype_implementer);
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GObject.
+  AtkHypertext*       gobj()       { return reinterpret_cast<AtkHypertext*>(gobject_); }
+
+  ///Provides access to the underlying C GObject.  
+  const AtkHypertext* gobj() const { return reinterpret_cast<AtkHypertext*>(gobject_); }
+
+private:
+
+public:
+
+  
+  /** Gets the link in this hypertext document at index 
+   *  @a link_index 
+   * @param link_index An integer specifying the desired link.
+   * @return The link in this hypertext document at
+   * index @a link_index .
+   */
+  Glib::RefPtr<Hyperlink> get_link(int link_index);
+  
+  /** Gets the link in this hypertext document at index 
+   *  @a link_index 
+   * @param link_index An integer specifying the desired link.
+   * @return The link in this hypertext document at
+   * index @a link_index .
+   */
+  Glib::RefPtr<const Hyperlink> get_link(int link_index) const;
+  
+  /** Gets the number of links within this hypertext document.
+   * @return The number of links within this hypertext document.
+   */
+  int get_n_links() const;
+  
+  /** Gets the index into the array of hyperlinks that is associated with
+   * the character specified by @a char_index , or -1 if there is no hyperlink
+   * associated with this character.
+   * @param char_index A character index.
+   * @return An index into the array of hyperlinks in @a hypertext .
+   */
+  int get_link_index(int char_index) const;
+
+  
+  Glib::SignalProxy1< void,int > signal_link_selected();
+
+
+    virtual Glib::RefPtr<Hyperlink> get_link_vfunc(int link_index);
+    virtual int get_n_links_vfunc() const;
+    virtual int get_link_index_vfunc(int char_index) const;
+
+
+public:
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+  virtual void on_link_selected(int link_index);
+
+
+};
+
+} // namespace Atk
+
+
+namespace Glib
+{
+  /** @relates Atk::Hypertext
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Glib::RefPtr<Atk::Hypertext> wrap(AtkHypertext* object, bool take_copy = false);
+
+} // namespace Glib
+
+#endif /* _ATKMM_HYPERTEXT_H */
+
diff --git a/libs/gtkmm2/atk/atkmm/image.cc b/libs/gtkmm2/atk/atkmm/image.cc
new file mode 100644
index 0000000000..2f1df28c18
--- /dev/null
+++ b/libs/gtkmm2/atk/atkmm/image.cc
@@ -0,0 +1,349 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <atkmm/image.h>
+#include <atkmm/private/image_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <atkmm/object.h>
+#include <atk/atkimage.h>
+
+
+namespace
+{
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Glib::RefPtr<Atk::Image> wrap(AtkImage* object, bool take_copy)
+{
+  return Glib::RefPtr<Atk::Image>( dynamic_cast<Atk::Image*> (Glib::wrap_auto ((GObject*)(object), take_copy)) );
+  //We use dynamic_cast<> in case of multiple inheritance.
+}
+
+} // namespace Glib
+
+
+namespace Atk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Interface_Class& Image_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Interface_Class has to know the interface init function
+    // in order to add interfaces to implementing types.
+    class_init_func_ = &Image_Class::iface_init_function;
+
+    // We can not derive from another interface, and it is not necessary anyway.
+    gtype_ = atk_image_get_type();
+  }
+
+  return *this;
+}
+
+void Image_Class::iface_init_function(void* g_iface, void*)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_iface);
+
+  //This is just to avoid an "unused variable" warning when there are no vfuncs or signal handlers to connect.
+  //This is a temporary fix until I find out why I can not seem to derive a GtkFileChooser interface. murrayc
+  g_assert(klass != 0); 
+
+  klass->set_image_description = &set_image_description_vfunc_callback;
+  klass->get_image_description = &get_image_description_vfunc_callback;
+  klass->get_image_position = &get_image_position_vfunc_callback;
+  klass->get_image_size = &get_image_size_vfunc_callback;
+}
+
+gboolean Image_Class::set_image_description_vfunc_callback(AtkImage* self, const gchar* description)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return static_cast<int>(obj->set_image_description_vfunc(Glib::convert_const_gchar_ptr_to_ustring(description)
+));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->set_image_description)
+      return (*base->set_image_description)(self, description);
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+const gchar* Image_Class::get_image_description_vfunc_callback(AtkImage* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return obj->get_image_description_vfunc();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->get_image_description)
+      return (*base->get_image_description)(self);
+  }
+
+  typedef const gchar* RType;
+  return RType();
+}
+
+void Image_Class::get_image_position_vfunc_callback(AtkImage* self, gint* x, gint* y, AtkCoordType coord_type)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->get_image_position_vfunc(*(x)
+, *(y)
+, ((CoordType)(coord_type))
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->get_image_position)
+      (*base->get_image_position)(self, x, y, coord_type);
+  }
+}
+
+void Image_Class::get_image_size_vfunc_callback(AtkImage* self, gint* width, gint* height)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->get_image_size_vfunc(*(width)
+, *(height)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->get_image_size)
+      (*base->get_image_size)(self, width, height);
+  }
+}
+
+
+Glib::ObjectBase* Image_Class::wrap_new(GObject* object)
+{
+  return new Image((AtkImage*)(object));
+}
+
+
+/* The implementation: */
+
+Image::Image()
+:
+  Glib::Interface(image_class_.init())
+{}
+
+Image::Image(AtkImage* castitem)
+:
+  Glib::Interface((GObject*)(castitem))
+{}
+
+Image::~Image()
+{}
+
+// static
+void Image::add_interface(GType gtype_implementer)
+{
+  image_class_.init().add_interface(gtype_implementer);
+}
+
+Image::CppClassType Image::image_class_; // initialize static member
+
+GType Image::get_type()
+{
+  return image_class_.init().get_type();
+}
+
+GType Image::get_base_type()
+{
+  return atk_image_get_type();
+}
+
+
+bool Image::set_image_description(const Glib::ustring& description)
+{
+  return atk_image_set_image_description(gobj(), description.c_str());
+}
+
+Glib::ustring Image::get_image_description() const
+{
+  return Glib::convert_const_gchar_ptr_to_ustring(atk_image_get_image_description(const_cast<AtkImage*>(gobj())));
+}
+
+void Image::get_image_size(int& width, int& height) const
+{
+  atk_image_get_image_size(const_cast<AtkImage*>(gobj()), &width, &height);
+}
+
+void Image::get_image_position(int& x, int& y, CoordType coord_type) const
+{
+  atk_image_get_image_position(const_cast<AtkImage*>(gobj()), &x, &y, ((AtkCoordType)(coord_type)));
+}
+
+
+bool Atk::Image::set_image_description_vfunc(const Glib::ustring& description) 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->set_image_description)
+    return (*base->set_image_description)(gobj(),description.c_str());
+
+  typedef bool RType;
+  return RType();
+}
+
+const char* Atk::Image::get_image_description_vfunc() const
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->get_image_description)
+    return (*base->get_image_description)(const_cast<AtkImage*>(gobj()));
+
+  typedef const char* RType;
+  return RType();
+}
+
+void Atk::Image::get_image_position_vfunc(int& x, int& y, CoordType coord_type) const
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->get_image_position)
+    (*base->get_image_position)(const_cast<AtkImage*>(gobj()),&x,&y,((AtkCoordType)(coord_type)));
+}
+
+void Atk::Image::get_image_size_vfunc(int& width, int& height) const
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->get_image_size)
+    (*base->get_image_size)(const_cast<AtkImage*>(gobj()),&width,&height);
+}
+
+
+} // namespace Atk
+
+
diff --git a/libs/gtkmm2/atk/atkmm/image.h b/libs/gtkmm2/atk/atkmm/image.h
new file mode 100644
index 0000000000..a6af34884a
--- /dev/null
+++ b/libs/gtkmm2/atk/atkmm/image.h
@@ -0,0 +1,173 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _ATKMM_IMAGE_H
+#define _ATKMM_IMAGE_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* Copyright (C) 2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+
+#include <atkmm/component.h> /* for Atk::CoordType */
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+extern "C"
+{
+  typedef struct _AtkImageIface AtkImageIface;
+  typedef struct _AtkImage      AtkImage;
+}
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _AtkImage AtkImage;
+typedef struct _AtkImageClass AtkImageClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Atk
+{ class Image_Class; } // namespace Atk
+namespace Atk
+{
+
+/** The ATK Interface implemented by components which expose image or pixmap content on-screen.
+ * This should be implemented by Atk::Object subtypes on behalf of components which display image/pixmap information
+ * onscreen, and which provide information (other than just widget borders, etc.) via that image content. For instance,
+ * icons, buttons with icons, toolbar elements, and image viewing panes typically should implement AtkImage.
+ *
+ * Atk::Image primarily provides two types of information: coordinate information (useful for screen review mode of
+ * screenreaders, and for use by onscreen magnifiers), and descriptive information. The descriptive information is
+ * provided for alternative, text-only presentation of the most significant information present in the image. 
+ */
+
+class Image : public Glib::Interface
+{
+  
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+public:
+  typedef Image CppObjectType;
+  typedef Image_Class CppClassType;
+  typedef AtkImage BaseObjectType;
+  typedef AtkImageIface BaseClassType;
+
+private:
+  friend class Image_Class;
+  static CppClassType image_class_;
+
+  // noncopyable
+  Image(const Image&);
+  Image& operator=(const Image&);
+
+protected:
+  Image(); // you must derive from this class
+  explicit Image(AtkImage* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+  virtual ~Image();
+
+  static void add_interface(GType gtype_implementer);
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GObject.
+  AtkImage*       gobj()       { return reinterpret_cast<AtkImage*>(gobject_); }
+
+  ///Provides access to the underlying C GObject.  
+  const AtkImage* gobj() const { return reinterpret_cast<AtkImage*>(gobject_); }
+
+private:
+
+
+public:
+  
+  /** Sets the textual description for this image.
+   * @param description A string description to set for @a image .
+   * @return Boolean <tt>true</tt>, or <tt>false</tt> if operation could
+   * not be completed.
+   */
+  bool set_image_description(const Glib::ustring& description);
+  
+  /** Get a textual description of this image.
+   * @return A string representing the image description.
+   */
+  Glib::ustring get_image_description() const;
+
+  
+  /** Get the width and height in pixels for the specified image.
+   * The values of @a width  and @a height  are returned as -1 if the
+   * values cannot be obtained.
+   * @param width Filled with the image width.
+   * @param height Filled with the image height.
+   */
+  void get_image_size(int& width, int& height) const;
+  
+  /** Gets the position of the image in the form of a point specifying the
+   * images top-left corner.  The values of @a x  and @a y  are returned as -1
+   * if the values cannot be obtained.
+   * @param x Address of <tt>int</tt> to put x coordinate position.
+   * @param y Address of <tt>int</tt> to put y coordinate position.
+   * @param coord_type Specifies whether the coordinates are relative to the screen
+   * or to the components top level window.
+   */
+  void get_image_position(int& x, int& y, CoordType coord_type) const;
+
+protected:
+    virtual bool set_image_description_vfunc(const Glib::ustring& description);
+    virtual const char* get_image_description_vfunc() const;
+
+    virtual void get_image_position_vfunc(int& x, int& y, CoordType coord_type) const;
+    virtual void get_image_size_vfunc(int& width, int& height) const;
+
+
+public:
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+};
+
+} // namespace Atk
+
+
+namespace Glib
+{
+  /** @relates Atk::Image
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Glib::RefPtr<Atk::Image> wrap(AtkImage* object, bool take_copy = false);
+
+} // namespace Glib
+
+#endif /* _ATKMM_IMAGE_H */
+
diff --git a/libs/gtkmm2/atk/atkmm/implementor.cc b/libs/gtkmm2/atk/atkmm/implementor.cc
new file mode 100644
index 0000000000..303bf3d0a1
--- /dev/null
+++ b/libs/gtkmm2/atk/atkmm/implementor.cc
@@ -0,0 +1,175 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <atkmm/implementor.h>
+#include <atkmm/private/implementor_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <atkmm/object.h>
+#include <atk/atkobject.h>
+
+
+namespace
+{
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Glib::RefPtr<Atk::Implementor> wrap(AtkImplementor* object, bool take_copy)
+{
+  return Glib::RefPtr<Atk::Implementor>( dynamic_cast<Atk::Implementor*> (Glib::wrap_auto ((GObject*)(object), take_copy)) );
+  //We use dynamic_cast<> in case of multiple inheritance.
+}
+
+} // namespace Glib
+
+
+namespace Atk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Interface_Class& Implementor_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Interface_Class has to know the interface init function
+    // in order to add interfaces to implementing types.
+    class_init_func_ = &Implementor_Class::iface_init_function;
+
+    // We can not derive from another interface, and it is not necessary anyway.
+    gtype_ = atk_implementor_get_type();
+  }
+
+  return *this;
+}
+
+void Implementor_Class::iface_init_function(void* g_iface, void*)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_iface);
+
+  //This is just to avoid an "unused variable" warning when there are no vfuncs or signal handlers to connect.
+  //This is a temporary fix until I find out why I can not seem to derive a GtkFileChooser interface. murrayc
+  g_assert(klass != 0); 
+
+  klass->ref_accessible = &ref_accessible_vfunc_callback;
+}
+
+AtkObject* Implementor_Class::ref_accessible_vfunc_callback(AtkImplementor* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return Glib::unwrap(obj->ref_accessibile_vfunc());
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->ref_accessible)
+      return (*base->ref_accessible)(self);
+  }
+
+  typedef AtkObject* RType;
+  return RType();
+}
+
+
+Glib::ObjectBase* Implementor_Class::wrap_new(GObject* object)
+{
+  return new Implementor((AtkImplementor*)(object));
+}
+
+
+/* The implementation: */
+
+Implementor::Implementor()
+:
+  Glib::Interface(implementor_class_.init())
+{}
+
+Implementor::Implementor(AtkImplementor* castitem)
+:
+  Glib::Interface((GObject*)(castitem))
+{}
+
+Implementor::~Implementor()
+{}
+
+// static
+void Implementor::add_interface(GType gtype_implementer)
+{
+  implementor_class_.init().add_interface(gtype_implementer);
+}
+
+Implementor::CppClassType Implementor::implementor_class_; // initialize static member
+
+GType Implementor::get_type()
+{
+  return implementor_class_.init().get_type();
+}
+
+GType Implementor::get_base_type()
+{
+  return atk_implementor_get_type();
+}
+
+
+Glib::RefPtr<Object> Atk::Implementor::ref_accessibile_vfunc() 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->ref_accessible)
+    return Glib::wrap((*base->ref_accessible)(gobj()));
+
+  typedef Glib::RefPtr<Object> RType;
+  return RType();
+}
+
+
+} // namespace Atk
+
+
diff --git a/libs/gtkmm2/atk/atkmm/implementor.h b/libs/gtkmm2/atk/atkmm/implementor.h
new file mode 100644
index 0000000000..7df786ce27
--- /dev/null
+++ b/libs/gtkmm2/atk/atkmm/implementor.h
@@ -0,0 +1,127 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _ATKMM_IMPLEMENTOR_H
+#define _ATKMM_IMPLEMENTOR_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* Copyright (C) 2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+
+#include <atkmm/object.h>
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+extern "C"
+{
+  typedef struct _AtkImplementorIface AtkImplementorIface;
+  typedef struct _AtkImplementor      AtkImplementor;
+}
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _AtkImplementor AtkImplementor;
+typedef struct _AtkImplementorClass AtkImplementorClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Atk
+{ class Implementor_Class; } // namespace Atk
+namespace Atk
+{
+
+
+class Implementor : public Glib::Interface
+{
+  
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+public:
+  typedef Implementor CppObjectType;
+  typedef Implementor_Class CppClassType;
+  typedef AtkImplementor BaseObjectType;
+  typedef AtkImplementorIface BaseClassType;
+
+private:
+  friend class Implementor_Class;
+  static CppClassType implementor_class_;
+
+  // noncopyable
+  Implementor(const Implementor&);
+  Implementor& operator=(const Implementor&);
+
+protected:
+  Implementor(); // you must derive from this class
+  explicit Implementor(AtkImplementor* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+  virtual ~Implementor();
+
+  static void add_interface(GType gtype_implementer);
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GObject.
+  AtkImplementor*       gobj()       { return reinterpret_cast<AtkImplementor*>(gobject_); }
+
+  ///Provides access to the underlying C GObject.  
+  const AtkImplementor* gobj() const { return reinterpret_cast<AtkImplementor*>(gobject_); }
+
+private:
+
+
+protected:
+    virtual Glib::RefPtr<Object> ref_accessibile_vfunc();
+
+
+public:
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+};
+
+} // namespace Atk
+
+
+namespace Glib
+{
+  /** @relates Atk::Implementor
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Glib::RefPtr<Atk::Implementor> wrap(AtkImplementor* object, bool take_copy = false);
+
+} // namespace Glib
+
+#endif /* _ATKMM_IMPLEMENTOR_H */
+
diff --git a/libs/gtkmm2/atk/atkmm/init.cc b/libs/gtkmm2/atk/atkmm/init.cc
new file mode 100644
index 0000000000..0b103a9b05
--- /dev/null
+++ b/libs/gtkmm2/atk/atkmm/init.cc
@@ -0,0 +1,34 @@
+// -*- c++ -*-
+/* $Id$ */
+
+/* Copyright (C) 2003 The atkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <glibmm/init.h>
+#include <atkmm/wrap_init.h>
+
+namespace Atk
+{
+
+void init()
+{
+  Glib::init();
+  Atk::wrap_init(); 
+}
+
+} // namespace Atk
+
diff --git a/libs/gtkmm2/atk/atkmm/init.h b/libs/gtkmm2/atk/atkmm/init.h
new file mode 100644
index 0000000000..05bdd07f34
--- /dev/null
+++ b/libs/gtkmm2/atk/atkmm/init.h
@@ -0,0 +1,40 @@
+// -*- c++ -*-
+#ifndef _ATKMM_INIT_H
+#define _ATKMM_INIT_H
+
+/* $Id$ */
+
+/* Copyright (C) 2003 The atkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+namespace Atk
+{
+
+/** Initialize atkmm.
+ * You may call this more than once.
+ * You do not need to call this if you are using Gtk::Main,
+ * because it calls this for you.
+ */
+void init();
+
+} // namespace Atk
+
+
+
+#endif // _ATKMM_INIT_H
+
+
diff --git a/libs/gtkmm2/atk/atkmm/noopobject.cc b/libs/gtkmm2/atk/atkmm/noopobject.cc
new file mode 100644
index 0000000000..c9c78627cd
--- /dev/null
+++ b/libs/gtkmm2/atk/atkmm/noopobject.cc
@@ -0,0 +1,132 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <atkmm/noopobject.h>
+#include <atkmm/private/noopobject_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <atk/atknoopobject.h>
+
+
+namespace
+{
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Glib::RefPtr<Atk::NoOpObject> wrap(AtkNoOpObject* object, bool take_copy)
+{
+  return Glib::RefPtr<Atk::NoOpObject>( dynamic_cast<Atk::NoOpObject*> (Glib::wrap_auto ((GObject*)(object), take_copy)) );
+  //We use dynamic_cast<> in case of multiple inheritance.
+}
+
+} /* namespace Glib */
+
+
+namespace Atk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& NoOpObject_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &NoOpObject_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(atk_no_op_object_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  Component::add_interface(get_type());
+  Action::add_interface(get_type());
+  EditableText::add_interface(get_type());
+  Image::add_interface(get_type());
+  Selection::add_interface(get_type());
+  Table::add_interface(get_type());
+  Text::add_interface(get_type());
+  Hypertext::add_interface(get_type());
+  Value::add_interface(get_type());
+  }
+
+  return *this;
+}
+
+void NoOpObject_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+}
+
+
+Glib::ObjectBase* NoOpObject_Class::wrap_new(GObject* object)
+{
+  return new NoOpObject((AtkNoOpObject*)object);
+}
+
+
+/* The implementation: */
+
+AtkNoOpObject* NoOpObject::gobj_copy()
+{
+  reference();
+  return gobj();
+}
+
+NoOpObject::NoOpObject(const Glib::ConstructParams& construct_params)
+:
+  Atk::Object(construct_params)
+{}
+
+NoOpObject::NoOpObject(AtkNoOpObject* castitem)
+:
+  Atk::Object((AtkObject*)(castitem))
+{}
+
+NoOpObject::~NoOpObject()
+{}
+
+
+NoOpObject::CppClassType NoOpObject::noopobject_class_; // initialize static member
+
+GType NoOpObject::get_type()
+{
+  return noopobject_class_.init().get_type();
+}
+
+GType NoOpObject::get_base_type()
+{
+  return atk_no_op_object_get_type();
+}
+
+
+} // namespace Atk
+
+
diff --git a/libs/gtkmm2/atk/atkmm/noopobject.h b/libs/gtkmm2/atk/atkmm/noopobject.h
new file mode 100644
index 0000000000..b5ee9bed0c
--- /dev/null
+++ b/libs/gtkmm2/atk/atkmm/noopobject.h
@@ -0,0 +1,143 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _ATKMM_NOOPOBJECT_H
+#define _ATKMM_NOOPOBJECT_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* Copyright (C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <atkmm/object.h>
+#include <atkmm/component.h>
+#include <atkmm/action.h>
+#include <atkmm/editabletext.h>
+#include <atkmm/image.h>
+#include <atkmm/selection.h>
+#include <atkmm/table.h>
+#include <atkmm/value.h>
+#include <atkmm/hypertext.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _AtkNoOpObject AtkNoOpObject;
+typedef struct _AtkNoOpObjectClass AtkNoOpObjectClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Atk
+{ class NoOpObject_Class; } // namespace Atk
+namespace Atk
+{
+
+/** An Atk::NoOpObject is an Atk::Object which purports to implement all ATK interfaces.
+ * It is the type of Atk::Object which is created if an accessible object is requested for an object type for which no
+ * factory type is specified.
+ */
+
+class NoOpObject
+:
+  public Atk::Object,
+  public Atk::Component,
+  public Atk::Action,
+  public Atk::EditableText,
+  public Atk::Image,
+  public Atk::Selection,
+  public Atk::Table,
+  public Atk::Text,
+  public Atk::Hypertext,
+  public Atk::Value
+{
+  
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+public:
+  typedef NoOpObject CppObjectType;
+  typedef NoOpObject_Class CppClassType;
+  typedef AtkNoOpObject BaseObjectType;
+  typedef AtkNoOpObjectClass BaseClassType;
+
+private:  friend class NoOpObject_Class;
+  static CppClassType noopobject_class_;
+
+private:
+  // noncopyable
+  NoOpObject(const NoOpObject&);
+  NoOpObject& operator=(const NoOpObject&);
+
+protected:
+  explicit NoOpObject(const Glib::ConstructParams& construct_params);
+  explicit NoOpObject(AtkNoOpObject* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+  virtual ~NoOpObject();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GObject.
+  AtkNoOpObject*       gobj()       { return reinterpret_cast<AtkNoOpObject*>(gobject_); }
+
+  ///Provides access to the underlying C GObject.
+  const AtkNoOpObject* gobj() const { return reinterpret_cast<AtkNoOpObject*>(gobject_); }
+
+  ///Provides access to the underlying C instance. The caller is responsible for unrefing it. Use when directly setting fields in structs.
+  AtkNoOpObject* gobj_copy();
+
+private:
+
+  
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  friend class Atk::Object_Class;
+#endif
+
+
+public:
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+};
+
+} // namespace Atk
+
+
+namespace Glib
+{
+  /** @relates Atk::NoOpObject
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Glib::RefPtr<Atk::NoOpObject> wrap(AtkNoOpObject* object, bool take_copy = false);
+}
+
+
+#endif /* _ATKMM_NOOPOBJECT_H */
+
diff --git a/libs/gtkmm2/atk/atkmm/object.cc b/libs/gtkmm2/atk/atkmm/object.cc
new file mode 100644
index 0000000000..44e7301691
--- /dev/null
+++ b/libs/gtkmm2/atk/atkmm/object.cc
@@ -0,0 +1,834 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <atkmm/object.h>
+#include <atkmm/private/object_p.h>
+
+#include <atk/atk-enum-types.h>
+// -*- c++ -*-
+/* $Id$ */
+
+/* Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <atkmm/noopobject.h>
+#include <atkmm/relation.h>
+#include <atkmm/relationset.h>
+#include <atkmm/stateset.h>
+#include <atk/atkobject.h>
+
+
+namespace Atk
+{
+
+/* AtkObject is actually an abstract base class.  So if this wrap_new()
+ * function is called, it means that no wrapper exists for the real C object.
+ * The problem is that gail (the real accessibility implementation) is
+ * currently not wrapped and will probably never be.  Therefore, code like
+ * in the following example is doomed to fail:
+ *
+ * Gtk::Image image ("icon.png");
+ * Glib::RefPtr<Atk::Image> accessible = Glib::RefPtr<Atk::Image>::cast_dynamic(image.get_accessible());
+ * accessible->set_image_description("my icon");
+ *
+ * This would segfault, even though the accessible object _does_ implement
+ * AtkImage.  But Atk::Image is an interface class that can't be instantiated
+ * as is.  It needs an object.
+ *
+ * The solution is to instantiate a dummy object that implements all of the
+ * ATK interfaces.  Fortunately, ATK already provides us with such a thing,
+ * AtkNoOpObject.  All widget accessible objects are of this type if the gail
+ * module is not loaded (which is the default).
+ *
+ * So what we do here is abusing Atk::NoOpObject to get around the lack of
+ * C++ wrappers for gail.  Instead of instantiating a useless instance of an
+ * abstract base class, we just create a Atk::NoOpObject instance which can
+ * be casted to any of the Atk interface classes.
+ */
+Glib::ObjectBase* Object_Class::wrap_new(GObject* object)
+{
+  return new Atk::NoOpObject((AtkNoOpObject*) object);
+}
+
+} // namespace Atk
+
+
+namespace
+{
+
+void Object_signal_children_changed_callback(AtkObject* self, guint p0,gpointer p1,void* data)
+{
+  using namespace Atk;
+  typedef sigc::slot< void,guint,gpointer > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(p0, p1);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+}
+
+const Glib::SignalProxyInfo Object_signal_children_changed_info =
+{
+  "children_changed",
+  (GCallback) &Object_signal_children_changed_callback,
+  (GCallback) &Object_signal_children_changed_callback
+};
+
+
+void Object_signal_focus_event_callback(AtkObject* self, gboolean p0,void* data)
+{
+  using namespace Atk;
+  typedef sigc::slot< void,bool > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(p0
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+}
+
+const Glib::SignalProxyInfo Object_signal_focus_event_info =
+{
+  "focus_event",
+  (GCallback) &Object_signal_focus_event_callback,
+  (GCallback) &Object_signal_focus_event_callback
+};
+
+
+void Object_signal_property_change_callback(AtkObject* self, AtkPropertyValues* p0,void* data)
+{
+  using namespace Atk;
+  typedef sigc::slot< void,AtkPropertyValues* > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(p0);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+}
+
+const Glib::SignalProxyInfo Object_signal_property_change_info =
+{
+  "property_change",
+  (GCallback) &Object_signal_property_change_callback,
+  (GCallback) &Object_signal_property_change_callback
+};
+
+
+void Object_signal_state_change_callback(AtkObject* self, const gchar* p0,gboolean p1,void* data)
+{
+  using namespace Atk;
+  typedef sigc::slot< void,const Glib::ustring&,bool > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(Glib::convert_const_gchar_ptr_to_ustring(p0)
+, p1
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+}
+
+const Glib::SignalProxyInfo Object_signal_state_change_info =
+{
+  "state_change",
+  (GCallback) &Object_signal_state_change_callback,
+  (GCallback) &Object_signal_state_change_callback
+};
+
+
+const Glib::SignalProxyInfo Object_signal_visible_data_changed_info =
+{
+  "visible_data_changed",
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
+};
+
+
+void Object_signal_active_descendant_changed_callback(AtkObject* self, gpointer* p0,void* data)
+{
+  using namespace Atk;
+  typedef sigc::slot< void,void** > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(p0
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+}
+
+const Glib::SignalProxyInfo Object_signal_active_descendant_changed_info =
+{
+  "active_descendant_changed",
+  (GCallback) &Object_signal_active_descendant_changed_callback,
+  (GCallback) &Object_signal_active_descendant_changed_callback
+};
+
+} // anonymous namespace
+
+// static
+GType Glib::Value<Atk::Role>::value_type()
+{
+  return atk_role_get_type();
+}
+
+
+namespace Glib
+{
+
+Glib::RefPtr<Atk::Object> wrap(AtkObject* object, bool take_copy)
+{
+  return Glib::RefPtr<Atk::Object>( dynamic_cast<Atk::Object*> (Glib::wrap_auto ((GObject*)(object), take_copy)) );
+  //We use dynamic_cast<> in case of multiple inheritance.
+}
+
+} /* namespace Glib */
+
+
+namespace Atk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& Object_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &Object_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(atk_object_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void Object_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+  klass->children_changed = &children_changed_callback;
+  klass->focus_event = &focus_event_callback;
+  klass->property_change = &property_change_callback;
+  klass->state_change = &state_change_callback;
+  klass->visible_data_changed = &visible_data_changed_callback;
+  klass->active_descendant_changed = &active_descendant_changed_callback;
+}
+
+
+void Object_Class::children_changed_callback(AtkObject* self, guint p0, gpointer p1)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_children_changed(p0, p1);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->children_changed)
+      (*base->children_changed)(self, p0, p1);
+  }
+}
+
+void Object_Class::focus_event_callback(AtkObject* self, gboolean p0)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_focus_event(p0
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->focus_event)
+      (*base->focus_event)(self, p0);
+  }
+}
+
+void Object_Class::property_change_callback(AtkObject* self, AtkPropertyValues* p0)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_property_change(p0);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->property_change)
+      (*base->property_change)(self, p0);
+  }
+}
+
+void Object_Class::state_change_callback(AtkObject* self, const gchar* p0, gboolean p1)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_state_change(Glib::convert_const_gchar_ptr_to_ustring(p0)
+, p1
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->state_change)
+      (*base->state_change)(self, p0, p1);
+  }
+}
+
+void Object_Class::visible_data_changed_callback(AtkObject* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_visible_data_changed();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->visible_data_changed)
+      (*base->visible_data_changed)(self);
+  }
+}
+
+void Object_Class::active_descendant_changed_callback(AtkObject* self, gpointer* p0)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_active_descendant_changed(p0
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->active_descendant_changed)
+      (*base->active_descendant_changed)(self, p0);
+  }
+}
+
+
+/* The implementation: */
+
+AtkObject* Object::gobj_copy()
+{
+  reference();
+  return gobj();
+}
+
+Object::Object(const Glib::ConstructParams& construct_params)
+:
+  Glib::Object(construct_params)
+{}
+
+Object::Object(AtkObject* castitem)
+:
+  Glib::Object((GObject*)(castitem))
+{}
+
+Object::~Object()
+{}
+
+
+Object::CppClassType Object::object_class_; // initialize static member
+
+GType Object::get_type()
+{
+  return object_class_.init().get_type();
+}
+
+GType Object::get_base_type()
+{
+  return atk_object_get_type();
+}
+
+
+Glib::ustring Object::get_name() const
+{
+  return Glib::convert_const_gchar_ptr_to_ustring(atk_object_get_name(const_cast<AtkObject*>(gobj())));
+}
+
+Glib::ustring Object::get_description() const
+{
+  return Glib::convert_const_gchar_ptr_to_ustring(atk_object_get_description(const_cast<AtkObject*>(gobj())));
+}
+
+Glib::RefPtr<Atk::Object> Object::get_parent()
+{
+
+  Glib::RefPtr<Atk::Object> retvalue = Glib::wrap(atk_object_get_parent(gobj()));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+int Object::get_n_accessible_children() const
+{
+  return atk_object_get_n_accessible_children(const_cast<AtkObject*>(gobj()));
+}
+
+Glib::RefPtr<Atk::Object> Object::get_accessible_child(int i)
+{
+  return Glib::wrap(atk_object_ref_accessible_child(gobj(), i));
+}
+
+Glib::RefPtr<RelationSet> Object::get_relation_set()
+{
+
+  Glib::RefPtr<RelationSet> retvalue = Glib::wrap(atk_object_ref_relation_set(gobj()));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Role Object::get_role() const
+{
+  return ((Role)(atk_object_get_role(const_cast<AtkObject*>(gobj()))));
+}
+
+Glib::RefPtr<StateSet> Object::get_state_set()
+{
+  return Glib::wrap(atk_object_ref_state_set(gobj()));
+}
+
+int Object::get_index_in_parent()
+{
+  return atk_object_get_index_in_parent(gobj());
+}
+
+void Object::set_name(const Glib::ustring& name)
+{
+  atk_object_set_name(gobj(), name.c_str());
+}
+
+void Object::set_description(const Glib::ustring& description)
+{
+  atk_object_set_description(gobj(), description.c_str());
+}
+
+void Object::set_parent(const Glib::RefPtr<Atk::Object>& parent)
+{
+  atk_object_set_parent(gobj(), Glib::unwrap(parent));
+}
+
+void Object::set_role(Role role)
+{
+  atk_object_set_role(gobj(), ((AtkRole)(role)));
+}
+
+void Object::notify_state_change(State state, bool value)
+{
+  atk_object_notify_state_change(gobj(), state, static_cast<int>(value));
+}
+
+bool Object::add_relationship(RelationType relationship, const Glib::RefPtr<Object>& target)
+{
+  return atk_object_add_relationship(gobj(), ((AtkRelationType)(relationship)), Glib::unwrap(target));
+}
+
+bool Object::remove_relationship(RelationType relationship, const Glib::RefPtr<Object>& target)
+{
+  return atk_object_remove_relationship(gobj(), ((AtkRelationType)(relationship)), Glib::unwrap(target));
+}
+
+
+Glib::SignalProxy2< void,guint,gpointer > Object::signal_children_changed()
+{
+  return Glib::SignalProxy2< void,guint,gpointer >(this, &Object_signal_children_changed_info);
+}
+
+Glib::SignalProxy1< void,bool > Object::signal_focus_event()
+{
+  return Glib::SignalProxy1< void,bool >(this, &Object_signal_focus_event_info);
+}
+
+Glib::SignalProxy1< void,AtkPropertyValues* > Object::signal_property_change()
+{
+  return Glib::SignalProxy1< void,AtkPropertyValues* >(this, &Object_signal_property_change_info);
+}
+
+Glib::SignalProxy2< void,const Glib::ustring&,bool > Object::signal_state_change()
+{
+  return Glib::SignalProxy2< void,const Glib::ustring&,bool >(this, &Object_signal_state_change_info);
+}
+
+Glib::SignalProxy0< void > Object::signal_visible_data_changed()
+{
+  return Glib::SignalProxy0< void >(this, &Object_signal_visible_data_changed_info);
+}
+
+Glib::SignalProxy1< void,void** > Object::signal_active_descendant_changed()
+{
+  return Glib::SignalProxy1< void,void** >(this, &Object_signal_active_descendant_changed_info);
+}
+
+
+Glib::PropertyProxy<Glib::ustring> Object::property_accessible_name() 
+{
+  return Glib::PropertyProxy<Glib::ustring>(this, "accessible-name");
+}
+
+Glib::PropertyProxy_ReadOnly<Glib::ustring> Object::property_accessible_name() const
+{
+  return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "accessible-name");
+}
+
+Glib::PropertyProxy<Glib::ustring> Object::property_accessible_description() 
+{
+  return Glib::PropertyProxy<Glib::ustring>(this, "accessible-description");
+}
+
+Glib::PropertyProxy_ReadOnly<Glib::ustring> Object::property_accessible_description() const
+{
+  return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "accessible-description");
+}
+
+Glib::PropertyProxy< Glib::RefPtr<Atk::Object> > Object::property_accessible_parent() 
+{
+  return Glib::PropertyProxy< Glib::RefPtr<Atk::Object> >(this, "accessible-parent");
+}
+
+Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Atk::Object> > Object::property_accessible_parent() const
+{
+  return Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Atk::Object> >(this, "accessible-parent");
+}
+
+Glib::PropertyProxy<double> Object::property_accessible_value() 
+{
+  return Glib::PropertyProxy<double>(this, "accessible-value");
+}
+
+Glib::PropertyProxy_ReadOnly<double> Object::property_accessible_value() const
+{
+  return Glib::PropertyProxy_ReadOnly<double>(this, "accessible-value");
+}
+
+Glib::PropertyProxy<int> Object::property_accessible_role() 
+{
+  return Glib::PropertyProxy<int>(this, "accessible-role");
+}
+
+Glib::PropertyProxy_ReadOnly<int> Object::property_accessible_role() const
+{
+  return Glib::PropertyProxy_ReadOnly<int>(this, "accessible-role");
+}
+
+Glib::PropertyProxy_ReadOnly<int> Object::property_accessible_component_layer() const
+{
+  return Glib::PropertyProxy_ReadOnly<int>(this, "accessible-component-layer");
+}
+
+Glib::PropertyProxy_ReadOnly<int> Object::property_accessible_component_mdi_zorder() const
+{
+  return Glib::PropertyProxy_ReadOnly<int>(this, "accessible-component-mdi-zorder");
+}
+
+Glib::PropertyProxy<Glib::ustring> Object::property_accessible_table_caption() 
+{
+  return Glib::PropertyProxy<Glib::ustring>(this, "accessible-table-caption");
+}
+
+Glib::PropertyProxy_ReadOnly<Glib::ustring> Object::property_accessible_table_caption() const
+{
+  return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "accessible-table-caption");
+}
+
+Glib::PropertyProxy<Glib::ustring> Object::property_accessible_table_column_description() 
+{
+  return Glib::PropertyProxy<Glib::ustring>(this, "accessible-table-column-description");
+}
+
+Glib::PropertyProxy_ReadOnly<Glib::ustring> Object::property_accessible_table_column_description() const
+{
+  return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "accessible-table-column-description");
+}
+
+Glib::PropertyProxy< Glib::RefPtr<Atk::Object> > Object::property_accessible_table_column_header() 
+{
+  return Glib::PropertyProxy< Glib::RefPtr<Atk::Object> >(this, "accessible-table-column-header");
+}
+
+Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Atk::Object> > Object::property_accessible_table_column_header() const
+{
+  return Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Atk::Object> >(this, "accessible-table-column-header");
+}
+
+Glib::PropertyProxy<Glib::ustring> Object::property_accessible_table_row_description() 
+{
+  return Glib::PropertyProxy<Glib::ustring>(this, "accessible-table-row-description");
+}
+
+Glib::PropertyProxy_ReadOnly<Glib::ustring> Object::property_accessible_table_row_description() const
+{
+  return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "accessible-table-row-description");
+}
+
+Glib::PropertyProxy< Glib::RefPtr<Atk::Object> > Object::property_accessible_table_row_header() 
+{
+  return Glib::PropertyProxy< Glib::RefPtr<Atk::Object> >(this, "accessible-table-row-header");
+}
+
+Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Atk::Object> > Object::property_accessible_table_row_header() const
+{
+  return Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Atk::Object> >(this, "accessible-table-row-header");
+}
+
+Glib::PropertyProxy< Glib::RefPtr<Atk::Object> > Object::property_accessible_table_summary() 
+{
+  return Glib::PropertyProxy< Glib::RefPtr<Atk::Object> >(this, "accessible-table-summary");
+}
+
+Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Atk::Object> > Object::property_accessible_table_summary() const
+{
+  return Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Atk::Object> >(this, "accessible-table-summary");
+}
+
+
+void Atk::Object::on_children_changed(guint change_index, gpointer changed_child)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->children_changed)
+    (*base->children_changed)(gobj(),change_index,changed_child);
+}
+
+void Atk::Object::on_focus_event(bool focus_in)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->focus_event)
+    (*base->focus_event)(gobj(),static_cast<int>(focus_in));
+}
+
+void Atk::Object::on_property_change(AtkPropertyValues* values)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->property_change)
+    (*base->property_change)(gobj(),values);
+}
+
+void Atk::Object::on_state_change(const Glib::ustring& name, bool state_set)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->state_change)
+    (*base->state_change)(gobj(),name.c_str(),static_cast<int>(state_set));
+}
+
+void Atk::Object::on_visible_data_changed()
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->visible_data_changed)
+    (*base->visible_data_changed)(gobj());
+}
+
+void Atk::Object::on_active_descendant_changed(void** child)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->active_descendant_changed)
+    (*base->active_descendant_changed)(gobj(),child);
+}
+
+
+} // namespace Atk
+
+
diff --git a/libs/gtkmm2/atk/atkmm/object.h b/libs/gtkmm2/atk/atkmm/object.h
new file mode 100644
index 0000000000..047cb2a254
--- /dev/null
+++ b/libs/gtkmm2/atk/atkmm/object.h
@@ -0,0 +1,570 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _ATKMM_OBJECT_H
+#define _ATKMM_OBJECT_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* Copyright (C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+
+#include <atkmm/component.h>
+#include <atkmm/relation.h>
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+extern "C" { typedef struct _AtkPropertyValues AtkPropertyValues; }
+#endif
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _AtkObject AtkObject;
+typedef struct _AtkObjectClass AtkObjectClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Atk
+{ class Object_Class; } // namespace Atk
+namespace Atk
+{
+
+
+/** @addtogroup atkmmEnums Enums and Flags */
+
+/**
+ * @ingroup atkmmEnums
+ */
+enum Role
+{
+  ROLE_INVALID,
+  ROLE_ACCEL_LABEL,
+  ROLE_ALERT,
+  ROLE_ANIMATION,
+  ROLE_ARROW,
+  ROLE_CALENDAR,
+  ROLE_CANVAS,
+  ROLE_CHECK_BOX,
+  ROLE_CHECK_MENU_ITEM,
+  ROLE_COLOR_CHOOSER,
+  ROLE_COLUMN_HEADER,
+  ROLE_COMBO_BOX,
+  ROLE_DATE_EDITOR,
+  ROLE_DESKTOP_ICON,
+  ROLE_DESKTOP_FRAME,
+  ROLE_DIAL,
+  ROLE_DIALOG,
+  ROLE_DIRECTORY_PANE,
+  ROLE_DRAWING_AREA,
+  ROLE_FILE_CHOOSER,
+  ROLE_FILLER,
+  ROLE_FONT_CHOOSER,
+  ROLE_FRAME,
+  ROLE_GLASS_PANE,
+  ROLE_HTML_CONTAINER,
+  ROLE_ICON,
+  ROLE_IMAGE,
+  ROLE_INTERNAL_FRAME,
+  ROLE_LABEL,
+  ROLE_LAYERED_PANE,
+  ROLE_LIST,
+  ROLE_LIST_ITEM,
+  ROLE_MENU,
+  ROLE_MENU_BAR,
+  ROLE_MENU_ITEM,
+  ROLE_OPTION_PANE,
+  ROLE_PAGE_TAB,
+  ROLE_PAGE_TAB_LIST,
+  ROLE_PANEL,
+  ROLE_PASSWORD_TEXT,
+  ROLE_POPUP_MENU,
+  ROLE_PROGRESS_BAR,
+  ROLE_PUSH_BUTTON,
+  ROLE_RADIO_BUTTON,
+  ROLE_RADIO_MENU_ITEM,
+  ROLE_ROOT_PANE,
+  ROLE_ROW_HEADER,
+  ROLE_SCROLL_BAR,
+  ROLE_SCROLL_PANE,
+  ROLE_SEPARATOR,
+  ROLE_SLIDER,
+  ROLE_SPLIT_PANE,
+  ROLE_SPIN_BUTTON,
+  ROLE_STATUSBAR,
+  ROLE_TABLE,
+  ROLE_TABLE_CELL,
+  ROLE_TABLE_COLUMN_HEADER,
+  ROLE_TABLE_ROW_HEADER,
+  ROLE_TEAR_OFF_MENU_ITEM,
+  ROLE_TERMINAL,
+  ROLE_TEXT,
+  ROLE_TOGGLE_BUTTON,
+  ROLE_TOOL_BAR,
+  ROLE_TOOL_TIP,
+  ROLE_TREE,
+  ROLE_TREE_TABLE,
+  ROLE_UNKNOWN,
+  ROLE_VIEWPORT,
+  ROLE_WINDOW,
+  ROLE_HEADER,
+  ROLE_FOOTER,
+  ROLE_PARAGRAPH,
+  ROLE_RULER,
+  ROLE_APPLICATION,
+  ROLE_AUTOCOMPLETE,
+  ROLE_EDITBAR,
+  ROLE_EMBEDDED,
+  ROLE_LAST_DEFINED
+};
+
+} // namespace Atk
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Atk::Role> : public Glib::Value_Enum<Atk::Role>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Atk
+{
+
+
+class RelationSet;
+class Relation;
+class StateSet;
+
+typedef guint64 State;
+
+/** The base object class for the Accessibility Toolkit API.
+ * This class is the primary class for accessibility support via the Accessibility ToolKit (ATK). Objects which are
+ * instances of Atk::Object (or instances of Atk::Object-derived types) are queried for properties which relate basic
+ * (and generic) properties of a UI component such as name and description. Instances of Atk::Object may also be queried
+ * as to whether they implement other ATK interfaces (e.g. Atk::Action, Atk::Component, etc.), as appropriate to the role
+ * which a given UI component plays in a user interface.
+ *
+ * All UI components in an application which provide useful information or services to the user must provide corresponding
+ * Atk::Object instances on request (in GTK+, for instance, usually on a call to Gtk::Widget::get_accessible()), either via
+ * ATK support built into the toolkit for the widget class or ancestor class, or in the case of custom widgets, if the
+ * inherited Atk::Object implementation is insufficient, via instances of a new Atk::Object subclass. 
+ */
+
+class Object : public Glib::Object
+{
+  
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+public:
+  typedef Object CppObjectType;
+  typedef Object_Class CppClassType;
+  typedef AtkObject BaseObjectType;
+  typedef AtkObjectClass BaseClassType;
+
+private:  friend class Object_Class;
+  static CppClassType object_class_;
+
+private:
+  // noncopyable
+  Object(const Object&);
+  Object& operator=(const Object&);
+
+protected:
+  explicit Object(const Glib::ConstructParams& construct_params);
+  explicit Object(AtkObject* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+  virtual ~Object();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GObject.
+  AtkObject*       gobj()       { return reinterpret_cast<AtkObject*>(gobject_); }
+
+  ///Provides access to the underlying C GObject.
+  const AtkObject* gobj() const { return reinterpret_cast<AtkObject*>(gobject_); }
+
+  ///Provides access to the underlying C instance. The caller is responsible for unrefing it. Use when directly setting fields in structs.
+  AtkObject* gobj_copy();
+
+private:
+
+   // see wrap_new() implementation in object.ccg
+  
+public:
+
+  
+  /** Gets the accessible name of the accessible.
+   * @return A character string representing the accessible name of the object.
+   */
+  Glib::ustring get_name() const;
+  
+  /** Gets the accessible description of the accessible.
+   * @return A character string representing the accessible description
+   * of the accessible.
+   */
+  Glib::ustring get_description() const;
+  
+  /** Gets the accessible parent of the accessible.
+   * @return A Atk::Object representing the accessible parent of the accessible.
+   */
+  Glib::RefPtr<Atk::Object> get_parent();
+  
+  /** Gets the number of accessible children of the accessible.
+   * @return An integer representing the number of accessible children
+   * of the accessible.
+   */
+  int get_n_accessible_children() const;
+  
+  /** Gets a reference to the specified accessible child of the object.
+   * The accessible children are 0-based so the first accessible child is
+   * at index 0, the second at index 1 and so on.
+   * @param i A <tt>int</tt> representing the position of the child, starting from 0.
+   * @return An Atk::Object representing the specified accessible child
+   * of the accessible.
+   */
+  Glib::RefPtr<Atk::Object> get_accessible_child(int i);
+  
+  /** Gets the Atk::RelationSet associated with the object.
+   * @return An Atk::RelationSet representing the relation set of the object.
+   */
+  Glib::RefPtr<RelationSet> get_relation_set();
+  
+  /** Gets the role of the accessible.
+   * @return An Atk::Role which is the role of the accessible.
+   */
+  Role get_role() const;
+  
+  /** Gets a reference to the state set of the accessible; the caller must
+   * unreference it when it is no longer needed.
+   * @return A reference to an Atk::StateSet which is the state
+   * set of the accessible.
+   */
+  Glib::RefPtr<StateSet> get_state_set();
+  
+  /** Gets the 0-based index of this accessible in its parent; returns -1 if the
+   * accessible does not have an accessible parent.
+   * @return An integer which is the index of the accessible in its parent.
+   */
+  int get_index_in_parent();
+  
+  /** Sets the accessible name of the accessible.
+   * @param name A character string to be set as the accessible name.
+   */
+  void set_name(const Glib::ustring& name);
+  
+  /** Sets the accessible description of the accessible.
+   * @param description A character string to be set as the accessible description.
+   */
+  void set_description(const Glib::ustring& description);
+  
+  /** Sets the accessible parent of the accessible.
+   * @param parent An Atk::Object to be set as the accessible parent.
+   */
+  void set_parent(const Glib::RefPtr<Atk::Object>& parent);
+  
+  /** Sets the role of the accessible.
+   * @param role An Atk::Role to be set as the role.
+   */
+  void set_role(Role role);
+  //_WRAP_METHOD(guint connect_property_change_handler(AtkPropertyChangeHandler* handler), atk_object_connect_property_change_handler)
+  //_WRAP_METHOD(void remove_property_change_handler(guint handler_id), atk_object_remove_property_change_handler)
+  
+  /** Emits a state-change signal for the specified state.
+   * @param state An Atk::State whose state is changed.
+   * @param value A <tt>bool</tt> which indicates whether the state is being set on or off.
+   */
+  void notify_state_change(State state, bool value);
+
+  
+  /** Adds a relationship of the specified type with the specified target.
+   * @param relationship The Atk::RelationType of the relation.
+   * @param target The Atk::Object which is to be the target of the relation.
+   * @return <tt>true</tt> if the relationship is added.
+   */
+  bool add_relationship(RelationType relationship, const Glib::RefPtr<Object>& target);
+  
+  /** Removes a relationship of the specified type with the specified target.
+   * @param relationship The Atk::RelationType of the relation.
+   * @param target The Atk::Object which is the target of the relation to be removed.
+   * @return <tt>true</tt> if the relationship is removed.
+   */
+  bool remove_relationship(RelationType relationship, const Glib::RefPtr<Object>& target);
+
+  
+  Glib::SignalProxy2< void,guint,gpointer > signal_children_changed();
+
+  
+  Glib::SignalProxy1< void,bool > signal_focus_event();
+
+  
+  Glib::SignalProxy1< void,AtkPropertyValues* > signal_property_change();
+
+  
+  Glib::SignalProxy2< void,const Glib::ustring&,bool > signal_state_change();
+
+  
+  Glib::SignalProxy0< void > signal_visible_data_changed();
+
+  
+  Glib::SignalProxy1< void,void** > signal_active_descendant_changed();
+
+
+  /** Object instance's name formatted for assistive technology access.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Glib::ustring> property_accessible_name() ;
+
+/** Object instance's name formatted for assistive technology access.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Glib::ustring> property_accessible_name() const;
+
+  /** Description of an object
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Glib::ustring> property_accessible_description() ;
+
+/** Description of an object
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Glib::ustring> property_accessible_description() const;
+
+  /** Is used to notify that the parent has changed.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy< Glib::RefPtr<Atk::Object> > property_accessible_parent() ;
+
+/** Is used to notify that the parent has changed.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Atk::Object> > property_accessible_parent() const;
+
+  /** Is used to notify that the value has changed.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<double> property_accessible_value() ;
+
+/** Is used to notify that the value has changed.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<double> property_accessible_value() const;
+
+  /** The accessible role of this object.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<int> property_accessible_role() ;
+
+/** The accessible role of this object.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<int> property_accessible_role() const;
+
+  /** The accessible layer of this object.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<int> property_accessible_component_layer() const;
+
+
+  /** The accessible MDI value of this object.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<int> property_accessible_component_mdi_zorder() const;
+
+
+  /** Is used to notify that the table caption has changed; this property should not be used. accessible-table-caption-object should be used instead.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Glib::ustring> property_accessible_table_caption() ;
+
+/** Is used to notify that the table caption has changed; this property should not be used. accessible-table-caption-object should be used instead.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Glib::ustring> property_accessible_table_caption() const;
+
+  /** Is used to notify that the table column description has changed.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Glib::ustring> property_accessible_table_column_description() ;
+
+/** Is used to notify that the table column description has changed.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Glib::ustring> property_accessible_table_column_description() const;
+
+  /** Is used to notify that the table column header has changed.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy< Glib::RefPtr<Atk::Object> > property_accessible_table_column_header() ;
+
+/** Is used to notify that the table column header has changed.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Atk::Object> > property_accessible_table_column_header() const;
+
+  /** Is used to notify that the table row description has changed.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Glib::ustring> property_accessible_table_row_description() ;
+
+/** Is used to notify that the table row description has changed.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Glib::ustring> property_accessible_table_row_description() const;
+
+  /** Is used to notify that the table row header has changed.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy< Glib::RefPtr<Atk::Object> > property_accessible_table_row_header() ;
+
+/** Is used to notify that the table row header has changed.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Atk::Object> > property_accessible_table_row_header() const;
+
+  /** Is used to notify that the table summary has changed.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy< Glib::RefPtr<Atk::Object> > property_accessible_table_summary() ;
+
+/** Is used to notify that the table summary has changed.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Atk::Object> > property_accessible_table_summary() const;
+
+
+public:
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+  virtual void on_children_changed(guint change_index, gpointer changed_child);
+  virtual void on_focus_event(bool focus_in);
+  virtual void on_property_change(AtkPropertyValues* values);
+  virtual void on_state_change(const Glib::ustring& name, bool state_set);
+  virtual void on_visible_data_changed();
+  virtual void on_active_descendant_changed(void** child);
+
+
+};
+
+} // namespace Atk
+
+
+namespace Glib
+{
+  /** @relates Atk::Object
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Glib::RefPtr<Atk::Object> wrap(AtkObject* object, bool take_copy = false);
+}
+
+
+#endif /* _ATKMM_OBJECT_H */
+
diff --git a/libs/gtkmm2/atk/atkmm/objectaccessible.cc b/libs/gtkmm2/atk/atkmm/objectaccessible.cc
new file mode 100644
index 0000000000..da4136bef7
--- /dev/null
+++ b/libs/gtkmm2/atk/atkmm/objectaccessible.cc
@@ -0,0 +1,165 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <atkmm/objectaccessible.h>
+#include <atkmm/private/objectaccessible_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* 
+ *
+ * Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <atk/atkgobjectaccessible.h>
+
+namespace
+{
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Glib::RefPtr<Atk::ObjectAccessible> wrap(AtkGObjectAccessible* object, bool take_copy)
+{
+  return Glib::RefPtr<Atk::ObjectAccessible>( dynamic_cast<Atk::ObjectAccessible*> (Glib::wrap_auto ((GObject*)(object), take_copy)) );
+  //We use dynamic_cast<> in case of multiple inheritance.
+}
+
+} /* namespace Glib */
+
+
+namespace Atk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& ObjectAccessible_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &ObjectAccessible_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(atk_gobject_accessible_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void ObjectAccessible_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+}
+
+
+Glib::ObjectBase* ObjectAccessible_Class::wrap_new(GObject* object)
+{
+  return new ObjectAccessible((AtkGObjectAccessible*)object);
+}
+
+
+/* The implementation: */
+
+AtkGObjectAccessible* ObjectAccessible::gobj_copy()
+{
+  reference();
+  return gobj();
+}
+
+ObjectAccessible::ObjectAccessible(const Glib::ConstructParams& construct_params)
+:
+  Atk::Object(construct_params)
+{}
+
+ObjectAccessible::ObjectAccessible(AtkGObjectAccessible* castitem)
+:
+  Atk::Object((AtkObject*)(castitem))
+{}
+
+ObjectAccessible::~ObjectAccessible()
+{}
+
+
+ObjectAccessible::CppClassType ObjectAccessible::objectaccessible_class_; // initialize static member
+
+GType ObjectAccessible::get_type()
+{
+  return objectaccessible_class_.init().get_type();
+}
+
+GType ObjectAccessible::get_base_type()
+{
+  return atk_gobject_accessible_get_type();
+}
+
+
+Glib::RefPtr<Glib::Object> ObjectAccessible::get_object()
+{
+
+  Glib::RefPtr<Glib::Object> retvalue = Glib::wrap(atk_gobject_accessible_get_object(gobj()));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::RefPtr<const Glib::Object> ObjectAccessible::get_object() const
+{
+
+  Glib::RefPtr<const Glib::Object> retvalue = Glib::wrap(atk_gobject_accessible_get_object(const_cast<AtkGObjectAccessible*>(gobj())));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::RefPtr<Atk::Object> ObjectAccessible::for_object(const Glib::RefPtr<Glib::Object>& obj)
+{
+
+  Glib::RefPtr<Atk::Object> retvalue = Glib::wrap(atk_gobject_accessible_for_object(Glib::unwrap(obj)));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::RefPtr<const Atk::Object> ObjectAccessible::for_object(const Glib::RefPtr<const Glib::Object>& obj)
+{
+
+  Glib::RefPtr<const Atk::Object> retvalue = Glib::wrap(atk_gobject_accessible_for_object(const_cast<GObject*>(Glib::unwrap<Glib::Object>(obj))));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+
+} // namespace Atk
+
+
diff --git a/libs/gtkmm2/atk/atkmm/objectaccessible.h b/libs/gtkmm2/atk/atkmm/objectaccessible.h
new file mode 100644
index 0000000000..d266f9a97e
--- /dev/null
+++ b/libs/gtkmm2/atk/atkmm/objectaccessible.h
@@ -0,0 +1,145 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _ATKMM_OBJECTACCESSIBLE_H
+#define _ATKMM_OBJECTACCESSIBLE_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* Copyright (C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+ 
+#include <atkmm/object.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _AtkGObjectAccessible AtkGObjectAccessible;
+typedef struct _AtkGObjectAccessibleClass AtkGObjectAccessibleClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Atk
+{ class ObjectAccessible_Class; } // namespace Atk
+namespace Atk
+{
+
+/** This object class is derived from AtkObject and can be used as a basis implementing accessible objects.
+ * This can be used as a basis for implementing accessible objects for Glib::Objects which are not derived from
+ * Gtk::Widget. One example of its use is in providing an accessible object for GnomeCanvasItem in the GAIL library.
+ */
+
+class ObjectAccessible : public Atk::Object
+{
+   
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+public:
+  typedef ObjectAccessible CppObjectType;
+  typedef ObjectAccessible_Class CppClassType;
+  typedef AtkGObjectAccessible BaseObjectType;
+  typedef AtkGObjectAccessibleClass BaseClassType;
+
+private:  friend class ObjectAccessible_Class;
+  static CppClassType objectaccessible_class_;
+
+private:
+  // noncopyable
+  ObjectAccessible(const ObjectAccessible&);
+  ObjectAccessible& operator=(const ObjectAccessible&);
+
+protected:
+  explicit ObjectAccessible(const Glib::ConstructParams& construct_params);
+  explicit ObjectAccessible(AtkGObjectAccessible* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+  virtual ~ObjectAccessible();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GObject.
+  AtkGObjectAccessible*       gobj()       { return reinterpret_cast<AtkGObjectAccessible*>(gobject_); }
+
+  ///Provides access to the underlying C GObject.
+  const AtkGObjectAccessible* gobj() const { return reinterpret_cast<AtkGObjectAccessible*>(gobject_); }
+
+  ///Provides access to the underlying C instance. The caller is responsible for unrefing it. Use when directly setting fields in structs.
+  AtkGObjectAccessible* gobj_copy();
+
+private:
+
+protected:
+
+  
+  /** Gets the GObject for which @a obj  is the accessible object.
+   * @return A G::Object which is the object for which @a obj  is the accessible objedct.
+   */
+  Glib::RefPtr<Glib::Object> get_object();
+  
+  /** Gets the GObject for which @a obj  is the accessible object.
+   * @return A G::Object which is the object for which @a obj  is the accessible objedct.
+   */
+  Glib::RefPtr<const Glib::Object> get_object() const;
+
+  
+  /** Gets the accessible object for the specified @a obj .
+   * @param obj A G::Object.
+   * @return A Atk::Object which is the accessible object for the @a obj .
+   */
+  static Glib::RefPtr<Atk::Object> for_object(const Glib::RefPtr<Glib::Object>& obj);
+  
+  /** Gets the accessible object for the specified @a obj .
+   * @param obj A G::Object.
+   * @return A Atk::Object which is the accessible object for the @a obj .
+   */
+  static Glib::RefPtr<const Atk::Object> for_object(const Glib::RefPtr<const Glib::Object>& obj);
+
+
+public:
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+};
+
+} // namespace Atk
+
+
+namespace Glib
+{
+  /** @relates Atk::ObjectAccessible
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Glib::RefPtr<Atk::ObjectAccessible> wrap(AtkGObjectAccessible* object, bool take_copy = false);
+}
+
+
+#endif /* _ATKMM_OBJECTACCESSIBLE_H */
+
diff --git a/libs/gtkmm2/atk/atkmm/private/action_p.h b/libs/gtkmm2/atk/atkmm/private/action_p.h
new file mode 100644
index 0000000000..bb3c5afa09
--- /dev/null
+++ b/libs/gtkmm2/atk/atkmm/private/action_p.h
@@ -0,0 +1,47 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _ATKMM_ACTION_P_H
+#define _ATKMM_ACTION_P_H
+#include <glibmm/private/interface_p.h>
+
+#include <glibmm/private/interface_p.h>
+
+namespace Atk
+{
+
+class Action_Class : public Glib::Interface_Class
+{
+public:
+  typedef Action CppObjectType;
+  typedef AtkAction BaseObjectType;
+  typedef AtkActionIface BaseClassType;
+  typedef Glib::Interface_Class CppClassParent;
+
+  friend class Action;
+
+  const Glib::Interface_Class& init();
+
+  static void iface_init_function(void* g_iface, void* iface_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+  static gboolean do_action_vfunc_callback(AtkAction* self, gint i);
+  static gint get_n_actions_vfunc_callback(AtkAction* self);
+  static const gchar* get_description_vfunc_callback(AtkAction* self, gint i);
+  static const gchar* get_name_vfunc_callback(AtkAction* self, gint i);
+  static const gchar* get_keybinding_vfunc_callback(AtkAction* self, gint i);
+  static gboolean set_description_vfunc_callback(AtkAction* self, gint i, const gchar* desc);
+};
+
+
+} // namespace Atk
+
+#endif /* _ATKMM_ACTION_P_H */
+
diff --git a/libs/gtkmm2/atk/atkmm/private/component_p.h b/libs/gtkmm2/atk/atkmm/private/component_p.h
new file mode 100644
index 0000000000..010df9e92f
--- /dev/null
+++ b/libs/gtkmm2/atk/atkmm/private/component_p.h
@@ -0,0 +1,54 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _ATKMM_COMPONENT_P_H
+#define _ATKMM_COMPONENT_P_H
+#include <atk/atkcomponent.h>
+
+#include <glibmm/private/interface_p.h>
+
+namespace Atk
+{
+
+class Component_Class : public Glib::Interface_Class
+{
+public:
+  typedef Component CppObjectType;
+  typedef AtkComponent BaseObjectType;
+  typedef AtkComponentIface BaseClassType;
+  typedef Glib::Interface_Class CppClassParent;
+
+  friend class Component;
+
+  const Glib::Interface_Class& init();
+
+  static void iface_init_function(void* g_iface, void* iface_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+  static guint add_focus_handler_vfunc_callback(AtkComponent* self, AtkFocusHandler handler);
+  static gboolean contains_vfunc_callback(AtkComponent* self, gint x, gint y, AtkCoordType coord_type);
+  static AtkObject* ref_accessible_at_point_vfunc_callback(AtkComponent* self, gint x, gint y, AtkCoordType coord_type);
+  static void get_extents_vfunc_callback(AtkComponent* self, gint* x, gint* y, gint* width, gint* height, AtkCoordType coord_type);
+  static void get_position_vfunc_callback(AtkComponent* self, gint* x, gint* y, AtkCoordType coord_type);
+  static void get_size_vfunc_callback(AtkComponent* self, gint* width, gint* height);
+  static AtkLayer get_layer_vfunc_callback(AtkComponent* self);
+  static gint get_mdi_zorder_vfunc_callback(AtkComponent* self);
+  static gboolean grab_focus_vfunc_callback(AtkComponent* self);
+  static void remove_focus_handler_vfunc_callback(AtkComponent* self, guint handler_id);
+  static gboolean set_extents_vfunc_callback(AtkComponent* self, gint x, gint y, gint width, gint height, AtkCoordType coord_type);
+  static gboolean set_position_vfunc_callback(AtkComponent* self, gint x, gint y, AtkCoordType coord_type);
+  static gboolean set_size_vfunc_callback(AtkComponent* self, gint width, gint height);
+};
+
+
+} // namespace Atk
+
+#endif /* _ATKMM_COMPONENT_P_H */
+
diff --git a/libs/gtkmm2/atk/atkmm/private/document_p.h b/libs/gtkmm2/atk/atkmm/private/document_p.h
new file mode 100644
index 0000000000..01115486b5
--- /dev/null
+++ b/libs/gtkmm2/atk/atkmm/private/document_p.h
@@ -0,0 +1,43 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _ATKMM_DOCUMENT_P_H
+#define _ATKMM_DOCUMENT_P_H
+#include <glibmm/private/object_p.h>
+
+#include <glibmm/private/interface_p.h>
+
+namespace Atk
+{
+
+class Document_Class : public Glib::Interface_Class
+{
+public:
+  typedef Document CppObjectType;
+  typedef AtkDocument BaseObjectType;
+  typedef AtkDocumentIface BaseClassType;
+  typedef Glib::Interface_Class CppClassParent;
+
+  friend class Document;
+
+  const Glib::Interface_Class& init();
+
+  static void iface_init_function(void* g_iface, void* iface_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+  static const gchar* get_document_type_vfunc_callback(AtkDocument* self);
+  static gpointer get_document_vfunc_callback(AtkDocument* self);
+};
+
+
+} // namespace Atk
+
+#endif /* _ATKMM_DOCUMENT_P_H */
+
diff --git a/libs/gtkmm2/atk/atkmm/private/editabletext_p.h b/libs/gtkmm2/atk/atkmm/private/editabletext_p.h
new file mode 100644
index 0000000000..fb5004ed1d
--- /dev/null
+++ b/libs/gtkmm2/atk/atkmm/private/editabletext_p.h
@@ -0,0 +1,47 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _ATKMM_EDITABLETEXT_P_H
+#define _ATKMM_EDITABLETEXT_P_H
+
+#include <glibmm/private/interface_p.h>
+
+namespace Atk
+{
+
+class EditableText_Class : public Glib::Interface_Class
+{
+public:
+  typedef EditableText CppObjectType;
+  typedef AtkEditableText BaseObjectType;
+  typedef AtkEditableTextIface BaseClassType;
+  typedef Glib::Interface_Class CppClassParent;
+
+  friend class EditableText;
+
+  const Glib::Interface_Class& init();
+
+  static void iface_init_function(void* g_iface, void* iface_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+  static gboolean set_run_attributes_vfunc_callback(AtkEditableText* self, AtkAttributeSet* attrib_set, gint start_offset, gint end_offset);
+  static void set_text_contents_vfunc_callback(AtkEditableText* self, const gchar* string);
+  static void insert_text_vfunc_callback(AtkEditableText* self, const gchar* string, gint length, gint* position);
+  static void copy_text_vfunc_callback(AtkEditableText* self, gint start_pos, gint end_pos);
+  static void cut_text_vfunc_callback(AtkEditableText* self, gint start_pos, gint end_pos);
+  static void delete_text_vfunc_callback(AtkEditableText* self, gint start_pos, gint end_pos);
+  static void paste_text_vfunc_callback(AtkEditableText* self, gint position);
+};
+
+
+} // namespace Atk
+
+#endif /* _ATKMM_EDITABLETEXT_P_H */
+
diff --git a/libs/gtkmm2/atk/atkmm/private/hyperlink_p.h b/libs/gtkmm2/atk/atkmm/private/hyperlink_p.h
new file mode 100644
index 0000000000..a5d9e61275
--- /dev/null
+++ b/libs/gtkmm2/atk/atkmm/private/hyperlink_p.h
@@ -0,0 +1,54 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _ATKMM_HYPERLINK_P_H
+#define _ATKMM_HYPERLINK_P_H
+#include <glibmm/private/object_p.h>
+#include <atk/atkobject.h>
+
+#include <glibmm/class.h>
+
+namespace Atk
+{
+
+class Hyperlink_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Hyperlink CppObjectType;
+  typedef AtkHyperlink BaseObjectType;
+  typedef AtkHyperlinkClass BaseClassType;
+  typedef Glib::Object_Class CppClassParent;
+  typedef GObjectClass BaseClassParent;
+
+  friend class Hyperlink;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+  static void link_activated_callback(AtkHyperlink* self);
+
+  //Callbacks (virtual functions):
+  static gchar* get_uri_vfunc_callback(AtkHyperlink* self, gint i);
+  static AtkObject* get_object_vfunc_callback(AtkHyperlink* self, gint i);
+  static gint get_end_index_vfunc_callback(AtkHyperlink* self);
+  static gint get_start_index_vfunc_callback(AtkHyperlink* self);
+  static gboolean is_valid_vfunc_callback(AtkHyperlink* self);
+  static gint get_n_anchors_vfunc_callback(AtkHyperlink* self);
+  static guint link_state_vfunc_callback(AtkHyperlink* self);
+  static gboolean is_selected_link_vfunc_callback(AtkHyperlink* self);
+};
+
+
+} // namespace Atk
+
+#endif /* _ATKMM_HYPERLINK_P_H */
+
diff --git a/libs/gtkmm2/atk/atkmm/private/hypertext_p.h b/libs/gtkmm2/atk/atkmm/private/hypertext_p.h
new file mode 100644
index 0000000000..79eaad32c5
--- /dev/null
+++ b/libs/gtkmm2/atk/atkmm/private/hypertext_p.h
@@ -0,0 +1,45 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _ATKMM_HYPERTEXT_P_H
+#define _ATKMM_HYPERTEXT_P_H
+#include <glibmm/private/object_p.h>
+
+#include <glibmm/private/interface_p.h>
+
+namespace Atk
+{
+
+class Hypertext_Class : public Glib::Interface_Class
+{
+public:
+  typedef Hypertext CppObjectType;
+  typedef AtkHypertext BaseObjectType;
+  typedef AtkHypertextIface BaseClassType;
+  typedef Glib::Interface_Class CppClassParent;
+
+  friend class Hypertext;
+
+  const Glib::Interface_Class& init();
+
+  static void iface_init_function(void* g_iface, void* iface_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+  static void link_selected_callback(AtkHypertext* self, gint p0);
+
+  //Callbacks (virtual functions):
+  static AtkHyperlink* get_link_vfunc_callback(AtkHypertext* self, gint link_index);
+  static gint get_n_links_vfunc_callback(AtkHypertext* self);
+  static gint get_link_index_vfunc_callback(AtkHypertext* self, gint char_index);
+};
+
+
+} // namespace Atk
+
+#endif /* _ATKMM_HYPERTEXT_P_H */
+
diff --git a/libs/gtkmm2/atk/atkmm/private/image_p.h b/libs/gtkmm2/atk/atkmm/private/image_p.h
new file mode 100644
index 0000000000..b2e8d327ca
--- /dev/null
+++ b/libs/gtkmm2/atk/atkmm/private/image_p.h
@@ -0,0 +1,45 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _ATKMM_IMAGE_P_H
+#define _ATKMM_IMAGE_P_H
+#include <atk/atkimage.h>
+
+#include <glibmm/private/interface_p.h>
+
+namespace Atk
+{
+
+class Image_Class : public Glib::Interface_Class
+{
+public:
+  typedef Image CppObjectType;
+  typedef AtkImage BaseObjectType;
+  typedef AtkImageIface BaseClassType;
+  typedef Glib::Interface_Class CppClassParent;
+
+  friend class Image;
+
+  const Glib::Interface_Class& init();
+
+  static void iface_init_function(void* g_iface, void* iface_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+  static gboolean set_image_description_vfunc_callback(AtkImage* self, const gchar* description);
+  static const gchar* get_image_description_vfunc_callback(AtkImage* self);
+  static void get_image_position_vfunc_callback(AtkImage* self, gint* x, gint* y, AtkCoordType coord_type);
+  static void get_image_size_vfunc_callback(AtkImage* self, gint* width, gint* height);
+};
+
+
+} // namespace Atk
+
+#endif /* _ATKMM_IMAGE_P_H */
+
diff --git a/libs/gtkmm2/atk/atkmm/private/implementor_p.h b/libs/gtkmm2/atk/atkmm/private/implementor_p.h
new file mode 100644
index 0000000000..7c5fc8804f
--- /dev/null
+++ b/libs/gtkmm2/atk/atkmm/private/implementor_p.h
@@ -0,0 +1,41 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _ATKMM_IMPLEMENTOR_P_H
+#define _ATKMM_IMPLEMENTOR_P_H
+
+#include <glibmm/private/interface_p.h>
+
+namespace Atk
+{
+
+class Implementor_Class : public Glib::Interface_Class
+{
+public:
+  typedef Implementor CppObjectType;
+  typedef AtkImplementor BaseObjectType;
+  typedef AtkImplementorIface BaseClassType;
+  typedef Glib::Interface_Class CppClassParent;
+
+  friend class Implementor;
+
+  const Glib::Interface_Class& init();
+
+  static void iface_init_function(void* g_iface, void* iface_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+  static AtkObject* ref_accessible_vfunc_callback(AtkImplementor* self);
+};
+
+
+} // namespace Atk
+
+#endif /* _ATKMM_IMPLEMENTOR_P_H */
+
diff --git a/libs/gtkmm2/atk/atkmm/private/noopobject_p.h b/libs/gtkmm2/atk/atkmm/private/noopobject_p.h
new file mode 100644
index 0000000000..afa515b316
--- /dev/null
+++ b/libs/gtkmm2/atk/atkmm/private/noopobject_p.h
@@ -0,0 +1,44 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _ATKMM_NOOPOBJECT_P_H
+#define _ATKMM_NOOPOBJECT_P_H
+#include <atkmm/private/object_p.h>
+
+#include <glibmm/class.h>
+
+namespace Atk
+{
+
+class NoOpObject_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef NoOpObject CppObjectType;
+  typedef AtkNoOpObject BaseObjectType;
+  typedef AtkNoOpObjectClass BaseClassType;
+  typedef Atk::Object_Class CppClassParent;
+  typedef AtkObjectClass BaseClassParent;
+
+  friend class NoOpObject;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Atk
+
+#endif /* _ATKMM_NOOPOBJECT_P_H */
+
diff --git a/libs/gtkmm2/atk/atkmm/private/object_p.h b/libs/gtkmm2/atk/atkmm/private/object_p.h
new file mode 100644
index 0000000000..f65e8f8c08
--- /dev/null
+++ b/libs/gtkmm2/atk/atkmm/private/object_p.h
@@ -0,0 +1,50 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _ATKMM_OBJECT_P_H
+#define _ATKMM_OBJECT_P_H
+#include <glibmm/private/object_p.h>
+
+#include <glibmm/class.h>
+
+namespace Atk
+{
+
+class Object_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Object CppObjectType;
+  typedef AtkObject BaseObjectType;
+  typedef AtkObjectClass BaseClassType;
+  typedef Glib::Object_Class CppClassParent;
+  typedef GObjectClass BaseClassParent;
+
+  friend class Object;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+  static void children_changed_callback(AtkObject* self, guint p0, gpointer p1);
+  static void focus_event_callback(AtkObject* self, gboolean p0);
+  static void property_change_callback(AtkObject* self, AtkPropertyValues* p0);
+  static void state_change_callback(AtkObject* self, const gchar* p0, gboolean p1);
+  static void visible_data_changed_callback(AtkObject* self);
+  static void active_descendant_changed_callback(AtkObject* self, gpointer* p0);
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Atk
+
+#endif /* _ATKMM_OBJECT_P_H */
+
diff --git a/libs/gtkmm2/atk/atkmm/private/objectaccessible_p.h b/libs/gtkmm2/atk/atkmm/private/objectaccessible_p.h
new file mode 100644
index 0000000000..b94c1320e5
--- /dev/null
+++ b/libs/gtkmm2/atk/atkmm/private/objectaccessible_p.h
@@ -0,0 +1,44 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _ATKMM_OBJECTACCESSIBLE_P_H
+#define _ATKMM_OBJECTACCESSIBLE_P_H
+#include <atkmm/private/object_p.h>
+
+#include <glibmm/class.h>
+
+namespace Atk
+{
+
+class ObjectAccessible_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef ObjectAccessible CppObjectType;
+  typedef AtkGObjectAccessible BaseObjectType;
+  typedef AtkGObjectAccessibleClass BaseClassType;
+  typedef Atk::Object_Class CppClassParent;
+  typedef AtkObjectClass BaseClassParent;
+
+  friend class ObjectAccessible;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Atk
+
+#endif /* _ATKMM_OBJECTACCESSIBLE_P_H */
+
diff --git a/libs/gtkmm2/atk/atkmm/private/relation_p.h b/libs/gtkmm2/atk/atkmm/private/relation_p.h
new file mode 100644
index 0000000000..63513db828
--- /dev/null
+++ b/libs/gtkmm2/atk/atkmm/private/relation_p.h
@@ -0,0 +1,44 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _ATKMM_RELATION_P_H
+#define _ATKMM_RELATION_P_H
+#include <glibmm/private/object_p.h>
+
+#include <glibmm/class.h>
+
+namespace Atk
+{
+
+class Relation_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Relation CppObjectType;
+  typedef AtkRelation BaseObjectType;
+  typedef AtkRelationClass BaseClassType;
+  typedef Glib::Object_Class CppClassParent;
+  typedef GObjectClass BaseClassParent;
+
+  friend class Relation;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Atk
+
+#endif /* _ATKMM_RELATION_P_H */
+
diff --git a/libs/gtkmm2/atk/atkmm/private/relationset_p.h b/libs/gtkmm2/atk/atkmm/private/relationset_p.h
new file mode 100644
index 0000000000..8d3787e6e6
--- /dev/null
+++ b/libs/gtkmm2/atk/atkmm/private/relationset_p.h
@@ -0,0 +1,44 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _ATKMM_RELATIONSET_P_H
+#define _ATKMM_RELATIONSET_P_H
+#include <glibmm/private/object_p.h>
+
+#include <glibmm/class.h>
+
+namespace Atk
+{
+
+class RelationSet_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef RelationSet CppObjectType;
+  typedef AtkRelationSet BaseObjectType;
+  typedef AtkRelationSetClass BaseClassType;
+  typedef Glib::Object_Class CppClassParent;
+  typedef GObjectClass BaseClassParent;
+
+  friend class RelationSet;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Atk
+
+#endif /* _ATKMM_RELATIONSET_P_H */
+
diff --git a/libs/gtkmm2/atk/atkmm/private/selection_p.h b/libs/gtkmm2/atk/atkmm/private/selection_p.h
new file mode 100644
index 0000000000..dd5f27702a
--- /dev/null
+++ b/libs/gtkmm2/atk/atkmm/private/selection_p.h
@@ -0,0 +1,49 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _ATKMM_SELECTION_P_H
+#define _ATKMM_SELECTION_P_H
+#include <atk/atkobject.h>
+
+#include <glibmm/private/interface_p.h>
+
+namespace Atk
+{
+
+class Selection_Class : public Glib::Interface_Class
+{
+public:
+  typedef Selection CppObjectType;
+  typedef AtkSelection BaseObjectType;
+  typedef AtkSelectionIface BaseClassType;
+  typedef Glib::Interface_Class CppClassParent;
+
+  friend class Selection;
+
+  const Glib::Interface_Class& init();
+
+  static void iface_init_function(void* g_iface, void* iface_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+  static void selection_changed_callback(AtkSelection* self);
+
+  //Callbacks (virtual functions):
+  static gboolean add_selection_vfunc_callback(AtkSelection* self, gint i);
+  static gboolean clear_selection_vfunc_callback(AtkSelection* self);
+  static AtkObject* ref_selection_vfunc_callback(AtkSelection* self, gint i);
+  static gint get_selection_count_vfunc_callback(AtkSelection* self);
+  static gboolean is_child_selected_vfunc_callback(AtkSelection* self, gint i);
+  static gboolean remove_selection_vfunc_callback(AtkSelection* self, gint i);
+  static gboolean select_all_selection_vfunc_callback(AtkSelection* self);
+};
+
+
+} // namespace Atk
+
+#endif /* _ATKMM_SELECTION_P_H */
+
diff --git a/libs/gtkmm2/atk/atkmm/private/stateset_p.h b/libs/gtkmm2/atk/atkmm/private/stateset_p.h
new file mode 100644
index 0000000000..51dd352ec0
--- /dev/null
+++ b/libs/gtkmm2/atk/atkmm/private/stateset_p.h
@@ -0,0 +1,44 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _ATKMM_STATESET_P_H
+#define _ATKMM_STATESET_P_H
+#include <glibmm/private/object_p.h>
+
+#include <glibmm/class.h>
+
+namespace Atk
+{
+
+class StateSet_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef StateSet CppObjectType;
+  typedef AtkStateSet BaseObjectType;
+  typedef AtkStateSetClass BaseClassType;
+  typedef Glib::Object_Class CppClassParent;
+  typedef GObjectClass BaseClassParent;
+
+  friend class StateSet;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Atk
+
+#endif /* _ATKMM_STATESET_P_H */
+
diff --git a/libs/gtkmm2/atk/atkmm/private/streamablecontent_p.h b/libs/gtkmm2/atk/atkmm/private/streamablecontent_p.h
new file mode 100644
index 0000000000..7c22e8c8ec
--- /dev/null
+++ b/libs/gtkmm2/atk/atkmm/private/streamablecontent_p.h
@@ -0,0 +1,44 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _ATKMM_STREAMABLECONTENT_P_H
+#define _ATKMM_STREAMABLECONTENT_P_H
+#include <glibmm/private/object_p.h>
+
+#include <glibmm/private/interface_p.h>
+
+namespace Atk
+{
+
+class StreamableContent_Class : public Glib::Interface_Class
+{
+public:
+  typedef StreamableContent CppObjectType;
+  typedef AtkStreamableContent BaseObjectType;
+  typedef AtkStreamableContentIface BaseClassType;
+  typedef Glib::Interface_Class CppClassParent;
+
+  friend class StreamableContent;
+
+  const Glib::Interface_Class& init();
+
+  static void iface_init_function(void* g_iface, void* iface_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+  static int get_n_mime_types_vfunc_callback(AtkStreamableContent* self);
+  static const gchar* get_mime_type_vfunc_callback(AtkStreamableContent* self, gint i);
+  static GIOChannel* get_stream_vfunc_callback(AtkStreamableContent* self, const gchar* mime_type);
+};
+
+
+} // namespace Atk
+
+#endif /* _ATKMM_STREAMABLECONTENT_P_H */
+
diff --git a/libs/gtkmm2/atk/atkmm/private/table_p.h b/libs/gtkmm2/atk/atkmm/private/table_p.h
new file mode 100644
index 0000000000..5516bb05c9
--- /dev/null
+++ b/libs/gtkmm2/atk/atkmm/private/table_p.h
@@ -0,0 +1,77 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _ATKMM_TABLE_P_H
+#define _ATKMM_TABLE_P_H
+#include <atk/atkobject.h>
+
+#include <glibmm/private/interface_p.h>
+
+namespace Atk
+{
+
+class Table_Class : public Glib::Interface_Class
+{
+public:
+  typedef Table CppObjectType;
+  typedef AtkTable BaseObjectType;
+  typedef AtkTableIface BaseClassType;
+  typedef Glib::Interface_Class CppClassParent;
+
+  friend class Table;
+
+  const Glib::Interface_Class& init();
+
+  static void iface_init_function(void* g_iface, void* iface_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+  static void row_inserted_callback(AtkTable* self, gint p0, gint p1);
+  static void column_inserted_callback(AtkTable* self, gint p0, gint p1);
+  static void row_deleted_callback(AtkTable* self, gint p0, gint p1);
+  static void column_deleted_callback(AtkTable* self, gint p0, gint p1);
+  static void row_reordered_callback(AtkTable* self);
+  static void column_reordered_callback(AtkTable* self);
+  static void model_changed_callback(AtkTable* self);
+
+  //Callbacks (virtual functions):
+  static AtkObject* ref_at_vfunc_callback(AtkTable* self, gint row, gint column);
+  static gint get_index_at_vfunc_callback(AtkTable* self, gint row, gint column);
+  static gint get_column_at_index_vfunc_callback(AtkTable* self, gint index_);
+  static gint get_row_at_index_vfunc_callback(AtkTable* self, gint index_);
+  static gint get_n_columns_vfunc_callback(AtkTable* self);
+  static gint get_n_rows_vfunc_callback(AtkTable* self);
+  static gint get_column_extent_at_vfunc_callback(AtkTable* self, gint row, gint column);
+  static gint get_row_extent_at_vfunc_callback(AtkTable* self, gint row, gint column);
+  static AtkObject* get_caption_vfunc_callback(AtkTable* self);
+  static const gchar* get_column_description_vfunc_callback(AtkTable* self, gint column);
+  static AtkObject* get_column_header_vfunc_callback(AtkTable* self, gint column);
+  static const gchar* get_row_description_vfunc_callback(AtkTable* self, gint row);
+  static AtkObject* get_row_header_vfunc_callback(AtkTable* self, gint row);
+  static AtkObject* get_summary_vfunc_callback(AtkTable* self);
+  static void set_caption_vfunc_callback(AtkTable* self, AtkObject* caption);
+  static void set_column_description_vfunc_callback(AtkTable* self, gint column, const gchar* description);
+  static void set_column_header_vfunc_callback(AtkTable* self, gint column, AtkObject* header);
+  static void set_row_description_vfunc_callback(AtkTable* self, gint row, const gchar* description);
+  static void set_row_header_vfunc_callback(AtkTable* self, gint row, AtkObject* header);
+  static void set_summary_vfunc_callback(AtkTable* self, AtkObject* accessible);
+  static gboolean is_column_selected_vfunc_callback(AtkTable* self, gint column);
+  static gboolean is_row_selected_vfunc_callback(AtkTable* self, gint row);
+  static gboolean is_selected_vfunc_callback(AtkTable* self, gint row, gint column);
+  static gboolean add_row_selection_vfunc_callback(AtkTable* self, gint row);
+  static gboolean remove_row_selection_vfunc_callback(AtkTable* self, gint row);
+  static gboolean add_column_selection_vfunc_callback(AtkTable* self, gint column);
+  static gboolean remove_column_selection_vfunc_callback(AtkTable* self, gint column);
+  static gint get_selected_columns_vfunc_callback(AtkTable* self, gint** selected);
+  static gint get_selected_rows_vfunc_callback(AtkTable* self, gint** selected);
+};
+
+
+} // namespace Atk
+
+#endif /* _ATKMM_TABLE_P_H */
+
diff --git a/libs/gtkmm2/atk/atkmm/private/text_p.h b/libs/gtkmm2/atk/atkmm/private/text_p.h
new file mode 100644
index 0000000000..3ccc748965
--- /dev/null
+++ b/libs/gtkmm2/atk/atkmm/private/text_p.h
@@ -0,0 +1,61 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _ATKMM_TEXT_P_H
+#define _ATKMM_TEXT_P_H
+
+#include <glibmm/private/interface_p.h>
+
+namespace Atk
+{
+
+class Text_Class : public Glib::Interface_Class
+{
+public:
+  typedef Text CppObjectType;
+  typedef AtkText BaseObjectType;
+  typedef AtkTextIface BaseClassType;
+  typedef Glib::Interface_Class CppClassParent;
+
+  friend class Text;
+
+  const Glib::Interface_Class& init();
+
+  static void iface_init_function(void* g_iface, void* iface_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+  static void text_changed_callback(AtkText* self, gint p0, gint p1);
+  static void text_caret_moved_callback(AtkText* self, gint p0);
+  static void text_selection_changed_callback(AtkText* self);
+  static void text_attributes_changed_callback(AtkText* self);
+
+  //Callbacks (virtual functions):
+  static gchar* get_text_vfunc_callback(AtkText* self, gint start_offset, gint end_offset);
+  static gunichar get_character_at_offset_vfunc_callback(AtkText* self, gint offset);
+  static gchar* get_text_after_offset_vfunc_callback(AtkText* self, gint offset, AtkTextBoundary boundary_type, gint* start_offset, gint* end_offset);
+  static gchar* get_text_at_offset_vfunc_callback(AtkText* self, gint offset, AtkTextBoundary boundary_type, gint* start_offset, gint* end_offset);
+  static gchar* get_text_before_offset_vfunc_callback(AtkText* self, gint offset, AtkTextBoundary boundary_type, gint* start_offset, gint* end_offset);
+  static gint get_caret_offset_vfunc_callback(AtkText* self);
+  static void get_character_extents_vfunc_callback(AtkText* self, gint offset, gint* x, gint* y, gint* width, gint* height, AtkCoordType coords);
+  static AtkAttributeSet* get_run_attributes_vfunc_callback(AtkText* self, gint offset, gint* start_offset, gint* end_offset);
+  static AtkAttributeSet* get_default_attributes_vfunc_callback(AtkText* self);
+  static gint get_character_count_vfunc_callback(AtkText* self);
+  static gint get_offset_at_point_vfunc_callback(AtkText* self, gint x, gint y, AtkCoordType coords);
+  static gint get_n_selections_vfunc_callback(AtkText* self);
+  static gchar* get_selection_vfunc_callback(AtkText* self, gint selection_num, gint* start_offset, gint* end_offset);
+  static gboolean add_selection_vfunc_callback(AtkText* self, gint start_offset, gint end_offset);
+  static gboolean remove_selection_vfunc_callback(AtkText* self, gint selection_num);
+  static gboolean set_selection_vfunc_callback(AtkText* self, gint selection_num, gint start_offset, gint end_offset);
+  static gboolean set_caret_offset_vfunc_callback(AtkText* self, gint offset);
+};
+
+
+} // namespace Atk
+
+#endif /* _ATKMM_TEXT_P_H */
+
diff --git a/libs/gtkmm2/atk/atkmm/private/value_p.h b/libs/gtkmm2/atk/atkmm/private/value_p.h
new file mode 100644
index 0000000000..f712e3cd70
--- /dev/null
+++ b/libs/gtkmm2/atk/atkmm/private/value_p.h
@@ -0,0 +1,44 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _ATKMM_VALUE_P_H
+#define _ATKMM_VALUE_P_H
+
+#include <glibmm/private/interface_p.h>
+
+namespace Atk
+{
+
+class Value_Class : public Glib::Interface_Class
+{
+public:
+  typedef Value CppObjectType;
+  typedef AtkValue BaseObjectType;
+  typedef AtkValueIface BaseClassType;
+  typedef Glib::Interface_Class CppClassParent;
+
+  friend class Value;
+
+  const Glib::Interface_Class& init();
+
+  static void iface_init_function(void* g_iface, void* iface_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+  static void get_current_value_vfunc_callback(AtkValue* self, GValue* value);
+  static void get_maximum_value_vfunc_callback(AtkValue* self, GValue* value);
+  static void get_minimum_value_vfunc_callback(AtkValue* self, GValue* value);
+  static gboolean set_current_value_vfunc_callback(AtkValue* self, const GValue* value);
+};
+
+
+} // namespace Atk
+
+#endif /* _ATKMM_VALUE_P_H */
+
diff --git a/libs/gtkmm2/atk/atkmm/relation.cc b/libs/gtkmm2/atk/atkmm/relation.cc
new file mode 100644
index 0000000000..94c3fe2d48
--- /dev/null
+++ b/libs/gtkmm2/atk/atkmm/relation.cc
@@ -0,0 +1,177 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <atkmm/relation.h>
+#include <atkmm/private/relation_p.h>
+
+#include <atk/atk-enum-types.h>
+// -*- c++ -*-
+/* $Id$ */
+
+/* Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <atkmm/object.h>
+#include <atk/atkobject.h>
+#include <atk/atkrelation.h>
+
+
+namespace Atk
+{
+
+//TODO: Implement this with the new GValue array thingy. See bug #74246.
+Relation::Relation(const Glib::ArrayHandle< Glib::RefPtr<Atk::Object> >& targets,
+                   RelationType relationship)
+:
+  Glib::Object((GObject*) atk_relation_new(const_cast<AtkObject**>(targets.data()), targets.size(),
+                                           (AtkRelationType) relationship))
+{}
+
+Glib::ArrayHandle< Glib::RefPtr<Atk::Object> > Relation::get_target()
+{
+  GPtrArray *const parray = atk_relation_get_target(gobj());
+
+  return Glib::ArrayHandle< Glib::RefPtr<Atk::Object> >
+      (reinterpret_cast<AtkObject**>(parray->pdata), parray->len, Glib::OWNERSHIP_NONE);
+}
+
+Glib::ArrayHandle< Glib::RefPtr<const Atk::Object> > Relation::get_target() const
+{
+  GPtrArray *const parray = atk_relation_get_target(const_cast<AtkRelation*>(gobj()));
+
+  return Glib::ArrayHandle< Glib::RefPtr<const Atk::Object> >
+      (reinterpret_cast<AtkObject**>(parray->pdata), parray->len, Glib::OWNERSHIP_NONE);
+}
+
+} // namespace Atk
+
+
+namespace
+{
+} // anonymous namespace
+
+// static
+GType Glib::Value<Atk::RelationType>::value_type()
+{
+  return atk_relation_type_get_type();
+}
+
+
+namespace Glib
+{
+
+Glib::RefPtr<Atk::Relation> wrap(AtkRelation* object, bool take_copy)
+{
+  return Glib::RefPtr<Atk::Relation>( dynamic_cast<Atk::Relation*> (Glib::wrap_auto ((GObject*)(object), take_copy)) );
+  //We use dynamic_cast<> in case of multiple inheritance.
+}
+
+} /* namespace Glib */
+
+
+namespace Atk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& Relation_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &Relation_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(atk_relation_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void Relation_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+}
+
+
+Glib::ObjectBase* Relation_Class::wrap_new(GObject* object)
+{
+  return new Relation((AtkRelation*)object);
+}
+
+
+/* The implementation: */
+
+AtkRelation* Relation::gobj_copy()
+{
+  reference();
+  return gobj();
+}
+
+Relation::Relation(const Glib::ConstructParams& construct_params)
+:
+  Glib::Object(construct_params)
+{}
+
+Relation::Relation(AtkRelation* castitem)
+:
+  Glib::Object((GObject*)(castitem))
+{}
+
+Relation::~Relation()
+{}
+
+
+Relation::CppClassType Relation::relation_class_; // initialize static member
+
+GType Relation::get_type()
+{
+  return relation_class_.init().get_type();
+}
+
+GType Relation::get_base_type()
+{
+  return atk_relation_get_type();
+}
+
+
+Glib::RefPtr<Relation> Relation::create(const Glib::ArrayHandle< Glib::RefPtr<Atk::Object> >& targets, RelationType relationship)
+{
+  return Glib::RefPtr<Relation>( new Relation(targets, relationship) );
+}
+RelationType Relation::get_relation_type() const
+{
+  return ((RelationType)(atk_relation_get_relation_type(const_cast<AtkRelation*>(gobj()))));
+}
+
+void Relation::add_target(const Glib::RefPtr<Atk::Object>& target)
+{
+  atk_relation_add_target(gobj(), Glib::unwrap(target));
+}
+
+
+} // namespace Atk
+
+
diff --git a/libs/gtkmm2/atk/atkmm/relation.h b/libs/gtkmm2/atk/atkmm/relation.h
new file mode 100644
index 0000000000..683b938947
--- /dev/null
+++ b/libs/gtkmm2/atk/atkmm/relation.h
@@ -0,0 +1,187 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _ATKMM_RELATION_H
+#define _ATKMM_RELATION_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* Copyright (C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _AtkRelation AtkRelation;
+typedef struct _AtkRelationClass AtkRelationClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Atk
+{ class Relation_Class; } // namespace Atk
+namespace Atk
+{
+
+
+/** @addtogroup atkmmEnums Enums and Flags */
+
+/**
+ * @ingroup atkmmEnums
+ */
+enum RelationType
+{
+  RELATION_NULL,
+  RELATION_CONTROLLED_BY,
+  RELATION_CONTROLLER_FOR,
+  RELATION_LABEL_FOR,
+  RELATION_LABELLED_BY,
+  RELATION_MEMBER_OF,
+  RELATION_NODE_CHILD_OF,
+  RELATION_FLOWS_TO,
+  RELATION_FLOWS_FROM,
+  RELATION_SUBWINDOW_OF,
+  RELATION_EMBEDS,
+  RELATION_EMBEDDED_BY,
+  RELATION_POPUP_FOR,
+  RELATION_PARENT_WINDOW_OF,
+  RELATION_LAST_DEFINED
+};
+
+} // namespace Atk
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Atk::RelationType> : public Glib::Value_Enum<Atk::RelationType>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Atk
+{
+
+
+class Object;
+
+/** An Atk::Relation describes a relation between an object and one or more other objects.
+ * The actual relations that an object has with other objects are defined as an Atk::RelationSet,
+ * which is a set of Atk::Relations.
+ */
+
+class Relation : public Glib::Object
+{
+  
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+public:
+  typedef Relation CppObjectType;
+  typedef Relation_Class CppClassType;
+  typedef AtkRelation BaseObjectType;
+  typedef AtkRelationClass BaseClassType;
+
+private:  friend class Relation_Class;
+  static CppClassType relation_class_;
+
+private:
+  // noncopyable
+  Relation(const Relation&);
+  Relation& operator=(const Relation&);
+
+protected:
+  explicit Relation(const Glib::ConstructParams& construct_params);
+  explicit Relation(AtkRelation* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+  virtual ~Relation();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GObject.
+  AtkRelation*       gobj()       { return reinterpret_cast<AtkRelation*>(gobject_); }
+
+  ///Provides access to the underlying C GObject.
+  const AtkRelation* gobj() const { return reinterpret_cast<AtkRelation*>(gobject_); }
+
+  ///Provides access to the underlying C instance. The caller is responsible for unrefing it. Use when directly setting fields in structs.
+  AtkRelation* gobj_copy();
+
+private:
+
+
+protected:
+  explicit Relation(const Glib::ArrayHandle< Glib::RefPtr<Atk::Object> >& targets,
+                    RelationType relationship);
+
+public:
+  
+  static Glib::RefPtr<Relation> create(const Glib::ArrayHandle< Glib::RefPtr<Atk::Object> >& targets, RelationType relationship =  RELATION_NULL);
+
+
+  /** Gets the type of @a relation 
+   * @return The type of @a relation .
+   */
+  RelationType get_relation_type() const;
+
+  Glib::ArrayHandle< Glib::RefPtr<Atk::Object> > get_target();
+  Glib::ArrayHandle< Glib::RefPtr<const Atk::Object> > get_target() const;
+  
+  
+  void add_target(const Glib::RefPtr<Atk::Object>& target);
+
+
+public:
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+};
+
+} // namespace Atk
+
+
+namespace Glib
+{
+  /** @relates Atk::Relation
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Glib::RefPtr<Atk::Relation> wrap(AtkRelation* object, bool take_copy = false);
+}
+
+
+#endif /* _ATKMM_RELATION_H */
+
diff --git a/libs/gtkmm2/atk/atkmm/relationset.cc b/libs/gtkmm2/atk/atkmm/relationset.cc
new file mode 100644
index 0000000000..2060639bc1
--- /dev/null
+++ b/libs/gtkmm2/atk/atkmm/relationset.cc
@@ -0,0 +1,181 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <atkmm/relationset.h>
+#include <atkmm/private/relationset_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <atk/atkobject.h>
+#include <atk/atkrelationset.h>
+
+
+namespace
+{
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Glib::RefPtr<Atk::RelationSet> wrap(AtkRelationSet* object, bool take_copy)
+{
+  return Glib::RefPtr<Atk::RelationSet>( dynamic_cast<Atk::RelationSet*> (Glib::wrap_auto ((GObject*)(object), take_copy)) );
+  //We use dynamic_cast<> in case of multiple inheritance.
+}
+
+} /* namespace Glib */
+
+
+namespace Atk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& RelationSet_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &RelationSet_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(atk_relation_set_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void RelationSet_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+}
+
+
+Glib::ObjectBase* RelationSet_Class::wrap_new(GObject* object)
+{
+  return new RelationSet((AtkRelationSet*)object);
+}
+
+
+/* The implementation: */
+
+AtkRelationSet* RelationSet::gobj_copy()
+{
+  reference();
+  return gobj();
+}
+
+RelationSet::RelationSet(const Glib::ConstructParams& construct_params)
+:
+  Glib::Object(construct_params)
+{}
+
+RelationSet::RelationSet(AtkRelationSet* castitem)
+:
+  Glib::Object((GObject*)(castitem))
+{}
+
+RelationSet::~RelationSet()
+{}
+
+
+RelationSet::CppClassType RelationSet::relationset_class_; // initialize static member
+
+GType RelationSet::get_type()
+{
+  return relationset_class_.init().get_type();
+}
+
+GType RelationSet::get_base_type()
+{
+  return atk_relation_set_get_type();
+}
+
+
+RelationSet::RelationSet()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Glib::Object(Glib::ConstructParams(relationset_class_.init()))
+{
+  }
+
+Glib::RefPtr<RelationSet> RelationSet::create()
+{
+  return Glib::RefPtr<RelationSet>( new RelationSet() );
+}
+bool RelationSet::set_contains(RelationType relationship)
+{
+  return atk_relation_set_contains(gobj(), ((AtkRelationType)(relationship)));
+}
+
+void RelationSet::set_remove(const Glib::RefPtr<Relation>& relation)
+{
+  atk_relation_set_remove(gobj(), Glib::unwrap(relation));
+}
+
+void RelationSet::set_add(const Glib::RefPtr<Relation>& relation)
+{
+  atk_relation_set_add(gobj(), Glib::unwrap(relation));
+}
+
+int RelationSet::get_n_relations() const
+{
+  return atk_relation_set_get_n_relations(const_cast<AtkRelationSet*>(gobj()));
+}
+
+Glib::RefPtr<Relation> RelationSet::get_relation(gint i)
+{
+
+  Glib::RefPtr<Relation> retvalue = Glib::wrap(atk_relation_set_get_relation(gobj(), i));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::RefPtr<Relation> RelationSet::get_relation(RelationType relationship)
+{
+
+  Glib::RefPtr<Relation> retvalue = Glib::wrap(atk_relation_set_get_relation_by_type(gobj(), ((AtkRelationType)(relationship))));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+void RelationSet::add_relation_by_type(RelationType relationship, const Glib::RefPtr<Atk::Object>& target)
+{
+  atk_relation_set_add_relation_by_type(gobj(), ((AtkRelationType)(relationship)), Glib::unwrap(target));
+}
+
+
+} // namespace Atk
+
+
diff --git a/libs/gtkmm2/atk/atkmm/relationset.h b/libs/gtkmm2/atk/atkmm/relationset.h
new file mode 100644
index 0000000000..3702083fa5
--- /dev/null
+++ b/libs/gtkmm2/atk/atkmm/relationset.h
@@ -0,0 +1,171 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _ATKMM_RELATIONSET_H
+#define _ATKMM_RELATIONSET_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* Copyright (C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+
+#include <atkmm/relation.h>
+#include <atkmm/object.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _AtkRelationSet AtkRelationSet;
+typedef struct _AtkRelationSetClass AtkRelationSetClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Atk
+{ class RelationSet_Class; } // namespace Atk
+namespace Atk
+{
+
+/** A set of Atk::Relations, normally the set of AtkRelations which an Atk::Object has.
+ */
+
+class RelationSet : public Glib::Object
+{
+  
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+public:
+  typedef RelationSet CppObjectType;
+  typedef RelationSet_Class CppClassType;
+  typedef AtkRelationSet BaseObjectType;
+  typedef AtkRelationSetClass BaseClassType;
+
+private:  friend class RelationSet_Class;
+  static CppClassType relationset_class_;
+
+private:
+  // noncopyable
+  RelationSet(const RelationSet&);
+  RelationSet& operator=(const RelationSet&);
+
+protected:
+  explicit RelationSet(const Glib::ConstructParams& construct_params);
+  explicit RelationSet(AtkRelationSet* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+  virtual ~RelationSet();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GObject.
+  AtkRelationSet*       gobj()       { return reinterpret_cast<AtkRelationSet*>(gobject_); }
+
+  ///Provides access to the underlying C GObject.
+  const AtkRelationSet* gobj() const { return reinterpret_cast<AtkRelationSet*>(gobject_); }
+
+  ///Provides access to the underlying C instance. The caller is responsible for unrefing it. Use when directly setting fields in structs.
+  AtkRelationSet* gobj_copy();
+
+private:
+
+protected:
+  RelationSet();
+
+public:
+  
+  static Glib::RefPtr<RelationSet> create();
+
+
+  /** Determines whether the relation set contains a relation that matches the
+   * specified type.
+   * @param relationship An Atk::RelationType.
+   * @return <tt>true</tt> if @a relationship  is the relationship type of a relation
+   * in @a set , <tt>false</tt> otherwise.
+   */
+  bool set_contains(RelationType relationship);
+  
+  /** Removes a relation from the relation set.
+   * This function unref's the Atk::Relation so it will be deleted unless there
+   * is another reference to it.
+   * @param relation An Atk::Relation.
+   */
+  void set_remove(const Glib::RefPtr<Relation>& relation);
+  
+  /** Add a new relation to the current relation set if it is not already
+   * present.
+   * This function ref's the AtkRelation so the caller of this function
+   * should unref it to ensure that it will be destroyed when the AtkRelationSet
+   * is destroyed.
+   * @param relation An Atk::Relation.
+   */
+  void set_add(const Glib::RefPtr<Relation>& relation);
+  
+  /** Determines the number of relations in a relation set.
+   * @return An integer representing the number of relations in the set.
+   */
+  int get_n_relations() const;
+  
+  /** Determines the relation at the specified position in the relation set.
+   * @param i A <tt>int</tt> representing a position in the set, starting from 0.
+   * @return A Atk::Relation, which is the relation at position i in the set.
+   */
+  Glib::RefPtr<Relation> get_relation(gint i);
+  
+  /** Finds a relation that matches the specified type.
+   * @param relationship An Atk::RelationType.
+   * @return An Atk::Relation, which is a relation matching the specified type.
+   */
+  Glib::RefPtr<Relation> get_relation(RelationType relationship);
+  
+  
+  void add_relation_by_type(RelationType relationship, const Glib::RefPtr<Atk::Object>& target);
+
+
+public:
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+};
+
+} // namespace Atk
+
+
+namespace Glib
+{
+  /** @relates Atk::RelationSet
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Glib::RefPtr<Atk::RelationSet> wrap(AtkRelationSet* object, bool take_copy = false);
+}
+
+
+#endif /* _ATKMM_RELATIONSET_H */
+
diff --git a/libs/gtkmm2/atk/atkmm/selection.cc b/libs/gtkmm2/atk/atkmm/selection.cc
new file mode 100644
index 0000000000..95c6a0a60a
--- /dev/null
+++ b/libs/gtkmm2/atk/atkmm/selection.cc
@@ -0,0 +1,596 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <atkmm/selection.h>
+#include <atkmm/private/selection_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <atkmm/object.h>
+#include <atk/atkselection.h>
+
+
+namespace
+{
+
+const Glib::SignalProxyInfo Selection_signal_selection_changed_info =
+{
+  "selection_changed",
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
+};
+
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Glib::RefPtr<Atk::Selection> wrap(AtkSelection* object, bool take_copy)
+{
+  return Glib::RefPtr<Atk::Selection>( dynamic_cast<Atk::Selection*> (Glib::wrap_auto ((GObject*)(object), take_copy)) );
+  //We use dynamic_cast<> in case of multiple inheritance.
+}
+
+} // namespace Glib
+
+
+namespace Atk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Interface_Class& Selection_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Interface_Class has to know the interface init function
+    // in order to add interfaces to implementing types.
+    class_init_func_ = &Selection_Class::iface_init_function;
+
+    // We can not derive from another interface, and it is not necessary anyway.
+    gtype_ = atk_selection_get_type();
+  }
+
+  return *this;
+}
+
+void Selection_Class::iface_init_function(void* g_iface, void*)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_iface);
+
+  //This is just to avoid an "unused variable" warning when there are no vfuncs or signal handlers to connect.
+  //This is a temporary fix until I find out why I can not seem to derive a GtkFileChooser interface. murrayc
+  g_assert(klass != 0); 
+
+  klass->add_selection = &add_selection_vfunc_callback;
+  klass->clear_selection = &clear_selection_vfunc_callback;
+  klass->ref_selection = &ref_selection_vfunc_callback;
+  klass->get_selection_count = &get_selection_count_vfunc_callback;
+  klass->is_child_selected = &is_child_selected_vfunc_callback;
+  klass->remove_selection = &remove_selection_vfunc_callback;
+  klass->select_all_selection = &select_all_selection_vfunc_callback;
+  klass->selection_changed = &selection_changed_callback;
+}
+
+gboolean Selection_Class::add_selection_vfunc_callback(AtkSelection* self, gint i)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return static_cast<int>(obj->add_selection_vfunc(i
+));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->add_selection)
+      return (*base->add_selection)(self, i);
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+gboolean Selection_Class::clear_selection_vfunc_callback(AtkSelection* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return static_cast<int>(obj->clear_selection_vfunc());
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->clear_selection)
+      return (*base->clear_selection)(self);
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+AtkObject* Selection_Class::ref_selection_vfunc_callback(AtkSelection* self, gint i)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return Glib::unwrap_copy(obj->get_selection_vfunc(i
+));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->ref_selection)
+      return (*base->ref_selection)(self, i);
+  }
+
+  typedef AtkObject* RType;
+  return RType();
+}
+
+gint Selection_Class::get_selection_count_vfunc_callback(AtkSelection* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return obj->get_selection_count_vfunc();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->get_selection_count)
+      return (*base->get_selection_count)(self);
+  }
+
+  typedef gint RType;
+  return RType();
+}
+
+gboolean Selection_Class::is_child_selected_vfunc_callback(AtkSelection* self, gint i)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return static_cast<int>(obj->is_child_selected_vfunc(i
+));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->is_child_selected)
+      return (*base->is_child_selected)(self, i);
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+gboolean Selection_Class::remove_selection_vfunc_callback(AtkSelection* self, gint i)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return static_cast<int>(obj->remove_selection_vfunc(i
+));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->remove_selection)
+      return (*base->remove_selection)(self, i);
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+gboolean Selection_Class::select_all_selection_vfunc_callback(AtkSelection* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return static_cast<int>(obj->select_all_selection_vfunc());
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->select_all_selection)
+      return (*base->select_all_selection)(self);
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+
+void Selection_Class::selection_changed_callback(AtkSelection* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_selection_changed();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->selection_changed)
+      (*base->selection_changed)(self);
+  }
+}
+
+
+Glib::ObjectBase* Selection_Class::wrap_new(GObject* object)
+{
+  return new Selection((AtkSelection*)(object));
+}
+
+
+/* The implementation: */
+
+Selection::Selection()
+:
+  Glib::Interface(selection_class_.init())
+{}
+
+Selection::Selection(AtkSelection* castitem)
+:
+  Glib::Interface((GObject*)(castitem))
+{}
+
+Selection::~Selection()
+{}
+
+// static
+void Selection::add_interface(GType gtype_implementer)
+{
+  selection_class_.init().add_interface(gtype_implementer);
+}
+
+Selection::CppClassType Selection::selection_class_; // initialize static member
+
+GType Selection::get_type()
+{
+  return selection_class_.init().get_type();
+}
+
+GType Selection::get_base_type()
+{
+  return atk_selection_get_type();
+}
+
+
+bool Selection::add_selection(int i)
+{
+  return atk_selection_add_selection(gobj(), i);
+}
+
+bool Selection::clear_selection()
+{
+  return atk_selection_clear_selection(gobj());
+}
+
+Glib::RefPtr<Atk::Object> Selection::get_selection(int i)
+{
+  return Glib::wrap(atk_selection_ref_selection(gobj(), i));
+}
+
+int Selection::get_selection_count() const
+{
+  return atk_selection_get_selection_count(const_cast<AtkSelection*>(gobj()));
+}
+
+bool Selection::is_child_selected(int i) const
+{
+  return atk_selection_is_child_selected(const_cast<AtkSelection*>(gobj()), i);
+}
+
+bool Selection::remove_selection(int i)
+{
+  return atk_selection_remove_selection(gobj(), i);
+}
+
+bool Selection::select_all_selection()
+{
+  return atk_selection_select_all_selection(gobj());
+}
+
+
+Glib::SignalProxy0< void > Selection::signal_selection_changed()
+{
+  return Glib::SignalProxy0< void >(this, &Selection_signal_selection_changed_info);
+}
+
+
+void Atk::Selection::on_selection_changed()
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->selection_changed)
+    (*base->selection_changed)(gobj());
+}
+
+
+bool Atk::Selection::add_selection_vfunc(int i) 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->add_selection)
+    return (*base->add_selection)(gobj(),i);
+
+  typedef bool RType;
+  return RType();
+}
+
+bool Atk::Selection::clear_selection_vfunc() 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->clear_selection)
+    return (*base->clear_selection)(gobj());
+
+  typedef bool RType;
+  return RType();
+}
+
+Glib::RefPtr<Atk::Object> Atk::Selection::get_selection_vfunc(int i) 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->ref_selection)
+    return Glib::wrap((*base->ref_selection)(gobj(),i));
+
+  typedef Glib::RefPtr<Atk::Object> RType;
+  return RType();
+}
+
+int Atk::Selection::get_selection_count_vfunc() const
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->get_selection_count)
+    return (*base->get_selection_count)(const_cast<AtkSelection*>(gobj()));
+
+  typedef int RType;
+  return RType();
+}
+
+bool Atk::Selection::is_child_selected_vfunc(int i) const
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->is_child_selected)
+    return (*base->is_child_selected)(const_cast<AtkSelection*>(gobj()),i);
+
+  typedef bool RType;
+  return RType();
+}
+
+bool Atk::Selection::remove_selection_vfunc(int i) 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->remove_selection)
+    return (*base->remove_selection)(gobj(),i);
+
+  typedef bool RType;
+  return RType();
+}
+
+bool Atk::Selection::select_all_selection_vfunc() 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->select_all_selection)
+    return (*base->select_all_selection)(gobj());
+
+  typedef bool RType;
+  return RType();
+}
+
+
+} // namespace Atk
+
+
diff --git a/libs/gtkmm2/atk/atkmm/selection.h b/libs/gtkmm2/atk/atkmm/selection.h
new file mode 100644
index 0000000000..62185ed0d9
--- /dev/null
+++ b/libs/gtkmm2/atk/atkmm/selection.h
@@ -0,0 +1,208 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _ATKMM_SELECTION_H
+#define _ATKMM_SELECTION_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* Copyright (C) 2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+extern "C"
+{
+  typedef struct _AtkSelectionIface AtkSelectionIface;
+  typedef struct _AtkSelection      AtkSelection;
+}
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _AtkSelection AtkSelection;
+typedef struct _AtkSelectionClass AtkSelectionClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Atk
+{ class Selection_Class; } // namespace Atk
+namespace Atk
+{
+
+class Object;
+
+/** The ATK interface implemented by container objects whose Atk::Object children can be selected.
+ * This should be implemented by UI components with children which are exposed by Atk::Object::ref_child and
+ * Atk::Object::get_n_children, if the use of the parent UI component ordinarily involves selection of one or
+ * more of the objects corresponding to those AtkObject children - for example, selectable lists.
+ *
+ * Note that other types of "selection" (for instance text selection) are accomplished a other ATK interfaces -
+ * Atk::Selection is limited to the selection/deselection of children. 
+ */
+
+class Selection : public Glib::Interface
+{
+  
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+public:
+  typedef Selection CppObjectType;
+  typedef Selection_Class CppClassType;
+  typedef AtkSelection BaseObjectType;
+  typedef AtkSelectionIface BaseClassType;
+
+private:
+  friend class Selection_Class;
+  static CppClassType selection_class_;
+
+  // noncopyable
+  Selection(const Selection&);
+  Selection& operator=(const Selection&);
+
+protected:
+  Selection(); // you must derive from this class
+  explicit Selection(AtkSelection* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+  virtual ~Selection();
+
+  static void add_interface(GType gtype_implementer);
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GObject.
+  AtkSelection*       gobj()       { return reinterpret_cast<AtkSelection*>(gobject_); }
+
+  ///Provides access to the underlying C GObject.  
+  const AtkSelection* gobj() const { return reinterpret_cast<AtkSelection*>(gobject_); }
+
+private:
+
+
+public:
+  
+  /** Adds the specified accessible child of the object to the
+   * object's selection.
+   * @param i A <tt>int</tt> specifying the child index.
+   * @return <tt>true</tt> if success, <tt>false</tt> otherwise.
+   */
+  bool add_selection(int i);
+  
+  /** Clears the selection in the object so that no children in the object
+   * are selected.
+   * @return <tt>true</tt> if success, <tt>false</tt> otherwise.
+   */
+  bool clear_selection();
+  
+  /** Gets a reference to the accessible object representing the specified 
+   * selected child of the object.
+   * @note callers should not rely on <tt>0</tt> or on a zero value for
+   * indication of whether AtkSelectionIface is implemented, they should
+   * use type checking/interface checking macros or the
+   * atk_get_accessible_value() convenience method.
+   * @param i A <tt>int</tt> specifying the index in the selection set.  (e.g. the
+   * ith selection as opposed to the ith child).
+   * @return An Atk::Object representing the selected accessible , or <tt>0</tt>
+   * if @a selection  does not implement this interface.
+   */
+  Glib::RefPtr<Atk::Object> get_selection(int i);
+  
+  /** Gets the number of accessible children currently selected.
+   * @note callers should not rely on <tt>0</tt> or on a zero value for
+   * indication of whether AtkSelectionIface is implemented, they should
+   * use type checking/interface checking macros or the
+   * atk_get_accessible_value() convenience method.
+   * @return A <tt>int</tt> representing the number of items selected, or 0
+   * if @a selection  does not implement this interface.
+   */
+  int get_selection_count() const;
+  
+  /** Determines if the current child of this object is selected
+   * @note callers should not rely on <tt>0</tt> or on a zero value for
+   * indication of whether AtkSelectionIface is implemented, they should
+   * use type checking/interface checking macros or the
+   * atk_get_accessible_value() convenience method.
+   * @param i A <tt>int</tt> specifying the child index.
+   * @return A <tt>bool</tt> representing the specified child is selected, or 0
+   * if @a selection  does not implement this interface.
+   */
+  bool is_child_selected(int i) const;
+  
+  /** Removes the specified child of the object from the object's selection.
+   * @param i A <tt>int</tt> specifying the index in the selection set.  (e.g. the
+   * ith selection as opposed to the ith child).
+   * @return <tt>true</tt> if success, <tt>false</tt> otherwise.
+   */
+  bool remove_selection(int i);
+  
+  /** Causes every child of the object to be selected if the object
+   * supports multiple selections.
+   * @return <tt>true</tt> if success, <tt>false</tt> otherwise.
+   */
+  bool select_all_selection();
+
+  
+  Glib::SignalProxy0< void > signal_selection_changed();
+
+
+protected:
+    virtual bool add_selection_vfunc(int i);
+    virtual bool clear_selection_vfunc();
+    virtual Glib::RefPtr<Atk::Object> get_selection_vfunc(int i);
+    virtual int get_selection_count_vfunc() const;
+    virtual bool is_child_selected_vfunc(int i) const;
+    virtual bool remove_selection_vfunc(int i);
+    virtual bool select_all_selection_vfunc();
+
+
+public:
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+  virtual void on_selection_changed();
+
+
+};
+
+} // namespace Atk
+
+
+namespace Glib
+{
+  /** @relates Atk::Selection
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Glib::RefPtr<Atk::Selection> wrap(AtkSelection* object, bool take_copy = false);
+
+} // namespace Glib
+
+#endif /* _ATKMM_SELECTION_H */
+
diff --git a/libs/gtkmm2/atk/atkmm/stateset.cc b/libs/gtkmm2/atk/atkmm/stateset.cc
new file mode 100644
index 0000000000..6feb4d6ee3
--- /dev/null
+++ b/libs/gtkmm2/atk/atkmm/stateset.cc
@@ -0,0 +1,200 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <atkmm/stateset.h>
+#include <atkmm/private/stateset_p.h>
+
+#include <atk/atk-enum-types.h>
+// -*- c++ -*-
+/* $Id$ */
+
+/* Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <atk/atkobject.h>
+#include <atk/atkstateset.h>
+
+
+namespace Atk
+{
+
+void StateSet::add_states(const Glib::ArrayHandle<StateType>& types)
+{
+  atk_state_set_add_states(gobj(), (AtkStateType*) types.data(), types.size());
+}
+
+bool StateSet::contains_states(const Glib::ArrayHandle<StateType>& types) const
+{
+  return atk_state_set_contains_states(
+      const_cast<AtkStateSet*>(gobj()), (AtkStateType*) types.data(), types.size());
+}
+
+} // namespace Atk
+
+
+namespace
+{
+} // anonymous namespace
+
+// static
+GType Glib::Value<Atk::StateType>::value_type()
+{
+  return atk_state_type_get_type();
+}
+
+
+namespace Glib
+{
+
+Glib::RefPtr<Atk::StateSet> wrap(AtkStateSet* object, bool take_copy)
+{
+  return Glib::RefPtr<Atk::StateSet>( dynamic_cast<Atk::StateSet*> (Glib::wrap_auto ((GObject*)(object), take_copy)) );
+  //We use dynamic_cast<> in case of multiple inheritance.
+}
+
+} /* namespace Glib */
+
+
+namespace Atk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& StateSet_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &StateSet_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(atk_state_set_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void StateSet_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+}
+
+
+Glib::ObjectBase* StateSet_Class::wrap_new(GObject* object)
+{
+  return new StateSet((AtkStateSet*)object);
+}
+
+
+/* The implementation: */
+
+AtkStateSet* StateSet::gobj_copy()
+{
+  reference();
+  return gobj();
+}
+
+StateSet::StateSet(const Glib::ConstructParams& construct_params)
+:
+  Glib::Object(construct_params)
+{}
+
+StateSet::StateSet(AtkStateSet* castitem)
+:
+  Glib::Object((GObject*)(castitem))
+{}
+
+StateSet::~StateSet()
+{}
+
+
+StateSet::CppClassType StateSet::stateset_class_; // initialize static member
+
+GType StateSet::get_type()
+{
+  return stateset_class_.init().get_type();
+}
+
+GType StateSet::get_base_type()
+{
+  return atk_state_set_get_type();
+}
+
+
+StateSet::StateSet()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Glib::Object(Glib::ConstructParams(stateset_class_.init()))
+{
+  }
+
+Glib::RefPtr<StateSet> StateSet::create()
+{
+  return Glib::RefPtr<StateSet>( new StateSet() );
+}
+bool StateSet::is_empty() const
+{
+  return atk_state_set_is_empty(const_cast<AtkStateSet*>(gobj()));
+}
+
+bool StateSet::add_state(Atk::StateType type)
+{
+  return atk_state_set_add_state(gobj(), ((AtkStateType)(type)));
+}
+
+void StateSet::clear_states()
+{
+  atk_state_set_clear_states(gobj());
+}
+
+bool StateSet::contains_state(Atk::StateType type)
+{
+  return atk_state_set_contains_state(gobj(), ((AtkStateType)(type)));
+}
+
+bool StateSet::remove_state(Atk::StateType type)
+{
+  return atk_state_set_remove_state(gobj(), ((AtkStateType)(type)));
+}
+
+Glib::RefPtr<StateSet> StateSet::and_sets(const Glib::RefPtr<StateSet>& compare_set)
+{
+  return Glib::wrap(atk_state_set_and_sets(gobj(), Glib::unwrap(compare_set)));
+}
+
+Glib::RefPtr<StateSet> StateSet::or_sets(const Glib::RefPtr<StateSet>& compare_set)
+{
+  return Glib::wrap(atk_state_set_or_sets(gobj(), Glib::unwrap(compare_set)));
+}
+
+Glib::RefPtr<StateSet> StateSet::xor_sets(const Glib::RefPtr<StateSet>& compare_set)
+{
+  return Glib::wrap(atk_state_set_xor_sets(gobj(), Glib::unwrap(compare_set)));
+}
+
+
+} // namespace Atk
+
+
diff --git a/libs/gtkmm2/atk/atkmm/stateset.h b/libs/gtkmm2/atk/atkmm/stateset.h
new file mode 100644
index 0000000000..f3e8f70504
--- /dev/null
+++ b/libs/gtkmm2/atk/atkmm/stateset.h
@@ -0,0 +1,247 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _ATKMM_STATESET_H
+#define _ATKMM_STATESET_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* Copyright (C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _AtkStateSet AtkStateSet;
+typedef struct _AtkStateSetClass AtkStateSetClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Atk
+{ class StateSet_Class; } // namespace Atk
+namespace Atk
+{
+
+
+/** @addtogroup atkmmEnums Enums and Flags */
+
+/**
+ * @ingroup atkmmEnums
+ */
+enum StateType
+{
+  STATE_INVALID,
+  STATE_ACTIVE,
+  STATE_ARMED,
+  STATE_BUSY,
+  STATE_CHECKED,
+  STATE_DEFUNCT,
+  STATE_EDITABLE,
+  STATE_ENABLED,
+  STATE_EXPANDABLE,
+  STATE_EXPANDED,
+  STATE_FOCUSABLE,
+  STATE_FOCUSED,
+  STATE_HORIZONTAL,
+  STATE_ICONIFIED,
+  STATE_MODAL,
+  STATE_MULTI_LINE,
+  STATE_MULTISELECTABLE,
+  STATE_OPAQUE,
+  STATE_PRESSED,
+  STATE_RESIZABLE,
+  STATE_SELECTABLE,
+  STATE_SELECTED,
+  STATE_SENSITIVE,
+  STATE_SHOWING,
+  STATE_SINGLE_LINE,
+  STATE_STALE,
+  STATE_TRANSIENT,
+  STATE_VERTICAL,
+  STATE_VISIBLE,
+  STATE_MANAGES_DESCENDANTS,
+  STATE_INDETERMINATE,
+  STATE_TRUNCATED,
+  STATE_LAST_DEFINED
+};
+
+} // namespace Atk
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Atk::StateType> : public Glib::Value_Enum<Atk::StateType>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Atk
+{
+
+
+/** An AtkStateSet determines a component's state set.
+ * It is composed of a set of Atk::States.
+ */
+
+class StateSet : public Glib::Object
+{
+  
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+public:
+  typedef StateSet CppObjectType;
+  typedef StateSet_Class CppClassType;
+  typedef AtkStateSet BaseObjectType;
+  typedef AtkStateSetClass BaseClassType;
+
+private:  friend class StateSet_Class;
+  static CppClassType stateset_class_;
+
+private:
+  // noncopyable
+  StateSet(const StateSet&);
+  StateSet& operator=(const StateSet&);
+
+protected:
+  explicit StateSet(const Glib::ConstructParams& construct_params);
+  explicit StateSet(AtkStateSet* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+  virtual ~StateSet();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GObject.
+  AtkStateSet*       gobj()       { return reinterpret_cast<AtkStateSet*>(gobject_); }
+
+  ///Provides access to the underlying C GObject.
+  const AtkStateSet* gobj() const { return reinterpret_cast<AtkStateSet*>(gobject_); }
+
+  ///Provides access to the underlying C instance. The caller is responsible for unrefing it. Use when directly setting fields in structs.
+  AtkStateSet* gobj_copy();
+
+private:
+
+
+protected:
+  StateSet();
+  
+public:
+  
+  static Glib::RefPtr<StateSet> create();
+
+
+  /** Checks whether the state set is empty, i.e.\ has no states set.
+   * @return <tt>true</tt> if @a set  has no states set, otherwise <tt>false</tt>.
+   */
+  bool is_empty() const;
+
+  //Note that we use Atk::StateType instead of StateType, because there is a Gtk::StateType too, and Doxygen gets confused.
+  
+  /** Add a new state for the specified type to the current state set if
+   * it is not already present.
+   * @param type An Atk::StateType.
+   * @return <tt>true</tt> if  the state for @a type  is not already in @a set .
+   */
+  bool add_state(Atk::StateType type);
+  void add_states(const Glib::ArrayHandle<Atk::StateType>& types);
+  
+  
+  /** Removes all states from the state set.
+   */
+  void clear_states();
+  
+  /** Checks whether the state for the specified type is in the specified set.
+   * @param type An Atk::StateType.
+   * @return <tt>true</tt> if @a type  is the state type is in @a set .
+   */
+  bool contains_state(Atk::StateType type);
+   bool contains_states(const Glib::ArrayHandle<Atk::StateType>& types) const;
+  
+  
+  /** Removes the state for the specified type from the state set.
+   * @param type An Atk::Type.
+   * @return <tt>true</tt> if @a type  was the state type is in @a set .
+   */
+  bool remove_state(Atk::StateType type);
+  
+  /** Constructs the intersection of the two sets, returning <tt>0</tt> if the
+   * intersection is empty.
+   * @param compare_set Another Atk::StateSet.
+   * @return A new Atk::StateSet which is the intersection of the two sets.
+   */
+  Glib::RefPtr<StateSet> and_sets(const Glib::RefPtr<StateSet>& compare_set);
+  
+  /** Constructs the union of the two sets.
+   * @param compare_set Another Atk::StateSet.
+   * @return A new Atk::StateSet which is the union of the two sets,
+   * returning <tt>0</tt> is empty.
+   */
+  Glib::RefPtr<StateSet> or_sets(const Glib::RefPtr<StateSet>& compare_set);
+  
+  /** Constructs the exclusive-or of the two sets, returning <tt>0</tt> is empty.
+   * The set returned by this operation contains the states in exactly
+   * one of the two sets.
+   * @param compare_set Another Atk::StateSet.
+   * @return A new Atk::StateSet which contains the states which are 
+   * in exactly one of the two sets.
+   */
+  Glib::RefPtr<StateSet> xor_sets(const Glib::RefPtr<StateSet>& compare_set);
+
+
+public:
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+};
+
+} // namespace Atk
+
+
+namespace Glib
+{
+  /** @relates Atk::StateSet
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Glib::RefPtr<Atk::StateSet> wrap(AtkStateSet* object, bool take_copy = false);
+}
+
+
+#endif /* _ATKMM_STATESET_H */
+
diff --git a/libs/gtkmm2/atk/atkmm/streamablecontent.cc b/libs/gtkmm2/atk/atkmm/streamablecontent.cc
new file mode 100644
index 0000000000..13916f861d
--- /dev/null
+++ b/libs/gtkmm2/atk/atkmm/streamablecontent.cc
@@ -0,0 +1,306 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <atkmm/streamablecontent.h>
+#include <atkmm/private/streamablecontent_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* Copyright 2003 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <atkmm/object.h>
+#include <atk/atkstreamablecontent.h>
+
+
+namespace Atk
+{
+
+
+} // namespace Atk
+
+
+namespace
+{
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Glib::RefPtr<Atk::StreamableContent> wrap(AtkStreamableContent* object, bool take_copy)
+{
+  return Glib::RefPtr<Atk::StreamableContent>( dynamic_cast<Atk::StreamableContent*> (Glib::wrap_auto ((GObject*)(object), take_copy)) );
+  //We use dynamic_cast<> in case of multiple inheritance.
+}
+
+} // namespace Glib
+
+
+namespace Atk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Interface_Class& StreamableContent_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Interface_Class has to know the interface init function
+    // in order to add interfaces to implementing types.
+    class_init_func_ = &StreamableContent_Class::iface_init_function;
+
+    // We can not derive from another interface, and it is not necessary anyway.
+    gtype_ = atk_streamable_content_get_type();
+  }
+
+  return *this;
+}
+
+void StreamableContent_Class::iface_init_function(void* g_iface, void*)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_iface);
+
+  //This is just to avoid an "unused variable" warning when there are no vfuncs or signal handlers to connect.
+  //This is a temporary fix until I find out why I can not seem to derive a GtkFileChooser interface. murrayc
+  g_assert(klass != 0); 
+
+  klass->get_n_mime_types = &get_n_mime_types_vfunc_callback;
+  klass->get_mime_type = &get_mime_type_vfunc_callback;
+  klass->get_stream = &get_stream_vfunc_callback;
+}
+
+int StreamableContent_Class::get_n_mime_types_vfunc_callback(AtkStreamableContent* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return obj->get_n_mime_types_vfunc();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->get_n_mime_types)
+      return (*base->get_n_mime_types)(self);
+  }
+
+  typedef int RType;
+  return RType();
+}
+
+const gchar* StreamableContent_Class::get_mime_type_vfunc_callback(AtkStreamableContent* self, gint i)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return obj->get_mime_type_vfunc(i
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->get_mime_type)
+      return (*base->get_mime_type)(self, i);
+  }
+
+  typedef const gchar* RType;
+  return RType();
+}
+
+GIOChannel* StreamableContent_Class::get_stream_vfunc_callback(AtkStreamableContent* self, const gchar* mime_type)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return obj->get_stream_vfunc(Glib::convert_const_gchar_ptr_to_ustring(mime_type)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->get_stream)
+      return (*base->get_stream)(self, mime_type);
+  }
+
+  typedef GIOChannel* RType;
+  return RType();
+}
+
+
+Glib::ObjectBase* StreamableContent_Class::wrap_new(GObject* object)
+{
+  return new StreamableContent((AtkStreamableContent*)(object));
+}
+
+
+/* The implementation: */
+
+StreamableContent::StreamableContent()
+:
+  Glib::Interface(streamablecontent_class_.init())
+{}
+
+StreamableContent::StreamableContent(AtkStreamableContent* castitem)
+:
+  Glib::Interface((GObject*)(castitem))
+{}
+
+StreamableContent::~StreamableContent()
+{}
+
+// static
+void StreamableContent::add_interface(GType gtype_implementer)
+{
+  streamablecontent_class_.init().add_interface(gtype_implementer);
+}
+
+StreamableContent::CppClassType StreamableContent::streamablecontent_class_; // initialize static member
+
+GType StreamableContent::get_type()
+{
+  return streamablecontent_class_.init().get_type();
+}
+
+GType StreamableContent::get_base_type()
+{
+  return atk_streamable_content_get_type();
+}
+
+
+int StreamableContent::get_n_mime_types() const
+{
+  return atk_streamable_content_get_n_mime_types(const_cast<AtkStreamableContent*>(gobj()));
+}
+
+Glib::ustring StreamableContent::get_mime_type(int i) const
+{
+  return Glib::convert_const_gchar_ptr_to_ustring(atk_streamable_content_get_mime_type(const_cast<AtkStreamableContent*>(gobj()), i));
+}
+
+Glib::RefPtr<Glib::IOChannel> StreamableContent::get_stream(const Glib::ustring& mime_type)
+{
+  return Glib::wrap(atk_streamable_content_get_stream(gobj(), mime_type.c_str()));
+}
+
+
+int Atk::StreamableContent::get_n_mime_types_vfunc() const
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->get_n_mime_types)
+    return (*base->get_n_mime_types)(const_cast<AtkStreamableContent*>(gobj()));
+
+  typedef int RType;
+  return RType();
+}
+
+const gchar* Atk::StreamableContent::get_mime_type_vfunc(int i) const
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->get_mime_type)
+    return (*base->get_mime_type)(const_cast<AtkStreamableContent*>(gobj()),i);
+
+  typedef const gchar* RType;
+  return RType();
+}
+
+GIOChannel* Atk::StreamableContent::get_stream_vfunc(const Glib::ustring& mime_type) 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->get_stream)
+    return (*base->get_stream)(gobj(),mime_type.c_str());
+
+  typedef GIOChannel* RType;
+  return RType();
+}
+
+
+} // namespace Atk
+
+
diff --git a/libs/gtkmm2/atk/atkmm/streamablecontent.h b/libs/gtkmm2/atk/atkmm/streamablecontent.h
new file mode 100644
index 0000000000..698aaef86b
--- /dev/null
+++ b/libs/gtkmm2/atk/atkmm/streamablecontent.h
@@ -0,0 +1,153 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _ATKMM_STREAMABLECONTENT_H
+#define _ATKMM_STREAMABLECONTENT_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* Copyright (C) 2003 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+extern "C"
+{
+  typedef struct _AtkStreamableContentIface AtkStreamableContentIface;
+  typedef struct _AtkStreamableContent      AtkStreamableContent;
+}
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _AtkStreamableContent AtkStreamableContent;
+typedef struct _AtkStreamableContentClass AtkStreamableContentClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Atk
+{ class StreamableContent_Class; } // namespace Atk
+namespace Atk
+{
+
+class Object;
+
+/** The ATK interface which provides access to streamable content.
+ */
+
+class StreamableContent : public Glib::Interface
+{
+  
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+public:
+  typedef StreamableContent CppObjectType;
+  typedef StreamableContent_Class CppClassType;
+  typedef AtkStreamableContent BaseObjectType;
+  typedef AtkStreamableContentIface BaseClassType;
+
+private:
+  friend class StreamableContent_Class;
+  static CppClassType streamablecontent_class_;
+
+  // noncopyable
+  StreamableContent(const StreamableContent&);
+  StreamableContent& operator=(const StreamableContent&);
+
+protected:
+  StreamableContent(); // you must derive from this class
+  explicit StreamableContent(AtkStreamableContent* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+  virtual ~StreamableContent();
+
+  static void add_interface(GType gtype_implementer);
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GObject.
+  AtkStreamableContent*       gobj()       { return reinterpret_cast<AtkStreamableContent*>(gobject_); }
+
+  ///Provides access to the underlying C GObject.  
+  const AtkStreamableContent* gobj() const { return reinterpret_cast<AtkStreamableContent*>(gobject_); }
+
+private:
+
+public:
+
+  
+  /** Gets the number of mime types supported by this object.
+   * @return A <tt>int</tt> which is the number of mime types supported by the object.
+   */
+  int get_n_mime_types() const;
+  
+  /** Gets the character string of the specified mime type. The first mime
+   * type is at position 0, the second at position 1, and so on.
+   * @param i A <tt>int</tt> representing the position of the mime type starting from 0.
+   * @return : a gchar* representing the specified mime type; the caller
+   * should not free the character string.
+   */
+  Glib::ustring get_mime_type(int i) const;
+  
+  /** Gets the content in the specified mime type.
+   * @param mime_type A gchar* representing the mime type.
+   * @return A G::IOChannel which contains the content in the specified mime
+   * type.
+   */
+  Glib::RefPtr<Glib::IOChannel> get_stream(const Glib::ustring& mime_type);
+
+protected:
+    virtual int get_n_mime_types_vfunc() const;
+    virtual const gchar* get_mime_type_vfunc(int i) const;
+    virtual GIOChannel* get_stream_vfunc(const Glib::ustring& mime_type);                                                   
+
+
+public:
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+};
+
+} // namespace Atk
+
+
+namespace Glib
+{
+  /** @relates Atk::StreamableContent
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Glib::RefPtr<Atk::StreamableContent> wrap(AtkStreamableContent* object, bool take_copy = false);
+
+} // namespace Glib
+
+#endif /* _ATKMM_STREAMABLECONTENT_H */
+
diff --git a/libs/gtkmm2/atk/atkmm/table.cc b/libs/gtkmm2/atk/atkmm/table.cc
new file mode 100644
index 0000000000..335fb55ece
--- /dev/null
+++ b/libs/gtkmm2/atk/atkmm/table.cc
@@ -0,0 +1,2394 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <atkmm/table.h>
+#include <atkmm/private/table_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <atkmm/object.h>
+#include <atk/atktable.h>
+
+
+namespace Atk
+{
+
+Glib::ArrayHandle<int> Table::get_selected_columns() const
+{
+  int* selected = 0;
+  const int n_selected = atk_table_get_selected_columns(const_cast<AtkTable*>(gobj()), &selected);
+
+  return Glib::ArrayHandle<int>(selected, n_selected, Glib::OWNERSHIP_SHALLOW);
+}
+
+Glib::ArrayHandle<int> Table::get_selected_rows() const
+{
+  int* selected = 0;
+  const int n_selected = atk_table_get_selected_rows(const_cast<AtkTable*>(gobj()), &selected);
+
+  return Glib::ArrayHandle<int>(selected, n_selected, Glib::OWNERSHIP_SHALLOW);
+}
+
+} // namespace Atk
+
+
+namespace
+{
+
+void Table_signal_row_inserted_callback(AtkTable* self, gint p0,gint p1,void* data)
+{
+  using namespace Atk;
+  typedef sigc::slot< void,int,int > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(p0
+, p1
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+}
+
+const Glib::SignalProxyInfo Table_signal_row_inserted_info =
+{
+  "row_inserted",
+  (GCallback) &Table_signal_row_inserted_callback,
+  (GCallback) &Table_signal_row_inserted_callback
+};
+
+
+void Table_signal_column_inserted_callback(AtkTable* self, gint p0,gint p1,void* data)
+{
+  using namespace Atk;
+  typedef sigc::slot< void,int,int > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(p0
+, p1
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+}
+
+const Glib::SignalProxyInfo Table_signal_column_inserted_info =
+{
+  "column_inserted",
+  (GCallback) &Table_signal_column_inserted_callback,
+  (GCallback) &Table_signal_column_inserted_callback
+};
+
+
+void Table_signal_row_deleted_callback(AtkTable* self, gint p0,gint p1,void* data)
+{
+  using namespace Atk;
+  typedef sigc::slot< void,int,int > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(p0
+, p1
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+}
+
+const Glib::SignalProxyInfo Table_signal_row_deleted_info =
+{
+  "row_deleted",
+  (GCallback) &Table_signal_row_deleted_callback,
+  (GCallback) &Table_signal_row_deleted_callback
+};
+
+
+void Table_signal_column_deleted_callback(AtkTable* self, gint p0,gint p1,void* data)
+{
+  using namespace Atk;
+  typedef sigc::slot< void,int,int > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(p0
+, p1
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+}
+
+const Glib::SignalProxyInfo Table_signal_column_deleted_info =
+{
+  "column_deleted",
+  (GCallback) &Table_signal_column_deleted_callback,
+  (GCallback) &Table_signal_column_deleted_callback
+};
+
+
+const Glib::SignalProxyInfo Table_signal_row_reordered_info =
+{
+  "row_reordered",
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
+};
+
+
+const Glib::SignalProxyInfo Table_signal_column_reordered_info =
+{
+  "column_reordered",
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
+};
+
+
+const Glib::SignalProxyInfo Table_signal_model_changed_info =
+{
+  "model_changed",
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
+};
+
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Glib::RefPtr<Atk::Table> wrap(AtkTable* object, bool take_copy)
+{
+  return Glib::RefPtr<Atk::Table>( dynamic_cast<Atk::Table*> (Glib::wrap_auto ((GObject*)(object), take_copy)) );
+  //We use dynamic_cast<> in case of multiple inheritance.
+}
+
+} // namespace Glib
+
+
+namespace Atk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Interface_Class& Table_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Interface_Class has to know the interface init function
+    // in order to add interfaces to implementing types.
+    class_init_func_ = &Table_Class::iface_init_function;
+
+    // We can not derive from another interface, and it is not necessary anyway.
+    gtype_ = atk_table_get_type();
+  }
+
+  return *this;
+}
+
+void Table_Class::iface_init_function(void* g_iface, void*)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_iface);
+
+  //This is just to avoid an "unused variable" warning when there are no vfuncs or signal handlers to connect.
+  //This is a temporary fix until I find out why I can not seem to derive a GtkFileChooser interface. murrayc
+  g_assert(klass != 0); 
+
+  klass->ref_at = &ref_at_vfunc_callback;
+  klass->get_index_at = &get_index_at_vfunc_callback;
+  klass->get_column_at_index = &get_column_at_index_vfunc_callback;
+  klass->get_row_at_index = &get_row_at_index_vfunc_callback;
+  klass->get_n_columns = &get_n_columns_vfunc_callback;
+  klass->get_n_rows = &get_n_rows_vfunc_callback;
+  klass->get_column_extent_at = &get_column_extent_at_vfunc_callback;
+  klass->get_row_extent_at = &get_row_extent_at_vfunc_callback;
+  klass->get_caption = &get_caption_vfunc_callback;
+  klass->get_column_description = &get_column_description_vfunc_callback;
+  klass->get_column_header = &get_column_header_vfunc_callback;
+  klass->get_row_description = &get_row_description_vfunc_callback;
+  klass->get_row_header = &get_row_header_vfunc_callback;
+  klass->get_summary = &get_summary_vfunc_callback;
+  klass->set_caption = &set_caption_vfunc_callback;
+  klass->set_column_description = &set_column_description_vfunc_callback;
+  klass->set_column_header = &set_column_header_vfunc_callback;
+  klass->set_row_description = &set_row_description_vfunc_callback;
+  klass->set_row_header = &set_row_header_vfunc_callback;
+  klass->set_summary = &set_summary_vfunc_callback;
+  klass->is_column_selected = &is_column_selected_vfunc_callback;
+  klass->is_row_selected = &is_row_selected_vfunc_callback;
+  klass->is_selected = &is_selected_vfunc_callback;
+  klass->add_row_selection = &add_row_selection_vfunc_callback;
+  klass->remove_row_selection = &remove_row_selection_vfunc_callback;
+  klass->add_column_selection = &add_column_selection_vfunc_callback;
+  klass->remove_column_selection = &remove_column_selection_vfunc_callback;
+  klass->get_selected_columns = &get_selected_columns_vfunc_callback;
+  klass->get_selected_rows = &get_selected_rows_vfunc_callback;
+  klass->row_inserted = &row_inserted_callback;
+  klass->column_inserted = &column_inserted_callback;
+  klass->row_deleted = &row_deleted_callback;
+  klass->column_deleted = &column_deleted_callback;
+  klass->row_reordered = &row_reordered_callback;
+  klass->column_reordered = &column_reordered_callback;
+  klass->model_changed = &model_changed_callback;
+}
+
+AtkObject* Table_Class::ref_at_vfunc_callback(AtkTable* self, gint row, gint column)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return Glib::unwrap_copy(obj->get_at_vfunc(row
+, column
+));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->ref_at)
+      return (*base->ref_at)(self, row, column);
+  }
+
+  typedef AtkObject* RType;
+  return RType();
+}
+
+gint Table_Class::get_index_at_vfunc_callback(AtkTable* self, gint row, gint column)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return obj->get_index_at_vfunc(row
+, column
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->get_index_at)
+      return (*base->get_index_at)(self, row, column);
+  }
+
+  typedef gint RType;
+  return RType();
+}
+
+gint Table_Class::get_column_at_index_vfunc_callback(AtkTable* self, gint index_)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return obj->get_column_at_index_vfunc(index_
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->get_column_at_index)
+      return (*base->get_column_at_index)(self, index_);
+  }
+
+  typedef gint RType;
+  return RType();
+}
+
+gint Table_Class::get_row_at_index_vfunc_callback(AtkTable* self, gint index_)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return obj->get_row_at_index_vfunc(index_
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->get_row_at_index)
+      return (*base->get_row_at_index)(self, index_);
+  }
+
+  typedef gint RType;
+  return RType();
+}
+
+gint Table_Class::get_n_columns_vfunc_callback(AtkTable* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return obj->get_n_columns_vfunc();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->get_n_columns)
+      return (*base->get_n_columns)(self);
+  }
+
+  typedef gint RType;
+  return RType();
+}
+
+gint Table_Class::get_n_rows_vfunc_callback(AtkTable* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return obj->get_n_rows_vfunc();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->get_n_rows)
+      return (*base->get_n_rows)(self);
+  }
+
+  typedef gint RType;
+  return RType();
+}
+
+gint Table_Class::get_column_extent_at_vfunc_callback(AtkTable* self, gint row, gint column)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return obj->get_column_extent_at_vfunc(row
+, column
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->get_column_extent_at)
+      return (*base->get_column_extent_at)(self, row, column);
+  }
+
+  typedef gint RType;
+  return RType();
+}
+
+gint Table_Class::get_row_extent_at_vfunc_callback(AtkTable* self, gint row, gint column)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return obj->get_row_extent_at_vfunc(row
+, column
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->get_row_extent_at)
+      return (*base->get_row_extent_at)(self, row, column);
+  }
+
+  typedef gint RType;
+  return RType();
+}
+
+AtkObject* Table_Class::get_caption_vfunc_callback(AtkTable* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return Glib::unwrap(obj->get_caption_vfunc());
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->get_caption)
+      return (*base->get_caption)(self);
+  }
+
+  typedef AtkObject* RType;
+  return RType();
+}
+
+const gchar* Table_Class::get_column_description_vfunc_callback(AtkTable* self, gint column)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return obj->get_column_description_vfunc(column
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->get_column_description)
+      return (*base->get_column_description)(self, column);
+  }
+
+  typedef const gchar* RType;
+  return RType();
+}
+
+AtkObject* Table_Class::get_column_header_vfunc_callback(AtkTable* self, gint column)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return Glib::unwrap(obj->get_column_header_vfunc(column
+));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->get_column_header)
+      return (*base->get_column_header)(self, column);
+  }
+
+  typedef AtkObject* RType;
+  return RType();
+}
+
+const gchar* Table_Class::get_row_description_vfunc_callback(AtkTable* self, gint row)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return obj->get_row_description_vfunc(row
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->get_row_description)
+      return (*base->get_row_description)(self, row);
+  }
+
+  typedef const gchar* RType;
+  return RType();
+}
+
+AtkObject* Table_Class::get_row_header_vfunc_callback(AtkTable* self, gint row)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return Glib::unwrap(obj->get_row_header_vfunc(row
+));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->get_row_header)
+      return (*base->get_row_header)(self, row);
+  }
+
+  typedef AtkObject* RType;
+  return RType();
+}
+
+AtkObject* Table_Class::get_summary_vfunc_callback(AtkTable* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return Glib::unwrap(obj->get_summary_vfunc());
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->get_summary)
+      return (*base->get_summary)(self);
+  }
+
+  typedef AtkObject* RType;
+  return RType();
+}
+
+void Table_Class::set_caption_vfunc_callback(AtkTable* self, AtkObject* caption)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->set_caption_vfunc(Glib::wrap(caption, true)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->set_caption)
+      (*base->set_caption)(self, caption);
+  }
+}
+
+void Table_Class::set_column_description_vfunc_callback(AtkTable* self, gint column, const gchar* description)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->set_column_description_vfunc(column
+, description
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->set_column_description)
+      (*base->set_column_description)(self, column, description);
+  }
+}
+
+void Table_Class::set_column_header_vfunc_callback(AtkTable* self, gint column, AtkObject* header)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->set_column_header_vfunc(column
+, Glib::wrap(header, true)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->set_column_header)
+      (*base->set_column_header)(self, column, header);
+  }
+}
+
+void Table_Class::set_row_description_vfunc_callback(AtkTable* self, gint row, const gchar* description)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->set_row_description_vfunc(row
+, description
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->set_row_description)
+      (*base->set_row_description)(self, row, description);
+  }
+}
+
+void Table_Class::set_row_header_vfunc_callback(AtkTable* self, gint row, AtkObject* header)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->set_row_header_vfunc(row
+, Glib::wrap(header, true)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->set_row_header)
+      (*base->set_row_header)(self, row, header);
+  }
+}
+
+void Table_Class::set_summary_vfunc_callback(AtkTable* self, AtkObject* accessible)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->set_summary_vfunc(Glib::wrap(accessible, true)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->set_summary)
+      (*base->set_summary)(self, accessible);
+  }
+}
+
+gboolean Table_Class::is_column_selected_vfunc_callback(AtkTable* self, gint column)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return static_cast<int>(obj->is_column_selected_vfunc(column
+));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->is_column_selected)
+      return (*base->is_column_selected)(self, column);
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+gboolean Table_Class::is_row_selected_vfunc_callback(AtkTable* self, gint row)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return static_cast<int>(obj->is_row_selected_vfunc(row
+));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->is_row_selected)
+      return (*base->is_row_selected)(self, row);
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+gboolean Table_Class::is_selected_vfunc_callback(AtkTable* self, gint row, gint column)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return static_cast<int>(obj->is_selected_vfunc(row
+, column
+));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->is_selected)
+      return (*base->is_selected)(self, row, column);
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+gboolean Table_Class::add_row_selection_vfunc_callback(AtkTable* self, gint row)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return static_cast<int>(obj->add_row_selection_vfunc(row
+));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->add_row_selection)
+      return (*base->add_row_selection)(self, row);
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+gboolean Table_Class::remove_row_selection_vfunc_callback(AtkTable* self, gint row)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return static_cast<int>(obj->remove_row_selection_vfunc(row
+));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->remove_row_selection)
+      return (*base->remove_row_selection)(self, row);
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+gboolean Table_Class::add_column_selection_vfunc_callback(AtkTable* self, gint column)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return static_cast<int>(obj->add_column_selection_vfunc(column
+));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->add_column_selection)
+      return (*base->add_column_selection)(self, column);
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+gboolean Table_Class::remove_column_selection_vfunc_callback(AtkTable* self, gint column)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return static_cast<int>(obj->remove_column_selection_vfunc(column
+));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->remove_column_selection)
+      return (*base->remove_column_selection)(self, column);
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+gint Table_Class::get_selected_columns_vfunc_callback(AtkTable* self, gint** selected)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return obj->get_selected_columns_vfunc(selected
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->get_selected_columns)
+      return (*base->get_selected_columns)(self, selected);
+  }
+
+  typedef gint RType;
+  return RType();
+}
+
+gint Table_Class::get_selected_rows_vfunc_callback(AtkTable* self, gint** selected)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return obj->get_selected_rows_vfunc(selected
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->get_selected_rows)
+      return (*base->get_selected_rows)(self, selected);
+  }
+
+  typedef gint RType;
+  return RType();
+}
+
+
+void Table_Class::row_inserted_callback(AtkTable* self, gint p0, gint p1)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_row_inserted(p0
+, p1
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->row_inserted)
+      (*base->row_inserted)(self, p0, p1);
+  }
+}
+
+void Table_Class::column_inserted_callback(AtkTable* self, gint p0, gint p1)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_column_inserted(p0
+, p1
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->column_inserted)
+      (*base->column_inserted)(self, p0, p1);
+  }
+}
+
+void Table_Class::row_deleted_callback(AtkTable* self, gint p0, gint p1)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_row_deleted(p0
+, p1
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->row_deleted)
+      (*base->row_deleted)(self, p0, p1);
+  }
+}
+
+void Table_Class::column_deleted_callback(AtkTable* self, gint p0, gint p1)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_column_deleted(p0
+, p1
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->column_deleted)
+      (*base->column_deleted)(self, p0, p1);
+  }
+}
+
+void Table_Class::row_reordered_callback(AtkTable* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_row_reordered();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->row_reordered)
+      (*base->row_reordered)(self);
+  }
+}
+
+void Table_Class::column_reordered_callback(AtkTable* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_column_reordered();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->column_reordered)
+      (*base->column_reordered)(self);
+  }
+}
+
+void Table_Class::model_changed_callback(AtkTable* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_model_changed();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->model_changed)
+      (*base->model_changed)(self);
+  }
+}
+
+
+Glib::ObjectBase* Table_Class::wrap_new(GObject* object)
+{
+  return new Table((AtkTable*)(object));
+}
+
+
+/* The implementation: */
+
+Table::Table()
+:
+  Glib::Interface(table_class_.init())
+{}
+
+Table::Table(AtkTable* castitem)
+:
+  Glib::Interface((GObject*)(castitem))
+{}
+
+Table::~Table()
+{}
+
+// static
+void Table::add_interface(GType gtype_implementer)
+{
+  table_class_.init().add_interface(gtype_implementer);
+}
+
+Table::CppClassType Table::table_class_; // initialize static member
+
+GType Table::get_type()
+{
+  return table_class_.init().get_type();
+}
+
+GType Table::get_base_type()
+{
+  return atk_table_get_type();
+}
+
+
+Glib::RefPtr<Atk::Object> Table::get_at(int row, int column)
+{
+  return Glib::wrap(atk_table_ref_at(gobj(), row, column));
+}
+
+int Table::get_index_at(int row, int column) const
+{
+  return atk_table_get_index_at(const_cast<AtkTable*>(gobj()), row, column);
+}
+
+int Table::get_column_at_index(int index) const
+{
+  return atk_table_get_column_at_index(const_cast<AtkTable*>(gobj()), index);
+}
+
+int Table::get_row_at_index(int index) const
+{
+  return atk_table_get_row_at_index(const_cast<AtkTable*>(gobj()), index);
+}
+
+int Table::get_n_columns() const
+{
+  return atk_table_get_n_columns(const_cast<AtkTable*>(gobj()));
+}
+
+int Table::get_n_rows() const
+{
+  return atk_table_get_n_rows(const_cast<AtkTable*>(gobj()));
+}
+
+int Table::get_column_extent_at(int row, int column) const
+{
+  return atk_table_get_column_extent_at(const_cast<AtkTable*>(gobj()), row, column);
+}
+
+int Table::get_row_extent_at(int row, int column) const
+{
+  return atk_table_get_row_extent_at(const_cast<AtkTable*>(gobj()), row, column);
+}
+
+Glib::RefPtr<Atk::Object> Table::get_caption()
+{
+
+  Glib::RefPtr<Atk::Object> retvalue = Glib::wrap(atk_table_get_caption(gobj()));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::RefPtr<const Atk::Object> Table::get_caption() const
+{
+
+  Glib::RefPtr<const Atk::Object> retvalue = Glib::wrap(atk_table_get_caption(const_cast<AtkTable*>(gobj())));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::ustring Table::get_column_description(int column) const
+{
+  return Glib::convert_const_gchar_ptr_to_ustring(atk_table_get_column_description(const_cast<AtkTable*>(gobj()), column));
+}
+
+Glib::RefPtr<Atk::Object> Table::get_column_header(int column)
+{
+
+  Glib::RefPtr<Atk::Object> retvalue = Glib::wrap(atk_table_get_column_header(gobj(), column));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::RefPtr<const Atk::Object> Table::get_column_header(int column) const
+{
+
+  Glib::RefPtr<const Atk::Object> retvalue = Glib::wrap(atk_table_get_column_header(const_cast<AtkTable*>(gobj()), column));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::ustring Table::get_row_description(int row) const
+{
+  return Glib::convert_const_gchar_ptr_to_ustring(atk_table_get_row_description(const_cast<AtkTable*>(gobj()), row));
+}
+
+Glib::RefPtr<Atk::Object> Table::get_row_header(int row)
+{
+
+  Glib::RefPtr<Atk::Object> retvalue = Glib::wrap(atk_table_get_row_header(gobj(), row));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::RefPtr<const Atk::Object> Table::get_row_header(int row) const
+{
+
+  Glib::RefPtr<const Atk::Object> retvalue = Glib::wrap(atk_table_get_row_header(const_cast<AtkTable*>(gobj()), row));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::RefPtr<Atk::Object> Table::get_summary()
+{
+
+  Glib::RefPtr<Atk::Object> retvalue = Glib::wrap(atk_table_get_summary(gobj()));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::RefPtr<const Atk::Object> Table::get_summary() const
+{
+
+  Glib::RefPtr<const Atk::Object> retvalue = Glib::wrap(atk_table_get_summary(const_cast<AtkTable*>(gobj())));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+void Table::set_caption(const Glib::RefPtr<Atk::Object>& caption)
+{
+  atk_table_set_caption(gobj(), Glib::unwrap(caption));
+}
+
+void Table::set_column_description(int column, const Glib::ustring& description)
+{
+  atk_table_set_column_description(gobj(), column, description.c_str());
+}
+
+void Table::set_column_header(int column, const Glib::RefPtr<Atk::Object>& header)
+{
+  atk_table_set_column_header(gobj(), column, Glib::unwrap(header));
+}
+
+void Table::set_row_description(int row, const Glib::ustring& description)
+{
+  atk_table_set_row_description(gobj(), row, description.c_str());
+}
+
+void Table::set_row_header(int row, const Glib::RefPtr<Atk::Object>& header)
+{
+  atk_table_set_row_header(gobj(), row, Glib::unwrap(header));
+}
+
+void Table::set_summary(const Glib::RefPtr<Atk::Object>& accessible)
+{
+  atk_table_set_summary(gobj(), Glib::unwrap(accessible));
+}
+
+bool Table::is_column_selected(int column) const
+{
+  return atk_table_is_column_selected(const_cast<AtkTable*>(gobj()), column);
+}
+
+bool Table::is_row_selected(int row) const
+{
+  return atk_table_is_row_selected(const_cast<AtkTable*>(gobj()), row);
+}
+
+bool Table::is_selected(int row, int column) const
+{
+  return atk_table_is_selected(const_cast<AtkTable*>(gobj()), row, column);
+}
+
+bool Table::add_row_selection(int row)
+{
+  return atk_table_add_row_selection(gobj(), row);
+}
+
+bool Table::remove_row_selection(int row)
+{
+  return atk_table_remove_row_selection(gobj(), row);
+}
+
+bool Table::add_column_selection(int column)
+{
+  return atk_table_add_column_selection(gobj(), column);
+}
+
+bool Table::remove_column_selection(int column)
+{
+  return atk_table_remove_column_selection(gobj(), column);
+}
+
+
+Glib::SignalProxy2< void,int,int > Table::signal_row_inserted()
+{
+  return Glib::SignalProxy2< void,int,int >(this, &Table_signal_row_inserted_info);
+}
+
+Glib::SignalProxy2< void,int,int > Table::signal_column_inserted()
+{
+  return Glib::SignalProxy2< void,int,int >(this, &Table_signal_column_inserted_info);
+}
+
+Glib::SignalProxy2< void,int,int > Table::signal_row_deleted()
+{
+  return Glib::SignalProxy2< void,int,int >(this, &Table_signal_row_deleted_info);
+}
+
+Glib::SignalProxy2< void,int,int > Table::signal_column_deleted()
+{
+  return Glib::SignalProxy2< void,int,int >(this, &Table_signal_column_deleted_info);
+}
+
+Glib::SignalProxy0< void > Table::signal_row_reordered()
+{
+  return Glib::SignalProxy0< void >(this, &Table_signal_row_reordered_info);
+}
+
+Glib::SignalProxy0< void > Table::signal_column_reordered()
+{
+  return Glib::SignalProxy0< void >(this, &Table_signal_column_reordered_info);
+}
+
+Glib::SignalProxy0< void > Table::signal_model_changed()
+{
+  return Glib::SignalProxy0< void >(this, &Table_signal_model_changed_info);
+}
+
+
+void Atk::Table::on_row_inserted(int row, int num_inserted)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->row_inserted)
+    (*base->row_inserted)(gobj(),row,num_inserted);
+}
+
+void Atk::Table::on_column_inserted(int column, int num_inserted)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->column_inserted)
+    (*base->column_inserted)(gobj(),column,num_inserted);
+}
+
+void Atk::Table::on_row_deleted(int row, int num_deleted)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->row_deleted)
+    (*base->row_deleted)(gobj(),row,num_deleted);
+}
+
+void Atk::Table::on_column_deleted(int column, int num_deleted)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->column_deleted)
+    (*base->column_deleted)(gobj(),column,num_deleted);
+}
+
+void Atk::Table::on_row_reordered()
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->row_reordered)
+    (*base->row_reordered)(gobj());
+}
+
+void Atk::Table::on_column_reordered()
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->column_reordered)
+    (*base->column_reordered)(gobj());
+}
+
+void Atk::Table::on_model_changed()
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->model_changed)
+    (*base->model_changed)(gobj());
+}
+
+
+Glib::RefPtr<Atk::Object> Atk::Table::get_at_vfunc(int row, int column) 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->ref_at)
+    return Glib::wrap((*base->ref_at)(gobj(),row,column));
+
+  typedef Glib::RefPtr<Atk::Object> RType;
+  return RType();
+}
+
+int Atk::Table::get_index_at_vfunc(int row, int column) const
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->get_index_at)
+    return (*base->get_index_at)(const_cast<AtkTable*>(gobj()),row,column);
+
+  typedef int RType;
+  return RType();
+}
+
+int Atk::Table::get_column_at_index_vfunc(int index) const
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->get_column_at_index)
+    return (*base->get_column_at_index)(const_cast<AtkTable*>(gobj()),index);
+
+  typedef int RType;
+  return RType();
+}
+
+int Atk::Table::get_row_at_index_vfunc(int index) const
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->get_row_at_index)
+    return (*base->get_row_at_index)(const_cast<AtkTable*>(gobj()),index);
+
+  typedef int RType;
+  return RType();
+}
+
+int Atk::Table::get_n_columns_vfunc() const
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->get_n_columns)
+    return (*base->get_n_columns)(const_cast<AtkTable*>(gobj()));
+
+  typedef int RType;
+  return RType();
+}
+
+int Atk::Table::get_n_rows_vfunc() const
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->get_n_rows)
+    return (*base->get_n_rows)(const_cast<AtkTable*>(gobj()));
+
+  typedef int RType;
+  return RType();
+}
+
+int Atk::Table::get_column_extent_at_vfunc(int row, int column) const
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->get_column_extent_at)
+    return (*base->get_column_extent_at)(const_cast<AtkTable*>(gobj()),row,column);
+
+  typedef int RType;
+  return RType();
+}
+
+int Atk::Table::get_row_extent_at_vfunc(int row, int column) const
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->get_row_extent_at)
+    return (*base->get_row_extent_at)(const_cast<AtkTable*>(gobj()),row,column);
+
+  typedef int RType;
+  return RType();
+}
+
+Glib::RefPtr<Atk::Object> Atk::Table::get_caption_vfunc() 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->get_caption)
+    return Glib::wrap((*base->get_caption)(gobj()));
+
+  typedef Glib::RefPtr<Atk::Object> RType;
+  return RType();
+}
+
+const char* Atk::Table::get_column_description_vfunc(int column) const
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->get_column_description)
+    return (*base->get_column_description)(const_cast<AtkTable*>(gobj()),column);
+
+  typedef const char* RType;
+  return RType();
+}
+
+Glib::RefPtr<Atk::Object> Atk::Table::get_column_header_vfunc(int column) 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->get_column_header)
+    return Glib::wrap((*base->get_column_header)(gobj(),column));
+
+  typedef Glib::RefPtr<Atk::Object> RType;
+  return RType();
+}
+
+const char* Atk::Table::get_row_description_vfunc(int row) const
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->get_row_description)
+    return (*base->get_row_description)(const_cast<AtkTable*>(gobj()),row);
+
+  typedef const char* RType;
+  return RType();
+}
+
+Glib::RefPtr<Atk::Object> Atk::Table::get_row_header_vfunc(int row) 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->get_row_header)
+    return Glib::wrap((*base->get_row_header)(gobj(),row));
+
+  typedef Glib::RefPtr<Atk::Object> RType;
+  return RType();
+}
+
+Glib::RefPtr<Atk::Object> Atk::Table::get_summary_vfunc() 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->get_summary)
+    return Glib::wrap((*base->get_summary)(gobj()));
+
+  typedef Glib::RefPtr<Atk::Object> RType;
+  return RType();
+}
+
+void Atk::Table::set_caption_vfunc(const Glib::RefPtr<Atk::Object>& caption) 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->set_caption)
+    (*base->set_caption)(gobj(),Glib::unwrap(caption));
+}
+
+void Atk::Table::set_column_description_vfunc(int column, const char* description) 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->set_column_description)
+    (*base->set_column_description)(gobj(),column,description);
+}
+
+void Atk::Table::set_column_header_vfunc(int column, const Glib::RefPtr<Atk::Object>& header) 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->set_column_header)
+    (*base->set_column_header)(gobj(),column,Glib::unwrap(header));
+}
+
+void Atk::Table::set_row_description_vfunc(int row, const char* description) 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->set_row_description)
+    (*base->set_row_description)(gobj(),row,description);
+}
+
+void Atk::Table::set_row_header_vfunc(int row, const Glib::RefPtr<Atk::Object>& header) 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->set_row_header)
+    (*base->set_row_header)(gobj(),row,Glib::unwrap(header));
+}
+
+void Atk::Table::set_summary_vfunc(const Glib::RefPtr<Atk::Object>& accessible) 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->set_summary)
+    (*base->set_summary)(gobj(),Glib::unwrap(accessible));
+}
+
+bool Atk::Table::is_column_selected_vfunc(int column) const
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->is_column_selected)
+    return (*base->is_column_selected)(const_cast<AtkTable*>(gobj()),column);
+
+  typedef bool RType;
+  return RType();
+}
+
+bool Atk::Table::is_row_selected_vfunc(int row) const
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->is_row_selected)
+    return (*base->is_row_selected)(const_cast<AtkTable*>(gobj()),row);
+
+  typedef bool RType;
+  return RType();
+}
+
+bool Atk::Table::is_selected_vfunc(int row, int column) const
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->is_selected)
+    return (*base->is_selected)(const_cast<AtkTable*>(gobj()),row,column);
+
+  typedef bool RType;
+  return RType();
+}
+
+bool Atk::Table::add_row_selection_vfunc(int row) 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->add_row_selection)
+    return (*base->add_row_selection)(gobj(),row);
+
+  typedef bool RType;
+  return RType();
+}
+
+bool Atk::Table::remove_row_selection_vfunc(int row) 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->remove_row_selection)
+    return (*base->remove_row_selection)(gobj(),row);
+
+  typedef bool RType;
+  return RType();
+}
+
+bool Atk::Table::add_column_selection_vfunc(int column) 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->add_column_selection)
+    return (*base->add_column_selection)(gobj(),column);
+
+  typedef bool RType;
+  return RType();
+}
+
+bool Atk::Table::remove_column_selection_vfunc(int column) 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->remove_column_selection)
+    return (*base->remove_column_selection)(gobj(),column);
+
+  typedef bool RType;
+  return RType();
+}
+
+int Atk::Table::get_selected_columns_vfunc(int** selected) const
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->get_selected_columns)
+    return (*base->get_selected_columns)(const_cast<AtkTable*>(gobj()),selected);
+
+  typedef int RType;
+  return RType();
+}
+
+int Atk::Table::get_selected_rows_vfunc(int** selected) const
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->get_selected_rows)
+    return (*base->get_selected_rows)(const_cast<AtkTable*>(gobj()),selected);
+
+  typedef int RType;
+  return RType();
+}
+
+
+} // namespace Atk
+
+
diff --git a/libs/gtkmm2/atk/atkmm/table.h b/libs/gtkmm2/atk/atkmm/table.h
new file mode 100644
index 0000000000..f1936afd49
--- /dev/null
+++ b/libs/gtkmm2/atk/atkmm/table.h
@@ -0,0 +1,427 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _ATKMM_TABLE_H
+#define _ATKMM_TABLE_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* Copyright (C) 2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+extern "C"
+{
+  typedef struct _AtkTableIface AtkTableIface;
+  typedef struct _AtkTable      AtkTable;
+}
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _AtkTable AtkTable;
+typedef struct _AtkTableClass AtkTableClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Atk
+{ class Table_Class; } // namespace Atk
+namespace Atk
+{
+
+class Object;
+
+/** The ATK interface implemented for UI components which contain tabular or row/column information.
+ * This should be implemented by components which present elements ordered via rows and columns. It may also be used to
+ * present tree-structured information if the nodes of the trees can be said to contain multiple "columns". Individual
+ * elements of an Atk::Table are typically referred to as "cells", and these cells are exposed by Atk::Table as child
+ * Atk::Objects of the Atk::Table. Both row/column and child-index-based access to these children is provided.
+ *
+ * Children of Atk::Table are frequently "lightweight" objects, that is, they may not have backing widgets in the host UI
+ * toolkit. They are therefore often transient.
+ *
+ * Since tables are often very complex, Atk::Table includes provision for offering simplified summary information, as
+ * well as row and column headers and captions. Headers and captions are AtkObjects which may implement other interfaces
+ * (Atk::Text, Atk::Image, etc.) as appropriate. Atk::Table summaries may themselves be (simplified) Atk::Tables, etc. 
+ */
+
+class Table : public Glib::Interface
+{
+  
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+public:
+  typedef Table CppObjectType;
+  typedef Table_Class CppClassType;
+  typedef AtkTable BaseObjectType;
+  typedef AtkTableIface BaseClassType;
+
+private:
+  friend class Table_Class;
+  static CppClassType table_class_;
+
+  // noncopyable
+  Table(const Table&);
+  Table& operator=(const Table&);
+
+protected:
+  Table(); // you must derive from this class
+  explicit Table(AtkTable* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+  virtual ~Table();
+
+  static void add_interface(GType gtype_implementer);
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GObject.
+  AtkTable*       gobj()       { return reinterpret_cast<AtkTable*>(gobject_); }
+
+  ///Provides access to the underlying C GObject.  
+  const AtkTable* gobj() const { return reinterpret_cast<AtkTable*>(gobject_); }
+
+private:
+
+
+public:
+  
+  /** Get a reference to the table cell at @a row , @a column .
+   * @param row A <tt>int</tt> representing a row in @a table .
+   * @param column A <tt>int</tt> representing a column in @a table .
+   * @return A AtkObject* representing the referred to accessible.
+   */
+  Glib::RefPtr<Atk::Object> get_at(int row, int column);
+  
+  /** Gets a <tt>int</tt> representing the index at the specified @a row  and @a column .
+   * The value -1 is returned if the object at row,column is not a child
+   * of table or table does not implement this interface.
+   * @param row A <tt>int</tt> representing a row in @a table .
+   * @param column A <tt>int</tt> representing a column in @a table .
+   * @return A <tt>int</tt> representing the index at specified position.
+   */
+  int get_index_at(int row, int column) const;
+  
+  /** Gets a <tt>int</tt> representing the column at the specified @a index , or -1
+   * if the table does not implement this interface
+   * @param index A <tt>int</tt> representing an index in @a table .
+   * @return A <tt>int</tt> representing the column at the specified index.
+   */
+  int get_column_at_index(int index) const;
+  
+  /** Gets a <tt>int</tt> representing the row at the specified @a index , or -1
+   * if the table does not implement this interface
+   * @param index A <tt>int</tt> representing an index in @a table .
+   * @return A <tt>int</tt> representing the row at the specified index.
+   */
+  int get_row_at_index(int index) const;
+  
+  /** Gets the number of columns in the table.
+   * @return A <tt>int</tt> representing the number of columns, or 0
+   * if value does not implement this interface.
+   */
+  int get_n_columns() const;
+  
+  /** Gets the number of rows in the table.
+   * @return A <tt>int</tt> representing the number of rows, or 0
+   * if value does not implement this interface.
+   */
+  int get_n_rows() const;
+  
+  /** Gets the number of columns occupied by the accessible object
+   * at the specified @a row  and @a column  in the @a table .
+   * @param row A <tt>int</tt> representing a row in @a table .
+   * @param column A <tt>int</tt> representing a column in @a table .
+   * @return A <tt>int</tt> representing the column extent at specified position, or 0
+   * if value does not implement this interface.
+   */
+  int get_column_extent_at(int row, int column) const;
+  
+  /** Gets the number of rows occupied by the accessible object
+   * at a specified @a row  and @a column  in the @a table .
+   * @param row A <tt>int</tt> representing a row in @a table .
+   * @param column A <tt>int</tt> representing a column in @a table .
+   * @return A <tt>int</tt> representing the row extent at specified position, or 0
+   * if value does not implement this interface.
+   */
+  int get_row_extent_at(int row, int column) const;
+  
+  
+  /** Gets the caption for the @a table .
+   * @return A AtkObject* representing the table caption, or <tt>0</tt>
+   * if value does not implement this interface.
+   */
+  Glib::RefPtr<Atk::Object> get_caption();
+  
+  /** Gets the caption for the @a table .
+   * @return A AtkObject* representing the table caption, or <tt>0</tt>
+   * if value does not implement this interface.
+   */
+  Glib::RefPtr<const Atk::Object> get_caption() const;
+  
+  
+  /** Gets the description text of the specified @a column  in the table
+   * @param column A <tt>int</tt> representing a column in @a table .
+   * @return A gchar* representing the column description, or <tt>0</tt>
+   * if value does not implement this interface.
+   */
+  Glib::ustring get_column_description(int column) const;
+  
+  
+  /** Gets the column header of a specified column in an accessible table.
+   * @param column A <tt>int</tt> representing a column in the table.
+   * @return A AtkObject* representing the specified column header, or
+   * <tt>0</tt> if value does not implement this interface.
+   */
+  Glib::RefPtr<Atk::Object> get_column_header(int column);
+  
+  /** Gets the column header of a specified column in an accessible table.
+   * @param column A <tt>int</tt> representing a column in the table.
+   * @return A AtkObject* representing the specified column header, or
+   * <tt>0</tt> if value does not implement this interface.
+   */
+  Glib::RefPtr<const Atk::Object> get_column_header(int column) const;
+
+  
+  /** Gets the description text of the specified row in the table
+   * @param row A <tt>int</tt> representing a row in @a table .
+   * @return A gchar* representing the row description, or <tt>0</tt>
+   * if value does not implement this interface.
+   */
+  Glib::ustring get_row_description(int row) const;
+
+  
+  /** Gets the row header of a specified row in an accessible table.
+   * @param row A <tt>int</tt> representing a row in the table.
+   * @return A AtkObject* representing the specified row header, or
+   * <tt>0</tt> if value does not implement this interface.
+   */
+  Glib::RefPtr<Atk::Object> get_row_header(int row);
+  
+  /** Gets the row header of a specified row in an accessible table.
+   * @param row A <tt>int</tt> representing a row in the table.
+   * @return A AtkObject* representing the specified row header, or
+   * <tt>0</tt> if value does not implement this interface.
+   */
+  Glib::RefPtr<const Atk::Object> get_row_header(int row) const;
+  
+  
+  /** Gets the summary description of the table.
+   * @return A AtkObject* representing a summary description of the table,
+   * or zero if value does not implement this interface.
+   */
+  Glib::RefPtr<Atk::Object> get_summary();
+  
+  /** Gets the summary description of the table.
+   * @return A AtkObject* representing a summary description of the table,
+   * or zero if value does not implement this interface.
+   */
+  Glib::RefPtr<const Atk::Object> get_summary() const;
+  
+  
+  /** Sets the caption for the table.
+   * @param caption A Atk::Object representing the caption to set for @a table .
+   */
+  void set_caption(const Glib::RefPtr<Atk::Object>& caption);
+  
+  /** Sets the description text for the specified @a column  of the @a table .
+   * @param column A <tt>int</tt> representing a column in @a table .
+   * @param description A #gchar representing the description text
+   * to set for the specified @a column  of the @a table .
+   */
+  void set_column_description(int column, const Glib::ustring& description);
+  
+  /** Sets the specified column header to @a header .
+   * @param column A <tt>int</tt> representing a column in @a table .
+   * @param header An Atk::Table.
+   */
+  void set_column_header(int column, const Glib::RefPtr<Atk::Object>& header);
+  
+  /** Sets the description text for the specified @a row  of @a table .
+   * @param row A <tt>int</tt> representing a row in @a table .
+   * @param description A #gchar representing the description text
+   * to set for the specified @a row  of @a table .
+   */
+  void set_row_description(int row, const Glib::ustring& description);
+  
+  /** Sets the specified row header to @a header .
+   * @param row A <tt>int</tt> representing a row in @a table .
+   * @param header An Atk::Table.
+   */
+  void set_row_header(int row, const Glib::RefPtr<Atk::Object>& header);
+  
+  /** Sets the summary description of the table.
+   * @param accessible An Atk::Object representing the summary description
+   * to set for @a table .
+   */
+  void set_summary(const Glib::RefPtr<Atk::Object>& accessible);
+
+  
+  Glib::ArrayHandle<int> get_selected_columns() const;
+  Glib::ArrayHandle<int> get_selected_rows() const;
+
+  
+  /** Gets a boolean value indicating whether the specified @a column 
+   * is selected
+   * @param column A <tt>int</tt> representing a column in @a table .
+   * @return A <tt>bool</tt> representing if the column is selected, or 0
+   * if value does not implement this interface.
+   */
+  bool is_column_selected(int column) const;
+  
+  /** Gets a boolean value indicating whether the specified @a row 
+   * is selected
+   * @param row A <tt>int</tt> representing a row in @a table .
+   * @return A <tt>bool</tt> representing if the row is selected, or 0
+   * if value does not implement this interface.
+   */
+  bool is_row_selected(int row) const;
+  
+  /** Gets a boolean value indicating whether the accessible object
+   * at the specified @a row  and @a column  is selected
+   * @param row A <tt>int</tt> representing a row in @a table .
+   * @param column A <tt>int</tt> representing a column in @a table .
+   * @return A <tt>bool</tt> representing if the cell is selected, or 0
+   * if value does not implement this interface.
+   */
+  bool is_selected(int row, int column) const;
+  
+  /** Adds the specified @a row  to the selection.
+   * @param row A <tt>int</tt> representing a row in @a table .
+   * @return A <tt>bool</tt> representing if row was successfully added to selection,
+   * or 0 if value does not implement this interface.
+   */
+  bool add_row_selection(int row);
+  
+  /** Removes the specified @a row  from the selection.
+   * @param row A <tt>int</tt> representing a row in @a table .
+   * @return A <tt>bool</tt> representing if the row was successfully removed from
+   * the selection, or 0 if value does not implement this interface.
+   */
+  bool remove_row_selection(int row);
+  
+  /** Adds the specified @a column  to the selection.
+   * @param column A <tt>int</tt> representing a column in @a table .
+   * @return A <tt>bool</tt> representing if the column was successfully added to 
+   * the selection, or 0 if value does not implement this interface.
+   */
+  bool add_column_selection(int column);
+  
+  /** Adds the specified @a column  to the selection.
+   * @param column A <tt>int</tt> representing a column in @a table .
+   * @return A <tt>bool</tt> representing if the column was successfully removed from
+   * the selection, or 0 if value does not implement this interface.
+   */
+  bool remove_column_selection(int column);
+
+  
+  Glib::SignalProxy2< void,int,int > signal_row_inserted();
+
+  
+  Glib::SignalProxy2< void,int,int > signal_column_inserted();
+
+  
+  Glib::SignalProxy2< void,int,int > signal_row_deleted();
+
+  
+  Glib::SignalProxy2< void,int,int > signal_column_deleted();
+
+  
+  Glib::SignalProxy0< void > signal_row_reordered();
+
+  
+  Glib::SignalProxy0< void > signal_column_reordered();
+
+  
+  Glib::SignalProxy0< void > signal_model_changed();
+
+
+protected:
+    virtual Glib::RefPtr<Atk::Object> get_at_vfunc(int row, int column);
+    virtual int get_index_at_vfunc(int row, int column) const;
+    virtual int get_column_at_index_vfunc(int index) const;
+    virtual int get_row_at_index_vfunc(int index) const;
+    virtual int get_n_columns_vfunc() const;
+    virtual int get_n_rows_vfunc() const;
+    virtual int get_column_extent_at_vfunc(int row, int column) const;
+    virtual int get_row_extent_at_vfunc(int row, int column) const;
+    virtual Glib::RefPtr<Atk::Object> get_caption_vfunc();
+    virtual const char* get_column_description_vfunc(int column) const;
+    virtual Glib::RefPtr<Atk::Object> get_column_header_vfunc(int column);
+    virtual const char* get_row_description_vfunc(int row) const;
+    virtual Glib::RefPtr<Atk::Object> get_row_header_vfunc(int row);
+    virtual Glib::RefPtr<Atk::Object> get_summary_vfunc();
+    virtual void set_caption_vfunc(const Glib::RefPtr<Atk::Object>& caption);
+    virtual void set_column_description_vfunc(int column, const char* description);
+    virtual void set_column_header_vfunc(int column, const Glib::RefPtr<Atk::Object>& header);
+    virtual void set_row_description_vfunc(int row, const char* description);
+    virtual void set_row_header_vfunc(int row, const Glib::RefPtr<Atk::Object>& header);
+    virtual void set_summary_vfunc(const Glib::RefPtr<Atk::Object>& accessible);
+    virtual bool is_column_selected_vfunc(int column) const;
+    virtual bool is_row_selected_vfunc(int row) const;
+    virtual bool is_selected_vfunc(int row, int column) const;
+    virtual bool add_row_selection_vfunc(int row);
+    virtual bool remove_row_selection_vfunc(int row);
+    virtual bool add_column_selection_vfunc(int column);
+    virtual bool remove_column_selection_vfunc(int column);
+    virtual int get_selected_columns_vfunc(int** selected) const;
+    virtual int get_selected_rows_vfunc(int** selected) const;
+
+
+public:
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+  virtual void on_row_inserted(int row, int num_inserted);
+  virtual void on_column_inserted(int column, int num_inserted);
+  virtual void on_row_deleted(int row, int num_deleted);
+  virtual void on_column_deleted(int column, int num_deleted);
+  virtual void on_row_reordered();
+  virtual void on_column_reordered();
+  virtual void on_model_changed();
+
+
+};
+
+} // namespace Atk
+
+
+namespace Glib
+{
+  /** @relates Atk::Table
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Glib::RefPtr<Atk::Table> wrap(AtkTable* object, bool take_copy = false);
+
+} // namespace Glib
+
+#endif /* _ATKMM_TABLE_H */
+
diff --git a/libs/gtkmm2/atk/atkmm/text.cc b/libs/gtkmm2/atk/atkmm/text.cc
new file mode 100644
index 0000000000..af101a5117
--- /dev/null
+++ b/libs/gtkmm2/atk/atkmm/text.cc
@@ -0,0 +1,1563 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <atkmm/text.h>
+#include <atkmm/private/text_p.h>
+
+#include <atk/atk-enum-types.h>
+// -*- c++ -*-
+/* $Id$ */
+
+/* Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <atkmm/object.h>
+#include <glib.h>
+#include <algorithm> /* for std::swap() */
+
+
+// static
+GType Glib::Value<Atk::TextAttribute>::value_type()
+{
+  return atk_text_attribute_get_type();
+}
+
+
+namespace Atk
+{
+
+/**** Atk::Attribute *******************************************************/
+
+Attribute::Attribute()
+{
+  gobject_.name  = 0;
+  gobject_.value = 0;
+}
+
+Attribute::Attribute(const Glib::ustring& name, const Glib::ustring& value)
+{
+  gobject_.name  = g_strndup(name .data(), name .bytes());
+  gobject_.value = g_strndup(value.data(), value.bytes());
+}
+
+Attribute::Attribute(const AtkAttribute* gobject)
+{
+  g_return_if_fail(gobject != 0);
+
+  gobject_.name  = g_strdup(gobject->name);
+  gobject_.value = g_strdup(gobject->value);
+}
+
+Attribute::~Attribute()
+{
+  g_free(gobject_.name);
+  g_free(gobject_.value);
+}
+
+Attribute::Attribute(const Attribute& other)
+{
+  gobject_.name  = g_strdup(other.gobject_.name);
+  gobject_.value = g_strdup(other.gobject_.value);
+}
+
+Attribute& Attribute::operator=(const Attribute& other)
+{
+  Attribute temp (other);
+  swap(temp);
+  return *this;
+}
+
+void Attribute::swap(Attribute& other)
+{
+  std::swap(gobject_.name,  other.gobject_.name);
+  std::swap(gobject_.value, other.gobject_.value);
+}
+
+
+/**** Atk::TextAttribute ***************************************************/
+
+// static
+TextAttribute TextAttribute::for_name(const Glib::ustring& name)
+{
+  return TextAttribute(int(atk_text_attribute_for_name(name.c_str())));
+}
+
+// static
+Glib::ustring TextAttribute::get_name(TextAttribute attribute)
+{
+  if(const char *const name = atk_text_attribute_get_name(AtkTextAttribute(int(attribute))))
+    return Glib::ustring(name);
+  else
+    return Glib::ustring();
+}
+
+// static
+Glib::ustring TextAttribute::get_value(TextAttribute attribute, int index)
+{
+  if(const char *const value = atk_text_attribute_get_value(AtkTextAttribute(int(attribute)), index))
+    return Glib::ustring(value);
+  else
+    return Glib::ustring();
+}
+
+} // namespace Atk
+
+
+namespace
+{
+
+void Text_signal_text_changed_callback(AtkText* self, gint p0,gint p1,void* data)
+{
+  using namespace Atk;
+  typedef sigc::slot< void,int,int > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(p0
+, p1
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+}
+
+const Glib::SignalProxyInfo Text_signal_text_changed_info =
+{
+  "text_changed",
+  (GCallback) &Text_signal_text_changed_callback,
+  (GCallback) &Text_signal_text_changed_callback
+};
+
+
+void Text_signal_text_caret_moved_callback(AtkText* self, gint p0,void* data)
+{
+  using namespace Atk;
+  typedef sigc::slot< void,int > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(p0
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+}
+
+const Glib::SignalProxyInfo Text_signal_text_caret_moved_info =
+{
+  "text_caret_moved",
+  (GCallback) &Text_signal_text_caret_moved_callback,
+  (GCallback) &Text_signal_text_caret_moved_callback
+};
+
+
+const Glib::SignalProxyInfo Text_signal_text_selection_changed_info =
+{
+  "text_selection_changed",
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
+};
+
+
+const Glib::SignalProxyInfo Text_signal_text_attributes_changed_info =
+{
+  "text_attributes_changed",
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
+};
+
+} // anonymous namespace
+
+
+namespace Atk
+{
+
+
+Glib::ustring Attribute::get_name() const
+{
+  return Glib::convert_const_gchar_ptr_to_ustring(gobj()->name);
+}
+
+Glib::ustring Attribute::get_value() const
+{
+  return Glib::convert_const_gchar_ptr_to_ustring(gobj()->value);
+}
+
+
+} // namespace Atk
+
+// static
+GType Glib::Value<Atk::BuiltinTextAttribute>::value_type()
+{
+  return atk_text_attribute_get_type();
+}
+
+// static
+GType Glib::Value<Atk::TextBoundary>::value_type()
+{
+  return atk_text_boundary_get_type();
+}
+
+// static
+GType Glib::Value<Atk::TextClipType>::value_type()
+{
+  return atk_text_clip_type_get_type();
+}
+
+
+namespace Glib
+{
+
+Glib::RefPtr<Atk::Text> wrap(AtkText* object, bool take_copy)
+{
+  return Glib::RefPtr<Atk::Text>( dynamic_cast<Atk::Text*> (Glib::wrap_auto ((GObject*)(object), take_copy)) );
+  //We use dynamic_cast<> in case of multiple inheritance.
+}
+
+} // namespace Glib
+
+
+namespace Atk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Interface_Class& Text_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Interface_Class has to know the interface init function
+    // in order to add interfaces to implementing types.
+    class_init_func_ = &Text_Class::iface_init_function;
+
+    // We can not derive from another interface, and it is not necessary anyway.
+    gtype_ = atk_text_get_type();
+  }
+
+  return *this;
+}
+
+void Text_Class::iface_init_function(void* g_iface, void*)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_iface);
+
+  //This is just to avoid an "unused variable" warning when there are no vfuncs or signal handlers to connect.
+  //This is a temporary fix until I find out why I can not seem to derive a GtkFileChooser interface. murrayc
+  g_assert(klass != 0); 
+
+  klass->get_text = &get_text_vfunc_callback;
+  klass->get_character_at_offset = &get_character_at_offset_vfunc_callback;
+  klass->get_text_after_offset = &get_text_after_offset_vfunc_callback;
+  klass->get_text_at_offset = &get_text_at_offset_vfunc_callback;
+  klass->get_text_before_offset = &get_text_before_offset_vfunc_callback;
+  klass->get_caret_offset = &get_caret_offset_vfunc_callback;
+  klass->get_character_extents = &get_character_extents_vfunc_callback;
+  klass->get_run_attributes = &get_run_attributes_vfunc_callback;
+  klass->get_default_attributes = &get_default_attributes_vfunc_callback;
+  klass->get_character_count = &get_character_count_vfunc_callback;
+  klass->get_offset_at_point = &get_offset_at_point_vfunc_callback;
+  klass->get_n_selections = &get_n_selections_vfunc_callback;
+  klass->get_selection = &get_selection_vfunc_callback;
+  klass->add_selection = &add_selection_vfunc_callback;
+  klass->remove_selection = &remove_selection_vfunc_callback;
+  klass->set_selection = &set_selection_vfunc_callback;
+  klass->set_caret_offset = &set_caret_offset_vfunc_callback;
+  klass->text_changed = &text_changed_callback;
+  klass->text_caret_moved = &text_caret_moved_callback;
+  klass->text_selection_changed = &text_selection_changed_callback;
+  klass->text_attributes_changed = &text_attributes_changed_callback;
+}
+
+gchar* Text_Class::get_text_vfunc_callback(AtkText* self, gint start_offset, gint end_offset)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return g_strdup((obj->get_text_vfunc(start_offset
+, end_offset
+)).c_str());
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->get_text)
+      return (*base->get_text)(self, start_offset, end_offset);
+  }
+
+  typedef gchar* RType;
+  return RType();
+}
+
+gunichar Text_Class::get_character_at_offset_vfunc_callback(AtkText* self, gint offset)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return obj->get_character_at_offset_vfunc(offset
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->get_character_at_offset)
+      return (*base->get_character_at_offset)(self, offset);
+  }
+
+  typedef gunichar RType;
+  return RType();
+}
+
+gchar* Text_Class::get_text_after_offset_vfunc_callback(AtkText* self, gint offset, AtkTextBoundary boundary_type, gint* start_offset, gint* end_offset)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return g_strdup((obj->get_text_after_offset_vfunc(offset
+, ((TextBoundary)(boundary_type))
+, *(start_offset)
+, *(end_offset)
+)).c_str());
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->get_text_after_offset)
+      return (*base->get_text_after_offset)(self, offset, boundary_type, start_offset, end_offset);
+  }
+
+  typedef gchar* RType;
+  return RType();
+}
+
+gchar* Text_Class::get_text_at_offset_vfunc_callback(AtkText* self, gint offset, AtkTextBoundary boundary_type, gint* start_offset, gint* end_offset)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return g_strdup((obj->get_text_at_offset_vfunc(offset
+, ((TextBoundary)(boundary_type))
+, *(start_offset)
+, *(end_offset)
+)).c_str());
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->get_text_at_offset)
+      return (*base->get_text_at_offset)(self, offset, boundary_type, start_offset, end_offset);
+  }
+
+  typedef gchar* RType;
+  return RType();
+}
+
+gchar* Text_Class::get_text_before_offset_vfunc_callback(AtkText* self, gint offset, AtkTextBoundary boundary_type, gint* start_offset, gint* end_offset)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return g_strdup((obj->get_text_before_offset_vfunc(offset
+, ((TextBoundary)(boundary_type))
+, *(start_offset)
+, *(end_offset)
+)).c_str());
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->get_text_before_offset)
+      return (*base->get_text_before_offset)(self, offset, boundary_type, start_offset, end_offset);
+  }
+
+  typedef gchar* RType;
+  return RType();
+}
+
+gint Text_Class::get_caret_offset_vfunc_callback(AtkText* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return obj->get_caret_offset_vfunc();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->get_caret_offset)
+      return (*base->get_caret_offset)(self);
+  }
+
+  typedef gint RType;
+  return RType();
+}
+
+void Text_Class::get_character_extents_vfunc_callback(AtkText* self, gint offset, gint* x, gint* y, gint* width, gint* height, AtkCoordType coords)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->get_character_extents_vfunc(offset
+, *(x)
+, *(y)
+, *(width)
+, *(height)
+, ((CoordType)(coords))
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->get_character_extents)
+      (*base->get_character_extents)(self, offset, x, y, width, height, coords);
+  }
+}
+
+AtkAttributeSet* Text_Class::get_run_attributes_vfunc_callback(AtkText* self, gint offset, gint* start_offset, gint* end_offset)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return obj->get_run_attributes_vfunc(offset
+, *(start_offset)
+, *(end_offset)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->get_run_attributes)
+      return (*base->get_run_attributes)(self, offset, start_offset, end_offset);
+  }
+
+  typedef AtkAttributeSet* RType;
+  return RType();
+}
+
+AtkAttributeSet* Text_Class::get_default_attributes_vfunc_callback(AtkText* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return obj->get_default_attributes_vfunc();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->get_default_attributes)
+      return (*base->get_default_attributes)(self);
+  }
+
+  typedef AtkAttributeSet* RType;
+  return RType();
+}
+
+gint Text_Class::get_character_count_vfunc_callback(AtkText* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return obj->get_character_count_vfunc();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->get_character_count)
+      return (*base->get_character_count)(self);
+  }
+
+  typedef gint RType;
+  return RType();
+}
+
+gint Text_Class::get_offset_at_point_vfunc_callback(AtkText* self, gint x, gint y, AtkCoordType coords)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return obj->get_offset_at_point_vfunc(x
+, y
+, ((CoordType)(coords))
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->get_offset_at_point)
+      return (*base->get_offset_at_point)(self, x, y, coords);
+  }
+
+  typedef gint RType;
+  return RType();
+}
+
+gint Text_Class::get_n_selections_vfunc_callback(AtkText* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return obj->get_n_selections_vfunc();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->get_n_selections)
+      return (*base->get_n_selections)(self);
+  }
+
+  typedef gint RType;
+  return RType();
+}
+
+gchar* Text_Class::get_selection_vfunc_callback(AtkText* self, gint selection_num, gint* start_offset, gint* end_offset)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return g_strdup((obj->get_selection_vfunc(selection_num
+, *(start_offset)
+, *(end_offset)
+)).c_str());
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->get_selection)
+      return (*base->get_selection)(self, selection_num, start_offset, end_offset);
+  }
+
+  typedef gchar* RType;
+  return RType();
+}
+
+gboolean Text_Class::add_selection_vfunc_callback(AtkText* self, gint start_offset, gint end_offset)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return static_cast<int>(obj->add_selection_vfunc(start_offset
+, end_offset
+));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->add_selection)
+      return (*base->add_selection)(self, start_offset, end_offset);
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+gboolean Text_Class::remove_selection_vfunc_callback(AtkText* self, gint selection_num)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return static_cast<int>(obj->remove_selection_vfunc(selection_num
+));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->remove_selection)
+      return (*base->remove_selection)(self, selection_num);
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+gboolean Text_Class::set_selection_vfunc_callback(AtkText* self, gint selection_num, gint start_offset, gint end_offset)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return static_cast<int>(obj->set_selection_vfunc(selection_num
+, start_offset
+, end_offset
+));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->set_selection)
+      return (*base->set_selection)(self, selection_num, start_offset, end_offset);
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+gboolean Text_Class::set_caret_offset_vfunc_callback(AtkText* self, gint offset)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return static_cast<int>(obj->set_caret_offset_vfunc(offset
+));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->set_caret_offset)
+      return (*base->set_caret_offset)(self, offset);
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+
+void Text_Class::text_changed_callback(AtkText* self, gint p0, gint p1)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_text_changed(p0
+, p1
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->text_changed)
+      (*base->text_changed)(self, p0, p1);
+  }
+}
+
+void Text_Class::text_caret_moved_callback(AtkText* self, gint p0)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_text_caret_moved(p0
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->text_caret_moved)
+      (*base->text_caret_moved)(self, p0);
+  }
+}
+
+void Text_Class::text_selection_changed_callback(AtkText* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_text_selection_changed();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->text_selection_changed)
+      (*base->text_selection_changed)(self);
+  }
+}
+
+void Text_Class::text_attributes_changed_callback(AtkText* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_text_attributes_changed();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->text_attributes_changed)
+      (*base->text_attributes_changed)(self);
+  }
+}
+
+
+Glib::ObjectBase* Text_Class::wrap_new(GObject* object)
+{
+  return new Text((AtkText*)(object));
+}
+
+
+/* The implementation: */
+
+Text::Text()
+:
+  Glib::Interface(text_class_.init())
+{}
+
+Text::Text(AtkText* castitem)
+:
+  Glib::Interface((GObject*)(castitem))
+{}
+
+Text::~Text()
+{}
+
+// static
+void Text::add_interface(GType gtype_implementer)
+{
+  text_class_.init().add_interface(gtype_implementer);
+}
+
+Text::CppClassType Text::text_class_; // initialize static member
+
+GType Text::get_type()
+{
+  return text_class_.init().get_type();
+}
+
+GType Text::get_base_type()
+{
+  return atk_text_get_type();
+}
+
+Glib::ustring Text::get_text(int start_offset, int end_offset) const
+{
+  return Glib::convert_return_gchar_ptr_to_ustring(atk_text_get_text(const_cast<AtkText*>(gobj()), start_offset, end_offset));
+}
+
+gunichar Text::get_character_at_offset(int offset) const
+{
+  return atk_text_get_character_at_offset(const_cast<AtkText*>(gobj()), offset);
+}
+
+Glib::ustring Text::get_text_after_offset(int offset, TextBoundary boundary_type, int& start_offset, int& end_offset) const
+{
+  return Glib::convert_return_gchar_ptr_to_ustring(atk_text_get_text_after_offset(const_cast<AtkText*>(gobj()), offset, ((AtkTextBoundary)(boundary_type)), &start_offset, &end_offset));
+}
+
+Glib::ustring Text::get_text_at_offset(int offset, TextBoundary boundary_type, int& start_offset, int& end_offset) const
+{
+  return Glib::convert_return_gchar_ptr_to_ustring(atk_text_get_text_at_offset(const_cast<AtkText*>(gobj()), offset, ((AtkTextBoundary)(boundary_type)), &start_offset, &end_offset));
+}
+
+Glib::ustring Text::get_text_before_offset(int offset, TextBoundary boundary_type, int& start_offset, int& end_offset) const
+{
+  return Glib::convert_return_gchar_ptr_to_ustring(atk_text_get_text_before_offset(const_cast<AtkText*>(gobj()), offset, ((AtkTextBoundary)(boundary_type)), &start_offset, &end_offset));
+}
+
+int Text::get_caret_offset() const
+{
+  return atk_text_get_caret_offset(const_cast<AtkText*>(gobj()));
+}
+
+void Text::get_character_extents(int offset, int& x, int& y, int& width, int& height, CoordType coords) const
+{
+  atk_text_get_character_extents(const_cast<AtkText*>(gobj()), offset, &x, &y, &width, &height, ((AtkCoordType)(coords)));
+}
+
+AttributeSet Text::get_run_attributes(int offset, int& start_offset, int& end_offset) const
+{
+  return AttributeSet(atk_text_get_run_attributes(const_cast<AtkText*>(gobj()), offset, &start_offset, &end_offset), Glib::OWNERSHIP_DEEP);
+}
+
+AttributeSet Text::get_default_attributes() const
+{
+  return AttributeSet(atk_text_get_default_attributes(const_cast<AtkText*>(gobj())), Glib::OWNERSHIP_DEEP);
+}
+
+int Text::get_character_count() const
+{
+  return atk_text_get_character_count(const_cast<AtkText*>(gobj()));
+}
+
+int Text::get_offset_at_point(int x, int y, CoordType coords) const
+{
+  return atk_text_get_offset_at_point(const_cast<AtkText*>(gobj()), x, y, ((AtkCoordType)(coords)));
+}
+
+int Text::get_n_selections() const
+{
+  return atk_text_get_n_selections(const_cast<AtkText*>(gobj()));
+}
+
+Glib::ustring Text::get_selection(int selection_num, int& start_offset, int& end_offset) const
+{
+  return Glib::convert_return_gchar_ptr_to_ustring(atk_text_get_selection(const_cast<AtkText*>(gobj()), selection_num, &start_offset, &end_offset));
+}
+
+bool Text::add_selection(int start_offset, int end_offset)
+{
+  return atk_text_add_selection(gobj(), start_offset, end_offset);
+}
+
+bool Text::remove_selection(int selection_num)
+{
+  return atk_text_remove_selection(gobj(), selection_num);
+}
+
+bool Text::set_selection(int selection_num, int start_offset, int end_offset)
+{
+  return atk_text_set_selection(gobj(), selection_num, start_offset, end_offset);
+}
+
+bool Text::set_caret_offset(int offset)
+{
+  return atk_text_set_caret_offset(gobj(), offset);
+}
+
+void Text::get_range_extents(int start_offset, int end_offset, CoordType coord_type, Rectangle& rect)
+{
+  atk_text_get_range_extents(gobj(), start_offset, end_offset, ((AtkCoordType)(coord_type)), &(rect));
+}
+
+AtkTextRange** Text::get_bounded_ranges(const Rectangle& rect, CoordType coord_type, TextClipType x_clip_type, TextClipType y_clip_type)
+{
+  return atk_text_get_bounded_ranges(gobj(), const_cast<AtkTextRectangle*>(&(rect)), ((AtkCoordType)(coord_type)), ((AtkTextClipType)(x_clip_type)), ((AtkTextClipType)(y_clip_type)));
+}
+
+
+Glib::SignalProxy2< void,int,int > Text::signal_text_changed()
+{
+  return Glib::SignalProxy2< void,int,int >(this, &Text_signal_text_changed_info);
+}
+
+Glib::SignalProxy1< void,int > Text::signal_text_caret_moved()
+{
+  return Glib::SignalProxy1< void,int >(this, &Text_signal_text_caret_moved_info);
+}
+
+Glib::SignalProxy0< void > Text::signal_text_selection_changed()
+{
+  return Glib::SignalProxy0< void >(this, &Text_signal_text_selection_changed_info);
+}
+
+Glib::SignalProxy0< void > Text::signal_text_attributes_changed()
+{
+  return Glib::SignalProxy0< void >(this, &Text_signal_text_attributes_changed_info);
+}
+
+
+void Atk::Text::on_text_changed(int position, int length)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->text_changed)
+    (*base->text_changed)(gobj(),position,length);
+}
+
+void Atk::Text::on_text_caret_moved(int location)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->text_caret_moved)
+    (*base->text_caret_moved)(gobj(),location);
+}
+
+void Atk::Text::on_text_selection_changed()
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->text_selection_changed)
+    (*base->text_selection_changed)(gobj());
+}
+
+void Atk::Text::on_text_attributes_changed()
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->text_attributes_changed)
+    (*base->text_attributes_changed)(gobj());
+}
+
+
+Glib::ustring Atk::Text::get_text_vfunc(int start_offset, int end_offset) const
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->get_text)
+    return Glib::convert_const_gchar_ptr_to_ustring((*base->get_text)(const_cast<AtkText*>(gobj()),start_offset,end_offset));
+
+  typedef Glib::ustring RType;
+  return RType();
+}
+
+gunichar Atk::Text::get_character_at_offset_vfunc(int offset) const
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->get_character_at_offset)
+    return (*base->get_character_at_offset)(const_cast<AtkText*>(gobj()),offset);
+
+  typedef gunichar RType;
+  return RType();
+}
+
+Glib::ustring Atk::Text::get_text_after_offset_vfunc(int offset, TextBoundary boundary_type, int& start_offset, int& end_offset) const
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->get_text_after_offset)
+    return Glib::convert_const_gchar_ptr_to_ustring((*base->get_text_after_offset)(const_cast<AtkText*>(gobj()),offset,((AtkTextBoundary)(boundary_type)),&start_offset,&end_offset));
+
+  typedef Glib::ustring RType;
+  return RType();
+}
+
+Glib::ustring Atk::Text::get_text_at_offset_vfunc(int offset, TextBoundary boundary_type, int& start_offset, int& end_offset) const
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->get_text_at_offset)
+    return Glib::convert_const_gchar_ptr_to_ustring((*base->get_text_at_offset)(const_cast<AtkText*>(gobj()),offset,((AtkTextBoundary)(boundary_type)),&start_offset,&end_offset));
+
+  typedef Glib::ustring RType;
+  return RType();
+}
+
+Glib::ustring Atk::Text::get_text_before_offset_vfunc(int offset, TextBoundary boundary_type, int& start_offset, int& end_offset) const
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->get_text_before_offset)
+    return Glib::convert_const_gchar_ptr_to_ustring((*base->get_text_before_offset)(const_cast<AtkText*>(gobj()),offset,((AtkTextBoundary)(boundary_type)),&start_offset,&end_offset));
+
+  typedef Glib::ustring RType;
+  return RType();
+}
+
+int Atk::Text::get_caret_offset_vfunc() const
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->get_caret_offset)
+    return (*base->get_caret_offset)(const_cast<AtkText*>(gobj()));
+
+  typedef int RType;
+  return RType();
+}
+
+void Atk::Text::get_character_extents_vfunc(int offset, int& x, int& y, int& width, int& height, CoordType coords) const
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->get_character_extents)
+    (*base->get_character_extents)(const_cast<AtkText*>(gobj()),offset,&x,&y,&width,&height,((AtkCoordType)(coords)));
+}
+
+AtkAttributeSet* Atk::Text::get_run_attributes_vfunc(int offset, int& start_offset, int& end_offset) const
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->get_run_attributes)
+    return (*base->get_run_attributes)(const_cast<AtkText*>(gobj()),offset,&start_offset,&end_offset);
+
+  typedef AtkAttributeSet* RType;
+  return RType();
+}
+
+AtkAttributeSet* Atk::Text::get_default_attributes_vfunc() const
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->get_default_attributes)
+    return (*base->get_default_attributes)(const_cast<AtkText*>(gobj()));
+
+  typedef AtkAttributeSet* RType;
+  return RType();
+}
+
+int Atk::Text::get_character_count_vfunc() const
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->get_character_count)
+    return (*base->get_character_count)(const_cast<AtkText*>(gobj()));
+
+  typedef int RType;
+  return RType();
+}
+
+int Atk::Text::get_offset_at_point_vfunc(int x, int y, CoordType coords) const
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->get_offset_at_point)
+    return (*base->get_offset_at_point)(const_cast<AtkText*>(gobj()),x,y,((AtkCoordType)(coords)));
+
+  typedef int RType;
+  return RType();
+}
+
+int Atk::Text::get_n_selections_vfunc() const
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->get_n_selections)
+    return (*base->get_n_selections)(const_cast<AtkText*>(gobj()));
+
+  typedef int RType;
+  return RType();
+}
+
+Glib::ustring Atk::Text::get_selection_vfunc(int selection_num, int& start_offset, int& end_offset) const
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->get_selection)
+    return Glib::convert_const_gchar_ptr_to_ustring((*base->get_selection)(const_cast<AtkText*>(gobj()),selection_num,&start_offset,&end_offset));
+
+  typedef Glib::ustring RType;
+  return RType();
+}
+
+bool Atk::Text::add_selection_vfunc(int start_offset, int end_offset) 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->add_selection)
+    return (*base->add_selection)(gobj(),start_offset,end_offset);
+
+  typedef bool RType;
+  return RType();
+}
+
+bool Atk::Text::remove_selection_vfunc(int selection_num) 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->remove_selection)
+    return (*base->remove_selection)(gobj(),selection_num);
+
+  typedef bool RType;
+  return RType();
+}
+
+bool Atk::Text::set_selection_vfunc(int selection_num, int start_offset, int end_offset) 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->set_selection)
+    return (*base->set_selection)(gobj(),selection_num,start_offset,end_offset);
+
+  typedef bool RType;
+  return RType();
+}
+
+bool Atk::Text::set_caret_offset_vfunc(int offset) 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->set_caret_offset)
+    return (*base->set_caret_offset)(gobj(),offset);
+
+  typedef bool RType;
+  return RType();
+}
+
+
+} // namespace Atk
+
+
diff --git a/libs/gtkmm2/atk/atkmm/text.h b/libs/gtkmm2/atk/atkmm/text.h
new file mode 100644
index 0000000000..86dee7ee39
--- /dev/null
+++ b/libs/gtkmm2/atk/atkmm/text.h
@@ -0,0 +1,687 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _ATKMM_TEXT_H
+#define _ATKMM_TEXT_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* Copyright (C) 2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+
+#include <atkmm/component.h> /* for Atk::CoordType */
+#include <atk/atktext.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _AtkText AtkText;
+typedef struct _AtkTextClass AtkTextClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Atk
+{ class Text_Class; } // namespace Atk
+namespace Atk
+{
+
+class Attribute
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Attribute CppObjectType;
+  typedef AtkAttribute BaseObjectType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+private:
+
+
+public:
+  Attribute();
+  Attribute(const Glib::ustring& name, const Glib::ustring& value);
+  explicit Attribute(const AtkAttribute* gobject);
+  ~Attribute();
+
+  Attribute(const Attribute& other);
+  Attribute& operator=(const Attribute& other);
+
+  void swap(Attribute& other);
+
+  Glib::ustring get_name() const;
+  Glib::ustring get_value() const;
+
+  /// Provides access to the underlying C GObject.
+  AtkAttribute*       gobj()       { return &gobject_; }
+
+  /// Provides access to the underlying C GObject.
+  const AtkAttribute* gobj() const { return &gobject_; }
+
+protected:
+  AtkAttribute gobject_;
+
+
+};
+
+/** @relates Atk::Attribute */
+inline void swap(Attribute& lhs, Attribute& rhs)
+  { lhs.swap(rhs); }
+
+struct AttributeTraits
+{
+  typedef Atk::Attribute      CppType;
+  typedef const AtkAttribute* CType;
+  typedef AtkAttribute*       CTypeNonConst;
+
+  static CType to_c_type(CType item)          { return item; }
+  static CType to_c_type(const CppType& item) { return item.gobj(); }
+  static CppType to_cpp_type(CType item)      { return CppType(item); }
+  static void release_c_type(CType item)      { g_free(const_cast<CTypeNonConst>(item)); }
+};
+
+typedef Glib::SListHandle<Attribute, AttributeTraits> AttributeSet;
+
+
+/** @addtogroup atkmmEnums Enums and Flags */
+
+/**
+ * @ingroup atkmmEnums
+ */
+enum BuiltinTextAttribute
+{
+  TEXT_ATTR_INVALID,
+  TEXT_ATTR_LEFT_MARGIN,
+  TEXT_ATTR_RIGHT_MARGIN,
+  TEXT_ATTR_INDENT,
+  TEXT_ATTR_INVISIBLE,
+  TEXT_ATTR_EDITABLE,
+  TEXT_ATTR_PIXELS_ABOVE_LINES,
+  TEXT_ATTR_PIXELS_BELOW_LINES,
+  TEXT_ATTR_PIXELS_INSIDE_WRAP,
+  TEXT_ATTR_BG_FULL_HEIGHT,
+  TEXT_ATTR_RISE,
+  TEXT_ATTR_UNDERLINE,
+  TEXT_ATTR_STRIKETHROUGH,
+  TEXT_ATTR_SIZE,
+  TEXT_ATTR_SCALE,
+  TEXT_ATTR_WEIGHT,
+  TEXT_ATTR_LANGUAGE,
+  TEXT_ATTR_FAMILY_NAME,
+  TEXT_ATTR_BG_COLOR,
+  TEXT_ATTR_FG_COLOR,
+  TEXT_ATTR_BG_STIPPLE,
+  TEXT_ATTR_FG_STIPPLE,
+  TEXT_ATTR_WRAP_MODE,
+  TEXT_ATTR_DIRECTION,
+  TEXT_ATTR_JUSTIFICATION,
+  TEXT_ATTR_STRETCH,
+  TEXT_ATTR_VARIANT,
+  TEXT_ATTR_STYLE,
+  TEXT_ATTR_LAST_DEFINED
+};
+
+} // namespace Atk
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Atk::BuiltinTextAttribute> : public Glib::Value_Enum<Atk::BuiltinTextAttribute>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Atk
+{
+
+
+class TextAttribute
+{
+private:
+  int attribute_;
+
+public:
+  TextAttribute() : attribute_ (0) {}
+  TextAttribute(BuiltinTextAttribute attribute) : attribute_ (attribute) {}
+
+  // Behave like an ordinary enum.
+  explicit TextAttribute(int attribute) : attribute_ (attribute) {}
+  operator int() const { return attribute_; }
+
+  static TextAttribute for_name(const Glib::ustring& name);
+  static Glib::ustring get_name(TextAttribute attribute);
+  static Glib::ustring get_value(TextAttribute attribute, int index);
+};
+
+} // namespace Atk
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Atk::TextAttribute> : public Glib::Value_Enum<Atk::TextAttribute>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+namespace Atk
+{
+
+/**
+ * @ingroup atkmmEnums
+ */
+enum TextBoundary
+{
+  TEXT_BOUNDARY_CHAR,
+  TEXT_BOUNDARY_WORD_START,
+  TEXT_BOUNDARY_WORD_END,
+  TEXT_BOUNDARY_SENTENCE_START,
+  TEXT_BOUNDARY_SENTENCE_END,
+  TEXT_BOUNDARY_LINE_START,
+  TEXT_BOUNDARY_LINE_END
+};
+
+} // namespace Atk
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Atk::TextBoundary> : public Glib::Value_Enum<Atk::TextBoundary>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Atk
+{
+
+/**
+ * @ingroup atkmmEnums
+ */
+enum TextClipType
+{
+  TEXT_CLIP_NONE,
+  TEXT_CLIP_MIN,
+  TEXT_CLIP_MAX,
+  TEXT_CLIP_BOTH
+};
+
+} // namespace Atk
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Atk::TextClipType> : public Glib::Value_Enum<Atk::TextClipType>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Atk
+{
+
+
+/** The ATK interface implemented by components with text content.
+ * This should be implemented by Atk::Objects on behalf of widgets that have text content which is either attributed
+ * or otherwise non-trivial. Atk::Objects whose text content is simple, unattributed, and very brief may expose that
+ * content via Atk::Object::get_name() instead; however if the text is editable, multi-line, typically longer than
+ * three or four words, attributed, selectable, or if the object already uses the 'name' ATK property for other
+ * information, this Text interface should be used to expose the text content. In the case of editable text content,
+ * Atk::EditableText (a subtype of the Atk::Text interface) should be implemented instead.
+ *
+ * Atk::Text provides not only traversal facilities and change notification for text content, but also caret tracking
+ * and glyph bounding box calculations. Note that the text strings are exposed as UTF-8, and are therefore potentially
+ * multi-byte, and caret-to-byte offset mapping makes no assumptions about the character length; also bounding box
+ * glyph-to-offset mapping may be complex for languages which use ligatures.
+ */
+
+class Text : public Glib::Interface
+{
+  
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+public:
+  typedef Text CppObjectType;
+  typedef Text_Class CppClassType;
+  typedef AtkText BaseObjectType;
+  typedef AtkTextIface BaseClassType;
+
+private:
+  friend class Text_Class;
+  static CppClassType text_class_;
+
+  // noncopyable
+  Text(const Text&);
+  Text& operator=(const Text&);
+
+protected:
+  Text(); // you must derive from this class
+  explicit Text(AtkText* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+  virtual ~Text();
+
+  static void add_interface(GType gtype_implementer);
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GObject.
+  AtkText*       gobj()       { return reinterpret_cast<AtkText*>(gobject_); }
+
+  ///Provides access to the underlying C GObject.  
+  const AtkText* gobj() const { return reinterpret_cast<AtkText*>(gobject_); }
+
+private:
+
+
+public:
+  
+  /** Gets the specified text.
+   * @param start_offset Start position.
+   * @param end_offset End position.
+   * @return The text from @a start_offset  up to, but not including @a end_offset .
+   */
+  Glib::ustring get_text(int start_offset, int end_offset) const;
+  
+  /** Gets the specified text.
+   * @param offset Position.
+   * @return The character at @a offset .
+   */
+  gunichar get_character_at_offset(int offset) const;
+  
+  /** Gets the specified text.
+   * 
+   * If the boundary_type if ATK_TEXT_BOUNDARY_CHAR the character after the 
+   * offset is returned.
+   * 
+   * If the boundary_type is ATK_TEXT_BOUNDARY_WORD_START the returned string
+   * is from the word start after the offset to the next word start.
+   * 
+   * The returned string will contain the word after the offset if the offset 
+   * is inside a word or if the offset is not inside a word.
+   * 
+   * If the boundary_type is ATK_TEXT_BOUNDARY_WORD_END the returned string
+   * is from the word end at or after the offset to the next work end.
+   * 
+   * The returned string will contain the word after the offset if the offset
+   * is inside a word and will contain the word after the word after the offset
+   * if the offset is not inside a word.
+   * 
+   * If the boundary type is ATK_TEXT_BOUNDARY_SENTENCE_START the returned
+   * string is from the sentence start after the offset to the next sentence
+   * start.
+   * 
+   * The returned string will contain the sentence after the offset if the offset
+   * is inside a sentence or if the offset is not inside a sentence.
+   * 
+   * If the boundary_type is ATK_TEXT_BOUNDARY_SENTENCE_END the returned string
+   * is from the sentence end at or after the offset to the next sentence end.
+   * 
+   * The returned string will contain the sentence after the offset if the offset
+   * is inside a sentence and will contain the sentence after the sentence
+   * after the offset if the offset is not inside a sentence.
+   * 
+   * If the boundary type is ATK_TEXT_BOUNDARY_LINE_START the returned
+   * string is from the line start after the offset to the next line start.
+   * 
+   * If the boundary_type is ATK_TEXT_BOUNDARY_LINE_END the returned string
+   * is from the line end at or after the offset to the next line start.
+   * @param offset Position.
+   * @param boundary_type An Atk::TextBoundary.
+   * @param start_offset The start offset of the returned string.
+   * @param end_offset The end offset of the returned string.
+   * @return The text after @a offset  bounded by the specified @a boundary_type .
+   */
+  Glib::ustring get_text_after_offset(int offset, TextBoundary boundary_type, int& start_offset, int& end_offset) const;
+  
+  /** Gets the specified text.
+   * 
+   * If the boundary_type if ATK_TEXT_BOUNDARY_CHAR the character at the
+   * offset is returned.
+   * 
+   * If the boundary_type is ATK_TEXT_BOUNDARY_WORD_START the returned string
+   * is from the word start at or before the offset to the word start after 
+   * the offset.
+   * 
+   * The returned string will contain the word at the offset if the offset
+   * is inside a word and will contain the word before the offset if the 
+   * offset is not inside a word.
+   * 
+   * If the boundary_type is ATK_TEXT_BOUNDARY_WORD_END the returned string
+   * is from the word end before the offset to the word end at or after the
+   * offset.
+   * 
+   * The returned string will contain the word at the offset if the offset
+   * is inside a word and will contain the word after to the offset if the 
+   * offset is not inside a word.
+   * 
+   * If the boundary type is ATK_TEXT_BOUNDARY_SENTENCE_START the returned
+   * string is from the sentence start at or before the offset to the sentence
+   * start after the offset.
+   * 
+   * The returned string will contain the sentence at the offset if the offset
+   * is inside a sentence and will contain the sentence before the offset 
+   * if the offset is not inside a sentence.
+   * 
+   * If the boundary_type is ATK_TEXT_BOUNDARY_SENTENCE_END the returned string
+   * is from the sentence end before the offset to the sentence end at or
+   * after the offset.
+   * 
+   * The returned string will contain the sentence at the offset if the offset
+   * is inside a sentence and will contain the sentence after the offset 
+   * if the offset is not inside a sentence.
+   * 
+   * If the boundary type is ATK_TEXT_BOUNDARY_LINE_START the returned
+   * string is from the line start at or before the offset to the line
+   * start after the offset.
+   * 
+   * If the boundary_type is ATK_TEXT_BOUNDARY_LINE_END the returned string
+   * is from the line end before the offset to the line end at or after
+   * the offset.
+   * @param offset Position.
+   * @param boundary_type An Atk::TextBoundary.
+   * @param start_offset The start offset of the returned string.
+   * @param end_offset The end offset of the returned string.
+   * @return The text at @a offset  bounded by the specified @a boundary_type .
+   */
+  Glib::ustring get_text_at_offset(int offset, TextBoundary boundary_type, int& start_offset, int& end_offset) const;
+  
+  /** Gets the specified text.
+   * 
+   * If the boundary_type if ATK_TEXT_BOUNDARY_CHAR the character before the
+   * offset is returned.
+   * 
+   * If the boundary_type is ATK_TEXT_BOUNDARY_WORD_START the returned string
+   * is from the word start before the word start before the offset to 
+   * the word start before the offset.
+   * 
+   * The returned string will contain the word before the offset if the offset
+   * is inside a word and will contain the word before the word before the 
+   * offset if the offset is not inside a word.
+   * 
+   * If the boundary_type is ATK_TEXT_BOUNDARY_WORD_END the returned string
+   * is from the word end before the word end at or before the offset to the 
+   * word end at or before the offset.
+   * 
+   * The returned string will contain the word before the offset if the offset
+   * is inside a word or if the offset is not inside a word.
+   * 
+   * If the boundary type is ATK_TEXT_BOUNDARY_SENTENCE_START the returned
+   * string is from the sentence start before the sentence start before 
+   * the offset to the sentence start before the offset.
+   * 
+   * The returned string will contain the sentence before the offset if the 
+   * offset is inside a sentence and will contain the sentence before the 
+   * sentence before the offset if the offset is not inside a sentence.
+   * 
+   * If the boundary_type is ATK_TEXT_BOUNDARY_SENTENCE_END the returned string
+   * is from the sentence end before the sentence end at or before the offset to 
+   * the sentence end at or before the offset.
+   * 
+   * The returned string will contain the sentence before the offset if the 
+   * offset is inside a sentence or if the offset is not inside a sentence.
+   * 
+   * If the boundary type is ATK_TEXT_BOUNDARY_LINE_START the returned
+   * string is from the line start before the line start ar or before the offset 
+   * to the line start ar or before the offset.
+   * 
+   * If the boundary_type is ATK_TEXT_BOUNDARY_LINE_END the returned string
+   * is from the line end before the line end before the offset to the 
+   * line end before the offset.
+   * @param offset Position.
+   * @param boundary_type An Atk::TextBoundary.
+   * @param start_offset The start offset of the returned string.
+   * @param end_offset The end offset of the returned string.
+   * @return The text before @a offset  bounded by the specified @a boundary_type .
+   */
+  Glib::ustring get_text_before_offset(int offset, TextBoundary boundary_type, int& start_offset, int& end_offset) const;
+  
+  /** Gets the offset position of the caret (cursor).
+   * @return The offset position of the caret (cursor).
+   */
+  int get_caret_offset() const;
+  
+  /** Get the bounding box containing the glyph representing the character at 
+   * a particular text offset.
+   * @param offset The offset of the text character for which bounding information is required.
+   * @param x Pointer for the x cordinate of the bounding box.
+   * @param y Pointer for the y cordinate of the bounding box.
+   * @param width Pointer for the width of the bounding box.
+   * @param height Pointer for the height of the bounding box.
+   * @param coords Specify whether coordinates are relative to the screen or widget window.
+   */
+  void get_character_extents(int offset, int& x, int& y, int& width, int& height, CoordType coords) const;
+  
+  /** Creates an Atk::AttributeSet which consists of the attributes explicitly
+   * set at the position @a offset  in the text. @a start_offset  and @a end_offset  are
+   * set to the start and end of the range around @a offset  where the attributes are
+   * invariant. See the enum AtkTextAttribute for types of text attributes that
+   * can be returned. Note that other attributes may also be returned.
+   * @param offset The offset at which to get the attributes.
+   * @param start_offset The address to put the start offset of the range.
+   * @param end_offset The address to put the end offset of the range.
+   * @return An Atk::AttributeSet which contains the attributes explicitly set
+   * at @a offset .
+   */
+  AttributeSet get_run_attributes(int offset, int& start_offset, int& end_offset) const;
+  
+  /** Creates an Atk::AttributeSet which consists of the default values of
+   * attributes for the text. See the enum AtkTextAttribute for types of text
+   * attributes that can be returned. Note that other attributes may also be
+   * returned.
+   * @return An Atk::AttributeSet which contains the default values of attributes.
+   * at @a offset .
+   */
+  AttributeSet get_default_attributes() const;
+  
+  /** Gets the character count.
+   * @return The number of characters.
+   */
+  int get_character_count() const;
+  
+  /** Gets the offset of the character located at coordinates @a x  and @a y . @a x  and @a y 
+   * are interpreted as being relative to the screen or this widget's window
+   * depending on @a coords .
+   * @param x Screen x-position of character.
+   * @param y Screen y-position of character.
+   * @param coords Specify whether coordinates are relative to the screen or
+   * widget window.
+   * @return The offset to the character which is located at
+   * the specified @a x  and @a y  coordinates.
+   */
+  int get_offset_at_point(int x, int y, CoordType coords) const;
+  
+  /** Gets the number of selected regions.
+   * @return The number of selected regions, or -1 if a failure
+   * occurred.
+   */
+  int get_n_selections() const;
+  
+  /** Gets the text from the specified selection.
+   * @param selection_num The selection number.  The selected regions are
+   * assigned numbers that correspond to how far the region is from the
+   * start of the text.  The selected region closest to the beginning
+   * of the text region is assigned the number 0, etc.  Note that adding,
+   * moving or deleting a selected region can change the numbering.
+   * @param start_offset Passes back the start position of the selected region.
+   * @param end_offset Passes back the end position of the selected region.
+   * @return The selected text.
+   */
+  Glib::ustring get_selection(int selection_num, int& start_offset, int& end_offset) const;
+  
+  /** Adds a selection bounded by the specified offsets.
+   * @param start_offset The start position of the selected region.
+   * @param end_offset The end position of the selected region.
+   * @return <tt>true</tt> if success, <tt>false</tt> otherwise.
+   */
+  bool add_selection(int start_offset, int end_offset);
+  
+  /** Removes the specified selection.
+   * @param selection_num The selection number.  The selected regions are
+   * assigned numbers that correspond to how far the region is from the
+   * start of the text.  The selected region closest to the beginning
+   * of the text region is assigned the number 0, etc.  Note that adding,
+   * moving or deleting a selected region can change the numbering.
+   * @return <tt>true</tt> if success, <tt>false</tt> otherwise.
+   */
+  bool remove_selection(int selection_num);
+  
+  /** Changes the start and end offset of the specified selection.
+   * @param selection_num The selection number.  The selected regions are
+   * assigned numbers that correspond to how far the region is from the
+   * start of the text.  The selected region closest to the beginning
+   * of the text region is assigned the number 0, etc.  Note that adding,
+   * moving or deleting a selected region can change the numbering.
+   * @param start_offset The new start position of the selection.
+   * @param end_offset The new end position of the selection.
+   * @return <tt>true</tt> if success, <tt>false</tt> otherwise.
+   */
+  bool set_selection(int selection_num, int start_offset, int end_offset);
+  
+  /** Sets the caret (cursor) position to the specified @a offset .
+   * @param offset Position.
+   * @return <tt>true</tt> if success, <tt>false</tt> otherwise.
+   */
+  bool set_caret_offset(int offset);
+  
+  typedef AtkTextRectangle Rectangle;
+    
+  
+  /** Get the bounding box for text within the specified range.
+   * @param start_offset The offset of the first text character for which boundary 
+   * information is required.
+   * @param end_offset The offset of the text character after the last character 
+   * for which boundary information is required.
+   * @param coord_type Specify whether coordinates are relative to the screen or widget window.
+   * @param rect A pointer to a AtkTextRectangle which is filled in by this function.
+   */
+  void get_range_extents(int start_offset, int end_offset,
+                                      CoordType coord_type,
+                                      Rectangle& rect);
+  
+  /** Get the ranges of text in the specified bounding box.
+   * @param rect An AtkTextRectagle giving the dimensions of the bounding box.
+   * @param coord_type Specify whether coordinates are relative to the screen or widget window.
+   * @param x_clip_type Specify the horizontal clip type.
+   * @param y_clip_type Specify the vertical clip type.
+   * @return Array of AtkTextRange. The last element of the array returned 
+   * by this function will be <tt>0</tt>.
+   */
+  AtkTextRange** get_bounded_ranges(const Rectangle& rect, CoordType coord_type,
+                                                 TextClipType x_clip_type, TextClipType y_clip_type);
+                                                           
+
+  Glib::SignalProxy2< void,int,int > signal_text_changed();
+
+  
+  Glib::SignalProxy1< void,int > signal_text_caret_moved();
+
+  
+  Glib::SignalProxy0< void > signal_text_selection_changed();
+
+  
+  Glib::SignalProxy0< void > signal_text_attributes_changed();
+
+
+protected:
+ 
+
+    virtual Glib::ustring get_text_vfunc(int start_offset, int end_offset) const;
+    virtual gunichar get_character_at_offset_vfunc(int offset) const;
+    virtual Glib::ustring get_text_after_offset_vfunc(int offset, TextBoundary boundary_type, int& start_offset, int& end_offset) const;
+    virtual Glib::ustring get_text_at_offset_vfunc(int offset, TextBoundary boundary_type, int& start_offset, int& end_offset) const;
+    virtual Glib::ustring get_text_before_offset_vfunc(int offset, TextBoundary boundary_type, int& start_offset, int& end_offset) const;
+    virtual int get_caret_offset_vfunc() const;
+    virtual void get_character_extents_vfunc(int offset, int& x, int& y, int& width, int& height, CoordType coords) const;
+    virtual AtkAttributeSet* get_run_attributes_vfunc(int offset, int& start_offset, int& end_offset) const;
+    virtual AtkAttributeSet* get_default_attributes_vfunc() const;
+    virtual int get_character_count_vfunc() const;
+    virtual int get_offset_at_point_vfunc(int x, int y, CoordType coords) const;
+    virtual int get_n_selections_vfunc() const;
+    virtual Glib::ustring get_selection_vfunc(int selection_num, int& start_offset, int& end_offset) const;
+    virtual bool add_selection_vfunc(int start_offset, int end_offset);
+    virtual bool remove_selection_vfunc(int selection_num);
+    virtual bool set_selection_vfunc(int selection_num, int start_offset, int end_offset);
+    virtual bool set_caret_offset_vfunc(int offset);
+  
+  //TODO: Add get_range_extents(), and get_bounded_ranges() vfuncs when we can break ABI.
+
+
+public:
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+  virtual void on_text_changed(int position, int length);
+  virtual void on_text_caret_moved(int location);
+  virtual void on_text_selection_changed();
+  virtual void on_text_attributes_changed();
+
+
+};
+
+} // namespace Atk
+
+
+namespace Glib
+{
+  /** @relates Atk::Text
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Glib::RefPtr<Atk::Text> wrap(AtkText* object, bool take_copy = false);
+
+} // namespace Glib
+
+#endif /* _ATKMM_TEXT_H */
+
diff --git a/libs/gtkmm2/atk/atkmm/value.cc b/libs/gtkmm2/atk/atkmm/value.cc
new file mode 100644
index 0000000000..eeff7dfd2f
--- /dev/null
+++ b/libs/gtkmm2/atk/atkmm/value.cc
@@ -0,0 +1,340 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <atkmm/value.h>
+#include <atkmm/private/value_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <atk/atkvalue.h>
+
+
+namespace
+{
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Glib::RefPtr<Atk::Value> wrap(AtkValue* object, bool take_copy)
+{
+  return Glib::RefPtr<Atk::Value>( dynamic_cast<Atk::Value*> (Glib::wrap_auto ((GObject*)(object), take_copy)) );
+  //We use dynamic_cast<> in case of multiple inheritance.
+}
+
+} // namespace Glib
+
+
+namespace Atk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Interface_Class& Value_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Interface_Class has to know the interface init function
+    // in order to add interfaces to implementing types.
+    class_init_func_ = &Value_Class::iface_init_function;
+
+    // We can not derive from another interface, and it is not necessary anyway.
+    gtype_ = atk_value_get_type();
+  }
+
+  return *this;
+}
+
+void Value_Class::iface_init_function(void* g_iface, void*)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_iface);
+
+  //This is just to avoid an "unused variable" warning when there are no vfuncs or signal handlers to connect.
+  //This is a temporary fix until I find out why I can not seem to derive a GtkFileChooser interface. murrayc
+  g_assert(klass != 0); 
+
+  klass->get_current_value = &get_current_value_vfunc_callback;
+  klass->get_maximum_value = &get_maximum_value_vfunc_callback;
+  klass->get_minimum_value = &get_minimum_value_vfunc_callback;
+  klass->set_current_value = &set_current_value_vfunc_callback;
+}
+
+void Value_Class::get_current_value_vfunc_callback(AtkValue* self, GValue* value)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->get_current_value_vfunc(*reinterpret_cast<Glib::ValueBase*>(value)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->get_current_value)
+      (*base->get_current_value)(self, value);
+  }
+}
+
+void Value_Class::get_maximum_value_vfunc_callback(AtkValue* self, GValue* value)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->get_maximum_value_vfunc(*reinterpret_cast<Glib::ValueBase*>(value)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->get_maximum_value)
+      (*base->get_maximum_value)(self, value);
+  }
+}
+
+void Value_Class::get_minimum_value_vfunc_callback(AtkValue* self, GValue* value)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->get_minimum_value_vfunc(*reinterpret_cast<Glib::ValueBase*>(value)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->get_minimum_value)
+      (*base->get_minimum_value)(self, value);
+  }
+}
+
+gboolean Value_Class::set_current_value_vfunc_callback(AtkValue* self, const GValue* value)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return static_cast<int>(obj->set_current_value_vfunc(*reinterpret_cast<const Glib::ValueBase*>(value)
+));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->set_current_value)
+      return (*base->set_current_value)(self, value);
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+
+Glib::ObjectBase* Value_Class::wrap_new(GObject* object)
+{
+  return new Value((AtkValue*)(object));
+}
+
+
+/* The implementation: */
+
+Value::Value()
+:
+  Glib::Interface(value_class_.init())
+{}
+
+Value::Value(AtkValue* castitem)
+:
+  Glib::Interface((GObject*)(castitem))
+{}
+
+Value::~Value()
+{}
+
+// static
+void Value::add_interface(GType gtype_implementer)
+{
+  value_class_.init().add_interface(gtype_implementer);
+}
+
+Value::CppClassType Value::value_class_; // initialize static member
+
+GType Value::get_type()
+{
+  return value_class_.init().get_type();
+}
+
+GType Value::get_base_type()
+{
+  return atk_value_get_type();
+}
+
+
+void Value::get_current_value(Glib::ValueBase& value) const
+{
+  atk_value_get_current_value(const_cast<AtkValue*>(gobj()), (value).gobj());
+}
+
+void Value::get_maximum_value(Glib::ValueBase& value) const
+{
+  atk_value_get_maximum_value(const_cast<AtkValue*>(gobj()), (value).gobj());
+}
+
+void Value::get_minimum_value(Glib::ValueBase& value) const
+{
+  atk_value_get_minimum_value(const_cast<AtkValue*>(gobj()), (value).gobj());
+}
+
+bool Value::set_current_value(const Glib::ValueBase& value)
+{
+  return atk_value_set_current_value(gobj(), (value).gobj());
+}
+
+
+void Atk::Value::get_current_value_vfunc(Glib::ValueBase& value) const
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->get_current_value)
+    (*base->get_current_value)(const_cast<AtkValue*>(gobj()),(value).gobj());
+}
+
+void Atk::Value::get_maximum_value_vfunc(Glib::ValueBase& value) const
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->get_maximum_value)
+    (*base->get_maximum_value)(const_cast<AtkValue*>(gobj()),(value).gobj());
+}
+
+void Atk::Value::get_minimum_value_vfunc(Glib::ValueBase& value) const
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->get_minimum_value)
+    (*base->get_minimum_value)(const_cast<AtkValue*>(gobj()),(value).gobj());
+}
+
+bool Atk::Value::set_current_value_vfunc(const Glib::ValueBase& value) 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->set_current_value)
+    return (*base->set_current_value)(gobj(),(value).gobj());
+
+  typedef bool RType;
+  return RType();
+}
+
+
+} // namespace Atk
+
+
diff --git a/libs/gtkmm2/atk/atkmm/value.h b/libs/gtkmm2/atk/atkmm/value.h
new file mode 100644
index 0000000000..25615dd92e
--- /dev/null
+++ b/libs/gtkmm2/atk/atkmm/value.h
@@ -0,0 +1,157 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _ATKMM_VALUE_H
+#define _ATKMM_VALUE_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* Copyright (C) 2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+extern "C"
+{
+  typedef struct _AtkValueIface AtkValueIface;
+  typedef struct _AtkValue      AtkValue;
+}
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _AtkValue AtkValue;
+typedef struct _AtkValueClass AtkValueClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Atk
+{ class Value_Class; } // namespace Atk
+namespace Atk
+{
+
+/** The ATK interface implemented by valuators and components which display or select a value from a bounded range of values.
+ * This should be implemented for components which either display a value from a bounded range, or which allow the user
+ * to specify a value from a bounded range, or both. For instance, most sliders and range controls, as well as dials,
+ * should have Atk::Object representations which implement Atk::Value on the component's behalf. Atk::Values may be
+ * read-only, in which case attempts to alter the value return false to indicate failure.
+ */
+
+class Value : public Glib::Interface
+{
+  
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+public:
+  typedef Value CppObjectType;
+  typedef Value_Class CppClassType;
+  typedef AtkValue BaseObjectType;
+  typedef AtkValueIface BaseClassType;
+
+private:
+  friend class Value_Class;
+  static CppClassType value_class_;
+
+  // noncopyable
+  Value(const Value&);
+  Value& operator=(const Value&);
+
+protected:
+  Value(); // you must derive from this class
+  explicit Value(AtkValue* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+  virtual ~Value();
+
+  static void add_interface(GType gtype_implementer);
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GObject.
+  AtkValue*       gobj()       { return reinterpret_cast<AtkValue*>(gobject_); }
+
+  ///Provides access to the underlying C GObject.  
+  const AtkValue* gobj() const { return reinterpret_cast<AtkValue*>(gobject_); }
+
+private:
+
+
+public:
+  
+  /** Gets the value of this object.
+   * @param value A G::Value representing the current accessible value.
+   */
+  void get_current_value(Glib::ValueBase& value) const;
+  
+  /** Gets the maximum value of this object.
+   * @param value A G::Value representing the maximum accessible value.
+   */
+  void get_maximum_value(Glib::ValueBase& value) const;
+  
+  /** Gets the minimum value of this object.
+   * @param value A G::Value representing the minimum accessible value.
+   */
+  void get_minimum_value(Glib::ValueBase& value) const;
+  
+  /** Sets the value of this object.
+   * @param value A G::Value which is the desired new accessible value.
+   * @return <tt>true</tt> if new value is successfully set, <tt>false</tt> otherwise.
+   */
+  bool set_current_value(const Glib::ValueBase& value);
+
+protected:
+    virtual void get_current_value_vfunc(Glib::ValueBase& value) const;
+    virtual void get_maximum_value_vfunc(Glib::ValueBase& value) const;
+    virtual void get_minimum_value_vfunc(Glib::ValueBase& value) const;
+    virtual bool set_current_value_vfunc(const Glib::ValueBase& value);
+
+
+public:
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+};
+
+} // namespace Atk
+
+
+namespace Glib
+{
+  /** @relates Atk::Value
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Glib::RefPtr<Atk::Value> wrap(AtkValue* object, bool take_copy = false);
+
+} // namespace Glib
+
+#endif /* _ATKMM_VALUE_H */
+
diff --git a/libs/gtkmm2/atk/atkmm/wrap_init.cc b/libs/gtkmm2/atk/atkmm/wrap_init.cc
new file mode 100644
index 0000000000..1c72a15488
--- /dev/null
+++ b/libs/gtkmm2/atk/atkmm/wrap_init.cc
@@ -0,0 +1,91 @@
+
+#include <glib.h>
+
+// Disable the 'const' function attribute of the get_type() functions.
+// GCC would optimize them out because we don't use the return value.
+#undef  G_GNUC_CONST
+#define G_GNUC_CONST /* empty */
+
+#include <atkmm/wrap_init.h>
+#include <glibmm/error.h>
+#include <glibmm/object.h>
+
+// #include the widget headers so that we can call the get_type() static methods:
+
+#include "action.h"
+#include "component.h"
+#include "document.h"
+#include "editabletext.h"
+#include "hyperlink.h"
+#include "hypertext.h"
+#include "image.h"
+#include "implementor.h"
+#include "noopobject.h"
+#include "object.h"
+#include "objectaccessible.h"
+#include "relation.h"
+#include "relationset.h"
+#include "selection.h"
+#include "stateset.h"
+#include "streamablecontent.h"
+#include "table.h"
+#include "text.h"
+#include "value.h"
+
+extern "C"
+{
+
+//Declarations of the *_get_type() functions:
+
+GType atk_hyperlink_get_type(void);
+GType atk_no_op_object_get_type(void);
+GType atk_object_get_type(void);
+GType atk_gobject_accessible_get_type(void);
+GType atk_relation_get_type(void);
+GType atk_relation_set_get_type(void);
+GType atk_state_set_get_type(void);
+
+//Declarations of the *_error_quark() functions:
+
+} // extern "C"
+
+
+//Declarations of the *_Class::wrap_new() methods, instead of including all the private headers:
+
+namespace Atk {  class Hyperlink_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Atk {  class NoOpObject_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Atk {  class Object_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Atk {  class ObjectAccessible_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Atk {  class Relation_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Atk {  class RelationSet_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Atk {  class StateSet_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+
+namespace Atk { 
+
+void wrap_init()
+{
+  // Register Error domains:
+
+// Map gtypes to gtkmm wrapper-creation functions:
+  Glib::wrap_register(atk_hyperlink_get_type(), &Atk::Hyperlink_Class::wrap_new);
+  Glib::wrap_register(atk_no_op_object_get_type(), &Atk::NoOpObject_Class::wrap_new);
+  Glib::wrap_register(atk_object_get_type(), &Atk::Object_Class::wrap_new);
+  Glib::wrap_register(atk_gobject_accessible_get_type(), &Atk::ObjectAccessible_Class::wrap_new);
+  Glib::wrap_register(atk_relation_get_type(), &Atk::Relation_Class::wrap_new);
+  Glib::wrap_register(atk_relation_set_get_type(), &Atk::RelationSet_Class::wrap_new);
+  Glib::wrap_register(atk_state_set_get_type(), &Atk::StateSet_Class::wrap_new);
+
+  // Register the gtkmm gtypes:
+  Atk::Hyperlink::get_type();
+  Atk::NoOpObject::get_type();
+  Atk::Object::get_type();
+  Atk::ObjectAccessible::get_type();
+  Atk::Relation::get_type();
+  Atk::RelationSet::get_type();
+  Atk::StateSet::get_type();
+
+} // wrap_init()
+
+} //Atk
+
+
diff --git a/libs/gtkmm2/atk/atkmm/wrap_init.h b/libs/gtkmm2/atk/atkmm/wrap_init.h
new file mode 100644
index 0000000000..2015280680
--- /dev/null
+++ b/libs/gtkmm2/atk/atkmm/wrap_init.h
@@ -0,0 +1,32 @@
+#ifndef _ATKMM_WRAP_INIT_H
+#define _ATKMM_WRAP_INIT_H
+
+/* wrap_init.h
+ *
+ * Copyright (C) 1998-2001 The Gtk-- Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+// wrap_init.cc is generated by tools/generate_wrap_init.pl
+
+namespace Atk
+{
+
+void wrap_init();
+
+} /* namespace Atk */
+
+#endif // _ATKMM_WRAP_INIT_H
diff --git a/libs/gtkmm2/gdk/.DS_Store b/libs/gtkmm2/gdk/.DS_Store
new file mode 100644
index 0000000000..5008ddfcf5
--- /dev/null
+++ b/libs/gtkmm2/gdk/.DS_Store
diff --git a/libs/gtkmm2/gdk/SConscript b/libs/gtkmm2/gdk/SConscript
new file mode 100644
index 0000000000..05c5288d51
--- /dev/null
+++ b/libs/gtkmm2/gdk/SConscript
@@ -0,0 +1,10 @@
+import glob
+
+gdkmm2_files = glob.glob('gdkmm/*.cc')
+
+Import('env libraries')
+gdkmm2 = env.Copy()
+gdkmm2.Merge([libraries['glibmm2'], libraries['gtk2'], libraries['sigc2'], libraries['pangomm'], libraries['gtkmm2']])
+
+libgdkmm2 = gdkmm2.StaticLibrary('gdkmm2', gdkmm2_files)
+Default(libgdkmm2)
diff --git a/libs/gtkmm2/gdk/gdkmm.h b/libs/gtkmm2/gdk/gdkmm.h
new file mode 100644
index 0000000000..4af8eda3a0
--- /dev/null
+++ b/libs/gtkmm2/gdk/gdkmm.h
@@ -0,0 +1,48 @@
+// This is -*- C++ -*-
+
+/* 
+ * gdkmm.h
+ *
+ * Copyright 2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library 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 _GDKMM_GDKMM_H_
+#define _GDKMM_GDKMM_H_
+
+#include <gdkmm/types.h>
+#include <gdkmm/visual.h>
+#include <gdkmm/gc.h>
+#include <gdkmm/drawable.h>
+#include <gdkmm/window.h>
+#include <gdkmm/pixbuf.h>
+#include <gdkmm/pixbufanimation.h>
+#include <gdkmm/pixbufformat.h>
+#include <gdkmm/pixbufloader.h>
+#include <gdkmm/pixmap.h>
+#include <gdkmm/bitmap.h>
+#include <gdkmm/image.h>
+#include <gdkmm/cursor.h>
+#include <gdkmm/rectangle.h>
+#include <gdkmm/display.h>
+#include <gdkmm/displaymanager.h>
+#include <gdkmm/screen.h>
+#include <gdkmm/general.h>
+#include <gdkmm/rgb.h>
+
+#endif /* _GDKMM_GDKMM_H_ */
+
diff --git a/libs/gtkmm2/gdk/gdkmm/bitmap.cc b/libs/gtkmm2/gdk/gdkmm/bitmap.cc
new file mode 100644
index 0000000000..27063537a6
--- /dev/null
+++ b/libs/gtkmm2/gdk/gdkmm/bitmap.cc
@@ -0,0 +1,71 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gdkmm/bitmap.h>
+#include <gdkmm/private/bitmap_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* Copyright 2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gdk/gdkpixmap.h>
+#include <gdkmm/window.h>
+
+
+namespace Gdk
+{
+
+Bitmap::Bitmap(GdkBitmap* castitem)
+:
+  Pixmap((GdkPixmap*) castitem)
+{}
+
+Bitmap::Bitmap(const char* data, int width, int height)
+:
+  Pixmap((GdkPixmap*) gdk_bitmap_create_from_data(0, data, width, height))
+{}
+
+Bitmap::Bitmap(const Glib::RefPtr<Drawable>& drawable, const char* data, int width, int height)
+:
+  Pixmap((GdkPixmap*) gdk_bitmap_create_from_data(Glib::unwrap(drawable), data, width, height))
+{}
+
+} // namespace Gdk
+
+
+namespace
+{
+} // anonymous namespace
+
+
+namespace Gdk
+{
+
+
+Glib::RefPtr<Bitmap> Bitmap::create(const char* data, int width, int height)
+{
+  return Glib::RefPtr<Bitmap>( new Bitmap(data, width, height) );
+}
+Glib::RefPtr<Bitmap> Bitmap::create(const Glib::RefPtr<Gdk::Drawable>& drawable, const char* data, int width, int height)
+{
+  return Glib::RefPtr<Bitmap>( new Bitmap(drawable, data, width, height) );
+}
+
+} // namespace Gdk
+
+
diff --git a/libs/gtkmm2/gdk/gdkmm/bitmap.h b/libs/gtkmm2/gdk/gdkmm/bitmap.h
new file mode 100644
index 0000000000..57dc9fb087
--- /dev/null
+++ b/libs/gtkmm2/gdk/gdkmm/bitmap.h
@@ -0,0 +1,79 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GDKMM_BITMAP_H
+#define _GDKMM_BITMAP_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* Copyright (C) 2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gdkmm/pixmap.h>
+#include <gdk/gdkpixmap.h>
+
+
+namespace Gdk
+{
+
+class Window;
+
+// In GDK, GdkBitmap has the same type as GdkPixmap.  Both are typedefed
+// to their base type GdkDrawable, but the real type is GdkPixmapObject.
+// A GdkBitmap is a GdkPixmap with a depth of 1.
+
+/** Bitmaps are simply pixmaps with a depth of 1. (That is, they are monochrome bitmaps - each pixel can be either on or off).
+ */
+class Bitmap : public Gdk::Pixmap
+{
+  // The Bitmap type only really exists in gtkmm.  We fake its existence
+  // with a custom Gdk::Pixmap_Class::wrap_new() -- see comments there.
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Bitmap CppObjectType;
+  typedef GdkBitmap BaseObjectType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+private:
+
+
+protected:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  explicit Bitmap(GdkBitmap* castitem);
+  friend class Gdk::Pixmap_Class;
+#endif
+
+  Bitmap(const char* data, int width, int height);
+
+  Bitmap(const Glib::RefPtr<Gdk::Drawable>& drawable, const char* data, int width, int height);
+
+public:
+  
+  static Glib::RefPtr<Bitmap> create(const char* data, int width, int height);
+
+
+  static Glib::RefPtr<Bitmap> create(const Glib::RefPtr<Gdk::Drawable>& drawable, const char* data, int width, int height);
+
+
+};
+
+} // namespace Gdk
+
+
+#endif /* _GDKMM_BITMAP_H */
+
diff --git a/libs/gtkmm2/gdk/gdkmm/color.cc b/libs/gtkmm2/gdk/gdkmm/color.cc
new file mode 100644
index 0000000000..06c8e70cf5
--- /dev/null
+++ b/libs/gtkmm2/gdk/gdkmm/color.cc
@@ -0,0 +1,297 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gdkmm/color.h>
+#include <gdkmm/private/color_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/*
+ *
+ * Copyright 2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gdkmm/colormap.h>
+#include <gdk/gdkcolor.h>
+#include <gdk/gdkrgb.h>
+
+namespace Gdk
+{
+
+Color::Color()
+{
+  GdkColor tmp = { 0, 0, 0, 0, };
+  gobject_ = gdk_color_copy(&tmp);
+}
+
+Color::Color(const Glib::ustring& value)
+{
+  GdkColor tmp = { 0, 0, 0, 0, };
+  gobject_ = gdk_color_copy(&tmp);
+
+  set(value);
+}
+
+void Color::set_grey(gushort value)
+{
+  gobject_->red = gobject_->green = gobject_->blue = value;
+}
+
+void Color::set_grey_p(double g)
+{
+ gobject_->red = gobject_->green = gobject_->blue = (gushort)(g * 65535.0);
+}
+
+void Color::set_rgb(gushort red_, gushort green_, gushort blue_)
+{
+  gobject_->red = red_;
+  gobject_->green = green_;
+  gobject_->blue = blue_;
+}
+
+void Color::set_rgb_p(double red_, double green_, double blue_)
+{
+  gobject_->red = (gushort)(red_ * 65535.0);
+  gobject_->green = (gushort)(green_ * 65535.0);
+  gobject_->blue = (gushort)(blue_ * 65535.0);
+}
+
+void Color::set_hsv(double h, double s, double v)
+{
+  //TODO: Comments/Documentation. I have no idea what this code does. murrayc.
+  
+  h /= 60.0;
+  int i = (int)h;
+  double p = v * (1 - s);
+  double q = v * (1 - s * (h - i));
+  double t = v * (1 - s * (1 - h + i));
+
+  switch(i)
+  {
+    case 0:
+      set_rgb_p(v, t, p);
+      break;
+    case 1:
+      set_rgb_p(q, v, p);
+      break;
+    case 2:
+      set_rgb_p(p, v, t);
+      break;
+    case 3:
+      set_rgb_p(p, q, v);
+      break;
+    case 4:
+      set_rgb_p(t, p, v);
+      break;
+    default:
+      set_rgb_p(v, p, q);
+  }
+}
+
+void Color::set_hsl(double h, double s, double l)
+{
+  //TODO: Comments/Documentation. I have no idea what this code does. murrayc.
+
+  if(s == 0.0)
+    set_grey_p(l);
+  else
+  {
+    double t2 = (l < 0.5) ? l * (1.0 + s) : l + s - l * s;
+    double t1 = 2*l-t2;
+    h /= 360.0;
+
+    double tr = h + 1.0/3.0;
+    double tg = h;
+    double tb = h - 1.0/3.0;
+    if (tb < 0) tb += 1.0;
+
+    double r = 0.0, g = 0.0, b = 0.0;
+
+    if (tr < 1.0/6.0)
+      r = t1 +(t2-t1) * 6 * tr;
+    else if (tr < 1.0/2.0)
+      r = t2;
+    else if (tr < 2.0/3.0)
+      r = t1+(t2-t1)*(2.0/3.0 - tr) * 6.0;
+
+    if (tg < 1.0/6.0)
+      g = t1 + (t2 - t1) * 6 * tg;
+    else if (tg < 1.0/2.0)
+      g = t2;
+    else if (tg < 2.0/3.0)
+      g = t1+(t2-t1)*(2.0/3.0 - tg) * 6.0;
+
+    if (tb < 1.0/6.0)
+      b = t1 +(t2-t1) * 6 * tb;
+    else if (tb < 1.0/2.0)
+      b = t2;
+    else if (tb < 2.0/3.0)
+      b = t1+(t2-t1)*(2.0/3.0 - tb) * 6.0;
+
+    set_rgb_p(r, g, b);
+  }
+}
+
+bool Color::set(const Glib::ustring& value)
+{
+  return gdk_color_parse(value.c_str(), gobj());
+}
+
+bool Color::parse(const Glib::ustring& spec)
+{
+  return set(spec);
+}
+
+gushort Color::get_red() const
+{
+  return gobject_->red;
+}
+
+gushort Color::get_green() const
+{
+  return gobject_->green;
+
+}
+gushort Color::get_blue() const
+{
+ return gobject_->blue;
+}
+
+void Color::set_red(gushort value)
+{
+  gobject_->red = value;
+}
+
+void Color::set_green(gushort value)
+{
+  gobject_->green = value;
+}
+
+void Color::set_blue(gushort value)
+{
+  gobject_->blue = value;
+}
+
+void Color::rgb_find_color(const Glib::RefPtr<Gdk::Colormap>& map)
+{
+  gdk_rgb_find_color(map->gobj(), gobj());
+}
+
+guint Color::get_pixel() const
+{
+  return gobject_->pixel;
+}
+
+double Color::get_red_p() const
+{
+  return gobject_->red / 65535.0;
+}
+
+double Color::get_green_p() const
+{
+  return gobject_->green / 65535.0;
+}
+
+double Color::get_blue_p() const
+{
+  return gobject_->blue / 65535.0;
+}
+
+
+} //namespace Gdk
+
+
+namespace
+{
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Gdk::Color wrap(GdkColor* object, bool take_copy)
+{
+  return Gdk::Color(object, take_copy);
+}
+
+} // namespace Glib
+
+
+namespace Gdk
+{
+
+
+// static
+GType Color::get_type()
+{
+  return gdk_color_get_type();
+}
+
+
+Color::Color(const Color& other)
+:
+  gobject_ ((other.gobject_) ? gdk_color_copy(other.gobject_) : 0)
+{}
+
+Color::Color(GdkColor* gobject, bool make_a_copy)
+:
+  // For BoxedType wrappers, make_a_copy is true by default.  The static
+  // BoxedType wrappers must always take a copy, thus make_a_copy = true
+  // ensures identical behaviour if the default argument is used.
+  gobject_ ((make_a_copy && gobject) ? gdk_color_copy(gobject) : gobject)
+{}
+
+Color& Color::operator=(const Color& other)
+{
+  Color temp (other);
+  swap(temp);
+  return *this;
+}
+
+Color::~Color()
+{
+  if(gobject_)
+    gdk_color_free(gobject_);
+}
+
+void Color::swap(Color& other)
+{
+  GdkColor *const temp = gobject_;
+  gobject_ = other.gobject_;
+  other.gobject_ = temp;
+}
+
+GdkColor* Color::gobj_copy() const
+{
+  return gdk_color_copy(gobject_);
+}
+
+
+bool operator==(const Color& lhs, const Color& rhs)
+{
+  return (gdk_color_equal(lhs.gobj(), rhs.gobj()) != 0);
+}
+
+bool operator!=(const Color& lhs, const Color& rhs)
+{
+  return (gdk_color_equal(lhs.gobj(), rhs.gobj()) == 0);
+}
+
+
+} // namespace Gdk
+
+
diff --git a/libs/gtkmm2/gdk/gdkmm/color.h b/libs/gtkmm2/gdk/gdkmm/color.h
new file mode 100644
index 0000000000..c40ff67f25
--- /dev/null
+++ b/libs/gtkmm2/gdk/gdkmm/color.h
@@ -0,0 +1,274 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GDKMM_COLOR_H
+#define _GDKMM_COLOR_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* Copyright (C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gdk/gdkcolor.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+extern "C" { typedef struct _GdkColor GdkColor; }
+#endif
+
+namespace Gdk
+{
+
+class Colormap;
+
+/** Gdk::Color is used to describe an allocated or unallocated color.
+ * It contains the following data:
+ *   pixel: For allocated colors, the value used to draw this color on the screen.
+ *   red: The red component of the color. This is a value between 0 and 65535, with 65535 indicating full intensitiy.
+ *   green: The green component of the color.
+ *   blue: The blue component of the color.
+ */
+class Color
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Color CppObjectType;
+  typedef GdkColor BaseObjectType;
+
+  static GType get_type() G_GNUC_CONST;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+  explicit Color(GdkColor* gobject, bool make_a_copy = true);
+
+  Color(const Color& other);
+  Color& operator=(const Color& other);
+
+  ~Color();
+
+  void swap(Color& other);
+
+  ///Provides access to the underlying C instance.
+  GdkColor*       gobj()       { return gobject_; }
+
+  ///Provides access to the underlying C instance.
+  const GdkColor* gobj() const { return gobject_; }
+
+  ///Provides access to the underlying C instance. The caller is responsible for freeing it. Use when directly setting fields in structs.
+  GdkColor* gobj_copy() const;
+
+protected:
+  GdkColor* gobject_;
+
+private:
+
+public:
+
+  
+  /** Instantiate a new Gdk::Color.
+   * You should then use the set methods and call Gdk::Colormap::alloc_color().
+   */
+  Color();
+
+  /** Instantiate a new Gdk::Color.
+   * The color is not allocated - you must call Gdk::Colormap::alloc_color() yourself.
+   * The text string can be in any of the forms accepted by XParseColor; these include names for a color from rgb.txt,
+   * such as DarkSlateGray, or a hex specification such as 305050.
+   * @param value the string specifying the color..
+   */
+  explicit Color(const Glib::ustring& value);
+
+  /** Set a grey color, by using the same value for all color components.
+   * @param value The value to be used for the red, green, and blue components.
+   */
+  void set_grey(gushort value);
+  void set_grey_p(double g);
+
+  /** Set the color, by specifying red, green, and blue color component values.
+   * @param red_ The red component of the color.
+   * @param green_ The green component of the color.
+   * @param blue_ The blue component of the color.
+   */
+  void set_rgb(gushort red_, gushort green_, gushort blue_);
+
+  /** Set the color, by specifying red, green, and blue color component values, as percentages.
+   * @param red_ The red component of the color, as a percentage.
+   * @param green_ The green component of the color, as a percentage.
+   * @param blue_ The blue component of the color, as a percentage.
+   */
+  void set_rgb_p(double red_, double green_, double blue_);
+
+  void set_hsv(double h, double s, double v);
+  void set_hsl(double h, double s, double l);
+
+  /** Parses a textual specification of a color and fills in the red, green, and blue values.
+  * The color is not allocated - you must call Gdk::Colormap::alloc_color() yourself.
+  * The text string can be in any of the forms accepted by XParseColor; these include names for a color from rgb.txt,
+  * such as DarkSlateGray, or a hex specification such as 305050.
+  *
+  * @param value the string specifying the color.
+  * @result true if the parsing succeeded.
+  */
+  bool set(const Glib::ustring& value);
+
+  #ifndef GDKMM_DEPRECATED
+  /** 
+   * @deprecated See set().
+   */
+  bool parse(const Glib::ustring& spec);
+  #endif //GDKMM_DEPRECATED
+
+  /** Get the red component of the color.
+   * @result The red component of the color.
+   */
+  gushort get_red() const;
+
+  /** Get the green component of the color.
+   * @result The green component of the color.
+   */
+  gushort get_green() const;
+
+  /** Get the blue component of the color.
+   * @result The blue component of the color.
+   */
+  gushort get_blue() const;
+
+  /** Set the red component of the color.
+   * @param value The red component of the color.
+   */
+  void set_red(gushort value);
+
+  /** Set the green component of the color.
+   * @param value The green component of the color.
+   */
+  void set_green(gushort value);
+
+  /** Set the blue component of the color.
+   * @param value The blue component of the color.
+   */
+  void set_blue(gushort value);
+
+  /** This will fill in the pixel field with the best matching pixel from a color cube.
+   * The color is then ready to be used for drawing, e.g. you can call Gdk::GC::set_foreground() which expects pixel to be initialized.
+   * Call this after setting the red, green, and blue fields.
+   *
+   * In many cases, you can avoid this whole issue by calling Gdk::GC::set_rgb_fg_color() or Gdk::GC::set_rgb_bg_color(),
+   * which do not expect pixels to be initialized in advance. If you use those methods, there's no need for this method().
+   *
+   * @param map The colormap for the graphics context and drawable you're using to draw. If you're drawing to a Gtk::Widget, call Gtk::Widget::get_colormap().
+   */
+  void rgb_find_color(const Glib::RefPtr<Gdk::Colormap>& map);
+
+  /** Get the pixel value, for allocated colors.
+   * @result For allocated colors, the value used to draw this color on the screen.
+   */
+  guint get_pixel() const;
+
+  /** Get the red component of the color, as a percentage.
+   * @result The red component of the color, as a percentage.
+   */
+  double get_red_p() const;
+
+  /** Get the green component of the color, as a percentage.
+   * @result The green component of the color, as a percentage.
+   */
+  double get_green_p() const;
+
+  /** Get the blue component of the color, as a percentage.
+   * @result The blue component of the color, as a percentage.
+   */
+  double get_blue_p() const;
+
+
+};
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+/* These traits are for arrays of GdkColor structs -- not pointer arrays.
+ */
+struct ColorTraits
+{
+  typedef Gdk::Color  CppType;
+  typedef GdkColor    CType;
+  typedef GdkColor    CTypeNonConst;
+
+  static CType   to_c_type      (const CppType& obj) { return *obj.gobj(); }
+  static CType   to_c_type      (const CType&   obj) { return obj; }
+  static CppType to_cpp_type    (const CType&   obj) { return CppType(const_cast<CType*>(&obj), true); }
+  static void    release_c_type (const CType&)       {}
+};
+#endif //DOXYGEN_SHOULD_SKIP_THIS
+
+typedef Glib::ArrayHandle<Color,ColorTraits> ArrayHandle_Color;
+
+} // namespace Gdk
+
+
+namespace Gdk
+{
+
+/** @relates Gdk::Color
+ * @param lhs The left-hand side
+ * @param rhs The right-hand side
+ * @result The result
+ */
+bool operator==(const Color& lhs, const Color& rhs);
+
+/** @relates Gdk::Color
+ * @param lhs The left-hand side
+ * @param rhs The right-hand side
+ * @result The result
+ */
+bool operator!=(const Color& lhs, const Color& rhs);
+
+
+} // namespace Gdk
+
+
+namespace Gdk
+{
+
+/** @relates Gdk::Color
+ * @param lhs The left-hand side
+ * @param rhs The right-hand side
+ */
+inline void swap(Color& lhs, Color& rhs)
+  { lhs.swap(rhs); }
+
+} // namespace Gdk
+
+namespace Glib
+{
+
+/** @relates Gdk::Color
+ * @param object The C instance
+ * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+ * @result A C++ instance that wraps this C instance.
+ */
+Gdk::Color wrap(GdkColor* object, bool take_copy = false);
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+template <>
+class Value<Gdk::Color> : public Glib::Value_Boxed<Gdk::Color>
+{};
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+} // namespace Glib
+
+#endif /* _GDKMM_COLOR_H */
+
diff --git a/libs/gtkmm2/gdk/gdkmm/colormap.cc b/libs/gtkmm2/gdk/gdkmm/colormap.cc
new file mode 100644
index 0000000000..af2d64aec1
--- /dev/null
+++ b/libs/gtkmm2/gdk/gdkmm/colormap.cc
@@ -0,0 +1,209 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gdkmm/colormap.h>
+#include <gdkmm/private/colormap_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/*
+ *
+ * Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gdk/gdkcolor.h>
+
+namespace Gdk
+{
+
+Colormap::Colormap(const Glib::RefPtr<Visual>& visual, bool allocate)
+: Glib::Object( G_OBJECT( gdk_colormap_new(visual->gobj(), (gboolean)allocate) ) )
+  {}
+
+} /* namespace Gdk */
+
+
+namespace
+{
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Glib::RefPtr<Gdk::Colormap> wrap(GdkColormap* object, bool take_copy)
+{
+  return Glib::RefPtr<Gdk::Colormap>( dynamic_cast<Gdk::Colormap*> (Glib::wrap_auto ((GObject*)(object), take_copy)) );
+  //We use dynamic_cast<> in case of multiple inheritance.
+}
+
+} /* namespace Glib */
+
+
+namespace Gdk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& Colormap_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &Colormap_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gdk_colormap_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void Colormap_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+}
+
+
+Glib::ObjectBase* Colormap_Class::wrap_new(GObject* object)
+{
+  return new Colormap((GdkColormap*)object);
+}
+
+
+/* The implementation: */
+
+GdkColormap* Colormap::gobj_copy()
+{
+  reference();
+  return gobj();
+}
+
+Colormap::Colormap(const Glib::ConstructParams& construct_params)
+:
+  Glib::Object(construct_params)
+{}
+
+Colormap::Colormap(GdkColormap* castitem)
+:
+  Glib::Object((GObject*)(castitem))
+{}
+
+Colormap::~Colormap()
+{}
+
+
+Colormap::CppClassType Colormap::colormap_class_; // initialize static member
+
+GType Colormap::get_type()
+{
+  return colormap_class_.init().get_type();
+}
+
+GType Colormap::get_base_type()
+{
+  return gdk_colormap_get_type();
+}
+
+
+Glib::RefPtr<Colormap> Colormap::create(const Glib::RefPtr<Visual>& visual, bool allocate)
+{
+  return Glib::RefPtr<Colormap>( new Colormap(visual, allocate) );
+}
+Glib::RefPtr<Colormap> Colormap::get_system()
+{
+
+  Glib::RefPtr<Colormap> retvalue = Glib::wrap(gdk_colormap_get_system());
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+int Colormap::alloc_colors(ArrayHandle_Color& colors, int ncolors, bool writeable, bool best_match, Glib::ArrayHandle<bool>& success)
+{
+  return gdk_colormap_alloc_colors(gobj(), const_cast<GdkColor*>(colors.data()), ncolors, static_cast<int>(writeable), static_cast<int>(best_match), (gboolean*)(success.data()));
+}
+
+bool Colormap::alloc_color(Color& color, bool writeable, bool best_match)
+{
+  return gdk_colormap_alloc_color(gobj(), (color).gobj(), static_cast<int>(writeable), static_cast<int>(best_match));
+}
+
+void Colormap::free_colors(Color& colors, int ncolors)
+{
+  gdk_colormap_free_colors(gobj(), (colors).gobj(), ncolors);
+}
+
+void Colormap::query_color(gulong pixel, Color& result)
+{
+  gdk_colormap_query_color(gobj(), pixel, (result).gobj());
+}
+
+Glib::RefPtr<Visual> Colormap::get_visual()
+{
+
+  Glib::RefPtr<Visual> retvalue = Glib::wrap(gdk_colormap_get_visual(gobj()));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::RefPtr<const Visual> Colormap::get_visual() const
+{
+
+  Glib::RefPtr<const Visual> retvalue = Glib::wrap(gdk_colormap_get_visual(const_cast<GdkColormap*>(gobj())));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::RefPtr<Screen> Colormap::get_screen()
+{
+
+  Glib::RefPtr<Screen> retvalue = Glib::wrap(gdk_colormap_get_screen(gobj()));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::RefPtr<const Screen> Colormap::get_screen() const
+{
+
+  Glib::RefPtr<const Screen> retvalue = Glib::wrap(gdk_colormap_get_screen(const_cast<GdkColormap*>(gobj())));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+
+} // namespace Gdk
+
+
diff --git a/libs/gtkmm2/gdk/gdkmm/colormap.h b/libs/gtkmm2/gdk/gdkmm/colormap.h
new file mode 100644
index 0000000000..5f73acbf59
--- /dev/null
+++ b/libs/gtkmm2/gdk/gdkmm/colormap.h
@@ -0,0 +1,227 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GDKMM_COLORMAP_H
+#define _GDKMM_COLORMAP_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* box.h
+ *
+ * Copyright (C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <glibmm/object.h>
+#include <gdkmm/visual.h>
+#include <gdkmm/color.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GdkColormap GdkColormap;
+typedef struct _GdkColormapClass GdkColormapClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gdk
+{ class Colormap_Class; } // namespace Gdk
+namespace Gdk
+{
+
+/** A Colormap is an object that contains the mapping between the color values stored in memory and the RGB values that are
+ * used to display color values. In general, colormaps only contain significant information for pseudo-color visuals, but
+ * even for other visual types, a colormap object is required in some circumstances.
+ *
+ * There are a couple of special colormaps that can be retrieved. The system colormap (retrieved with get_system()) is the
+ * default colormap of the system. If you are using GdkRGB, there is another colormap that is important - the colormap in
+ * which GdkRGB works, retrieved with Gdk::rgb_get_colormap(). However, when using GdkRGB, it is not generally necessary to
+ * allocate colors directly.
+ */
+
+class Colormap : public Glib::Object
+{
+  
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+public:
+  typedef Colormap CppObjectType;
+  typedef Colormap_Class CppClassType;
+  typedef GdkColormap BaseObjectType;
+  typedef GdkColormapClass BaseClassType;
+
+private:  friend class Colormap_Class;
+  static CppClassType colormap_class_;
+
+private:
+  // noncopyable
+  Colormap(const Colormap&);
+  Colormap& operator=(const Colormap&);
+
+protected:
+  explicit Colormap(const Glib::ConstructParams& construct_params);
+  explicit Colormap(GdkColormap* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+  virtual ~Colormap();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GObject.
+  GdkColormap*       gobj()       { return reinterpret_cast<GdkColormap*>(gobject_); }
+
+  ///Provides access to the underlying C GObject.
+  const GdkColormap* gobj() const { return reinterpret_cast<GdkColormap*>(gobject_); }
+
+  ///Provides access to the underlying C instance. The caller is responsible for unrefing it. Use when directly setting fields in structs.
+  GdkColormap* gobj_copy();
+
+private:
+
+  
+protected:
+  explicit Colormap(const Glib::RefPtr<Visual>& visual, bool allocate);
+
+public:
+
+  
+  static Glib::RefPtr<Colormap> create(const Glib::RefPtr<Visual>& visual, bool allocate);
+
+
+  /** Gets the system's default colormap for the default screen. (See
+   * gdk_colormap_get_system_for_screen())
+   * @return The default colormap.
+   */
+  static Glib::RefPtr<Colormap> get_system();
+
+  //_WRAP_METHOD(void change(int ncolors), gdk_colormap_change)
+
+  // Both 'GdkColor* colors' and 'gboolean* success' are _array_ output arguments.
+ 
+
+  /** Allocates colors from a colormap.
+   * @param colors The color values to allocate. On return, the pixel
+   * values for allocated colors will be filled in.
+   * @param ncolors The number of colors in @a colors .
+   * @param writeable If <tt>true</tt>, the colors are allocated writeable
+   * (their values can later be changed using gdk_color_change()).
+   * Writeable colors cannot be shared between applications.
+   * @param best_match If <tt>true</tt>, GDK will attempt to do matching against
+   * existing colors if the colors cannot be allocated as requested.
+   * @param success An array of length @a ncolors . On return, this
+   * indicates whether the corresponding color in @a colors  was
+   * successfully allocated or not.
+   * @return The number of colors that were not successfully 
+   * allocated.
+   */
+  int alloc_colors(ArrayHandle_Color& colors, int ncolors, bool writeable, bool best_match, Glib::ArrayHandle<bool>& success);
+
+  
+  /** Allocates a single color from a colormap.
+   * @param color The color to allocate. On return the
+   * &lt;structfield&gt;pixel&lt;/structfield&gt; field will be
+   * filled in if allocation succeeds.
+   * @param writeable If <tt>true</tt>, the color is allocated writeable
+   * (their values can later be changed using gdk_color_change()).
+   * Writeable colors cannot be shared between applications.
+   * @param best_match If <tt>true</tt>, GDK will attempt to do matching against
+   * existing colors if the color cannot be allocated as requested.
+   * @return <tt>true</tt> if the allocation succeeded.
+   */
+  bool alloc_color(Color& color, bool writeable = false, bool best_match = true);
+  
+  /** Frees previously allocated colors.
+   * @param colors The colors to free.
+   * @param ncolors The number of colors in @a colors .
+   */
+  void free_colors(Color& colors, int ncolors);
+  
+  /** Locates the RGB color in @a colormap  corresponding to the given
+   * hardware pixel @a pixel . @a pixel  must be a valid pixel in the
+   * colormap; it's a programmer error to call this function with a
+   * pixel which is not in the colormap. Hardware pixels are normally
+   * obtained from alloc_colors(), or from a Gdk::Image. (A
+   * Gdk::Image contains image data in hardware format, a Gdk::Pixbuf
+   * contains image data in a canonical 24-bit RGB format.)
+   * 
+   * This function is rarely useful; it's used for example to
+   * implement the eyedropper feature in Gtk::ColorSelection.
+   * @param pixel Pixel value in hardware display format.
+   * @param result Gdk::Color with red, green, blue fields initialized.
+   */
+  void query_color (gulong pixel, Color& result);
+
+  
+  /** Returns the visual for which a given colormap was created.
+   * @return The visual of the colormap.
+   */
+  Glib::RefPtr<Visual> get_visual();
+  
+  /** Returns the visual for which a given colormap was created.
+   * @return The visual of the colormap.
+   */
+  Glib::RefPtr<const Visual> get_visual() const;
+  
+  
+  /** Gets the screen for which this colormap was created.
+   * @return The screen for which this colormap was created.
+   * 
+   * Since: 2.2.
+   */
+  Glib::RefPtr<Screen> get_screen();
+  
+  /** Gets the screen for which this colormap was created.
+   * @return The screen for which this colormap was created.
+   * 
+   * Since: 2.2.
+   */
+  Glib::RefPtr<const Screen> get_screen() const;
+  
+
+public:
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+};
+
+} /* namespace Gdk */
+
+
+namespace Glib
+{
+  /** @relates Gdk::Colormap
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Glib::RefPtr<Gdk::Colormap> wrap(GdkColormap* object, bool take_copy = false);
+}
+
+
+#endif /* _GDKMM_COLORMAP_H */
+
diff --git a/libs/gtkmm2/gdk/gdkmm/cursor.cc b/libs/gtkmm2/gdk/gdkmm/cursor.cc
new file mode 100644
index 0000000000..1a8e639472
--- /dev/null
+++ b/libs/gtkmm2/gdk/gdkmm/cursor.cc
@@ -0,0 +1,161 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gdkmm/cursor.h>
+#include <gdkmm/private/cursor_p.h>
+
+#include <gdk/gdkenumtypes.h>
+// -*- c++ -*-
+/* $Id$ */
+
+/*
+ *
+ * Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gdk/gdkcursor.h>
+
+namespace Gdk
+{
+
+Cursor::Cursor(CursorType cursor_type)
+{
+  gobject_ = gdk_cursor_new((GdkCursorType)cursor_type);
+}
+
+Cursor::Cursor(const Glib::RefPtr<Pixmap>& source, const Glib::RefPtr<Pixmap>& mask,
+				       const Color& fg, const Color& bg,
+				       int x, int y)
+{
+  gobject_ = gdk_cursor_new_from_pixmap(source->gobj(), mask->gobj(), 
+                                        const_cast<GdkColor*>(fg.gobj()),
+				        const_cast<GdkColor*>(bg.gobj()),
+                                        x, y);
+}
+
+Cursor::Cursor(const Glib::RefPtr<Display>& display, CursorType cursor_type)
+{
+  gobject_ = gdk_cursor_new_for_display(display->gobj(), (GdkCursorType)cursor_type);
+}
+
+Cursor::Cursor(const Glib::RefPtr<Display>& display, const Glib::RefPtr<Pixbuf>& pixbuf, int x, int y)
+{
+  gobject_ = gdk_cursor_new_from_pixbuf(display->gobj(), pixbuf->gobj(), x, y);
+}          
+
+} //namespace Gdk
+
+
+namespace
+{
+} // anonymous namespace
+
+// static
+GType Glib::Value<Gdk::CursorType>::value_type()
+{
+  return gdk_cursor_type_get_type();
+}
+
+
+namespace Glib
+{
+
+Gdk::Cursor wrap(GdkCursor* object, bool take_copy)
+{
+  return Gdk::Cursor(object, take_copy);
+}
+
+} // namespace Glib
+
+
+namespace Gdk
+{
+
+
+// static
+GType Cursor::get_type()
+{
+  return gdk_cursor_get_type();
+}
+
+Cursor::Cursor()
+:
+  gobject_ (0) // Allows creation of invalid wrapper, e.g. for output arguments to methods.
+{}
+
+Cursor::Cursor(const Cursor& other)
+:
+  gobject_ ((other.gobject_) ? gdk_cursor_ref(other.gobject_) : 0)
+{}
+
+Cursor::Cursor(GdkCursor* gobject, bool make_a_copy)
+:
+  // For BoxedType wrappers, make_a_copy is true by default.  The static
+  // BoxedType wrappers must always take a copy, thus make_a_copy = true
+  // ensures identical behaviour if the default argument is used.
+  gobject_ ((make_a_copy && gobject) ? gdk_cursor_ref(gobject) : gobject)
+{}
+
+Cursor& Cursor::operator=(const Cursor& other)
+{
+  Cursor temp (other);
+  swap(temp);
+  return *this;
+}
+
+Cursor::~Cursor()
+{
+  if(gobject_)
+    gdk_cursor_unref(gobject_);
+}
+
+void Cursor::swap(Cursor& other)
+{
+  GdkCursor *const temp = gobject_;
+  gobject_ = other.gobject_;
+  other.gobject_ = temp;
+}
+
+GdkCursor* Cursor::gobj_copy() const
+{
+  return gdk_cursor_ref(gobject_);
+}
+
+
+Glib::RefPtr<Display> Cursor::get_display()
+{
+
+  Glib::RefPtr<Display> retvalue = Glib::wrap(gdk_cursor_get_display(gobj()));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::RefPtr<const Display> Cursor::get_display() const
+{
+
+  Glib::RefPtr<const Display> retvalue = Glib::wrap(gdk_cursor_get_display(const_cast<GdkCursor*>(gobj())));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+
+} // namespace Gdk
+
+
diff --git a/libs/gtkmm2/gdk/gdkmm/cursor.h b/libs/gtkmm2/gdk/gdkmm/cursor.h
new file mode 100644
index 0000000000..59ab2f827f
--- /dev/null
+++ b/libs/gtkmm2/gdk/gdkmm/cursor.h
@@ -0,0 +1,251 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GDKMM_CURSOR_H
+#define _GDKMM_CURSOR_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* drawable.h
+ *
+ * Copyright (C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gdkmm/color.h>
+#include <gdkmm/bitmap.h>
+#include <gdkmm/display.h>
+#include <gdkmm/pixbuf.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+extern "C" { typedef struct _GdkCursor GdkCursor; }
+#endif
+
+namespace Gdk
+{
+
+
+/** @addtogroup gdkmmEnums Enums and Flags */
+
+/**
+ * @ingroup gdkmmEnums
+ */
+enum CursorType
+{
+  X_CURSOR = 0,
+  ARROW = 2,
+  BASED_ARROW_DOWN = 4,
+  BASED_ARROW_UP = 6,
+  BOAT = 8,
+  BOGOSITY = 10,
+  BOTTOM_LEFT_CORNER = 12,
+  BOTTOM_RIGHT_CORNER = 14,
+  BOTTOM_SIDE = 16,
+  BOTTOM_TEE = 18,
+  BOX_SPIRAL = 20,
+  CENTER_PTR = 22,
+  CIRCLE = 24,
+  CLOCK = 26,
+  COFFEE_MUG = 28,
+  CROSS = 30,
+  CROSS_REVERSE = 32,
+  CROSSHAIR = 34,
+  DIAMOND_CROSS = 36,
+  DOT = 38,
+  DOTBOX = 40,
+  DOUBLE_ARROW = 42,
+  DRAFT_LARGE = 44,
+  DRAFT_SMALL = 46,
+  DRAPED_BOX = 48,
+  EXCHANGE = 50,
+  FLEUR = 52,
+  GOBBLER = 54,
+  GUMBY = 56,
+  HAND1 = 58,
+  HAND2 = 60,
+  HEART = 62,
+  ICON = 64,
+  IRON_CROSS = 66,
+  LEFT_PTR = 68,
+  LEFT_SIDE = 70,
+  LEFT_TEE = 72,
+  LEFTBUTTON = 74,
+  LL_ANGLE = 76,
+  LR_ANGLE = 78,
+  MAN = 80,
+  MIDDLEBUTTON = 82,
+  MOUSE = 84,
+  PENCIL = 86,
+  PIRATE = 88,
+  PLUS = 90,
+  QUESTION_ARROW = 92,
+  RIGHT_PTR = 94,
+  RIGHT_SIDE = 96,
+  RIGHT_TEE = 98,
+  RIGHTBUTTON = 100,
+  RTL_LOGO = 102,
+  SAILBOAT = 104,
+  SB_DOWN_ARROW = 106,
+  SB_H_DOUBLE_ARROW = 108,
+  SB_LEFT_ARROW = 110,
+  SB_RIGHT_ARROW = 112,
+  SB_UP_ARROW = 114,
+  SB_V_DOUBLE_ARROW = 116,
+  SHUTTLE = 118,
+  SIZING = 120,
+  SPIDER = 122,
+  SPRAYCAN = 124,
+  STAR = 126,
+  TARGET = 128,
+  TCROSS = 130,
+  TOP_LEFT_ARROW = 132,
+  TOP_LEFT_CORNER = 134,
+  TOP_RIGHT_CORNER = 136,
+  TOP_SIDE = 138,
+  TOP_TEE = 140,
+  TREK = 142,
+  UL_ANGLE = 144,
+  UMBRELLA = 146,
+  UR_ANGLE = 148,
+  WATCH = 150,
+  XTERM = 152,
+  LAST_CURSOR = 153,
+  CURSOR_IS_PIXMAP = -1
+};
+
+} // namespace Gdk
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Gdk::CursorType> : public Glib::Value_Enum<Gdk::CursorType>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gdk
+{
+
+
+/** This represents a cursor.
+ */
+class Cursor
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Cursor CppObjectType;
+  typedef GdkCursor BaseObjectType;
+
+  static GType get_type() G_GNUC_CONST;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  Cursor();
+
+  explicit Cursor(GdkCursor* gobject, bool make_a_copy = true);
+
+  Cursor(const Cursor& other);
+  Cursor& operator=(const Cursor& other);
+
+  ~Cursor();
+
+  void swap(Cursor& other);
+
+  ///Provides access to the underlying C instance.
+  GdkCursor*       gobj()       { return gobject_; }
+
+  ///Provides access to the underlying C instance.
+  const GdkCursor* gobj() const { return gobject_; }
+
+  ///Provides access to the underlying C instance. The caller is responsible for freeing it. Use when directly setting fields in structs.
+  GdkCursor* gobj_copy() const;
+
+protected:
+  GdkCursor* gobject_;
+
+private:
+
+  
+public:
+  explicit Cursor(CursorType cursor_type);
+  Cursor(const Glib::RefPtr<Pixmap>& source, const Glib::RefPtr<Pixmap>& mask,
+         const Color& fg, const Color& bg,
+         int x, int y);
+  explicit Cursor(const Glib::RefPtr<Display>& display, CursorType cursor_type);
+  Cursor(const Glib::RefPtr<Display>& display, const Glib::RefPtr<Pixbuf>& pixbuf, int x, int y);
+
+  
+  /** Returns the display on which the Gdk::Cursor is defined.
+   * @return The Gdk::Display associated to @a cursor 
+   * 
+   * Since: 2.2.
+   */
+  Glib::RefPtr<Display> get_display();
+  
+  /** Returns the display on which the Gdk::Cursor is defined.
+   * @return The Gdk::Display associated to @a cursor 
+   * 
+   * Since: 2.2.
+   */
+  Glib::RefPtr<const Display> get_display() const;
+
+
+};
+
+} //namespace Gdk
+
+
+namespace Gdk
+{
+
+/** @relates Gdk::Cursor
+ * @param lhs The left-hand side
+ * @param rhs The right-hand side
+ */
+inline void swap(Cursor& lhs, Cursor& rhs)
+  { lhs.swap(rhs); }
+
+} // namespace Gdk
+
+namespace Glib
+{
+
+/** @relates Gdk::Cursor
+ * @param object The C instance
+ * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+ * @result A C++ instance that wraps this C instance.
+ */
+Gdk::Cursor wrap(GdkCursor* object, bool take_copy = false);
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+template <>
+class Value<Gdk::Cursor> : public Glib::Value_Boxed<Gdk::Cursor>
+{};
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+} // namespace Glib
+
+#endif /* _GDKMM_CURSOR_H */
+
diff --git a/libs/gtkmm2/gdk/gdkmm/device.cc b/libs/gtkmm2/gdk/gdkmm/device.cc
new file mode 100644
index 0000000000..78d223a363
--- /dev/null
+++ b/libs/gtkmm2/gdk/gdkmm/device.cc
@@ -0,0 +1,204 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gdkmm/device.h>
+#include <gdkmm/private/device_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* Copyright 2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gdk/gdkinput.h>
+
+namespace Gdk
+{
+
+
+} // namespace Gdk
+
+
+namespace
+{
+} // anonymous namespace
+
+// static
+GType Glib::Value<Gdk::InputMode>::value_type()
+{
+  return gdk_input_mode_get_type();
+}
+
+// static
+GType Glib::Value<Gdk::InputSource>::value_type()
+{
+  return gdk_input_source_get_type();
+}
+
+
+namespace Glib
+{
+
+Glib::RefPtr<Gdk::Device> wrap(GdkDevice* object, bool take_copy)
+{
+  return Glib::RefPtr<Gdk::Device>( dynamic_cast<Gdk::Device*> (Glib::wrap_auto ((GObject*)(object), take_copy)) );
+  //We use dynamic_cast<> in case of multiple inheritance.
+}
+
+} /* namespace Glib */
+
+
+namespace Gdk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& Device_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &Device_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gdk_device_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void Device_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+}
+
+
+Glib::ObjectBase* Device_Class::wrap_new(GObject* object)
+{
+  return new Device((GdkDevice*)object);
+}
+
+
+/* The implementation: */
+
+GdkDevice* Device::gobj_copy()
+{
+  reference();
+  return gobj();
+}
+
+Device::Device(const Glib::ConstructParams& construct_params)
+:
+  Glib::Object(construct_params)
+{}
+
+Device::Device(GdkDevice* castitem)
+:
+  Glib::Object((GObject*)(castitem))
+{}
+
+Device::~Device()
+{}
+
+
+Device::CppClassType Device::device_class_; // initialize static member
+
+GType Device::get_type()
+{
+  return device_class_.init().get_type();
+}
+
+GType Device::get_base_type()
+{
+  return gdk_device_get_type();
+}
+
+
+Device::Device()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Glib::Object(Glib::ConstructParams(device_class_.init()))
+{
+  }
+
+void Device::set_source(InputSource source)
+{
+  gdk_device_set_source(gobj(), ((GdkInputSource)(source)));
+}
+
+bool Device::set_mode(InputMode mode)
+{
+  return gdk_device_set_mode(gobj(), ((GdkInputMode)(mode)));
+}
+
+void Device::set_key(guint index_, guint keyval, ModifierType modifiers)
+{
+  gdk_device_set_key(gobj(), index_, keyval, ((GdkModifierType)(modifiers)));
+}
+
+void Device::set_axis_use(guint index_, AxisUse use)
+{
+  gdk_device_set_axis_use(gobj(), index_, ((GdkAxisUse)(use)));
+}
+
+void Device::get_state(const Glib::RefPtr<Window>& window, double& axes, ModifierType& mask)
+{
+  gdk_device_get_state(gobj(), Glib::unwrap(window), &(axes), ((GdkModifierType*) &(mask)));
+}
+
+bool Device::get_history(const Glib::RefPtr<Window>& window, guint32 start, guint32 stop, GdkTimeCoord**& events, int& n_events)
+{
+  return gdk_device_get_history(gobj(), Glib::unwrap(window), start, stop, &(events), &n_events);
+}
+
+bool Device::get_axis(double& axes, AxisUse use, double& value) const
+{
+  return gdk_device_get_axis(const_cast<GdkDevice*>(gobj()), &(axes), ((GdkAxisUse)(use)), &(value));
+}
+
+Glib::ustring Device::get_name() const
+{
+  return Glib::convert_const_gchar_ptr_to_ustring(gobj()->name);
+}
+
+InputSource Device::get_source() const
+{
+  return ((InputSource)(gobj()->source));
+}
+
+InputMode Device::get_mode() const
+{
+  return ((InputMode)(gobj()->mode));
+}
+
+bool Device::get_has_cursor() const
+{
+  return gobj()->has_cursor;
+}
+
+
+} // namespace Gdk
+
+
diff --git a/libs/gtkmm2/gdk/gdkmm/device.h b/libs/gtkmm2/gdk/gdkmm/device.h
new file mode 100644
index 0000000000..c3146c0010
--- /dev/null
+++ b/libs/gtkmm2/gdk/gdkmm/device.h
@@ -0,0 +1,254 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GDKMM_DEVICE_H
+#define _GDKMM_DEVICE_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* Copyright (C) 2002-2004 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gdkmm/window.h>
+#include <gdkmm/event.h>
+#include <gdk/gdkinput.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GdkDevice GdkDevice;
+typedef struct _GdkDeviceClass GdkDeviceClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gdk
+{ class Device_Class; } // namespace Gdk
+namespace Gdk
+{
+
+/** @addtogroup gdkmmEnums Enums and Flags */
+
+/**
+ * @ingroup gdkmmEnums
+ */
+enum InputMode
+{
+  MODE_DISABLED,
+  MODE_SCREEN,
+  MODE_WINDOW
+};
+
+} // namespace Gdk
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Gdk::InputMode> : public Glib::Value_Enum<Gdk::InputMode>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gdk
+{
+
+/**
+ * @ingroup gdkmmEnums
+ */
+enum InputSource
+{
+  SOURCE_MOUSE,
+  SOURCE_PEN,
+  SOURCE_ERASER,
+  SOURCE_CURSOR
+};
+
+} // namespace Gdk
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Gdk::InputSource> : public Glib::Value_Enum<Gdk::InputSource>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gdk
+{
+
+
+/** A Gdk::Device instance contains a detailed description of an extended input device.
+ */
+
+class Device : public Glib::Object
+{
+  
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+public:
+  typedef Device CppObjectType;
+  typedef Device_Class CppClassType;
+  typedef GdkDevice BaseObjectType;
+  typedef GdkDeviceClass BaseClassType;
+
+private:  friend class Device_Class;
+  static CppClassType device_class_;
+
+private:
+  // noncopyable
+  Device(const Device&);
+  Device& operator=(const Device&);
+
+protected:
+  explicit Device(const Glib::ConstructParams& construct_params);
+  explicit Device(GdkDevice* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+  virtual ~Device();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GObject.
+  GdkDevice*       gobj()       { return reinterpret_cast<GdkDevice*>(gobject_); }
+
+  ///Provides access to the underlying C GObject.
+  const GdkDevice* gobj() const { return reinterpret_cast<GdkDevice*>(gobject_); }
+
+  ///Provides access to the underlying C instance. The caller is responsible for unrefing it. Use when directly setting fields in structs.
+  GdkDevice* gobj_copy();
+
+private:
+
+
+protected:
+  Device();
+
+public:
+
+  
+  void set_source(InputSource source);
+  
+  bool set_mode(InputMode mode);
+  
+  void set_key(guint index_, guint keyval, ModifierType modifiers);
+  
+  void set_axis_use(guint index_, AxisUse use);
+  
+  void get_state(const Glib::RefPtr<Window>& window, double& axes, ModifierType& mask);
+  
+  /** Obtains the motion history for a device; given a starting and
+   * ending timestamp, return all events in the motion history for
+   * the device in the given range of time. Some windowing systems
+   * do not support motion history, in which case, <tt>false</tt> will
+   * be returned. (This is not distinguishable from the case where
+   * motion history is supported and no events were found.)
+   * @param window The window with respect to which which the event coordinates will be reported.
+   * @param start Starting timestamp for range of events to return.
+   * @param stop Ending timestamp for the range of events to return.
+   * @param events Location to store a newly-allocated array of Gdk::TimeCoord, or <tt>0</tt>.
+   * @param n_events Location to store the length of @a events , or <tt>0</tt>.
+   * @return <tt>true</tt> if the windowing system supports motion history and
+   * at least one event was found.
+   */
+  bool get_history(const Glib::RefPtr<Window>& window, guint32 start, guint32 stop, GdkTimeCoord**& events, int& n_events);
+  
+  /** Interprets an array of double as axis values for a given device,
+   * and locates the value in the array for a given axis use.
+   * @param axes Pointer to an array of axes.
+   * @param use The use to look for.
+   * @param value Location to store the found value.
+   * @return <tt>true</tt> if the given axis use was found, otherwise <tt>false</tt>.
+   */
+  bool get_axis(double& axes, AxisUse use, double& value) const;
+
+  /** Gets the name of this device.
+   * @result The name of this device.
+   */
+  Glib::ustring get_name() const;
+  
+  /** Gets the type of this device.
+   * @result The type of this device.
+   */
+  InputSource get_source() const;
+
+  /** Gets the mode of this device.
+   * @result The mode of this device.
+   */
+  InputMode get_mode() const;
+    
+  /** Discover whether the pointer follows device motion.
+   * @result true if the pointer follows device motion.
+   */
+  bool get_has_cursor() const;
+
+  //TODO: Add suitable accessor for the information in these fields. For now, people must use gobj() and access them directly.
+  //gint num_axes	the length of the axes array.
+  //GdkDeviceAxis *axes	an array of GdkDeviceAxis, describing the axes of this device.
+  //
+  //gint num_keys	the length of the keys array.
+  //GdkDeviceKey *keys	an array of GdkDeviceKey, describing the mapped macro buttons of this device.      
+
+
+public:
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+};
+
+} // namespace Gdk
+
+
+namespace Glib
+{
+  /** @relates Gdk::Device
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Glib::RefPtr<Gdk::Device> wrap(GdkDevice* object, bool take_copy = false);
+}
+
+
+#endif /* _GDKMM_DEVICE_H */
+
diff --git a/libs/gtkmm2/gdk/gdkmm/display.cc b/libs/gtkmm2/gdk/gdkmm/display.cc
new file mode 100644
index 0000000000..ff3f528fff
--- /dev/null
+++ b/libs/gtkmm2/gdk/gdkmm/display.cc
@@ -0,0 +1,596 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gdkmm/display.h>
+#include <gdkmm/private/display_p.h>
+
+#include <gdk/gdkenumtypes.h>
+// -*- c++ -*-
+/* $Id$ */
+
+/*
+ *
+ * Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gdkmm/window.h>
+#include <gdk/gdkdisplay.h>
+
+namespace Gdk
+{
+
+bool Display::set_selection_owner(const Glib::RefPtr<Window>& owner, Glib::ustring& selection, guint32 time_, bool send_event)
+{
+  return gdk_selection_owner_set_for_display(gobj(), owner->gobj(), Gdk::AtomString::to_c_type(selection), time_, (gboolean)send_event);
+}
+
+Glib::RefPtr<Window> Display::get_selection_owner(const Glib::ustring& selection)
+{
+  return Glib::wrap( (GdkWindowObject*)gdk_selection_owner_get_for_display(gobj(), Gdk::AtomString::to_c_type(selection)) , true);
+}
+
+void Display::selection_send_notify(guint32 requestor, Glib::ustring& selection, Glib::ustring& target, Glib::ustring& property, guint32 time_)
+{
+  gdk_selection_send_notify_for_display(gobj(), requestor, Gdk::AtomString::to_c_type(selection), Gdk::AtomString::to_c_type(target), Gdk::AtomString::to_c_type(property), time_);
+}
+
+void Display::get_pointer(Glib::RefPtr<Screen>& screen, int& x, int& y, ModifierType& mask)
+{
+  GdkScreen* cScreen = 0;
+  GdkModifierType cMask = (GdkModifierType)mask;
+  gdk_display_get_pointer(gobj(), &cScreen, &x, &y, &cMask);
+  screen = Glib::wrap(cScreen);
+  mask = (ModifierType)cMask;
+}
+
+void Display::get_pointer(int& x, int& y, ModifierType& mask)
+{
+  GdkModifierType cMask = (GdkModifierType)mask;
+  gdk_display_get_pointer(gobj(), 0, &x, &y, &cMask);
+  mask = (ModifierType)cMask;
+}
+
+
+Glib::RefPtr<Window> Display::get_window_at_pointer()
+{
+
+  Glib::RefPtr<Window> retvalue = Glib::wrap((GdkWindowObject*)(gdk_display_get_window_at_pointer(gobj(), 0, 0)));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::RefPtr<const Window> Display::get_window_at_pointer() const
+{
+
+  Glib::RefPtr<const Window> retvalue = Glib::wrap((GdkWindowObject*)(gdk_display_get_window_at_pointer(const_cast<GdkDisplay*>(gobj()), 0, 0)));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+GdkDisplayPointerHooks*  Display::unset_pointer_hooks()
+{
+  return gdk_display_set_pointer_hooks(gobj(), 0 /* See GDK docs */);  
+}
+
+ void Display::store_clipboard(const Glib::RefPtr<Gdk::Window>& clipboard_window, guint32 time_)
+ {
+   gdk_display_store_clipboard(gobj(), clipboard_window->gobj(), time_, 0 /* see the C docs */, 0);
+ }
+  
+ void Display::store_clipboard(const Glib::RefPtr<Gdk::Window>& clipboard_window, guint32 time_, const Glib::StringArrayHandle& targets)
+ {
+   //Put it into a real container that we can use:
+   std::vector<Glib::ustring> targets_copy = targets;
+   
+   //Create array of target GdkAtoms from target strings:
+   if(!targets_copy.empty())
+   {
+     GdkAtom* pAtoms = new GdkAtom[targets_copy.size()];
+     
+     for(guint i = 0; i < targets_copy.size(); ++i)
+     {
+       *pAtoms = Gdk::AtomString::to_c_type(targets_copy[i]);
+     }
+ 
+     gdk_display_store_clipboard(gobj(), clipboard_window->gobj(), time_, 0 /* see the C docs */, 0);
+     
+     delete[] pAtoms;
+   }
+ }
+
+} //Gdk
+
+
+namespace
+{
+
+void Display_signal_closed_callback(GdkDisplay* self, gboolean p0,void* data)
+{
+  using namespace Gdk;
+  typedef sigc::slot< void,bool > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(p0
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+}
+
+const Glib::SignalProxyInfo Display_signal_closed_info =
+{
+  "closed",
+  (GCallback) &Display_signal_closed_callback,
+  (GCallback) &Display_signal_closed_callback
+};
+
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Glib::RefPtr<Gdk::Display> wrap(GdkDisplay* object, bool take_copy)
+{
+  return Glib::RefPtr<Gdk::Display>( dynamic_cast<Gdk::Display*> (Glib::wrap_auto ((GObject*)(object), take_copy)) );
+  //We use dynamic_cast<> in case of multiple inheritance.
+}
+
+} /* namespace Glib */
+
+
+namespace Gdk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& Display_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &Display_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gdk_display_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void Display_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+  klass->closed = &closed_callback;
+}
+
+
+void Display_Class::closed_callback(GdkDisplay* self, gboolean p0)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_closed(p0
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->closed)
+      (*base->closed)(self, p0);
+  }
+}
+
+
+Glib::ObjectBase* Display_Class::wrap_new(GObject* object)
+{
+  return new Display((GdkDisplay*)object);
+}
+
+
+/* The implementation: */
+
+GdkDisplay* Display::gobj_copy()
+{
+  reference();
+  return gobj();
+}
+
+Display::Display(const Glib::ConstructParams& construct_params)
+:
+  Glib::Object(construct_params)
+{}
+
+Display::Display(GdkDisplay* castitem)
+:
+  Glib::Object((GObject*)(castitem))
+{}
+
+Display::~Display()
+{}
+
+
+Display::CppClassType Display::display_class_; // initialize static member
+
+GType Display::get_type()
+{
+  return display_class_.init().get_type();
+}
+
+GType Display::get_base_type()
+{
+  return gdk_display_get_type();
+}
+
+
+Display::Display()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Glib::Object(Glib::ConstructParams(display_class_.init()))
+{
+  }
+
+Glib::RefPtr<Display> Display::open(const Glib::ustring& display_name)
+{
+
+  Glib::RefPtr<Display> retvalue = Glib::wrap(gdk_display_open(display_name.c_str()));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::ustring Display::get_name() const
+{
+  return Glib::convert_const_gchar_ptr_to_ustring(gdk_display_get_name(const_cast<GdkDisplay*>(gobj())));
+}
+
+int Display::get_n_screens() const
+{
+  return gdk_display_get_n_screens(const_cast<GdkDisplay*>(gobj()));
+}
+
+Glib::RefPtr<Screen> Display::get_screen(int screen_num)
+{
+
+  Glib::RefPtr<Screen> retvalue = Glib::wrap(gdk_display_get_screen(gobj(), screen_num));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::RefPtr<const Screen> Display::get_screen(int screen_num) const
+{
+
+  Glib::RefPtr<const Screen> retvalue = Glib::wrap(gdk_display_get_screen(const_cast<GdkDisplay*>(gobj()), screen_num));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::RefPtr<Screen> Display::get_default_screen()
+{
+
+  Glib::RefPtr<Screen> retvalue = Glib::wrap(gdk_display_get_default_screen(gobj()));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::RefPtr<const Screen> Display::get_default_screen() const
+{
+
+  Glib::RefPtr<const Screen> retvalue = Glib::wrap(gdk_display_get_default_screen(const_cast<GdkDisplay*>(gobj())));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+void Display::pointer_ungrab(guint32 timestamp)
+{
+  gdk_display_pointer_ungrab(gobj(), timestamp);
+}
+
+void Display::keyboard_ungrab(guint32 timestamp)
+{
+  gdk_display_keyboard_ungrab(gobj(), timestamp);
+}
+
+bool Display::pointer_is_grabbed() const
+{
+  return gdk_display_pointer_is_grabbed(const_cast<GdkDisplay*>(gobj()));
+}
+
+void Display::beep()
+{
+  gdk_display_beep(gobj());
+}
+
+void Display::sync()
+{
+  gdk_display_sync(gobj());
+}
+
+void Display::close()
+{
+  gdk_display_close(gobj());
+}
+
+Glib::ListHandle< Glib::RefPtr<Device> > Display::list_devices()
+{
+  return Glib::ListHandle< Glib::RefPtr<Device> >(gdk_display_list_devices(gobj()), Glib::OWNERSHIP_DEEP);
+}
+
+Glib::ListHandle< Glib::RefPtr<const Device> > Display::list_devices() const
+{
+  return Glib::ListHandle< Glib::RefPtr<const Device> >(gdk_display_list_devices(const_cast<GdkDisplay*>(gobj())), Glib::OWNERSHIP_DEEP);
+}
+
+GdkEvent* Display::get_event()
+{
+  return gdk_display_get_event(gobj());
+}
+
+const GdkEvent* Display::get_event() const
+{
+  return (const GdkEvent*)(gdk_display_get_event(const_cast<GdkDisplay*>(gobj())));
+}
+
+GdkEvent* Display::peek_event()
+{
+  return gdk_display_peek_event(gobj());
+}
+
+GdkEvent* Display::peek_event() const
+{
+  return gdk_display_peek_event(const_cast<GdkDisplay*>(gobj()));
+}
+
+void Display::put_event(GdkEvent* event)
+{
+  gdk_display_put_event(gobj(), event);
+}
+
+void Display::add_client_message_filter(Glib::ustring& message_type, GdkFilterFunc func, gpointer data)
+{
+  gdk_display_add_client_message_filter(gobj(), Gdk::AtomString::to_c_type(message_type), func, data);
+}
+
+void Display::set_double_click_time(guint msec)
+{
+  gdk_display_set_double_click_time(gobj(), msec);
+}
+
+void Display::set_double_click_distance(guint distance)
+{
+  gdk_display_set_double_click_distance(gobj(), distance);
+}
+
+Glib::RefPtr<Display> Display::get_default()
+{
+
+  Glib::RefPtr<Display> retvalue = Glib::wrap(gdk_display_get_default());
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::RefPtr<Device> Display::get_core_pointer()
+{
+
+  Glib::RefPtr<Device> retvalue = Glib::wrap(gdk_display_get_core_pointer(gobj()));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::RefPtr<const Device> Display::get_core_pointer() const
+{
+
+  Glib::RefPtr<const Device> retvalue = Glib::wrap(gdk_display_get_core_pointer(const_cast<GdkDisplay*>(gobj())));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::RefPtr<Window> Display::get_window_at_pointer(int& win_x, int& win_y)
+{
+
+  Glib::RefPtr<Window> retvalue = Glib::wrap((GdkWindowObject*)(gdk_display_get_window_at_pointer(gobj(), &win_x, &win_y)));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::RefPtr<const Window> Display::get_window_at_pointer(int& win_x, int& win_y) const
+{
+
+  Glib::RefPtr<const Window> retvalue = Glib::wrap((GdkWindowObject*)(gdk_display_get_window_at_pointer(const_cast<GdkDisplay*>(gobj()), &win_x, &win_y)));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+GdkDisplayPointerHooks* Display::set_pointer_hooks(const GdkDisplayPointerHooks* new_hooks)
+{
+  return gdk_display_set_pointer_hooks(gobj(), new_hooks);
+}
+
+Glib::RefPtr<Display> Display::open_default_libgtk_only()
+{
+
+  Glib::RefPtr<Display> retvalue = Glib::wrap(gdk_display_open_default_libgtk_only());
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+guint32 Display::get_drag_protocol(guint32 xid, GdkDragProtocol& protocol)
+{
+  return gdk_drag_get_protocol_for_display(gobj(), xid, &(protocol));
+}
+
+GdkKeymap* Display::get_keymap()
+{
+  return gdk_keymap_get_for_display(gobj());
+}
+
+const GdkKeymap* Display::get_keymap() const
+{
+  return gdk_keymap_get_for_display(const_cast<GdkDisplay*>(gobj()));
+}
+
+Glib::RefPtr<Pixmap> Display::lookup_pixmap(NativeWindow anid)
+{
+  return Glib::wrap((GdkPixmapObject*)(gdk_pixmap_lookup_for_display(gobj(), (GdkNativeWindow)(anid))));
+}
+
+Glib::RefPtr<const Pixmap> Display::lookup_pixmap(NativeWindow anid) const
+{
+  return Glib::wrap((GdkPixmapObject*)(gdk_pixmap_lookup_for_display(const_cast<GdkDisplay*>(gobj()), (GdkNativeWindow)(anid))));
+}
+
+void Display::flush()
+{
+  gdk_display_flush(gobj());
+}
+
+bool Display::supports_cursor_alpha() const
+{
+  return gdk_display_supports_cursor_alpha(const_cast<GdkDisplay*>(gobj()));
+}
+
+bool Display::supports_cursor_color() const
+{
+  return gdk_display_supports_cursor_color(const_cast<GdkDisplay*>(gobj()));
+}
+
+guint Display::get_default_cursor_size() const
+{
+  return gdk_display_get_default_cursor_size(const_cast<GdkDisplay*>(gobj()));
+}
+
+void Display::get_maximal_cursor_size(guint& width, guint& height)
+{
+  gdk_display_get_maximal_cursor_size(gobj(), &(width), &(height));
+}
+
+Glib::RefPtr<Window> Display::get_default_group()
+{
+
+  Glib::RefPtr<Window> retvalue = Glib::wrap((GdkWindowObject*)(gdk_display_get_default_group(gobj())));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::RefPtr<const Window> Display::get_default_group() const
+{
+
+  Glib::RefPtr<const Window> retvalue = Glib::wrap((GdkWindowObject*)(gdk_display_get_default_group(const_cast<GdkDisplay*>(gobj()))));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+bool Display::supports_selection_notification() const
+{
+  return gdk_display_supports_selection_notification(const_cast<GdkDisplay*>(gobj()));
+}
+
+bool Display::request_selection_notification(const Glib::ustring& selection)
+{
+  return gdk_display_request_selection_notification(gobj(), Gdk::AtomString::to_c_type(selection));
+}
+
+bool Display::supports_clipboard_persistence() const
+{
+  return gdk_display_supports_clipboard_persistence(const_cast<GdkDisplay*>(gobj()));
+}
+
+
+Glib::SignalProxy1< void,bool > Display::signal_closed()
+{
+  return Glib::SignalProxy1< void,bool >(this, &Display_signal_closed_info);
+}
+
+
+void Gdk::Display::on_closed(bool is_error)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->closed)
+    (*base->closed)(gobj(),static_cast<int>(is_error));
+}
+
+
+} // namespace Gdk
+
+
diff --git a/libs/gtkmm2/gdk/gdkmm/display.h b/libs/gtkmm2/gdk/gdkmm/display.h
new file mode 100644
index 0000000000..238025599a
--- /dev/null
+++ b/libs/gtkmm2/gdk/gdkmm/display.h
@@ -0,0 +1,635 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GDKMM_DISPLAY_H
+#define _GDKMM_DISPLAY_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* display.h
+ *
+ * Copyright (C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gdkmm/screen.h>
+#include <gdkmm/device.h>
+#include <gdkmm/types.h> //For ModifierType
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GdkDisplay GdkDisplay;
+typedef struct _GdkDisplayClass GdkDisplayClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gdk
+{ class Display_Class; } // namespace Gdk
+namespace Gdk
+{
+
+
+class Drawable;
+
+ /** Gdk::Display object's purpose is two fold:
+ *   To grab/ungrab keyboard focus and mouse pointer
+ *   To manage and provide information about the Gdk::Screen(s) available for this Gdk::Display
+ *
+ * Gdk::Display objects are the GDK representation of the X Display which can be described as a workstation consisting
+ * of a keyboard a pointing device (such as a mouse) and one or more screens. It is used to open and keep track of
+ * various Gdk::Screen objects currently instantiated by the application. It is also used to grab and release the keyboard
+ * and the mouse pointer.
+ */
+
+class Display : public Glib::Object
+{
+  
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+public:
+  typedef Display CppObjectType;
+  typedef Display_Class CppClassType;
+  typedef GdkDisplay BaseObjectType;
+  typedef GdkDisplayClass BaseClassType;
+
+private:  friend class Display_Class;
+  static CppClassType display_class_;
+
+private:
+  // noncopyable
+  Display(const Display&);
+  Display& operator=(const Display&);
+
+protected:
+  explicit Display(const Glib::ConstructParams& construct_params);
+  explicit Display(GdkDisplay* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+  virtual ~Display();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GObject.
+  GdkDisplay*       gobj()       { return reinterpret_cast<GdkDisplay*>(gobject_); }
+
+  ///Provides access to the underlying C GObject.
+  const GdkDisplay* gobj() const { return reinterpret_cast<GdkDisplay*>(gobject_); }
+
+  ///Provides access to the underlying C instance. The caller is responsible for unrefing it. Use when directly setting fields in structs.
+  GdkDisplay* gobj_copy();
+
+private:
+
+protected:
+  Display();
+
+public:
+  
+  /** Opens a display.
+   * 
+   * Since: 2.2
+   * @param display_name The name of the display to open.
+   * @return A Gdk::Display, or <tt>0</tt> if the display
+   * could not be opened.
+   */
+  static Glib::RefPtr<Display> open(const Glib::ustring& display_name);
+
+  
+  /** Gets the name of the display.
+   * @return A string representing the display name. This string is owned
+   * by GDK and should not be modified or freed.
+   * 
+   * Since: 2.2.
+   */
+  Glib::ustring get_name() const;
+
+  
+  /** Gets the number of screen managed by the @a display .
+   * @return Number of screens.
+   * 
+   * Since: 2.2.
+   */
+  int get_n_screens() const;
+  
+  /** Returns a screen object for one of the screens of the display.
+   * @param screen_num The screen number.
+   * @return The Gdk::Screen object
+   * 
+   * Since: 2.2.
+   */
+  Glib::RefPtr<Screen> get_screen(int screen_num);
+  
+  /** Returns a screen object for one of the screens of the display.
+   * @param screen_num The screen number.
+   * @return The Gdk::Screen object
+   * 
+   * Since: 2.2.
+   */
+  Glib::RefPtr<const Screen> get_screen(int screen_num) const;
+  
+  
+  /** Get the default Gdk::Screen for @a display .
+   * @return The default Gdk::Screen object for @a display 
+   * 
+   * Since: 2.2.
+   */
+  Glib::RefPtr<Screen> get_default_screen();
+  
+  /** Get the default Gdk::Screen for @a display .
+   * @return The default Gdk::Screen object for @a display 
+   * 
+   * Since: 2.2.
+   */
+  Glib::RefPtr<const Screen> get_default_screen() const;
+  
+  
+  /** Release any pointer grab.
+   * 
+   * Since: 2.2
+   * @param timestamp A timestap (e.g. GDK_CURRENT_TIME).
+   */
+  void pointer_ungrab(guint32 timestamp);
+  
+  /** Release any keyboard grab
+   * 
+   * Since: 2.2
+   * @param timestamp A timestap (e.g Gdk::CURRENT_TIME).
+   */
+  void keyboard_ungrab(guint32 timestamp);
+  
+  /** Test if the pointer is grabbed.
+   * @return <tt>true</tt> if an active X pointer grab is in effect
+   * 
+   * Since: 2.2.
+   */
+  bool pointer_is_grabbed() const;
+  
+  /** Emits a short beep on @a display 
+   * 
+   * Since: 2.2
+   */
+  void beep();
+  
+  /** Flushes any requests queued for the windowing system and waits until all
+   * requests have been handled. This is often used for making sure that the
+   * display is synchronized with the current state of the program. Calling
+   * sync() before gdk_error_trap_pop() makes sure that any errors
+   * generated from earlier requests are handled before the error trap is 
+   * removed.
+   * 
+   * This is most useful for X11. On windowing systems where requests are
+   * handled synchronously, this function will do nothing.
+   * 
+   * Since: 2.2
+   */
+  void sync();
+  
+  /** Closes the connection to the windowing system for the given display,
+   * and cleans up associated resources.
+   * 
+   * Since: 2.2
+   */
+  void	close();
+
+  
+  /** Returns the list of available input devices attached to @a display .
+   * The list is statically allocated and should not be freed.
+   * @return A list of Gdk::Device
+   * 
+   * Since: 2.2.
+   */
+  Glib::ListHandle< Glib::RefPtr<Device> > list_devices();
+  
+  /** Returns the list of available input devices attached to @a display .
+   * The list is statically allocated and should not be freed.
+   * @return A list of Gdk::Device
+   * 
+   * Since: 2.2.
+   */
+  Glib::ListHandle< Glib::RefPtr<const Device> > list_devices() const;
+  
+  //TODO: Use C++ Gdk::Event:
+  //TODO: get_event() might remove the event - if so, then there should not be a const version:
+  
+  /** Gets the next Gdk::Event to be processed for @a display , fetching events from the
+   * windowing system if necessary.
+   * @return The next Gdk::Event to be processed, or <tt>0</tt> if no events
+   * are pending. The returned Gdk::Event should be freed with gdk_event_free().
+   * 
+   * Since: 2.2.
+   */
+  GdkEvent* get_event();
+  
+  /** Gets the next Gdk::Event to be processed for @a display , fetching events from the
+   * windowing system if necessary.
+   * @return The next Gdk::Event to be processed, or <tt>0</tt> if no events
+   * are pending. The returned Gdk::Event should be freed with gdk_event_free().
+   * 
+   * Since: 2.2.
+   */
+  const GdkEvent* get_event() const;
+  
+  
+  /** Gets a copy of the first Gdk::Event in the @a display 's event queue, without
+   * removing the event from the queue.  (Note that this function will
+   * not get more events from the windowing system.  It only checks the events
+   * that have already been moved to the GDK event queue.)
+   * @return A copy of the first Gdk::Event on the event queue, or <tt>0</tt> 
+   * if no events are in the queue. The returned Gdk::Event should be freed with
+   * gdk_event_free().
+   * 
+   * Since: 2.2.
+   */
+  GdkEvent* peek_event();
+  
+  /** Gets a copy of the first Gdk::Event in the @a display 's event queue, without
+   * removing the event from the queue.  (Note that this function will
+   * not get more events from the windowing system.  It only checks the events
+   * that have already been moved to the GDK event queue.)
+   * @return A copy of the first Gdk::Event on the event queue, or <tt>0</tt> 
+   * if no events are in the queue. The returned Gdk::Event should be freed with
+   * gdk_event_free().
+   * 
+   * Since: 2.2.
+   */
+  GdkEvent* peek_event() const;
+  
+  /** Appends a copy of the given event onto the front of the event
+   * queue for @a display .
+   * 
+   * Since: 2.2
+   * @param event A Gdk::Event.
+   */
+  void put_event(GdkEvent* event);
+
+  //TODO: Use a slot here, though this is probably never used anyway:
+  //Find out whether we can use a string representation for the atom - look for examples of this function's use.
+  
+  /** Adds a filter to be called when X ClientMessage events are received.
+   * 
+   * Since: 2.2
+   * @param message_type The type of ClientMessage events to receive.
+   * This will be checked against the @a message_type  field 
+   * of the XClientMessage event struct.
+   * @param func The function to call to process the event.
+   * @param data User data to pass to @a func .
+   */
+  void add_client_message_filter(Glib::ustring& message_type, GdkFilterFunc func, gpointer data);
+
+  
+  /** Sets the double click time (two clicks within this time interval
+   * count as a double click and result in a Gdk::2BUTTON_PRESS event).
+   * Applications should <em>not</em> set this, it is a global 
+   * user-configured setting.
+   * 
+   * Since: 2.2
+   * @param msec Double click time in milliseconds (thousandths of a second).
+   */
+  void set_double_click_time(guint msec);
+  
+  /** Sets the double click distance (two clicks within this distance
+   * count as a double click and result in a Gdk::2BUTTON_PRESS event).
+   * See also set_double_click_time().
+   * Applications should <em>not</em> set this, it is a global 
+   * user-configured setting.
+   * 
+   * Since: 2.4
+   * @param distance Distance in pixels.
+   */
+  void set_double_click_distance(guint distance);
+
+
+  /** Gets the default Gdk::Display. This is a convenience
+   * function for:
+   * 
+   * gdk_display_manager_get_default_display (manager_get())
+   * 
+   * @return A Gdk::Display, or <tt>0</tt> if there is no default
+   * display.
+   * 
+   * Since: 2.2.
+   */
+  static Glib::RefPtr<Display> get_default();
+
+  
+  /** Returns the core pointer device for the given display
+   * @return The core pointer device; this is owned by the
+   * display and should not be freed.
+   * 
+   * Since: 2.2.
+   */
+  Glib::RefPtr<Device> get_core_pointer();
+  
+  /** Returns the core pointer device for the given display
+   * @return The core pointer device; this is owned by the
+   * display and should not be freed.
+   * 
+   * Since: 2.2.
+   */
+  Glib::RefPtr<const Device> get_core_pointer() const;
+
+  /** Gets the current location of the pointer and the current modifier
+   * mask for a given display.
+   *
+   * @param screen location to store the screen that the cursor is on.
+   * @param x location to store root window X coordinate of pointer.
+   * @param y location to store root window Y coordinate of pointer.
+   * @param mask location to store current modifier mask.
+   *
+   **/
+  void get_pointer(Glib::RefPtr<Screen>& screen, int& x, int& y, ModifierType& mask);
+
+  // In fact, any one of these gdk_display_get_pointer() args can be NULL, but we don't need so many overloads.
+  /**
+   * Gets the current location of the pointer and the current modifier
+   * mask for a given display.
+   *
+   * @param x location to store root window X coordinate of pointer.
+   * @param y location to store root window Y coordinate of pointer.
+   * @param mask location to store current modifier mask.
+   *
+   **/
+  void get_pointer(int& x, int& y, ModifierType& mask); 
+  
+  
+  /** Obtains the window underneath the mouse pointer, returning the location
+   * of that window in @a win_x , @a win_y  for @a screen . Returns <tt>0</tt> if the window 
+   * under the mouse pointer is not known to GDK (for example, belongs to
+   * another application).
+   * @param win_x Return location for origin of the window under the pointer.
+   * @param win_y Return location for origin of the window under the pointer.
+   * @return The window under the mouse pointer, or <tt>0</tt>
+   * 
+   * Since: 2.2.
+   */
+  Glib::RefPtr<Window> get_window_at_pointer(int& win_x, int& win_y);
+  
+  /** Obtains the window underneath the mouse pointer, returning the location
+   * of that window in @a win_x , @a win_y  for @a screen . Returns <tt>0</tt> if the window 
+   * under the mouse pointer is not known to GDK (for example, belongs to
+   * another application).
+   * @param win_x Return location for origin of the window under the pointer.
+   * @param win_y Return location for origin of the window under the pointer.
+   * @return The window under the mouse pointer, or <tt>0</tt>
+   * 
+   * Since: 2.2.
+   */
+  Glib::RefPtr<const Window> get_window_at_pointer(int& win_x, int& win_y) const;
+
+  /** Obtains the window underneath the mouse pointer. Returns a null RefPtr if the window
+   * under the mouse pointer is not known to GDK (for example, belongs to
+   * another application).
+   * @result The window underneath the mouse pointer.
+   */
+  Glib::RefPtr<Window> get_window_at_pointer();
+
+  /** Obtains the window underneath the mouse pointer. Returns a null RefPtr if the window
+   * under the mouse pointer is not known to GDK (for example, belongs to
+   * another application).
+   * @result The window underneath the mouse pointer.
+   */
+  Glib::RefPtr<const Window> get_window_at_pointer() const;
+
+  
+  /** This function allows for hooking into the operation
+   * of getting the current location of the pointer on a particular
+   * display. This is only useful for such low-level tools as an
+   * event recorder. Applications should never have any
+   * reason to use this facility.
+   * @param new_hooks A table of pointers to functions for getting
+   * quantities related to the current pointer position.
+   * @return The previous pointer hook table
+   * 
+   * Since: 2.2.
+   */
+  GdkDisplayPointerHooks* set_pointer_hooks(const GdkDisplayPointerHooks* new_hooks);
+  GdkDisplayPointerHooks* unset_pointer_hooks();
+  
+  
+  /** Opens the default display specified by command line arguments or
+   * environment variables, sets it as the default display, and returns
+   * it.  gdk_parse_args must have been called first. If the default
+   * display has previously been set, simply returns that. An internal
+   * function that should not be used by applications.
+   * @return The default display, if it could be opened,
+   * otherwise <tt>0</tt>.
+   */
+  static Glib::RefPtr<Display> open_default_libgtk_only();
+
+  
+  /** Finds out the DND protocol supported by a window.
+   * 
+   * Since: 2.2
+   * @param xid The X id of the destination window.
+   * @param protocol Location where the supported DND protocol is returned.
+   * @return The X id of the window where the drop should happen. This 
+   * may be @a xid  or the X id of a proxy window, or None if @a xid  doesn't
+   * support Drag and Drop.
+   */
+  guint32 get_drag_protocol(guint32 xid, GdkDragProtocol& protocol);
+
+  
+  /** 
+   * @return The Gdk::Keymap attached to @a display .
+   * the Gdk::Keymap attached to @a display .
+   * 
+   * Since: 2.2.
+   */
+  GdkKeymap* get_keymap();
+  
+  /** 
+   * @return The Gdk::Keymap attached to @a display .
+   * the Gdk::Keymap attached to @a display .
+   * 
+   * Since: 2.2.
+   */
+  const GdkKeymap* get_keymap() const;
+
+  bool set_selection_owner(const Glib::RefPtr<Window>& owner, Glib::ustring& selection, guint32 time_, bool send_event);
+  Glib::RefPtr<Window> get_selection_owner(const Glib::ustring& selection);
+  void selection_send_notify(guint32 requestor, Glib::ustring& selection, Glib::ustring& target, Glib::ustring& property, guint32 time_);
+
+  
+  /** Looks up the Gdk::Pixmap that wraps the given native pixmap handle.
+   * 
+   * For example in the X backend, a native pixmap handle is an Xlib
+   * &lt;type&gt;XID&lt;/type&gt;.
+   * @param anid A native pixmap handle.
+   * @return The Gdk::Pixmap wrapper for the native pixmap,
+   * or <tt>0</tt> if there is none.
+   * 
+   * Since: 2.2.
+   */
+  Glib::RefPtr<Pixmap> lookup_pixmap(NativeWindow anid);
+  
+  /** Looks up the Gdk::Pixmap that wraps the given native pixmap handle.
+   * 
+   * For example in the X backend, a native pixmap handle is an Xlib
+   * &lt;type&gt;XID&lt;/type&gt;.
+   * @param anid A native pixmap handle.
+   * @return The Gdk::Pixmap wrapper for the native pixmap,
+   * or <tt>0</tt> if there is none.
+   * 
+   * Since: 2.2.
+   */
+  Glib::RefPtr<const Pixmap> lookup_pixmap(NativeWindow anid) const;
+
+  
+  /** Flushes any requests queued for the windowing system; this happens automatically
+   * when the main loop blocks waiting for new events, but if your application
+   * is drawing without returning control to the main loop, you may need
+   * to call this function explicitely. A common case where this function
+   * needs to be called is when an application is executing drawing commands
+   * from a thread other than the thread where the main loop is running.
+   * 
+   * This is most useful for X11. On windowing systems where requests are
+   * handled synchronously, this function will do nothing.
+   * 
+   * Since: 2.4
+   */
+  void flush();
+  
+  /** Returns <tt>true</tt> if cursors can use an 8bit alpha channel 
+   * on @a display . Otherwise, cursors are restricted to bilevel 
+   * alpha (i.e. a mask).
+   * @return Whether cursors can have alpha channels.
+   * 
+   * Since: 2.4.
+   */
+  bool supports_cursor_alpha() const;
+  
+  /** Returns <tt>true</tt> if multicolored cursors are supported
+   * on @a display . Otherwise, cursors have only a forground
+   * and a background color.
+   * @return Whether cursors can have multiple colors.
+   * 
+   * Since: 2.4.
+   */
+  bool supports_cursor_color() const;
+  
+  /** Returns the default size to use for cursors on @a display .
+   * @return The default cursor size.
+   * 
+   * Since: 2.4.
+   */
+  guint get_default_cursor_size() const;
+  
+  /** Gets the maximal size to use for cursors on @a display .
+   * 
+   * Since: 2.4
+   * @param width The return location for the maximal cursor width.
+   * @param height The return location for the maximal cursor height.
+   */
+  void get_maximal_cursor_size(guint& width, guint& height);
+
+  
+  /** Returns the default group leader window for all toplevel windows
+   * on @a display . This window is implicitly created by GDK. 
+   * See gdk_window_set_group().
+   * @return The default group leader window for @a display 
+   * 
+   * Since: 2.4.
+   */
+  Glib::RefPtr<Window> get_default_group(); 
+  
+  /** Returns the default group leader window for all toplevel windows
+   * on @a display . This window is implicitly created by GDK. 
+   * See gdk_window_set_group().
+   * @return The default group leader window for @a display 
+   * 
+   * Since: 2.4.
+   */
+  Glib::RefPtr<const Window> get_default_group() const;              
+      
+  //TODO: wrap the vfuncs, though they are not very useful because people will not derive from this class? murrayc.
+  
+
+  /** Returns whether Gdk::EventOwnerChange events will be 
+   * sent when the owner of a selection changes.
+   * @return Whether Gdk::EventOwnerChange events will 
+   * be sent.
+   * 
+   * Since: 2.6.
+   */
+  bool supports_selection_notification() const;
+  
+  /** Request Gdk::EventOwnerChange events for ownership changes
+   * of the selection named by the given atom.
+   * @param selection The Gdk::Atom naming the selection for which
+   * ownership change notification is requested.
+   * @return Whether Gdk::EventOwnerChange events will 
+   * be sent.
+   * 
+   * Since: 2.6.
+   */
+  bool request_selection_notification(const Glib::ustring& selection);
+
+  
+  /** Returns whether the speicifed display supports clipboard
+   * persistance; i.e.\ if it's possible to store the clipboard data after an
+   * application has quit. On X11 this checks if a clipboard daemon is
+   * running.
+   * @return <tt>true</tt> if the display supports clipboard persistance.
+   * 
+   * Since: 2.6.
+   */
+  bool supports_clipboard_persistence() const;
+
+  //TODO: Documentation, based on C docs:
+  void store_clipboard(const Glib::RefPtr<Gdk::Window>& clipboard_window, guint32 time_);
+  
+  void store_clipboard(const Glib::RefPtr<Gdk::Window>& clipboard_window, guint32 time_, const Glib::StringArrayHandle& targets);
+                                                     
+  
+  Glib::SignalProxy1< void,bool > signal_closed();
+
+
+public:
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+  virtual void on_closed(bool is_error);
+
+
+};
+
+} /* namespace Gdk */
+
+
+namespace Glib
+{
+  /** @relates Gdk::Display
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Glib::RefPtr<Gdk::Display> wrap(GdkDisplay* object, bool take_copy = false);
+}
+
+
+#endif /* _GDKMM_DISPLAY_H */
+
diff --git a/libs/gtkmm2/gdk/gdkmm/displaymanager.cc b/libs/gtkmm2/gdk/gdkmm/displaymanager.cc
new file mode 100644
index 0000000000..5edb22e506
--- /dev/null
+++ b/libs/gtkmm2/gdk/gdkmm/displaymanager.cc
@@ -0,0 +1,265 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gdkmm/displaymanager.h>
+#include <gdkmm/private/displaymanager_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/*
+ *
+ * Copyright 2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gdk/gdkdisplaymanager.h>
+namespace Gdk
+{
+
+
+} //Gdk
+
+
+namespace
+{
+
+void DisplayManager_signal_display_opened_callback(GdkDisplayManager* self, GdkDisplay* p0,void* data)
+{
+  using namespace Gdk;
+  typedef sigc::slot< void,const Glib::RefPtr<Display>& > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(Glib::wrap(p0, true)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+}
+
+const Glib::SignalProxyInfo DisplayManager_signal_display_opened_info =
+{
+  "display-opened",
+  (GCallback) &DisplayManager_signal_display_opened_callback,
+  (GCallback) &DisplayManager_signal_display_opened_callback
+};
+
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Glib::RefPtr<Gdk::DisplayManager> wrap(GdkDisplayManager* object, bool take_copy)
+{
+  return Glib::RefPtr<Gdk::DisplayManager>( dynamic_cast<Gdk::DisplayManager*> (Glib::wrap_auto ((GObject*)(object), take_copy)) );
+  //We use dynamic_cast<> in case of multiple inheritance.
+}
+
+} /* namespace Glib */
+
+
+namespace Gdk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& DisplayManager_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &DisplayManager_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gdk_display_manager_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void DisplayManager_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+  klass->display_opened = &display_opened_callback;
+}
+
+
+void DisplayManager_Class::display_opened_callback(GdkDisplayManager* self, GdkDisplay* p0)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_display_opened(Glib::wrap(p0, true)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->display_opened)
+      (*base->display_opened)(self, p0);
+  }
+}
+
+
+Glib::ObjectBase* DisplayManager_Class::wrap_new(GObject* object)
+{
+  return new DisplayManager((GdkDisplayManager*)object);
+}
+
+
+/* The implementation: */
+
+GdkDisplayManager* DisplayManager::gobj_copy()
+{
+  reference();
+  return gobj();
+}
+
+DisplayManager::DisplayManager(const Glib::ConstructParams& construct_params)
+:
+  Glib::Object(construct_params)
+{}
+
+DisplayManager::DisplayManager(GdkDisplayManager* castitem)
+:
+  Glib::Object((GObject*)(castitem))
+{}
+
+DisplayManager::~DisplayManager()
+{}
+
+
+DisplayManager::CppClassType DisplayManager::displaymanager_class_; // initialize static member
+
+GType DisplayManager::get_type()
+{
+  return displaymanager_class_.init().get_type();
+}
+
+GType DisplayManager::get_base_type()
+{
+  return gdk_display_manager_get_type();
+}
+
+
+Glib::RefPtr<DisplayManager> DisplayManager::get()
+{
+
+  Glib::RefPtr<DisplayManager> retvalue = Glib::wrap(gdk_display_manager_get());
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::RefPtr<Display> DisplayManager::get_default_display()
+{
+
+  Glib::RefPtr<Display> retvalue = Glib::wrap(gdk_display_manager_get_default_display(gobj()));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::RefPtr<const Display> DisplayManager::get_default_display() const
+{
+
+  Glib::RefPtr<const Display> retvalue = Glib::wrap(gdk_display_manager_get_default_display(const_cast<GdkDisplayManager*>(gobj())));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+void DisplayManager::set_default_display(const Glib::RefPtr<Display>& display)
+{
+  gdk_display_manager_set_default_display(gobj(), Glib::unwrap(display));
+}
+
+Glib::SListHandle< Glib::RefPtr<Display> > DisplayManager::list_displays()
+{
+  return Glib::SListHandle< Glib::RefPtr<Display> >(gdk_display_manager_list_displays(gobj()), Glib::OWNERSHIP_SHALLOW);
+}
+
+
+Glib::SignalProxy1< void,const Glib::RefPtr<Display>& > DisplayManager::signal_display_opened()
+{
+  return Glib::SignalProxy1< void,const Glib::RefPtr<Display>& >(this, &DisplayManager_signal_display_opened_info);
+}
+
+
+Glib::PropertyProxy< Glib::RefPtr<Display> > DisplayManager::property_default_display() 
+{
+  return Glib::PropertyProxy< Glib::RefPtr<Display> >(this, "default-display");
+}
+
+Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Display> > DisplayManager::property_default_display() const
+{
+  return Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Display> >(this, "default-display");
+}
+
+
+void Gdk::DisplayManager::on_display_opened(const Glib::RefPtr<Display>& display)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->display_opened)
+    (*base->display_opened)(gobj(),Glib::unwrap(display));
+}
+
+
+} // namespace Gdk
+
+
diff --git a/libs/gtkmm2/gdk/gdkmm/displaymanager.h b/libs/gtkmm2/gdk/gdkmm/displaymanager.h
new file mode 100644
index 0000000000..fb223270d6
--- /dev/null
+++ b/libs/gtkmm2/gdk/gdkmm/displaymanager.h
@@ -0,0 +1,186 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GDKMM_DISPLAYMANAGER_H
+#define _GDKMM_DISPLAYMANAGER_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* displaymanager.h
+ *
+ * Copyright (C) 2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <glibmm/object.h>
+#include <gdkmm/display.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GdkDisplayManager GdkDisplayManager;
+typedef struct _GdkDisplayManagerClass GdkDisplayManagerClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gdk
+{ class DisplayManager_Class; } // namespace Gdk
+namespace Gdk
+{
+
+/** The purpose of the GdkDisplayManager singleton object is to offer notification when displays appear or disappear or the
+ * default display changes.
+ */
+
+class DisplayManager : public Glib::Object
+{
+  
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+public:
+  typedef DisplayManager CppObjectType;
+  typedef DisplayManager_Class CppClassType;
+  typedef GdkDisplayManager BaseObjectType;
+  typedef GdkDisplayManagerClass BaseClassType;
+
+private:  friend class DisplayManager_Class;
+  static CppClassType displaymanager_class_;
+
+private:
+  // noncopyable
+  DisplayManager(const DisplayManager&);
+  DisplayManager& operator=(const DisplayManager&);
+
+protected:
+  explicit DisplayManager(const Glib::ConstructParams& construct_params);
+  explicit DisplayManager(GdkDisplayManager* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+  virtual ~DisplayManager();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GObject.
+  GdkDisplayManager*       gobj()       { return reinterpret_cast<GdkDisplayManager*>(gobject_); }
+
+  ///Provides access to the underlying C GObject.
+  const GdkDisplayManager* gobj() const { return reinterpret_cast<GdkDisplayManager*>(gobject_); }
+
+  ///Provides access to the underlying C instance. The caller is responsible for unrefing it. Use when directly setting fields in structs.
+  GdkDisplayManager* gobj_copy();
+
+private:
+
+protected:
+
+public:
+
+  
+  /** 
+   * @return The singleton Gdk::DisplayManager object.
+   * the global Gdk::DisplayManager singleton; gdk_parse_pargs(),
+   * gdk_init(), or gdk_init_check() must have been called first.
+   * 
+   * Since: 2.2.
+   */
+  static Glib::RefPtr<DisplayManager> get();
+  
+  /** Gets the default Gdk::Display.
+   * @return A Gdk::Display, or <tt>0</tt> if there is no default
+   * display.
+   * 
+   * Since: 2.2.
+   */
+  Glib::RefPtr<Display> get_default_display();
+  
+  /** Gets the default Gdk::Display.
+   * @return A Gdk::Display, or <tt>0</tt> if there is no default
+   * display.
+   * 
+   * Since: 2.2.
+   */
+  Glib::RefPtr<const Display> get_default_display() const;
+
+  
+  /** Sets @a display  as the default display.
+   * 
+   * Since: 2.2
+   * @param display A Gdk::Display.
+   */
+  void set_default_display(const Glib::RefPtr<Display>& display);
+
+  
+  /** List all currently open displays.
+   * @return A list of Gdk::Display objects.
+   * Since: 2.2.
+   */
+  Glib::SListHandle< Glib::RefPtr<Display> > list_displays();
+
+  /** The default display for GDK.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy< Glib::RefPtr<Display> > property_default_display() ;
+
+/** The default display for GDK.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Display> > property_default_display() const;
+
+  
+  Glib::SignalProxy1< void,const Glib::RefPtr<Display>& > signal_display_opened();
+
+
+public:
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+  virtual void on_display_opened(const Glib::RefPtr<Display>& display);
+
+
+};
+
+} /* namespace Gdk */
+
+
+namespace Glib
+{
+  /** @relates Gdk::DisplayManager
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Glib::RefPtr<Gdk::DisplayManager> wrap(GdkDisplayManager* object, bool take_copy = false);
+}
+
+
+#endif /* _GDKMM_DISPLAYMANAGER_H */
+
diff --git a/libs/gtkmm2/gdk/gdkmm/dragcontext.cc b/libs/gtkmm2/gdk/gdkmm/dragcontext.cc
new file mode 100644
index 0000000000..3a2574fb72
--- /dev/null
+++ b/libs/gtkmm2/gdk/gdkmm/dragcontext.cc
@@ -0,0 +1,310 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gdkmm/dragcontext.h>
+#include <gdkmm/private/dragcontext_p.h>
+
+#include <gdk/gdkenumtypes.h>
+// -*- c++ -*-
+/* $Id$ */
+
+/*
+ *
+ * Copyright 2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gdkmm/window.h>
+#include <gtk/gtkdnd.h>
+#include <gdk/gdkwindow.h>
+#include <glibmm/utility.h> //For ScopedPtr<>.
+
+namespace Gdk
+{
+
+void DragContext::find_window_for_screen(const Glib::RefPtr<Window>& drag_window, const Glib::RefPtr<Screen>& screen, int x_root, int y_root, Glib::RefPtr<Window>& dest_window, DragProtocol* protocol) const
+{
+  GdkWindow* cWindow = 0;
+  gdk_drag_find_window_for_screen(const_cast<GdkDragContext*>(gobj()), drag_window->gobj(), screen->gobj(), x_root, y_root, &cWindow, (GdkDragProtocol*)(protocol));
+  dest_window = Glib::wrap((GdkWindowObject*)cWindow);
+}
+
+void DragContext::drag_refuse(guint32 time)
+{
+  gdk_drag_status(gobj(), ((GdkDragAction)(0)) /* see GDK docs */, time);
+}
+
+Glib::StringArrayHandle DragContext::get_targets() const
+{
+  std::list<Glib::ustring> listTargets;
+
+  //Get a newly-allocated array of atoms:
+  GList* list = gobj()->targets;
+  while(list)
+  {
+    GdkAtom atom = (GdkAtom)list->data;
+    
+    //Convert the atom to a string:
+    gchar* const atom_name = gdk_atom_name(atom);
+
+    Glib::ustring target;
+    if(atom_name)
+      target = Glib::ScopedPtr<char>(atom_name).get(); //This frees the gchar*.
+      
+    listTargets.push_back(target);
+
+    list = list->next;
+  }
+
+  return listTargets;
+}
+
+} /* namespace Gdk */
+
+
+namespace
+{
+} // anonymous namespace
+
+// static
+GType Glib::Value<Gdk::DragAction>::value_type()
+{
+  return gdk_drag_action_get_type();
+}
+
+// static
+GType Glib::Value<Gdk::DragProtocol>::value_type()
+{
+  return gdk_drag_protocol_get_type();
+}
+
+
+namespace Glib
+{
+
+Glib::RefPtr<Gdk::DragContext> wrap(GdkDragContext* object, bool take_copy)
+{
+  return Glib::RefPtr<Gdk::DragContext>( dynamic_cast<Gdk::DragContext*> (Glib::wrap_auto ((GObject*)(object), take_copy)) );
+  //We use dynamic_cast<> in case of multiple inheritance.
+}
+
+} /* namespace Glib */
+
+
+namespace Gdk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& DragContext_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &DragContext_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gdk_drag_context_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void DragContext_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+}
+
+
+Glib::ObjectBase* DragContext_Class::wrap_new(GObject* object)
+{
+  return new DragContext((GdkDragContext*)object);
+}
+
+
+/* The implementation: */
+
+GdkDragContext* DragContext::gobj_copy()
+{
+  reference();
+  return gobj();
+}
+
+DragContext::DragContext(const Glib::ConstructParams& construct_params)
+:
+  Glib::Object(construct_params)
+{}
+
+DragContext::DragContext(GdkDragContext* castitem)
+:
+  Glib::Object((GObject*)(castitem))
+{}
+
+DragContext::~DragContext()
+{}
+
+
+DragContext::CppClassType DragContext::dragcontext_class_; // initialize static member
+
+GType DragContext::get_type()
+{
+  return dragcontext_class_.init().get_type();
+}
+
+GType DragContext::get_base_type()
+{
+  return gdk_drag_context_get_type();
+}
+
+
+DragContext::DragContext()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Glib::Object(Glib::ConstructParams(dragcontext_class_.init()))
+{
+  }
+
+Glib::RefPtr<DragContext> DragContext::create()
+{
+  return Glib::RefPtr<DragContext>( new DragContext() );
+}
+void DragContext::drag_status(DragAction action, guint32 time)
+{
+  gdk_drag_status(gobj(), ((GdkDragAction)(action)), time);
+}
+
+void DragContext::drop_reply(bool ok, guint32 time)
+{
+  gdk_drop_reply(gobj(), static_cast<int>(ok), time);
+}
+
+void DragContext::drop_finish(bool success, guint32 time)
+{
+  gdk_drop_finish(gobj(), static_cast<int>(success), time);
+}
+
+Glib::ustring DragContext::get_selection() const
+{
+  return Gdk::AtomString::to_cpp_type(gdk_drag_get_selection(const_cast<GdkDragContext*>(gobj())));
+}
+
+void DragContext::drag_finish(bool success, bool del, guint32 time)
+{
+  gtk_drag_finish(gobj(), static_cast<int>(success), static_cast<int>(del), time);
+}
+
+void DragContext::set_icon(const Glib::RefPtr<Gdk::Colormap>& colormap, const Glib::RefPtr<Gdk::Pixmap>& pixmap, const Glib::RefPtr<Gdk::Bitmap>& mask, int hot_x, int hot_y)
+{
+  gtk_drag_set_icon_pixmap(gobj(), Glib::unwrap(colormap), Glib::unwrap(pixmap), Glib::unwrap(mask), hot_x, hot_y);
+}
+
+void DragContext::set_icon(const Glib::RefPtr<Gdk::Pixbuf>& pixbuf, int hot_x, int hot_y)
+{
+  gtk_drag_set_icon_pixbuf(gobj(), Glib::unwrap(pixbuf), hot_x, hot_y);
+}
+
+void DragContext::set_icon(const Glib::ustring& stock_id, int hot_x, int hot_y)
+{
+  gtk_drag_set_icon_stock(gobj(), stock_id.c_str(), hot_x, hot_y);
+}
+
+void DragContext::set_icon()
+{
+  gtk_drag_set_icon_default(gobj());
+}
+
+Glib::RefPtr<Window> DragContext::get_source_window()
+{
+  Glib::RefPtr<Window> ref_ptr(Glib::wrap((GdkWindowObject*)(gobj()->source_window)));
+
+  if(ref_ptr)
+    ref_ptr->reference();
+
+  return ref_ptr;
+}
+
+Glib::RefPtr<const Window> DragContext::get_source_window() const
+{
+  Glib::RefPtr<const Window> ref_ptr(Glib::wrap((GdkWindowObject*)(gobj()->source_window)));
+
+  if(ref_ptr)
+    ref_ptr->reference();
+
+  return ref_ptr;
+}
+
+Glib::RefPtr<Window> DragContext::get_destination_window()
+{
+  Glib::RefPtr<Window> ref_ptr(Glib::wrap((GdkWindowObject*)(gobj()->dest_window)));
+
+  if(ref_ptr)
+    ref_ptr->reference();
+
+  return ref_ptr;
+}
+
+Glib::RefPtr<const Window> DragContext::get_destination_window() const
+{
+  Glib::RefPtr<const Window> ref_ptr(Glib::wrap((GdkWindowObject*)(gobj()->dest_window)));
+
+  if(ref_ptr)
+    ref_ptr->reference();
+
+  return ref_ptr;
+}
+
+DragProtocol DragContext::get_protocol() const
+{
+  return ((DragProtocol)(gobj()->protocol));
+}
+
+bool DragContext::get_is_source() const
+{
+  return gobj()->is_source;
+}
+
+DragAction DragContext::get_actions() const
+{
+  return ((DragAction)(gobj()->actions));
+}
+
+DragAction DragContext::get_suggested_action() const
+{
+  return ((DragAction)(gobj()->suggested_action));
+}
+
+DragAction DragContext::get_action() const
+{
+  return ((DragAction)(gobj()->action));
+}
+
+guint32 DragContext::get_start_time() const
+{
+  return gobj()->start_time;
+}
+
+
+} // namespace Gdk
+
+
diff --git a/libs/gtkmm2/gdk/gdkmm/dragcontext.h b/libs/gtkmm2/gdk/gdkmm/dragcontext.h
new file mode 100644
index 0000000000..57507df105
--- /dev/null
+++ b/libs/gtkmm2/gdk/gdkmm/dragcontext.h
@@ -0,0 +1,369 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GDKMM_DRAGCONTEXT_H
+#define _GDKMM_DRAGCONTEXT_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* dragcontext.h
+ *
+ * Copyright (C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gdkmm/color.h>
+#include <gdkmm/pixbuf.h>
+#include <gdkmm/bitmap.h>
+#include <glibmm/object.h>
+#include <gdk/gdkdnd.h>
+#include <glibmm/listhandle.h>
+#include <gtkmm/stockid.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GdkDragContext GdkDragContext;
+typedef struct _GdkDragContextClass GdkDragContextClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gdk
+{ class DragContext_Class; } // namespace Gdk
+namespace Gtk
+{
+  class Widget;
+} /* namespace Gtk */
+
+//typedef struct _GdkAtom            *GdkAtom;
+
+namespace Gdk
+{
+
+
+/** @addtogroup gdkmmEnums Enums and Flags */
+
+/**
+ * @ingroup gdkmmEnums
+ * @par Bitwise operators:
+ * <tt>%DragAction operator|(DragAction, DragAction)</tt><br>
+ * <tt>%DragAction operator&(DragAction, DragAction)</tt><br>
+ * <tt>%DragAction operator^(DragAction, DragAction)</tt><br>
+ * <tt>%DragAction operator~(DragAction)</tt><br>
+ * <tt>%DragAction& operator|=(DragAction&, DragAction)</tt><br>
+ * <tt>%DragAction& operator&=(DragAction&, DragAction)</tt><br>
+ * <tt>%DragAction& operator^=(DragAction&, DragAction)</tt><br>
+ */
+enum DragAction
+{
+  ACTION_DEFAULT = 1 << 0,
+  ACTION_COPY = 1 << 1,
+  ACTION_MOVE = 1 << 2,
+  ACTION_LINK = 1 << 3,
+  ACTION_PRIVATE = 1 << 4,
+  ACTION_ASK = 1 << 5
+};
+
+/** @ingroup gdkmmEnums */
+inline DragAction operator|(DragAction lhs, DragAction rhs)
+  { return static_cast<DragAction>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs)); }
+
+/** @ingroup gdkmmEnums */
+inline DragAction operator&(DragAction lhs, DragAction rhs)
+  { return static_cast<DragAction>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs)); }
+
+/** @ingroup gdkmmEnums */
+inline DragAction operator^(DragAction lhs, DragAction rhs)
+  { return static_cast<DragAction>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs)); }
+
+/** @ingroup gdkmmEnums */
+inline DragAction operator~(DragAction flags)
+  { return static_cast<DragAction>(~static_cast<unsigned>(flags)); }
+
+/** @ingroup gdkmmEnums */
+inline DragAction& operator|=(DragAction& lhs, DragAction rhs)
+  { return (lhs = static_cast<DragAction>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs))); }
+
+/** @ingroup gdkmmEnums */
+inline DragAction& operator&=(DragAction& lhs, DragAction rhs)
+  { return (lhs = static_cast<DragAction>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs))); }
+
+/** @ingroup gdkmmEnums */
+inline DragAction& operator^=(DragAction& lhs, DragAction rhs)
+  { return (lhs = static_cast<DragAction>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs))); }
+
+} // namespace Gdk
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Gdk::DragAction> : public Glib::Value_Flags<Gdk::DragAction>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gdk
+{
+
+/**
+ * @ingroup gdkmmEnums
+ */
+enum DragProtocol
+{
+  DRAG_PROTO_MOTIF,
+  DRAG_PROTO_XDND,
+  DRAG_PROTO_NONE,
+  DRAG_PROTO_WIN32_DROPFILES,
+  DRAG_PROTO_OLE2,
+  DRAG_PROTO_LOCAL
+};
+
+} // namespace Gdk
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Gdk::DragProtocol> : public Glib::Value_Enum<Gdk::DragProtocol>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gdk
+{
+
+
+/** A Gdk::DragContext holds information about a drag in progress. It is used on both source and destination sides.
+ */
+
+class DragContext : public Glib::Object
+{
+  
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+public:
+  typedef DragContext CppObjectType;
+  typedef DragContext_Class CppClassType;
+  typedef GdkDragContext BaseObjectType;
+  typedef GdkDragContextClass BaseClassType;
+
+private:  friend class DragContext_Class;
+  static CppClassType dragcontext_class_;
+
+private:
+  // noncopyable
+  DragContext(const DragContext&);
+  DragContext& operator=(const DragContext&);
+
+protected:
+  explicit DragContext(const Glib::ConstructParams& construct_params);
+  explicit DragContext(GdkDragContext* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+  virtual ~DragContext();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GObject.
+  GdkDragContext*       gobj()       { return reinterpret_cast<GdkDragContext*>(gobject_); }
+
+  ///Provides access to the underlying C GObject.
+  const GdkDragContext* gobj() const { return reinterpret_cast<GdkDragContext*>(gobject_); }
+
+  ///Provides access to the underlying C instance. The caller is responsible for unrefing it. Use when directly setting fields in structs.
+  GdkDragContext* gobj_copy();
+
+private:
+
+  
+protected:
+  DragContext();
+
+public:
+  
+  static Glib::RefPtr<DragContext> create();
+
+
+  /** Selects one of the actions offered by the drag source.
+   * 
+   * This function is called by the drag destination in response to
+   * gdk_drag_motion() called by the drag source.
+   * @param action The selected action which will be taken when a drop happens,
+   * or 0 to indicate that a drop will not be accepted.
+   * @param time The timestamp for this operation.
+   */
+  void drag_status(DragAction action, guint32 time);
+  void drag_refuse(guint32 time);
+  
+   //gdk_drag_motion is only used in GDK internally.
+  
+  
+  /** Accepts or rejects a drop. 
+   * 
+   * This function is called by the drag destination in response
+   * to a drop initiated by the drag source.
+   * @param ok <tt>true</tt> if the drop is accepted.
+   * @param time The timestamp for this operation.
+   */
+  void drop_reply(bool ok, guint32 time);
+  
+  /** Ends the drag operation after a drop.
+   * 
+   * This function is called by the drag destination.
+   * @param success <tt>true</tt> if the data was successfully received.
+   * @param time The timestamp for this operation.
+   */
+  void drop_finish(bool success, guint32 time);
+  
+  /** Returns the selection atom for the current source window.
+   * @return The selection atom.
+   */
+  Glib::ustring get_selection() const;
+
+  
+  void drag_finish(bool success, bool del, guint32 time);
+  //Gtk::Widget* get_source_widget() - see Gtk::Widget::drag_get_source_widget()
+
+  // void set_icon(Gtk::Widget* widget, int hot_x, int hot_y) - see Gtk::Widget::set_as_icon().
+  
+  void set_icon(const Glib::RefPtr<Gdk::Colormap>& colormap, const Glib::RefPtr<Gdk::Pixmap>& pixmap, const Glib::RefPtr<Gdk::Bitmap>& mask, int hot_x, int hot_y);
+  
+  void set_icon(const Glib::RefPtr<Gdk::Pixbuf>& pixbuf, int hot_x, int hot_y);
+
+  // The first argument was changed from StockID to ustring to avoid 
+  // cross-dependence between gdkmm and gtkmm.
+  // See http://bugzilla.gnome.org/show_bug.cgi?id=79124 for details
+  
+  void set_icon(const Glib::ustring& stock_id, int hot_x, int hot_y);
+  
+  void set_icon();
+
+  /** Get the the source window of this drag.
+   * @result the source window of this drag.
+   */
+  Glib::RefPtr<Window> get_source_window();
+  Glib::RefPtr<const Window> get_source_window() const;
+
+  /** Get the the source window of this drag.
+   * @result the source window of this drag.
+   */
+  Glib::RefPtr<Window> get_destination_window();
+  Glib::RefPtr<const Window> get_destination_window() const;
+    
+  /** Get a list of targets offered by the source.
+   * @result a list of targets offered by the source.
+   */
+  Glib::StringArrayHandle get_targets() const;
+
+  /** Get the DND protocol which governs this drag.
+   * @result the DND protocol which governs this drag.
+   */
+  DragProtocol get_protocol() const;
+  
+  /** Discover whether the context is used on the source side.
+   * @result true if the context is used on the source side.
+   */
+  bool get_is_source() const;
+
+  /** Get a bitmask of actions proposed by the source when the suggested_action is Gdk::ACTION_ASK
+   * @result a bitmask of actions proposed by the source when the suggested_action is Gdk::ACTION_ASK
+   */
+  DragAction get_actions() const;
+
+  /** Get the action suggested by the source.
+   * @result The action suggested by the source.
+   */
+  DragAction get_suggested_action() const;
+
+  /** Get the action chosen by the destination.
+   * @result the action chosen byt the destination.
+   */
+  DragAction get_action() const;
+
+  /** Get a timestamp recording the start time of this drag.
+   * @result a timestamp recording the start time of this drag.
+   */
+  guint32 get_start_time() const;
+
+  
+  /** Finds the destination window and DND protocol to use at the
+   * given pointer position. 
+   * 
+   * This function is called by the drag source to obtain the 
+   *  @a dest_window  and @a protocol  parameters for gdk_drag_motion().
+   * 
+   * Since: 2.2
+   * @param drag_window A window which may be at the pointer position, but
+   * should be ignored, since it is put up by the drag source as an icon.
+   * @param screen The screen where the destination window is sought.
+   * @param x_root The x position of the pointer in root coordinates.
+   * @param y_root The y position of the pointer in root coordinates.
+   * @param dest_window Location to store the destination window in.
+   * @param protocol Location to store the DND protocol in.
+   */
+
+  void find_window_for_screen(const Glib::RefPtr<Window>& drag_window, const Glib::RefPtr<Screen>& screen, int x_root, int y_root, Glib::RefPtr<Window>& dest_window, DragProtocol* protocol) const;
+  
+
+public:
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+};
+
+} /* namespace Gdk */
+
+
+namespace Glib
+{
+  /** @relates Gdk::DragContext
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Glib::RefPtr<Gdk::DragContext> wrap(GdkDragContext* object, bool take_copy = false);
+}
+
+
+#endif /* _GDKMM_DRAGCONTEXT_H */
+
diff --git a/libs/gtkmm2/gdk/gdkmm/drawable.cc b/libs/gtkmm2/gdk/gdkmm/drawable.cc
new file mode 100644
index 0000000000..58adc15cec
--- /dev/null
+++ b/libs/gtkmm2/gdk/gdkmm/drawable.cc
@@ -0,0 +1,369 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gdkmm/drawable.h>
+#include <gdkmm/private/drawable_p.h>
+
+#include <gdk/gdkenumtypes.h>
+// -*- c++ -*-
+/* $Id$ */
+
+/* Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gdkmm/gc.h>
+#include <gdkmm/display.h>
+#include <gdkmm/pixbuf.h>
+#include <gdk/gdkdrawable.h>
+
+namespace Gdk
+{
+
+void Drawable::draw_points(const Glib::RefPtr<const GC>& gc, const Glib::ArrayHandle<Point>& points)
+{
+  // Don't assume the reinterpret_cast<> works everywhere.  Gdk::Point is *special*.
+  gdk_draw_points(
+      gobj(), const_cast<GdkGC*>(Glib::unwrap<Gdk::GC>(gc)),
+      reinterpret_cast<GdkPoint*>(const_cast<Point*>(points.data())),
+      points.size());
+}
+
+void Drawable::draw_lines(const Glib::RefPtr<const GC>& gc, const Glib::ArrayHandle<Point>& points)
+{
+  // Don't assume the reinterpret_cast<> works everywhere.  Gdk::Point is *special*.
+  gdk_draw_lines(
+      gobj(), const_cast<GdkGC*>(Glib::unwrap<Gdk::GC>(gc)),
+      reinterpret_cast<GdkPoint*>(const_cast<Point*>(points.data())),
+      points.size());
+}
+
+void Drawable::draw_polygon(const Glib::RefPtr<const GC>& gc, bool filled,
+                            const Glib::ArrayHandle<Point>& points)
+{
+  // Don't assume the reinterpret_cast<> works everywhere.  Gdk::Point is *special*.
+  gdk_draw_polygon(
+      gobj(), const_cast<GdkGC*>(Glib::unwrap<Gdk::GC>(gc)), filled,
+      reinterpret_cast<GdkPoint*>(const_cast<Point*>(points.data())),
+      points.size());
+}
+
+void Drawable::copy_to_image(const Glib::RefPtr<Image>& image, int src_x, int src_y, int dest_x, int dest_y, int width, int height) const
+{
+  gdk_drawable_copy_to_image(const_cast<GdkDrawable*>(gobj()), Glib::unwrap(image), src_x, src_y, dest_x, dest_y, width, height);
+}
+
+
+} // namespace Gdk
+
+
+namespace
+{
+} // anonymous namespace
+
+// static
+GType Glib::Value<Gdk::RgbDither>::value_type()
+{
+  return gdk_rgb_dither_get_type();
+}
+
+
+namespace Glib
+{
+
+Glib::RefPtr<Gdk::Drawable> wrap(GdkDrawable* object, bool take_copy)
+{
+  return Glib::RefPtr<Gdk::Drawable>( dynamic_cast<Gdk::Drawable*> (Glib::wrap_auto ((GObject*)(object), take_copy)) );
+  //We use dynamic_cast<> in case of multiple inheritance.
+}
+
+} /* namespace Glib */
+
+
+namespace Gdk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& Drawable_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &Drawable_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gdk_drawable_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void Drawable_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+}
+
+
+Glib::ObjectBase* Drawable_Class::wrap_new(GObject* object)
+{
+  return new Drawable((GdkDrawable*)object);
+}
+
+
+/* The implementation: */
+
+GdkDrawable* Drawable::gobj_copy()
+{
+  reference();
+  return gobj();
+}
+
+Drawable::Drawable(const Glib::ConstructParams& construct_params)
+:
+  Glib::Object(construct_params)
+{}
+
+Drawable::Drawable(GdkDrawable* castitem)
+:
+  Glib::Object((GObject*)(castitem))
+{}
+
+Drawable::~Drawable()
+{}
+
+
+Drawable::CppClassType Drawable::drawable_class_; // initialize static member
+
+GType Drawable::get_type()
+{
+  return drawable_class_.init().get_type();
+}
+
+GType Drawable::get_base_type()
+{
+  return gdk_drawable_get_type();
+}
+
+
+Drawable::Drawable()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Glib::Object(Glib::ConstructParams(drawable_class_.init()))
+{
+  }
+
+Glib::RefPtr<Drawable> Drawable::create()
+{
+  return Glib::RefPtr<Drawable>( new Drawable() );
+}
+void Drawable::get_size(int& width, int& height)
+{
+  gdk_drawable_get_size(gobj(), &width, &height);
+}
+
+int Drawable::get_depth() const
+{
+  return gdk_drawable_get_depth(const_cast<GdkDrawable*>(gobj()));
+}
+
+void Drawable::set_colormap(const Glib::RefPtr<Colormap>& colormap)
+{
+  gdk_drawable_set_colormap(gobj(), Glib::unwrap(colormap));
+}
+
+Glib::RefPtr<Colormap> Drawable::get_colormap()
+{
+
+  Glib::RefPtr<Colormap> retvalue = Glib::wrap(gdk_drawable_get_colormap(gobj()));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::RefPtr<Visual> Drawable::get_visual()
+{
+
+  Glib::RefPtr<Visual> retvalue = Glib::wrap(gdk_drawable_get_visual(gobj()));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+void Drawable::draw_point(const Glib::RefPtr<const GC>& gc, int x, int y)
+{
+  gdk_draw_point(gobj(), const_cast<GdkGC*>(Glib::unwrap<GC>(gc)), x, y);
+}
+
+void Drawable::draw_line(const Glib::RefPtr<const GC>& gc, int x1, int y1, int x2, int y2)
+{
+  gdk_draw_line(gobj(), const_cast<GdkGC*>(Glib::unwrap<GC>(gc)), x1, y1, x2, y2);
+}
+
+void Drawable::draw_rectangle(const Glib::RefPtr<const GC>& gc, bool filled, int x, int y, int width, int height)
+{
+  gdk_draw_rectangle(gobj(), const_cast<GdkGC*>(Glib::unwrap<GC>(gc)), static_cast<int>(filled), x, y, width, height);
+}
+
+void Drawable::draw_arc(const Glib::RefPtr<const GC>& gc, bool filled, int x, int y, int width, int height, int angle1, int angle2)
+{
+  gdk_draw_arc(gobj(), const_cast<GdkGC*>(Glib::unwrap<GC>(gc)), static_cast<int>(filled), x, y, width, height, angle1, angle2);
+}
+
+void Drawable::draw_drawable(const Glib::RefPtr<const GC>& gc, const Glib::RefPtr<const Drawable>& src, int xsrc, int ysrc, int xdest, int ydest, int width, int height)
+{
+  gdk_draw_drawable(gobj(), const_cast<GdkGC*>(Glib::unwrap<GC>(gc)), const_cast<GdkDrawable*>(Glib::unwrap<Drawable>(src)), xsrc, ysrc, xdest, ydest, width, height);
+}
+
+void Drawable::draw_image(const Glib::RefPtr<const GC>& gc, const Glib::RefPtr<const Image>& image, int xsrc, int ysrc, int xdest, int ydest, int width, int height)
+{
+  gdk_draw_image(gobj(), const_cast<GdkGC*>(Glib::unwrap<GC>(gc)), const_cast<GdkImage*>(Glib::unwrap<Image>(image)), xsrc, ysrc, xdest, ydest, width, height);
+}
+
+void Drawable::draw_segments(const Glib::RefPtr<const GC>& gc, GdkSegment* segs, int nsegs)
+{
+  gdk_draw_segments(gobj(), const_cast<GdkGC*>(Glib::unwrap<GC>(gc)), segs, nsegs);
+}
+
+void Drawable::draw_glyphs(const Glib::RefPtr<const GC>& gc, const Glib::RefPtr<const Pango::Font>& font, int x, int y, const Pango::GlyphString& glyphs)
+{
+  gdk_draw_glyphs(gobj(), const_cast<GdkGC*>(Glib::unwrap<GC>(gc)), const_cast<PangoFont*>(Glib::unwrap<Pango::Font>(font)), x, y, const_cast<PangoGlyphString*>(glyphs.gobj()));
+}
+
+void Drawable::draw_layout_line(const Glib::RefPtr<const GC>& gc, int x, int y, const Glib::RefPtr<const Pango::LayoutLine>& line)
+{
+  gdk_draw_layout_line(gobj(), const_cast<GdkGC*>(Glib::unwrap<GC>(gc)), x, y, const_cast<PangoLayoutLine*>(Glib::unwrap<Pango::LayoutLine>(line)));
+}
+
+void Drawable::draw_layout_line(const Glib::RefPtr<const GC>& gc, int x, int y, const Glib::RefPtr<const Pango::LayoutLine>& line, const Color& foreground, const Color& background)
+{
+  gdk_draw_layout_line_with_colors(gobj(), const_cast<GdkGC*>(Glib::unwrap<GC>(gc)), x, y, const_cast<PangoLayoutLine*>(Glib::unwrap<Pango::LayoutLine>(line)), (foreground).gobj(), (background).gobj());
+}
+
+void Drawable::draw_layout(const Glib::RefPtr<const GC>& gc, int x, int y, const Glib::RefPtr<const Pango::Layout>& layout)
+{
+  gdk_draw_layout(gobj(), const_cast<GdkGC*>(Glib::unwrap<GC>(gc)), x, y, const_cast<PangoLayout*>(Glib::unwrap<Pango::Layout>(layout)));
+}
+
+void Drawable::draw_layout(const Glib::RefPtr<const GC>& gc, int x, int y, const Glib::RefPtr<const Pango::Layout>& layout, const Color& foreground, const Color& background)
+{
+  gdk_draw_layout_with_colors(gobj(), const_cast<GdkGC*>(Glib::unwrap<GC>(gc)), x, y, const_cast<PangoLayout*>(Glib::unwrap<Pango::Layout>(layout)), (foreground).gobj(), (background).gobj());
+}
+
+void Drawable::draw_pixbuf(const Glib::RefPtr<const GC>& gc, const Glib::RefPtr<Pixbuf>& pixbuf, int src_x, int src_y, int dest_x, int dest_y, int width, int height, RgbDither dither, int x_dither, int y_dither)
+{
+  gdk_draw_pixbuf(gobj(), const_cast<GdkGC*>(Glib::unwrap<GC>(gc)), Glib::unwrap(pixbuf), src_x, src_y, dest_x, dest_y, width, height, ((GdkRgbDither)(dither)), x_dither, y_dither);
+}
+
+Glib::RefPtr<Image> Drawable::get_image(int x, int y, int width, int height) const
+{
+  return Glib::wrap(gdk_drawable_get_image(const_cast<GdkDrawable*>(gobj()), x, y, width, height));
+}
+
+Region Drawable::get_clip_region() const
+{
+  return Region(gdk_drawable_get_clip_region(const_cast<GdkDrawable*>(gobj())));
+}
+
+Region Drawable::get_visible_region() const
+{
+  return Region(gdk_drawable_get_visible_region(const_cast<GdkDrawable*>(gobj())));
+}
+
+void Drawable::draw_rgb_image(const Glib::RefPtr<const GC>& gc, int x, int y, int width, int height, RgbDither dith, const guchar* rgb_buf, int rowstride)
+{
+  gdk_draw_rgb_image(gobj(), const_cast<GdkGC*>(Glib::unwrap<GC>(gc)), x, y, width, height, ((GdkRgbDither)(dith)), const_cast<guchar*>(rgb_buf), rowstride);
+}
+
+void Drawable::draw_rgb_image_dithalign(const Glib::RefPtr<const GC>& gc, int x, int y, int width, int height, RgbDither dith, const guchar* rgb_buf, int rowstride, int xdith, int ydith)
+{
+  gdk_draw_rgb_image_dithalign(gobj(), const_cast<GdkGC*>(Glib::unwrap<GC>(gc)), x, y, width, height, ((GdkRgbDither)(dith)), const_cast<guchar*>(rgb_buf), rowstride, xdith, ydith);
+}
+
+void Drawable::draw_rgb_32_image(const Glib::RefPtr<const GC>& gc, int x, int y, int width, int height, RgbDither dith, const guchar* rgb_buf, int rowstride)
+{
+  gdk_draw_rgb_32_image(gobj(), const_cast<GdkGC*>(Glib::unwrap<GC>(gc)), x, y, width, height, ((GdkRgbDither)(dith)), const_cast<guchar*>(rgb_buf), rowstride);
+}
+
+void Drawable::draw_rgb_32_image_dithalign(const Glib::RefPtr<const GC>& gc, int x, int y, int width, int height, RgbDither dith, const guchar* buf, int rowstride, int xdith, int ydith)
+{
+  gdk_draw_rgb_32_image_dithalign(gobj(), const_cast<GdkGC*>(Glib::unwrap<GC>(gc)), x, y, width, height, ((GdkRgbDither)(dith)), const_cast<guchar*>(buf), rowstride, xdith, ydith);
+}
+
+void Drawable::draw_gray_image(const Glib::RefPtr<const GC>& gc, int x, int y, int width, int height, RgbDither dith, const guchar* rgb_buf, int rowstride)
+{
+  gdk_draw_gray_image(gobj(), const_cast<GdkGC*>(Glib::unwrap<GC>(gc)), x, y, width, height, ((GdkRgbDither)(dith)), const_cast<guchar*>(rgb_buf), rowstride);
+}
+
+void Drawable::draw_indexed_image(const Glib::RefPtr<const GC>& gc, int x, int y, int width, int height, RgbDither dith, const guchar* rgb_buf, int rowstride, const RgbCmap& cmap)
+{
+  gdk_draw_indexed_image(gobj(), const_cast<GdkGC*>(Glib::unwrap<GC>(gc)), x, y, width, height, ((GdkRgbDither)(dith)), const_cast<guchar*>(rgb_buf), rowstride, const_cast<GdkRgbCmap*>(cmap.gobj()));
+}
+
+Glib::RefPtr<Screen> Drawable::get_screen()
+{
+
+  Glib::RefPtr<Screen> retvalue = Glib::wrap(gdk_drawable_get_screen(gobj()));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::RefPtr<const Screen> Drawable::get_screen() const
+{
+
+  Glib::RefPtr<const Screen> retvalue = Glib::wrap(gdk_drawable_get_screen(const_cast<GdkDrawable*>(gobj())));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::RefPtr<Display> Drawable::get_display()
+{
+
+  Glib::RefPtr<Display> retvalue = Glib::wrap(gdk_drawable_get_display(gobj()));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::RefPtr<const Display> Drawable::get_display() const
+{
+
+  Glib::RefPtr<const Display> retvalue = Glib::wrap(gdk_drawable_get_display(const_cast<GdkDrawable*>(gobj())));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+
+} // namespace Gdk
+
+
diff --git a/libs/gtkmm2/gdk/gdkmm/drawable.h b/libs/gtkmm2/gdk/gdkmm/drawable.h
new file mode 100644
index 0000000000..6331e46ff2
--- /dev/null
+++ b/libs/gtkmm2/gdk/gdkmm/drawable.h
@@ -0,0 +1,601 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GDKMM_DRAWABLE_H
+#define _GDKMM_DRAWABLE_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* Copyright (C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gdk/gdkdrawable.h>
+#include <gdk/gdkrgb.h>
+#include <pangomm/font.h>
+#include <pangomm/layout.h>
+#include <pangomm/layoutline.h>
+#include <pangomm/glyphstring.h>
+#include <gdkmm/gc.h>
+#include <gdkmm/image.h>
+#include <gdkmm/color.h>
+#include <gdkmm/region.h>
+#include <gdkmm/rgbcmap.h>
+#include <gdkmm/types.h>
+//#include <gdkmm/pixbuf.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GdkDrawable GdkDrawable;
+typedef struct _GdkDrawableClass GdkDrawableClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gdk
+{ class Drawable_Class; } // namespace Gdk
+namespace Gdk
+{
+
+
+/** @addtogroup gdkmmEnums Enums and Flags */
+
+/**
+ * @ingroup gdkmmEnums
+ */
+enum RgbDither
+{
+  RGB_DITHER_NONE,
+  RGB_DITHER_NORMAL,
+  RGB_DITHER_MAX
+};
+
+} // namespace Gdk
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Gdk::RgbDither> : public Glib::Value_Enum<Gdk::RgbDither>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gdk
+{
+
+
+class GC;
+class Pixbuf;
+
+/** Drawing Primitives.
+ * Gdk::Drawable is the base class for all of the objects that accept drawing
+ * commands.  The available drawables include pixmaps, windows, and bitmaps.
+ * Drawable is abstract as there is no such type on the server side.
+ *
+ * To use a drawable, create a concrete Drawable of the type you wish to use
+ * and a Gdk::GC (graphics context) for that Drawable.  With the GC you can
+ * draw lines, text, arcs and such.
+ */
+
+class Drawable : public Glib::Object
+{
+  
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+public:
+  typedef Drawable CppObjectType;
+  typedef Drawable_Class CppClassType;
+  typedef GdkDrawable BaseObjectType;
+  typedef GdkDrawableClass BaseClassType;
+
+private:  friend class Drawable_Class;
+  static CppClassType drawable_class_;
+
+private:
+  // noncopyable
+  Drawable(const Drawable&);
+  Drawable& operator=(const Drawable&);
+
+protected:
+  explicit Drawable(const Glib::ConstructParams& construct_params);
+  explicit Drawable(GdkDrawable* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+  virtual ~Drawable();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GObject.
+  GdkDrawable*       gobj()       { return reinterpret_cast<GdkDrawable*>(gobject_); }
+
+  ///Provides access to the underlying C GObject.
+  const GdkDrawable* gobj() const { return reinterpret_cast<GdkDrawable*>(gobject_); }
+
+  ///Provides access to the underlying C instance. The caller is responsible for unrefing it. Use when directly setting fields in structs.
+  GdkDrawable* gobj_copy();
+
+private:
+
+  
+protected:
+  Drawable();
+
+public:
+  
+  static Glib::RefPtr<Drawable> create();
+
+
+  /** Fills * @a width  and * @a height  with the size of @a drawable .
+   *  @a width  or @a height  can be <tt>0</tt> if you only want the other one.
+   * 
+   * On the X11 platform, if @a drawable  is a Gdk::Window, the returned
+   * size is the size reported in the most-recently-processed configure
+   * event, rather than the current size on the X server.
+   * @param width Location to store drawable's width, or <tt>0</tt>.
+   * @param height Location to store drawable's height, or <tt>0</tt>.
+   */
+  void get_size(int& width, int& height);
+  
+  /** Obtains the bit depth of the drawable, that is, the number of bits
+   * that make up a pixel in the drawable's visual. Examples are 8 bits
+   * per pixel, 24 bits per pixel, etc.
+   * @return Number of bits per pixel.
+   */
+  int get_depth() const;
+
+  
+  /** Sets the colormap associated with @a drawable . Normally this will
+   * happen automatically when the drawable is created; you only need to
+   * use this function if the drawable-creating function did not have a
+   * way to determine the colormap, and you then use drawable operations
+   * that require a colormap. The colormap for all drawables and
+   * graphics contexts you intend to use together should match. i.e.
+   * when using a Gdk::GC to draw to a drawable, or copying one drawable
+   * to another, the colormaps should match.
+   * @param colormap A Gdk::Colormap.
+   */
+  void set_colormap(const Glib::RefPtr<Colormap>& colormap);
+  
+  /** Gets the colormap for @a drawable , if one is set; returns
+   * <tt>0</tt> otherwise.
+   * @return The colormap, or <tt>0</tt>.
+   */
+  Glib::RefPtr<Colormap> get_colormap();
+  
+  /** Gets the Gdk::Visual describing the pixel format of @a drawable .
+   * @return A Gdk::Visual.
+   */
+  Glib::RefPtr<Visual> get_visual();
+
+  
+  /** Draws a point, using the foreground color and other attributes of 
+   * the Gdk::GC.
+   * @param gc A Gdk::GC.
+   * @param x The x coordinate of the point.
+   * @param y The y coordinate of the point.
+   */
+  void draw_point(const Glib::RefPtr<const GC>& gc, int x, int y);
+  void draw_points(const Glib::RefPtr<const GC>& gc, const Glib::ArrayHandle<Point>& points);
+
+  
+  /** Draws a line, using the foreground color and other attributes of 
+   * the Gdk::GC.
+   * @param gc A Gdk::GC.
+   * @param x1 The x coordinate of the start point.
+   * @param y1 The y coordinate of the start point.
+   * @param x2 The x coordinate of the end point.
+   * @param y2 The y coordinate of the end point.
+   */
+  void draw_line(const Glib::RefPtr<const GC>& gc, int x1, int y1, int x2, int y2);
+  void draw_lines(const Glib::RefPtr<const GC>& gc, const Glib::ArrayHandle<Point>& points);
+
+  
+  /** Draws a rectangular outline or filled rectangle, using the foreground color
+   * and other attributes of the Gdk::GC.
+   * 
+   * A rectangle drawn filled is 1 pixel smaller in both dimensions than a 
+   * rectangle outlined. Calling 
+   * <tt>gdk_draw_rectangle (window, gc, <tt>true</tt>, 0, 0, 20, 20)</tt> 
+   * results in a filled rectangle 20 pixels wide and 20 pixels high. Calling
+   * <tt>gdk_draw_rectangle (window, gc, <tt>false</tt>, 0, 0, 20, 20)</tt> 
+   * results in an outlined rectangle with corners at (0, 0), (0, 20), (20, 20),
+   * and (20, 0), which makes it 21 pixels wide and 21 pixels high.
+   * @param gc A Gdk::GC.
+   * @param filled <tt>true</tt> if the rectangle should be filled.
+   * @param x The x coordinate of the left edge of the rectangle.
+   * @param y The y coordinate of the top edge of the rectangle.
+   * @param width The width of the rectangle.
+   * @param height The height of the rectangle.
+   */
+  void draw_rectangle(const Glib::RefPtr<const GC>& gc, bool filled, int x, int y, int width, int height);
+  
+  /** Draws an arc or a filled 'pie slice'. The arc is defined by the bounding
+   * rectangle of the entire ellipse, and the start and end angles of the part 
+   * of the ellipse to be drawn.
+   * @param gc A Gdk::GC.
+   * @param filled <tt>true</tt> if the arc should be filled, producing a 'pie slice'.
+   * @param x The x coordinate of the left edge of the bounding rectangle.
+   * @param y The y coordinate of the top edge of the bounding rectangle.
+   * @param width The width of the bounding rectangle.
+   * @param height The height of the bounding rectangle.
+   * @param angle1 The start angle of the arc, relative to the 3 o'clock position,
+   * counter-clockwise, in 1/64ths of a degree.
+   * @param angle2 The end angle of the arc, relative to @a angle1 , in 1/64ths 
+   * of a degree.
+   */
+  void draw_arc(const Glib::RefPtr<const GC>& gc, bool filled, int x, int y, int width, int height, int angle1, int angle2);
+  void draw_polygon(const Glib::RefPtr<const GC>& gc, bool filled, const Glib::ArrayHandle<Point>& points);
+
+  
+  /** Copies the @a width  x @a height  region of @a src  at coordinates ( @a xsrc ,
+   *  @a ysrc ) to coordinates ( @a xdest , @a ydest ) in @a drawable .
+   *  @a width  and/or @a height  may be given as -1, in which case the entire
+   *  @a src  drawable will be copied.
+   * 
+   * Most fields in @a gc  are not used for this operation, but notably the
+   * clip mask or clip region will be honored.
+   * 
+   * The source and destination drawables must have the same visual and
+   * colormap, or errors will result. (On X11, failure to match
+   * visual/colormap results in a BadMatch error from the X server.)
+   * A common cause of this problem is an attempt to draw a bitmap to
+   * a color drawable. The way to draw a bitmap is to set the
+   * bitmap as a clip mask on your Gdk::GC, then use gdk_draw_rectangle()
+   * to draw a rectangle clipped to the bitmap.
+   * @param gc A Gdk::GC sharing the drawable's visual and colormap.
+   * @param src The source Gdk::Drawable, which may be the same as @a drawable .
+   * @param xsrc X position in @a src  of rectangle to draw.
+   * @param ysrc Y position in @a src  of rectangle to draw.
+   * @param xdest X position in @a drawable  where the rectangle should be drawn.
+   * @param ydest Y position in @a drawable  where the rectangle should be drawn.
+   * @param width Width of rectangle to draw, or -1 for entire @a src  width.
+   * @param height Height of rectangle to draw, or -1 for entire @a src  height.
+   */
+  void draw_drawable(const Glib::RefPtr<const GC>& gc, const Glib::RefPtr<const Drawable>& src, int xsrc, int ysrc, int xdest, int ydest, int width = -1, int height = -1);
+  
+  /** Draws a Gdk::Image onto a drawable.
+   * The depth of the Gdk::Image must match the depth of the Gdk::Drawable.
+   * @param gc A Gdk::GC.
+   * @param image The Gdk::Image to draw.
+   * @param xsrc The left edge of the source rectangle within @a image .
+   * @param ysrc The top of the source rectangle within @a image .
+   * @param xdest The x coordinate of the destination within @a drawable .
+   * @param ydest The y coordinate of the destination within @a drawable .
+   * @param width The width of the area to be copied, or -1 to make the area 
+   * extend to the right edge of @a image .
+   * @param height The height of the area to be copied, or -1 to make the area 
+   * extend to the bottom edge of @a image .
+   */
+  void draw_image(const Glib::RefPtr<const GC>& gc, const Glib::RefPtr<const Image>& image, int xsrc, int ysrc, int xdest, int ydest, int width = -1, int height = -1);
+
+  //segs is an array, and this function will be used so little that it doesn't seem worth wrapping it to use a container of C++ types.
+  
+  /** Draws a number of unconnected lines.
+   * @param gc A Gdk::GC.
+   * @param segs An array of Gdk::Segment structures specifying the start and 
+   * end points of the lines to be drawn.
+   * @param nsegs The number of line segments to draw, i.e. the size of the 
+   *  @a segs  array.
+   */
+  void draw_segments(const Glib::RefPtr<const GC>& gc, GdkSegment* segs, int nsegs); // TODO
+
+  //glyphs is not an array. I went down to pango_xft_render in pango and saw that PangoGlyphString here is not an array. -Bryan
+  
+  /** This is a low-level function; 99% of text rendering should be done
+   * using gdk_draw_layout() instead.
+   * 
+   * A glyph is a single image in a font. This function draws a sequence of
+   * glyphs.  To obtain a sequence of glyphs you have to understand a
+   * lot about internationalized text handling, which you don't want to
+   * understand; thus, use gdk_draw_layout() instead of this function,
+   * gdk_draw_layout() handles the details.
+   * @param gc A Gdk::GC.
+   * @param font Font to be used.
+   * @param x X coordinate of baseline origin.
+   * @param y Y coordinate of baseline origin.
+   * @param glyphs The glyph string to draw.
+   */
+  void draw_glyphs(const Glib::RefPtr<const GC>& gc, const Glib::RefPtr<const Pango::Font>& font, int x, int y, const Pango::GlyphString& glyphs);
+
+  
+  /** Render a Pango::LayoutLine onto an GDK drawable
+   * 
+   * If the layout's Pango::Context has a transformation matrix set, then
+   *  @a x  and @a y  specify the position of the left edge of the baseline
+   * (left is in before-tranform user coordinates) in after-transform
+   * device coordinates.
+   * @param gc Base graphics to use.
+   * @param x The x position of start of string (in pixels).
+   * @param y The y position of baseline (in pixels).
+   * @param line A Pango::LayoutLine.
+   */
+  void draw_layout_line(const Glib::RefPtr<const GC>& gc, int x, int y, const Glib::RefPtr<const Pango::LayoutLine>& line);
+  
+  /** Render a Pango::LayoutLine onto a Gdk::Drawable, overriding the
+   * layout's normal colors with @a foreground  and/or @a background .
+   *  @a foreground  and @a background  need not be allocated.
+   * 
+   * If the layout's Pango::Context has a transformation matrix set, then
+   *  @a x  and @a y  specify the position of the left edge of the baseline
+   * (left is in before-tranform user coordinates) in after-transform
+   * device coordinates.
+   * @param gc Base graphics to use.
+   * @param x The x position of start of string (in pixels).
+   * @param y The y position of baseline (in pixels).
+   * @param line A Pango::LayoutLine.
+   * @param foreground Foreground override color, or <tt>0</tt> for none.
+   * @param background Background override color, or <tt>0</tt> for none.
+   */
+  void draw_layout_line(const Glib::RefPtr<const GC>& gc, int x, int y, const Glib::RefPtr<const Pango::LayoutLine>& line, const Color& foreground, const Color& background);
+
+  
+  /** Render a Pango::Layout onto a GDK drawable
+   * 
+   * If the layout's Pango::Context has a transformation matrix set, then
+   *  @a x  and @a y  specify the position of the top left corner of the
+   * bounding box (in device space) of the transformed layout.
+   * 
+   * If you're using GTK+, the usual way to obtain a Pango::Layout
+   * is gtk_widget_create_pango_layout().
+   * @param gc Base graphics context to use.
+   * @param x The X position of the left of the layout (in pixels).
+   * @param y The Y position of the top of the layout (in pixels).
+   * @param layout A Pango::Layout.
+   */
+  void draw_layout(const Glib::RefPtr<const GC>& gc, int x, int y, const Glib::RefPtr<const Pango::Layout>& layout);
+  
+  /** Render a Pango::Layout onto a Gdk::Drawable, overriding the
+   * layout's normal colors with @a foreground  and/or @a background .
+   *  @a foreground  and @a background  need not be allocated.
+   * 
+   * If the layout's Pango::Context has a transformation matrix set, then
+   *  @a x  and @a y  specify the position of the top left corner of the
+   * bounding box (in device space) of the transformed layout.
+   * 
+   * If you're using GTK+, the ususal way to obtain a Pango::Layout
+   * is gtk_widget_create_pango_layout().
+   * @param gc Base graphics context to use.
+   * @param x The X position of the left of the layout (in pixels).
+   * @param y The Y position of the top of the layout (in pixels).
+   * @param layout A Pango::Layout.
+   * @param foreground Foreground override color, or <tt>0</tt> for none.
+   * @param background Background override color, or <tt>0</tt> for none.
+   */
+  void draw_layout(const Glib::RefPtr<const GC>& gc, int x, int y, const Glib::RefPtr<const Pango::Layout>& layout, const Color& foreground, const Color& background);
+
+  
+  /** Renders a rectangular portion of a pixbuf to a drawable.  The destination
+   * drawable must have a colormap. All windows have a colormap, however, pixmaps
+   * only have colormap by default if they were created with a non-<tt>0</tt> window 
+   * argument. Otherwise a colormap must be set on them with 
+   * Gdk::Drawable::set_colormap().
+   * 
+   * On older X servers, rendering pixbufs with an alpha channel involves round 
+   * trips to the X server, and may be somewhat slow.
+   * 
+   * The clip mask of @a gc  is ignored, but clip rectangles and clip regions work
+   * fine.
+   * 
+   * Since: 2.2
+   * @param gc A Gdk::GC, used for clipping, or <tt>0</tt>.
+   * @param pixbuf A Gdk::Pixbuf.
+   * @param src_x Source X coordinate within pixbuf.
+   * @param src_y Source Y coordinates within pixbuf.
+   * @param dest_x Destination X coordinate within drawable.
+   * @param dest_y Destination Y coordinate within drawable.
+   * @param width Width of region to render, in pixels, or -1 to use pixbuf width.
+   * @param height Height of region to render, in pixels, or -1 to use pixbuf height.
+   * @param dither Dithering mode for Gdk::RGB.
+   * @param x_dither X offset for dither.
+   * @param y_dither Y offset for dither.
+   */
+  void draw_pixbuf(const Glib::RefPtr<const GC>& gc, const Glib::RefPtr<Pixbuf>& pixbuf,
+    int src_x, int src_y, int dest_x, int dest_y,
+    int width, int height,
+    RgbDither dither, int x_dither, int y_dither);
+
+  // Note: This has no 'refreturn' because get_image() returns a newly created Image object.
+  
+  /** A Gdk::Image stores client-side image data (pixels). In contrast,
+   * Gdk::Pixmap and Gdk::Window are server-side
+   * objects. get_image() obtains the pixels from a
+   * server-side drawable as a client-side Gdk::Image.  The format of a
+   * Gdk::Image depends on the Gdk::Visual of the current display, which
+   * makes manipulating Gdk::Image extremely difficult; therefore, in
+   * most cases you should use Gdk::Pixbuf::get_from_drawable() instead of
+   * this lower-level function. A Gdk::Pixbuf contains image data in a
+   * canonicalized RGB format, rather than a display-dependent format.
+   * Of course, there's a convenience vs. speed tradeoff here, so you'll
+   * want to think about what makes sense for your application.
+   * 
+   *  @a x , @a y , @a width , and @a height  define the region of @a drawable  to
+   * obtain as an image.
+   * 
+   * You would usually copy image data to the client side if you intend
+   * to examine the values of individual pixels, for example to darken
+   * an image or add a red tint. It would be prohibitively slow to
+   * make a round-trip request to the windowing system for each pixel,
+   * so instead you get all of them at once, modify them, then copy
+   * them all back at once.
+   * 
+   * If the X server or other windowing system backend is on the local
+   * machine, this function may use shared memory to avoid copying
+   * the image data.
+   * 
+   * If the source drawable is a Gdk::Window and partially offscreen
+   * or obscured, then the obscured portions of the returned image
+   * will contain undefined data.
+   * @param x X coordinate on @a drawable .
+   * @param y Y coordinate on @a drawable .
+   * @param width Width of region to get.
+   * @param height Height or region to get.
+   * @return A Gdk::Image containing the contents of @a drawable .
+   */
+  Glib::RefPtr<Image> get_image(int x, int y, int width, int height) const;
+
+  // gdk_drawable_copy_to_image() returns a new GdkImage when the image parameter is NULL, but that seems to be much the
+  // same as gdk_drawable_get_image().
+  void copy_to_image(const Glib::RefPtr<Image>& image, int src_x, int src_y, int dest_x, int dest_y, int width, int height) const;
+  
+  
+  /** Computes the region of a drawable that potentially can be written
+   * to by drawing primitives. This region will not take into account
+   * the clip region for the GC, and may also not take into account
+   * other factors such as if the window is obscured by other windows,
+   * but no area outside of this region will be affected by drawing
+   * primitives.
+   * @return A Gdk::Region. This must be freed with gdk_region_destroy()
+   * when you are done.
+   */
+  Region get_clip_region() const;
+  
+  /** Computes the region of a drawable that is potentially visible.
+   * This does not necessarily take into account if the window is
+   * obscured by other windows, but no area outside of this region
+   * is visible.
+   * @return A Gdk::Region. This must be freed with gdk_region_destroy()
+   * when you are done.
+   */
+  Region get_visible_region() const;
+
+
+  // **** RGB stuff ****
+
+  
+  void draw_rgb_image(
+                   const Glib::RefPtr<const GC>& gc,
+                   int x, int y, int width, int height,
+                   RgbDither dith, const guchar* rgb_buf, int rowstride);
+
+  
+  void draw_rgb_image_dithalign(
+                   const Glib::RefPtr<const GC>& gc,
+                   int x, int y, int width, int height,
+                   RgbDither dith, const guchar* rgb_buf, int rowstride,
+                   int xdith, int ydith);
+
+  
+  void draw_rgb_32_image(
+                   const Glib::RefPtr<const GC>& gc,
+                   int x, int y, int width, int height,
+                   RgbDither dith, const guchar* rgb_buf, int rowstride);
+
+  
+  /** Like gdk_draw_rgb_32_image(), but allows you to specify the dither
+   * offsets. See gdk_draw_rgb_image_dithalign() for more details.
+   * @param gc A Gdk::GC.
+   * @param x X coordinate on @a drawable  where image should go.
+   * @param y Y coordinate on @a drawable  where image should go.
+   * @param width Width of area of image to draw.
+   * @param height Height of area of image to draw.
+   * @param dith Dithering mode.
+   * @param buf RGB image data.
+   * @param rowstride Rowstride of RGB image data.
+   * @param xdith X dither offset.
+   * @param ydith Y dither offset.
+   */
+  void draw_rgb_32_image_dithalign(
+                   const Glib::RefPtr<const GC>& gc,
+                   int x, int y, int width, int height,
+                   RgbDither dith, const guchar* buf, int rowstride,
+                   int xdith, int ydith);
+
+  
+  void draw_gray_image(
+                   const Glib::RefPtr<const GC>& gc,
+                   int x, int y, int width, int height,
+                   RgbDither dith, const guchar* rgb_buf, int rowstride);
+
+  
+  void draw_indexed_image(
+                   const Glib::RefPtr<const GC>& gc,
+                   int x, int y, int width, int height,
+                   RgbDither dith, const guchar* rgb_buf, int rowstride,
+                   const RgbCmap& cmap);
+
+  
+  /** Gets the Gdk::Screen associated with a Gdk::Drawable.
+   * @return The Gdk::Screen associated with @a drawable 
+   * 
+   * Since: 2.2.
+   */
+  Glib::RefPtr<Screen> get_screen();
+  
+  /** Gets the Gdk::Screen associated with a Gdk::Drawable.
+   * @return The Gdk::Screen associated with @a drawable 
+   * 
+   * Since: 2.2.
+   */
+  Glib::RefPtr<const Screen> get_screen() const;
+
+  
+  /** Gets the Gdk::Display associated with a Gdk::Drawable.
+   * @return The Gdk::Display associated with @a drawable 
+   * 
+   * Since: 2.2.
+   */
+  Glib::RefPtr<Display> get_display();
+  
+  /** Gets the Gdk::Display associated with a Gdk::Drawable.
+   * @return The Gdk::Display associated with @a drawable 
+   * 
+   * Since: 2.2.
+   */
+  Glib::RefPtr<const Display> get_display() const;
+
+
+public:
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+};
+
+} // namespace Gdk
+
+
+namespace Glib
+{
+  /** @relates Gdk::Drawable
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Glib::RefPtr<Gdk::Drawable> wrap(GdkDrawable* object, bool take_copy = false);
+}
+
+
+#endif /* _GDKMM_DRAWABLE_H */
+
diff --git a/libs/gtkmm2/gdk/gdkmm/event.cc b/libs/gtkmm2/gdk/gdkmm/event.cc
new file mode 100644
index 0000000000..e9a71e918c
--- /dev/null
+++ b/libs/gtkmm2/gdk/gdkmm/event.cc
@@ -0,0 +1,223 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gdkmm/event.h>
+#include <gdkmm/private/event_p.h>
+
+#include <gdk/gdkenumtypes.h>
+// -*- c++ -*-
+/* $Id$ */
+
+/*
+ *
+ * Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gdkmm/display.h>
+
+namespace Gdk
+{
+
+bool Event::send_client_message(const Glib::RefPtr<Display>& display, NativeWindow winid)
+{
+  return gdk_event_send_client_message_for_display(display->gobj(), gobj(), winid);
+}
+
+} //namespace Gdk
+
+
+namespace
+{
+} // anonymous namespace
+
+// static
+GType Glib::Value<Gdk::EventType>::value_type()
+{
+  return gdk_event_type_get_type();
+}
+
+// static
+GType Glib::Value<Gdk::ExtensionMode>::value_type()
+{
+  return gdk_extension_mode_get_type();
+}
+
+// static
+GType Glib::Value<Gdk::AxisUse>::value_type()
+{
+  return gdk_axis_use_get_type();
+}
+
+
+namespace Glib
+{
+
+Gdk::Event wrap(GdkEvent* object, bool take_copy)
+{
+  return Gdk::Event(object, take_copy);
+}
+
+} // namespace Glib
+
+
+namespace Gdk
+{
+
+
+// static
+GType Event::get_type()
+{
+  return gdk_event_get_type();
+}
+
+Event::Event()
+:
+  gobject_ (0) // Allows creation of invalid wrapper, e.g. for output arguments to methods.
+{}
+
+Event::Event(const Event& other)
+:
+  gobject_ ((other.gobject_) ? gdk_event_copy(other.gobject_) : 0)
+{}
+
+Event::Event(GdkEvent* gobject, bool make_a_copy)
+:
+  // For BoxedType wrappers, make_a_copy is true by default.  The static
+  // BoxedType wrappers must always take a copy, thus make_a_copy = true
+  // ensures identical behaviour if the default argument is used.
+  gobject_ ((make_a_copy && gobject) ? gdk_event_copy(gobject) : gobject)
+{}
+
+Event& Event::operator=(const Event& other)
+{
+  Event temp (other);
+  swap(temp);
+  return *this;
+}
+
+Event::~Event()
+{
+  if(gobject_)
+    gdk_event_free(gobject_);
+}
+
+void Event::swap(Event& other)
+{
+  GdkEvent *const temp = gobject_;
+  gobject_ = other.gobject_;
+  other.gobject_ = temp;
+}
+
+GdkEvent* Event::gobj_copy() const
+{
+  return gdk_event_copy(gobject_);
+}
+
+
+Event Event::get()
+{
+  return Event(gdk_event_get());
+}
+
+Event Event::peek()
+{
+  return Event(gdk_event_peek());
+}
+
+Event Event::get_graphics_expose(const Glib::RefPtr<Window>& window)
+{
+  return Event(gdk_event_get_graphics_expose(Glib::unwrap(window)));
+}
+
+void Event::put()
+{
+  gdk_event_put(gobj());
+}
+
+bool Event::events_pending()
+{
+  return gdk_events_pending();
+}
+
+guint32 Event::get_time() const
+{
+  return gdk_event_get_time(const_cast<GdkEvent*>(gobj()));
+}
+
+bool Event::get_state(ModifierType& state) const
+{
+  return gdk_event_get_state(const_cast<GdkEvent*>(gobj()), ((GdkModifierType*) &(state)));
+}
+
+bool Event::get_coords(double& x_win, double& y_win) const
+{
+  return gdk_event_get_coords(const_cast<GdkEvent*>(gobj()), &(x_win), &(y_win));
+}
+
+bool Event::get_root_coords(double& x_root, double& y_root) const
+{
+  return gdk_event_get_root_coords(const_cast<GdkEvent*>(gobj()), &(x_root), &(y_root));
+}
+
+bool Event::get_axis(AxisUse axis_use, double& value) const
+{
+  return gdk_event_get_axis(const_cast<GdkEvent*>(gobj()), ((GdkAxisUse)(axis_use)), &(value));
+}
+
+void Event::set_show_events(bool show_events)
+{
+  gdk_set_show_events(static_cast<int>(show_events));
+}
+
+bool Event::get_show_events()
+{
+  return gdk_get_show_events();
+}
+
+void Event::set_screen(const Glib::RefPtr<Screen>& screen)
+{
+  gdk_event_set_screen(gobj(), Glib::unwrap(screen));
+}
+
+Glib::RefPtr<Screen> Event::get_screen()
+{
+
+  Glib::RefPtr<Screen> retvalue = Glib::wrap(gdk_event_get_screen(gobj()));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::RefPtr<const Screen> Event::get_screen() const
+{
+
+  Glib::RefPtr<const Screen> retvalue = Glib::wrap(gdk_event_get_screen(const_cast<GdkEvent*>(gobj())));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+bool Event::send_client_message(NativeWindow winid)
+{
+  return gdk_event_send_client_message(gobj(), (GdkNativeWindow)(winid));
+}
+
+
+} // namespace Gdk
+
+
diff --git a/libs/gtkmm2/gdk/gdkmm/event.h b/libs/gtkmm2/gdk/gdkmm/event.h
new file mode 100644
index 0000000000..8d1095d46b
--- /dev/null
+++ b/libs/gtkmm2/gdk/gdkmm/event.h
@@ -0,0 +1,398 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GDKMM_EVENT_H
+#define _GDKMM_EVENT_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* Copyright (C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+
+#include <gdkmm/window.h>
+#include <gdkmm/screen.h>
+
+/* Shadow DELETE macro (from winnt.h).
+ */
+#if defined(DELETE) && !defined(GTKMM_MACRO_SHADOW_DELETE)
+enum { GTKMM_MACRO_DEFINITION_DELETE = DELETE };
+#undef DELETE
+enum { DELETE = GTKMM_MACRO_DEFINITION_DELETE };
+#define DELETE DELETE
+#define GTKMM_MACRO_SHADOW_DELETE 1
+#endif
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+extern "C" { typedef union _GdkEvent GdkEvent; }
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gdk
+{
+
+/** @addtogroup gdkmmEnums Enums and Flags */
+
+/**
+ * @ingroup gdkmmEnums
+ */
+enum EventType
+{
+  NOTHING = -1,
+  DELETE,
+  DESTROY,
+  EXPOSE,
+  MOTION_NOTIFY,
+  BUTTON_PRESS,
+  DOUBLE_BUTTON_PRESS,
+  TRIPLE_BUTTON_PRESS,
+  BUTTON_RELEASE,
+  KEY_PRESS,
+  KEY_RELEASE,
+  ENTER_NOTIFY,
+  LEAVE_NOTIFY,
+  FOCUS_CHANGE,
+  CONFIGURE,
+  MAP,
+  UNMAP,
+  PROPERTY_NOTIFY,
+  SELECTION_CLEAR,
+  SELECTION_REQUEST,
+  SELECTION_NOTIFY,
+  PROXIMITY_IN,
+  PROXIMITY_OUT,
+  DRAG_ENTER,
+  DRAG_LEAVE,
+  DRAG_MOTION,
+  DRAG_STATUS,
+  DROP_START,
+  DROP_FINISHED,
+  CLIENT_EVENT,
+  VISIBILITY_NOTIFY,
+  NO_EXPOSE,
+  SCROLL,
+  WINDOW_STATE,
+  SETTING,
+  OWNER_CHANGE
+};
+
+} // namespace Gdk
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Gdk::EventType> : public Glib::Value_Enum<Gdk::EventType>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gdk
+{
+
+
+/**
+ * @ingroup gdkmmEnums
+ */
+enum ExtensionMode
+{
+  EXTENSION_EVENTS_NONE,
+  EXTENSION_EVENTS_ALL,
+  EXTENSION_EVENTS_CURSOR
+};
+
+} // namespace Gdk
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Gdk::ExtensionMode> : public Glib::Value_Enum<Gdk::ExtensionMode>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gdk
+{
+
+/**
+ * @ingroup gdkmmEnums
+ */
+enum AxisUse
+{
+  AXIS_IGNORE,
+  AXIS_X,
+  AXIS_Y,
+  AXIS_PRESSURE,
+  AXIS_XTILT,
+  AXIS_YTILT,
+  AXIS_WHEEL,
+  AXIS_LAST
+};
+
+} // namespace Gdk
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Gdk::AxisUse> : public Glib::Value_Enum<Gdk::AxisUse>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gdk
+{
+
+
+//TODO: Actually use this class instead of GdkEvent?
+class Event
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Event CppObjectType;
+  typedef GdkEvent BaseObjectType;
+
+  static GType get_type() G_GNUC_CONST;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  Event();
+
+  explicit Event(GdkEvent* gobject, bool make_a_copy = true);
+
+  Event(const Event& other);
+  Event& operator=(const Event& other);
+
+  ~Event();
+
+  void swap(Event& other);
+
+  ///Provides access to the underlying C instance.
+  GdkEvent*       gobj()       { return gobject_; }
+
+  ///Provides access to the underlying C instance.
+  const GdkEvent* gobj() const { return gobject_; }
+
+  ///Provides access to the underlying C instance. The caller is responsible for freeing it. Use when directly setting fields in structs.
+  GdkEvent* gobj_copy() const;
+
+protected:
+  GdkEvent* gobject_;
+
+private:
+
+  
+public:
+
+  
+  /** Checks all open displays for a Gdk::Event to process,to be processed
+   * on, fetching events from the windowing system if necessary.
+   * See Gdk::Display::get_event().
+   * @return The next Gdk::Event to be processed, or <tt>0</tt> if no events
+   * are pending. The returned Gdk::Event should be freed with gdk_event_free().
+   */
+  static Event get();
+  
+  /** If there is an event waiting in the event queue of some open
+   * display, returns a copy of it. See Gdk::Display::peek_event().
+   * @return A copy of the first Gdk::Event on some event queue, or <tt>0</tt> if no
+   * events are in any queues. The returned Gdk::Event should be freed with
+   * gdk_event_free().
+   */
+  static Event peek();
+  
+  /** Waits for a GraphicsExpose or NoExpose event from the X server.
+   * This is used in the Gtk::Text and Gtk::CList widgets in GTK+ to make sure any
+   * GraphicsExpose events are handled before the widget is scrolled.
+   * @param window The Gdk::Window to wait for the events for.
+   * @return A Gdk::EventExpose if a GraphicsExpose was received, or <tt>0</tt> if a
+   * NoExpose event was received.
+   */
+  static Event get_graphics_expose(const Glib::RefPtr<Window>& window);
+  
+  /** Appends a copy of the given event onto the front of the event
+   * queue for event->any.window's display, or the default event
+   * queue if event->any.window is <tt>0</tt>. See Gdk::Display::put_event().
+   */
+  void put();
+
+  
+  /** Checks if any events are ready to be processed for any display.
+   * @return <tt>true</tt> if any events are pending.
+   */
+  static bool events_pending();
+
+  
+  /** Returns the time stamp from @a event , if there is one; otherwise
+   * returns Gdk::CURRENT_TIME. If @a event  is <tt>0</tt>, returns Gdk::CURRENT_TIME.
+   * @return Time stamp field from @a event .
+   */
+  guint32 get_time() const;
+  
+  /** If the event contains a "state" field, puts that field in @a state . Otherwise
+   * stores an empty state (0). Returns <tt>true</tt> if there was a state field
+   * in the event. @a event  may be <tt>0</tt>, in which case it's treated
+   * as if the event had no state field.
+   * @param state Return location for state.
+   * @return <tt>true</tt> if there was a state field in the event.
+   */
+  bool get_state(ModifierType& state) const;
+  
+  /** Extract the event window relative x/y coordinates from an event.
+   * @param x_win Location to put event window x coordinate.
+   * @param y_win Location to put event window y coordinate.
+   * @return <tt>true</tt> if the event delivered event window coordinates.
+   */
+  bool get_coords(double& x_win, double& y_win) const;
+  
+  /** Extract the root window relative x/y coordinates from an event.
+   * @param x_root Location to put root window x coordinate.
+   * @param y_root Location to put root window y coordinate.
+   * @return <tt>true</tt> if the event delivered root window coordinates.
+   */
+  bool get_root_coords(double& x_root, double& y_root) const;
+  
+  /** Extract the axis value for a particular axis use from
+   * an event structure.
+   * @param axis_use The axis use to look for.
+   * @param value Location to store the value found.
+   * @return <tt>true</tt> if the specified axis was found, otherwise <tt>false</tt>.
+   */
+  bool get_axis(AxisUse axis_use, double& value) const;
+  //_WRAP_METHOD(void	gdk_event_handler_set(GdkEventFunc func, gpointer data, GDestroyNotify  notify), gdk_event_handler_set)
+
+  
+  /** Sets whether a trace of received events is output.
+   * Note that GTK+ must be compiled with debugging (that is,
+   * configured using the &lt;option&gt;--enable-debug&lt;/option&gt; option)
+   * to use this option.
+   * @param show_events <tt>true</tt> to output event debugging information.
+   */
+  static void set_show_events(bool show_events);
+  
+  /** Gets whether event debugging output is enabled.
+   * @return <tt>true</tt> if event debugging output is enabled.
+   */
+  static bool get_show_events();
+
+  
+  /** Sets the screen for @a event  to @a screen . The event must
+   * have been allocated by GTK+, for instance, by
+   * gdk_event_copy().
+   * 
+   * Since: 2.2
+   * @param screen A Gdk::Screen.
+   */
+  void set_screen(const Glib::RefPtr<Screen>& screen);
+  
+  /** Returns the screen for the event. The screen is
+   * typically the screen for <tt>event->any.window</tt>, but
+   * for events such as mouse events, it is the screen
+   * where the the pointer was when the event occurs -
+   * that is, the screen which has the root window 
+   * to which <tt>event->motion.x_root</tt> and
+   * <tt>event->motion.y_root</tt> are relative.
+   * @return The screen for the event
+   * 
+   * Since: 2.2.
+   */
+  Glib::RefPtr<Screen> get_screen();
+  
+  /** Returns the screen for the event. The screen is
+   * typically the screen for <tt>event->any.window</tt>, but
+   * for events such as mouse events, it is the screen
+   * where the the pointer was when the event occurs -
+   * that is, the screen which has the root window 
+   * to which <tt>event->motion.x_root</tt> and
+   * <tt>event->motion.y_root</tt> are relative.
+   * @return The screen for the event
+   * 
+   * Since: 2.2.
+   */
+  Glib::RefPtr<const Screen> get_screen() const;
+
+  
+  /** Sends an X ClientMessage event to a given window (which must be
+   * on the default Gdk::Display.)
+   * This could be used for communicating between different applications,
+   * though the amount of data is limited to 20 bytes.
+   * @param winid The window to send the X ClientMessage event to.
+   * @return Non-zero on success.
+   */
+  bool send_client_message(NativeWindow winid);
+  bool send_client_message(const Glib::RefPtr<Display>& display, NativeWindow winid);
+  
+
+};
+
+} // namespace Gdk
+
+
+namespace Gdk
+{
+
+/** @relates Gdk::Event
+ * @param lhs The left-hand side
+ * @param rhs The right-hand side
+ */
+inline void swap(Event& lhs, Event& rhs)
+  { lhs.swap(rhs); }
+
+} // namespace Gdk
+
+namespace Glib
+{
+
+/** @relates Gdk::Event
+ * @param object The C instance
+ * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+ * @result A C++ instance that wraps this C instance.
+ */
+Gdk::Event wrap(GdkEvent* object, bool take_copy = false);
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+template <>
+class Value<Gdk::Event> : public Glib::Value_Boxed<Gdk::Event>
+{};
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+} // namespace Glib
+
+#endif /* _GDKMM_EVENT_H */
+
diff --git a/libs/gtkmm2/gdk/gdkmm/gc.cc b/libs/gtkmm2/gdk/gdkmm/gc.cc
new file mode 100644
index 0000000000..456cad5f9e
--- /dev/null
+++ b/libs/gtkmm2/gdk/gdkmm/gc.cc
@@ -0,0 +1,326 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gdkmm/gc.h>
+#include <gdkmm/private/gc_p.h>
+
+#include <gdk/gdkenumtypes.h>
+// -*- c++ -*-
+/* $Id$ */
+
+/*
+ *
+ * Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gdk/gdkgc.h>
+#include <gdkmm/color.h>
+//#include <gdkmm/font.h>
+//#include <gdkmm/pixmap.h>
+#include <gdkmm/bitmap.h>
+#include <gdkmm/colormap.h>
+
+namespace Gdk
+{
+
+GC::GC(const Glib::RefPtr<Drawable>& drawable)
+: Object( G_OBJECT( gdk_gc_new(drawable->gobj()) ) )
+{
+  //We need a construct function if we really want to use our own GClass. Bug #86867
+}
+
+
+}
+
+
+namespace
+{
+} // anonymous namespace
+
+// static
+GType Glib::Value<Gdk::LineStyle>::value_type()
+{
+  return gdk_line_style_get_type();
+}
+
+// static
+GType Glib::Value<Gdk::CapStyle>::value_type()
+{
+  return gdk_cap_style_get_type();
+}
+
+// static
+GType Glib::Value<Gdk::JoinStyle>::value_type()
+{
+  return gdk_join_style_get_type();
+}
+
+// static
+GType Glib::Value<Gdk::Fill>::value_type()
+{
+  return gdk_fill_get_type();
+}
+
+// static
+GType Glib::Value<Gdk::Function>::value_type()
+{
+  return gdk_function_get_type();
+}
+
+// static
+GType Glib::Value<Gdk::SubwindowMode>::value_type()
+{
+  return gdk_subwindow_mode_get_type();
+}
+
+// static
+GType Glib::Value<Gdk::GCValuesMask>::value_type()
+{
+  return gdk_gc_values_mask_get_type();
+}
+
+
+namespace Glib
+{
+
+Glib::RefPtr<Gdk::GC> wrap(GdkGC* object, bool take_copy)
+{
+  return Glib::RefPtr<Gdk::GC>( dynamic_cast<Gdk::GC*> (Glib::wrap_auto ((GObject*)(object), take_copy)) );
+  //We use dynamic_cast<> in case of multiple inheritance.
+}
+
+} /* namespace Glib */
+
+
+namespace Gdk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& GC_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &GC_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gdk_gc_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void GC_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+}
+
+
+Glib::ObjectBase* GC_Class::wrap_new(GObject* object)
+{
+  return new GC((GdkGC*)object);
+}
+
+
+/* The implementation: */
+
+GdkGC* GC::gobj_copy()
+{
+  reference();
+  return gobj();
+}
+
+GC::GC(const Glib::ConstructParams& construct_params)
+:
+  Glib::Object(construct_params)
+{}
+
+GC::GC(GdkGC* castitem)
+:
+  Glib::Object((GObject*)(castitem))
+{}
+
+GC::~GC()
+{}
+
+
+GC::CppClassType GC::gc_class_; // initialize static member
+
+GType GC::get_type()
+{
+  return gc_class_.init().get_type();
+}
+
+GType GC::get_base_type()
+{
+  return gdk_gc_get_type();
+}
+
+
+GC::GC()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Glib::Object(Glib::ConstructParams(gc_class_.init()))
+{
+  }
+
+Glib::RefPtr<GC> GC::create()
+{
+  return Glib::RefPtr<GC>( new GC() );
+}
+Glib::RefPtr<GC> GC::create(const Glib::RefPtr<Drawable>& drawable)
+{
+  return Glib::RefPtr<GC>( new GC(drawable) );
+}
+void GC::set_foreground(const Color& color)
+{
+  gdk_gc_set_foreground(gobj(), (color).gobj());
+}
+
+void GC::set_background(const Color& color)
+{
+  gdk_gc_set_background(gobj(), (color).gobj());
+}
+
+void GC::set_function(Function function)
+{
+  gdk_gc_set_function(gobj(), ((GdkFunction)(function)));
+}
+
+void GC::set_fill(Fill fill)
+{
+  gdk_gc_set_fill(gobj(), ((GdkFill)(fill)));
+}
+
+void GC::set_tile(const Glib::RefPtr<Pixmap>& tile)
+{
+  gdk_gc_set_tile(gobj(), Glib::unwrap(tile));
+}
+
+void GC::set_stipple(const Glib::RefPtr<Pixmap>& stipple)
+{
+  gdk_gc_set_stipple(gobj(), Glib::unwrap(stipple));
+}
+
+void GC::set_ts_origin(int x, int y)
+{
+  gdk_gc_set_ts_origin(gobj(), x, y);
+}
+
+void GC::set_clip_origin(int x, int y)
+{
+  gdk_gc_set_clip_origin(gobj(), x, y);
+}
+
+void GC::set_clip_mask(const Glib::RefPtr<Bitmap>& mask)
+{
+  gdk_gc_set_clip_mask(gobj(), Glib::unwrap(mask));
+}
+
+void GC::set_clip_rectangle(Rectangle& rectangle)
+{
+  gdk_gc_set_clip_rectangle(gobj(), (rectangle).gobj());
+}
+
+void GC::set_clip_region(const Region& region)
+{
+  gdk_gc_set_clip_region(gobj(), const_cast<GdkRegion*>((region).gobj()));
+}
+
+void GC::set_subwindow(SubwindowMode mode)
+{
+  gdk_gc_set_subwindow(gobj(), ((GdkSubwindowMode)(mode)));
+}
+
+void GC::set_exposures(bool exposures)
+{
+  gdk_gc_set_exposures(gobj(), static_cast<int>(exposures));
+}
+
+void GC::set_line_attributes(int line_width, LineStyle line_style, CapStyle cap_style, JoinStyle join_style)
+{
+  gdk_gc_set_line_attributes(gobj(), line_width, ((GdkLineStyle)(line_style)), ((GdkCapStyle)(cap_style)), ((GdkJoinStyle)(join_style)));
+}
+
+void GC::set_dashes(int dash_offset, gint8* dash_list, int n)
+{
+  gdk_gc_set_dashes(gobj(), dash_offset, dash_list, n);
+}
+
+void GC::offset(int x_offset, int y_offset)
+{
+  gdk_gc_offset(gobj(), x_offset, y_offset);
+}
+
+void GC::set_colormap(const Glib::RefPtr<Colormap>& colormap)
+{
+  gdk_gc_set_colormap(gobj(), Glib::unwrap(colormap));
+}
+
+Glib::RefPtr<Colormap> GC::get_colormap()
+{
+
+  Glib::RefPtr<Colormap> retvalue = Glib::wrap(gdk_gc_get_colormap(gobj()));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+void GC::set_rgb_fg_color(const Color& color)
+{
+  gdk_gc_set_rgb_fg_color(gobj(), (color).gobj());
+}
+
+void GC::set_rgb_bg_color(const Color& color)
+{
+  gdk_gc_set_rgb_bg_color(gobj(), (color).gobj());
+}
+
+Glib::RefPtr<Screen> GC::get_screen()
+{
+
+  Glib::RefPtr<Screen> retvalue = Glib::wrap(gdk_gc_get_screen(gobj()));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::RefPtr<const Screen> GC::get_screen() const
+{
+
+  Glib::RefPtr<const Screen> retvalue = Glib::wrap(gdk_gc_get_screen(const_cast<GdkGC*>(gobj())));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+
+} // namespace Gdk
+
+
diff --git a/libs/gtkmm2/gdk/gdkmm/gc.h b/libs/gtkmm2/gdk/gdkmm/gc.h
new file mode 100644
index 0000000000..854995eee5
--- /dev/null
+++ b/libs/gtkmm2/gdk/gdkmm/gc.h
@@ -0,0 +1,617 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GDKMM_GC_H
+#define _GDKMM_GC_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* gc.h
+ *
+ * Copyright (C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <glibmm/object.h>
+#include <gdkmm/drawable.h>
+#include <gdkmm/types.h>
+#include <gdkmm/rectangle.h>
+#include <gdkmm/region.h>
+#include <gdkmm/screen.h>
+#include <gdk/gdkgc.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GdkGC GdkGC;
+typedef struct _GdkGCClass GdkGCClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gdk
+{ class GC_Class; } // namespace Gdk
+namespace Gdk
+{
+
+
+/** @addtogroup gdkmmEnums Enums and Flags */
+
+/**
+ * @ingroup gdkmmEnums
+ */
+enum LineStyle
+{
+  LINE_SOLID,
+  LINE_ON_OFF_DASH,
+  LINE_DOUBLE_DASH
+};
+
+} // namespace Gdk
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Gdk::LineStyle> : public Glib::Value_Enum<Gdk::LineStyle>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gdk
+{
+
+/**
+ * @ingroup gdkmmEnums
+ */
+enum CapStyle
+{
+  CAP_NOT_LAST,
+  CAP_BUTT,
+  CAP_ROUND,
+  CAP_PROJECTING
+};
+
+} // namespace Gdk
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Gdk::CapStyle> : public Glib::Value_Enum<Gdk::CapStyle>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gdk
+{
+
+/**
+ * @ingroup gdkmmEnums
+ */
+enum JoinStyle
+{
+  JOIN_MITER,
+  JOIN_ROUND,
+  JOIN_BEVEL
+};
+
+} // namespace Gdk
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Gdk::JoinStyle> : public Glib::Value_Enum<Gdk::JoinStyle>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gdk
+{
+
+/**
+ * @ingroup gdkmmEnums
+ */
+enum Fill
+{
+  SOLID,
+  TILED,
+  STIPPLED,
+  OPAQUE_STIPPLED
+};
+
+} // namespace Gdk
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Gdk::Fill> : public Glib::Value_Enum<Gdk::Fill>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gdk
+{
+
+/**
+ * @ingroup gdkmmEnums
+ */
+enum Function
+{
+  COPY,
+  INVERT,
+  XOR,
+  CLEAR,
+  AND,
+  AND_REVERSE,
+  AND_INVERT,
+  NOOP,
+  OR,
+  EQUIV,
+  OR_REVERSE,
+  COPY_INVERT,
+  OR_INVERT,
+  NAND,
+  NOR,
+  SET
+};
+
+} // namespace Gdk
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Gdk::Function> : public Glib::Value_Enum<Gdk::Function>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gdk
+{
+
+/**
+ * @ingroup gdkmmEnums
+ */
+enum SubwindowMode
+{
+  CLIP_BY_CHILDREN,
+  INCLUDE_INFERIORS
+};
+
+} // namespace Gdk
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Gdk::SubwindowMode> : public Glib::Value_Enum<Gdk::SubwindowMode>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gdk
+{
+
+/**
+ * @ingroup gdkmmEnums
+ * @par Bitwise operators:
+ * <tt>%GCValuesMask operator|(GCValuesMask, GCValuesMask)</tt><br>
+ * <tt>%GCValuesMask operator&(GCValuesMask, GCValuesMask)</tt><br>
+ * <tt>%GCValuesMask operator^(GCValuesMask, GCValuesMask)</tt><br>
+ * <tt>%GCValuesMask operator~(GCValuesMask)</tt><br>
+ * <tt>%GCValuesMask& operator|=(GCValuesMask&, GCValuesMask)</tt><br>
+ * <tt>%GCValuesMask& operator&=(GCValuesMask&, GCValuesMask)</tt><br>
+ * <tt>%GCValuesMask& operator^=(GCValuesMask&, GCValuesMask)</tt><br>
+ */
+enum GCValuesMask
+{
+  GC_FOREGROUND = 1 << 0,
+  GC_BACKGROUND = 1 << 1,
+  GC_FONT = 1 << 2,
+  GC_FUNCTION = 1 << 3,
+  GC_FILL = 1 << 4,
+  GC_TILE = 1 << 5,
+  GC_STIPPLE = 1 << 6,
+  GC_CLIP_MASK = 1 << 7,
+  GC_SUBWINDOW = 1 << 8,
+  GC_TS_X_ORIGIN = 1 << 9,
+  GC_TS_Y_ORIGIN = 1 << 10,
+  GC_CLIP_X_ORIGIN = 1 << 11,
+  GC_CLIP_Y_ORIGIN = 1 << 12,
+  GC_EXPOSURES = 1 << 13,
+  GC_LINE_WIDTH = 1 << 14,
+  GC_LINE_STYLE = 1 << 15,
+  GC_CAP_STYLE = 1 << 16,
+  GC_JOIN_STYLE = 1 << 17
+};
+
+/** @ingroup gdkmmEnums */
+inline GCValuesMask operator|(GCValuesMask lhs, GCValuesMask rhs)
+  { return static_cast<GCValuesMask>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs)); }
+
+/** @ingroup gdkmmEnums */
+inline GCValuesMask operator&(GCValuesMask lhs, GCValuesMask rhs)
+  { return static_cast<GCValuesMask>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs)); }
+
+/** @ingroup gdkmmEnums */
+inline GCValuesMask operator^(GCValuesMask lhs, GCValuesMask rhs)
+  { return static_cast<GCValuesMask>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs)); }
+
+/** @ingroup gdkmmEnums */
+inline GCValuesMask operator~(GCValuesMask flags)
+  { return static_cast<GCValuesMask>(~static_cast<unsigned>(flags)); }
+
+/** @ingroup gdkmmEnums */
+inline GCValuesMask& operator|=(GCValuesMask& lhs, GCValuesMask rhs)
+  { return (lhs = static_cast<GCValuesMask>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs))); }
+
+/** @ingroup gdkmmEnums */
+inline GCValuesMask& operator&=(GCValuesMask& lhs, GCValuesMask rhs)
+  { return (lhs = static_cast<GCValuesMask>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs))); }
+
+/** @ingroup gdkmmEnums */
+inline GCValuesMask& operator^=(GCValuesMask& lhs, GCValuesMask rhs)
+  { return (lhs = static_cast<GCValuesMask>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs))); }
+
+} // namespace Gdk
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Gdk::GCValuesMask> : public Glib::Value_Flags<Gdk::GCValuesMask>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gdk
+{
+
+
+class Drawable;
+
+/** All drawing operations in GDK take a graphics context (GC) argument.
+ * A graphics context encapsulates information about the way things are drawn, such as the foreground color or line width.
+ * By using graphics contexts, the number of arguments to each drawing call is greatly reduced, and communication overhead
+ * is minimized, since identical arguments do not need to be passed repeatedly.
+ */
+
+class GC : public Glib::Object
+{
+  
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+public:
+  typedef GC CppObjectType;
+  typedef GC_Class CppClassType;
+  typedef GdkGC BaseObjectType;
+  typedef GdkGCClass BaseClassType;
+
+private:  friend class GC_Class;
+  static CppClassType gc_class_;
+
+private:
+  // noncopyable
+  GC(const GC&);
+  GC& operator=(const GC&);
+
+protected:
+  explicit GC(const Glib::ConstructParams& construct_params);
+  explicit GC(GdkGC* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+  virtual ~GC();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GObject.
+  GdkGC*       gobj()       { return reinterpret_cast<GdkGC*>(gobject_); }
+
+  ///Provides access to the underlying C GObject.
+  const GdkGC* gobj() const { return reinterpret_cast<GdkGC*>(gobject_); }
+
+  ///Provides access to the underlying C instance. The caller is responsible for unrefing it. Use when directly setting fields in structs.
+  GdkGC* gobj_copy();
+
+private:
+
+  
+protected:
+  GC();
+  explicit GC(const Glib::RefPtr<Drawable>& drawable);
+
+public:
+  
+  static Glib::RefPtr<GC> create();
+
+  
+  static Glib::RefPtr<GC> create(const Glib::RefPtr<Drawable>& drawable);
+
+
+  // Custom wrap these?, maybe with a Gdk::GC::Value class. Need to do take care of refcounts of GdkGCValue's fields.
+  // Actually, I don't see the need for these methods. murrayc.
+  //_WRAP_METHOD(void get_values(GdkGCValues& values) const, gdk_gc_get_values)
+  //_WRAP_METHOD(void set_values(const GdkGCValues& values, GCValuesMask values_mask), gdk_gc_set_values)
+  //__IGNORE(gdk_gc_get_values, gdk_gc_set_values)
+
+  
+  /** Sets the foreground color for a graphics context.
+   * Note that this function uses @a color -&gt;pixel, use 
+   * set_rgb_fg_color() to specify the foreground 
+   * color as red, green, blue components.
+   * @param color The new foreground color.
+   */
+  void set_foreground(const Color& color);
+  
+  /** Sets the background color for a graphics context.
+   * Note that this function uses @a color -&gt;pixel, use 
+   * set_rgb_bg_color() to specify the background 
+   * color as red, green, blue components.
+   * @param color The new background color.
+   */
+  void set_background(const Color& color);
+  
+  /** Determines how the current pixel values and the
+   * pixel values being drawn are combined to produce
+   * the final pixel values.
+   * @param function The Gdk::Function to use.
+   */
+  void set_function(Function function);
+  
+  /** Set the fill mode for a graphics context.
+   * @param fill The new fill mode.
+   */
+  void set_fill(Fill fill);
+  
+  /** Set a tile pixmap for a graphics context.
+   * This will only be used if the fill mode
+   * is Gdk::TILED.
+   * @param tile The new tile pixmap.
+   */
+  void set_tile(const Glib::RefPtr<Pixmap>& tile);
+  
+  /** Set the stipple bitmap for a graphics context. The
+   * stipple will only be used if the fill mode is
+   * Gdk::STIPPLED or Gdk::OPAQUE_STIPPLED.
+   * @param stipple The new stipple bitmap.
+   */
+  void set_stipple(const Glib::RefPtr<Pixmap>& stipple);
+  
+  /** Set the origin when using tiles or stipples with
+   * the GC. The tile or stipple will be aligned such
+   * that the upper left corner of the tile or stipple
+   * will coincide with this point.
+   * @param x The x-coordinate of the origin.
+   * @param y The y-coordinate of the origin.
+   */
+  void set_ts_origin(int x, int y);
+  
+  /** Sets the origin of the clip mask. The coordinates are
+   * interpreted relative to the upper-left corner of
+   * the destination drawable of the current operation.
+   * @param x The x-coordinate of the origin.
+   * @param y The y-coordinate of the origin.
+   */
+  void set_clip_origin(int x, int y);
+  
+  /** Sets the clip mask for a graphics context from a bitmap.
+   * The clip mask is interpreted relative to the clip
+   * origin. (See set_clip_origin()).
+   * @param mask A bitmap.
+   */
+  void set_clip_mask(const Glib::RefPtr<Bitmap>& mask);
+  
+  /** Sets the clip mask for a graphics context from a
+   * rectangle. The clip mask is interpreted relative to the clip
+   * origin. (See set_clip_origin()).
+   * @param rectangle The rectangle to clip to.
+   */
+  void set_clip_rectangle(Rectangle& rectangle);
+  
+  /** Sets the clip mask for a graphics context from a region structure.
+   * The clip mask is interpreted relative to the clip origin. (See
+   * set_clip_origin()).
+   * @param region The Gdk::Region.
+   */
+  void set_clip_region(const Region& region);
+  
+  /** Sets how drawing with this GC on a window will affect child
+   * windows of that window.
+   * @param mode The subwindow mode.
+   */
+  void set_subwindow(SubwindowMode mode);
+  
+  /** Sets whether copying non-visible portions of a drawable
+   * using this graphics context generate exposure events
+   * for the corresponding regions of the destination
+   * drawable. (See gdk_draw_drawable()).
+   * @param exposures If <tt>true</tt>, exposure events will be generated.
+   */
+  void set_exposures(bool exposures);
+  
+  /** Sets various attributes of how lines are drawn. See
+   * the corresponding members of Gdk::GCValues for full
+   * explanations of the arguments.
+   * @param line_width The width of lines.
+   * @param line_style The dash-style for lines.
+   * @param cap_style The manner in which the ends of lines are drawn.
+   * @param join_style The in which lines are joined together.
+   */
+  void set_line_attributes(int line_width, LineStyle line_style, CapStyle cap_style, JoinStyle join_style);
+  
+  /** Sets the way dashed-lines are drawn. Lines will be
+   * drawn with alternating on and off segments of the
+   * lengths specified in @a dash_list . The manner in
+   * which the on and off segments are drawn is determined
+   * by the @a line_style  value of the GC. (This can
+   * be changed with set_line_attributes().)
+   * 
+   * The @a dash_offset  defines the phase of the pattern, 
+   * specifying how many pixels into the dash-list the pattern 
+   * should actually begin.
+   * @param dash_offset The phase of the dash pattern.
+   * @param dash_list An array of dash lengths.
+   * @param n The number of elements in @a dash_list .
+   */
+  void set_dashes(int dash_offset, gint8* dash_list, int n);
+  
+  /** Offset attributes such as the clip and tile-stipple origins
+   * of the GC so that drawing at x - x_offset, y - y_offset with
+   * the offset GC  has the same effect as drawing at x, y with the original
+   * GC.
+   * @param x_offset Amount by which to offset the GC in the X direction.
+   * @param y_offset Amount by which to offset the GC in the Y direction.
+   */
+  void offset(int x_offset, int y_offset);
+  
+  /** Sets the colormap for the GC to the given colormap. The depth
+   * of the colormap's visual must match the depth of the drawable
+   * for which the GC was created.
+   * @param colormap A Gdk::Colormap.
+   */
+  void set_colormap(const Glib::RefPtr<Colormap>& colormap);
+  
+  /** Retrieves the colormap for a given GC, if it exists.
+   * A GC will have a colormap if the drawable for which it was created
+   * has a colormap, or if a colormap was set explicitely with
+   * gdk_gc_set_colormap.
+   * @return The colormap of @a gc , or <tt>0</tt> if @a gc  doesn't have one.
+   */
+  Glib::RefPtr<Colormap> get_colormap();
+  
+  /** Set the foreground color of a GC using an unallocated color. The
+   * pixel value for the color will be determined using GdkRGB. If the
+   * colormap for the GC has not previously been initialized for GdkRGB,
+   * then for pseudo-color colormaps (colormaps with a small modifiable
+   * number of colors), a colorcube will be allocated in the colormap.
+   * 
+   * Calling this function for a GC without a colormap is an error.
+   * @param color An unallocated Gdk::Color.
+   */
+  void set_rgb_fg_color(const Color& color);
+  
+  /** Set the background color of a GC using an unallocated color. The
+   * pixel value for the color will be determined using GdkRGB. If the
+   * colormap for the GC has not previously been initialized for GdkRGB,
+   * then for pseudo-color colormaps (colormaps with a small modifiable
+   * number of colors), a colorcube will be allocated in the colormap.
+   * 
+   * Calling this function for a GC without a colormap is an error.
+   * @param color An unallocated Gdk::Color.
+   */
+  void set_rgb_bg_color(const Color& color);
+
+  
+  /** Gets the Gdk::Screen for which @a gc  was created
+   * @return The Gdk::Screen for @a gc .
+   * 
+   * Since: 2.2.
+   */
+  Glib::RefPtr<Screen> get_screen();
+  
+  /** Gets the Gdk::Screen for which @a gc  was created
+   * @return The Gdk::Screen for @a gc .
+   * 
+   * Since: 2.2.
+   */
+  Glib::RefPtr<const Screen> get_screen() const;
+
+
+public:
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+};
+
+} /* namespace Gdk */
+
+
+namespace Glib
+{
+  /** @relates Gdk::GC
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Glib::RefPtr<Gdk::GC> wrap(GdkGC* object, bool take_copy = false);
+}
+
+
+#endif /* _GDKMM_GC_H */
+
diff --git a/libs/gtkmm2/gdk/gdkmm/general.cc b/libs/gtkmm2/gdk/gdkmm/general.cc
new file mode 100644
index 0000000000..f07cce2b14
--- /dev/null
+++ b/libs/gtkmm2/gdk/gdkmm/general.cc
@@ -0,0 +1,54 @@
+// -*- c++ -*-
+/* $Id$ */
+
+/* Copyright 2002      The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gdkmm/general.h>
+#include <gdk/gdk.h>
+
+namespace Gdk
+{
+
+int screen_width()
+{
+  return gdk_screen_width();
+}
+
+int screen_height()
+{
+  return gdk_screen_height();
+}
+
+int screen_width_mm()
+{
+  return gdk_screen_width_mm();
+}
+
+int screen_height_mm()
+{
+  return gdk_screen_height_mm();
+}
+
+
+void flush()
+{
+  gdk_flush();
+}
+
+} //namespace Gdk
+
diff --git a/libs/gtkmm2/gdk/gdkmm/general.h b/libs/gtkmm2/gdk/gdkmm/general.h
new file mode 100644
index 0000000000..1d37ab0e3b
--- /dev/null
+++ b/libs/gtkmm2/gdk/gdkmm/general.h
@@ -0,0 +1,37 @@
+/* $Id$ */
+
+/* Copyright 2002      The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#ifndef _GDKMM_GENERAL_H
+#define _GDKMM_GENERAL_H
+
+namespace Gdk
+{
+
+int screen_width();
+int screen_height();
+
+int screen_width_mm();
+int screen_height_mm();
+
+void flush();
+
+} //namespace Gdk
+
+#endif //_GDKMM_GENERAL_H
+
diff --git a/libs/gtkmm2/gdk/gdkmm/image.cc b/libs/gtkmm2/gdk/gdkmm/image.cc
new file mode 100644
index 0000000000..787124f36f
--- /dev/null
+++ b/libs/gtkmm2/gdk/gdkmm/image.cc
@@ -0,0 +1,250 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gdkmm/image.h>
+#include <gdkmm/private/image_p.h>
+
+#include <gdk/gdkenumtypes.h>
+// -*- c++ -*-
+/* $Id$ */
+
+/*
+ *
+ * Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+namespace Gdk
+{
+
+Image::Image(ImageType type, const Glib::RefPtr<Visual>& visual, int width, int height)
+:
+  Object( G_OBJECT( gdk_image_new((GdkImageType)type, visual->gobj(), width, height) ) )
+{}
+
+} /* namespace Gdk */
+
+
+namespace
+{
+} // anonymous namespace
+
+// static
+GType Glib::Value<Gdk::ImageType>::value_type()
+{
+  return gdk_image_type_get_type();
+}
+
+
+namespace Glib
+{
+
+Glib::RefPtr<Gdk::Image> wrap(GdkImage* object, bool take_copy)
+{
+  return Glib::RefPtr<Gdk::Image>( dynamic_cast<Gdk::Image*> (Glib::wrap_auto ((GObject*)(object), take_copy)) );
+  //We use dynamic_cast<> in case of multiple inheritance.
+}
+
+} /* namespace Glib */
+
+
+namespace Gdk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& Image_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &Image_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gdk_image_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void Image_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+}
+
+
+Glib::ObjectBase* Image_Class::wrap_new(GObject* object)
+{
+  return new Image((GdkImage*)object);
+}
+
+
+/* The implementation: */
+
+GdkImage* Image::gobj_copy()
+{
+  reference();
+  return gobj();
+}
+
+Image::Image(const Glib::ConstructParams& construct_params)
+:
+  Glib::Object(construct_params)
+{}
+
+Image::Image(GdkImage* castitem)
+:
+  Glib::Object((GObject*)(castitem))
+{}
+
+Image::~Image()
+{}
+
+
+Image::CppClassType Image::image_class_; // initialize static member
+
+GType Image::get_type()
+{
+  return image_class_.init().get_type();
+}
+
+GType Image::get_base_type()
+{
+  return gdk_image_get_type();
+}
+
+
+Glib::RefPtr<Image> Image::create(ImageType type, const Glib::RefPtr<Visual>& visual, int width, int height)
+{
+  return Glib::RefPtr<Image>( new Image(type, visual, width, height) );
+}
+void Image::put_pixel(int x, int y, guint32 pixel)
+{
+  gdk_image_put_pixel(gobj(), x, y, pixel);
+}
+
+guint32 Image::get_pixel(int x, int y) const
+{
+  return gdk_image_get_pixel(const_cast<GdkImage*>(gobj()), x, y);
+}
+
+void Image::set_colormap(const Glib::RefPtr<Colormap>& colormap)
+{
+  gdk_image_set_colormap(gobj(), Glib::unwrap(colormap));
+}
+
+Glib::RefPtr<Colormap> Image::get_colormap()
+{
+
+  Glib::RefPtr<Colormap> retvalue = Glib::wrap(gdk_image_get_colormap(gobj()));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::RefPtr<const Colormap> Image::get_colormap() const
+{
+
+  Glib::RefPtr<const Colormap> retvalue = Glib::wrap(gdk_image_get_colormap(const_cast<GdkImage*>(gobj())));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+ImageType Image::get_image_type() const
+{
+  return ((ImageType)(gobj()->type));
+}
+
+Glib::RefPtr<Visual> Image::get_visual()
+{
+  Glib::RefPtr<Visual> ref_ptr(Glib::wrap(gobj()->visual));
+
+  if(ref_ptr)
+    ref_ptr->reference();
+
+  return ref_ptr;
+}
+
+Glib::RefPtr<const Visual> Image::get_visual() const
+{
+  Glib::RefPtr<const Visual> ref_ptr(Glib::wrap(gobj()->visual));
+
+  if(ref_ptr)
+    ref_ptr->reference();
+
+  return ref_ptr;
+}
+
+ByteOrder Image::get_byte_order() const
+{
+  return ((ByteOrder)(gobj()->byte_order));
+}
+
+int Image::get_width() const
+{
+  return gobj()->width;
+}
+
+int Image::get_height() const
+{
+  return gobj()->height;
+}
+
+guint16 Image::get_bpp() const
+{
+  return gobj()->bpp;
+}
+
+guint16 Image::get_bpl() const
+{
+  return gobj()->bpl;
+}
+
+guint16 Image::get_bits_per_pixel() const
+{
+  return gobj()->bits_per_pixel;
+}
+
+void* Image::get_mem()
+{
+  return gobj()->mem;
+}
+
+const void* Image::get_mem() const
+{
+  return (const void*)(gobj()->mem);
+}
+
+void* Image::get_windowing_data() const
+{
+  return gobj()->windowing_data;
+}
+
+
+} // namespace Gdk
+
+
diff --git a/libs/gtkmm2/gdk/gdkmm/image.h b/libs/gtkmm2/gdk/gdkmm/image.h
new file mode 100644
index 0000000000..7d5f8f6078
--- /dev/null
+++ b/libs/gtkmm2/gdk/gdkmm/image.h
@@ -0,0 +1,231 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GDKMM_IMAGE_H
+#define _GDKMM_IMAGE_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* bitmap.h
+ *
+ * Copyright (C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <glibmm/object.h>
+#include <gdkmm/visual.h>
+#include <gdkmm/colormap.h>
+#include <gdkmm/types.h> //For ByteOrder.
+#include <gdk/gdkimage.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GdkImage GdkImage;
+typedef struct _GdkImageClass GdkImageClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gdk
+{ class Image_Class; } // namespace Gdk
+namespace Gdk
+{
+
+
+/** @addtogroup gdkmmEnums Enums and Flags */
+
+/**
+ * @ingroup gdkmmEnums
+ */
+enum ImageType
+{
+  IMAGE_NORMAL,
+  IMAGE_SHARED,
+  IMAGE_FASTEST
+};
+
+} // namespace Gdk
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Gdk::ImageType> : public Glib::Value_Enum<Gdk::ImageType>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gdk
+{
+
+
+/** This represents an area for drawing graphics. It has now been superceded to a large extent by the much more flexible
+ * Gdk::Drawable RGB functions.
+ * To create an image from part of a Gdk::Window use Gdk::Drawable::get_image().
+ *
+ * The image can be manipulated with get_pixel() and put_pixel(), or alternatively by changing the actual pixel data, though
+ * manipulating the pixel data requires complicated code to cope with the different formats that may be used.
+ * To draw a Gdk::Image in a Gdk::Window or Gdk::Pixmap use Gdk::Drawable::draw_image().
+ */
+
+class Image : public Glib::Object
+{
+  
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+public:
+  typedef Image CppObjectType;
+  typedef Image_Class CppClassType;
+  typedef GdkImage BaseObjectType;
+  typedef GdkImageClass BaseClassType;
+
+private:  friend class Image_Class;
+  static CppClassType image_class_;
+
+private:
+  // noncopyable
+  Image(const Image&);
+  Image& operator=(const Image&);
+
+protected:
+  explicit Image(const Glib::ConstructParams& construct_params);
+  explicit Image(GdkImage* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+  virtual ~Image();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GObject.
+  GdkImage*       gobj()       { return reinterpret_cast<GdkImage*>(gobject_); }
+
+  ///Provides access to the underlying C GObject.
+  const GdkImage* gobj() const { return reinterpret_cast<GdkImage*>(gobject_); }
+
+  ///Provides access to the underlying C instance. The caller is responsible for unrefing it. Use when directly setting fields in structs.
+  GdkImage* gobj_copy();
+
+private:
+
+  
+protected:
+
+  /** Instantiate a new Gdk::Image.
+   *
+   * @param type The type of the Gdk::Image. Gdk::IMAGE_FASTEST is probably the best choice, since it will try to create a Gdk::IMAGE_SHARED image first and if that fails it will then use Gdk::IMAGE_NORMAL.
+   * @param visual The Gdk::Visual to use for the image.
+   * @param width The width of the image in pixels.
+   * @param height The height of the image in pixels.
+   */
+  Image(ImageType type, const Glib::RefPtr<Visual>& visual, int	width, int height);
+  
+  
+public:
+  
+  static Glib::RefPtr<Image> create(ImageType type, const Glib::RefPtr<Visual>& visual, int width, int height);
+
+
+  //We ignore gdk_image_new_bitmap() because the documentation says that it is incredibly broken.
+  
+
+  void put_pixel(int x, int y, guint32 pixel);
+  
+  guint32 get_pixel(int	x, int	y) const;
+  
+  /** Sets the colormap for the image to the given colormap.  Normally
+   * there's no need to use this function, images are created with the
+   * correct colormap if you get the image from a drawable. If you
+   * create the image from scratch, use the colormap of the drawable you
+   * intend to render the image to.
+   * @param colormap A Gdk::Colormap.
+   */
+  void set_colormap(const Glib::RefPtr<Colormap>& colormap);
+  
+  /** Retrieves the colormap for a given image, if it exists.  An image
+   * will have a colormap if the drawable from which it was created has
+   * a colormap, or if a colormap was set explicitely with
+   * set_colormap().
+   * @return Colormap for the image.
+   */
+  Glib::RefPtr<Colormap> get_colormap();
+  
+  /** Retrieves the colormap for a given image, if it exists.  An image
+   * will have a colormap if the drawable from which it was created has
+   * a colormap, or if a colormap was set explicitely with
+   * set_colormap().
+   * @return Colormap for the image.
+   */
+  Glib::RefPtr<const Colormap> get_colormap() const;
+  
+  ImageType get_image_type() const;
+  Glib::RefPtr<Visual> get_visual();
+  Glib::RefPtr<const Visual> get_visual() const;
+  ByteOrder get_byte_order() const;
+  int get_width() const;
+  int get_height() const;
+  guint16 get_bpp() const;
+  guint16 get_bpl() const;
+  guint16 get_bits_per_pixel() const;
+
+  //This memory block is not read-only, apparently:
+  void* get_mem();
+  const void* get_mem() const;
+
+  //TODO: This should be const really.
+  void* get_windowing_data() const;
+
+
+public:
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+};
+
+} /* namespace Gdk */
+
+
+namespace Glib
+{
+  /** @relates Gdk::Image
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Glib::RefPtr<Gdk::Image> wrap(GdkImage* object, bool take_copy = false);
+}
+
+
+#endif /* _GDKMM_IMAGE_H */
+
diff --git a/libs/gtkmm2/gdk/gdkmm/list.h b/libs/gtkmm2/gdk/gdkmm/list.h
new file mode 100644
index 0000000000..2c4da23bb7
--- /dev/null
+++ b/libs/gtkmm2/gdk/gdkmm/list.h
@@ -0,0 +1,157 @@
+#ifndef _GDKMM_LIST_H_
+#define _GDKMM_LIST_H_
+
+namespace Gdk {
+
+#ifdef GTKMM_CXX_HAVE_PARTIAL_SPECIALIZATION
+// Dummy class to make it appear as though the user has the list.
+/*
+template<class Parent,class Iterator,class Access>
+  class List 
+  {
+   public:
+     typedef List<Parent,Iterator,Access> List;
+   private:
+     Parent* parent;
+   public:
+     List(Parent& p):parent(p) {}
+     List():parent(0) {}
+     List(const List& list):parent(list.parent) {}
+
+     Iterator begin() 
+       {
+        if (parent)
+          return Access::begin(parent);
+        return Iterator();
+       }
+     Iterator end();
+       {
+        if (parent)
+          return Access::end(parent);
+        return Iterator();
+       }
+  };
+*/
+
+// An iterator that caches the current object to C++ for speed
+template<class C_Obj, class Cpp_Obj>
+  class List_Iterator 
+  {
+   public:
+     typedef List_Iterator<C_Obj,Cpp_Obj> self;
+
+   private:
+     GList *node;
+     Cpp_Obj cache;
+     
+   public:
+     self& operator=(const self& x) 
+       {
+        cache.free();
+        node=x.node;
+       }
+
+     bool operator==(const self& x) const 
+       { return node == x.node; }
+     bool operator!=(const self& x) const 
+       { return node != x.node; }
+
+     List_Iterator(GList *n) : node(n),cache(0) 
+       {}
+     List_Iterator() :node(0),cache(0)
+       {}
+     List_Iterator(const self& x) 
+        : node(x.node),cache(0) 
+       {}
+
+     Cpp_Obj& operator*() const 
+       {
+        if (node) 
+          {if (cache.gobj()!=node->data)
+             cache=Cpp_Obj(node->data);
+          }
+        else
+          cache=Cpp_Obj(0);
+        cache=0;
+        return ;
+       }
+
+     Cpp_Obj* operator->() const 
+       {
+        return &(operator*());
+       }
+
+     self&  operator++() 
+       { 
+        cache.free();
+        if (node && node->next) 
+          node = node->next;
+        return *this;
+       }
+
+     self operator++(int) 
+       { 
+        self tmp = *this;
+        ++*this;
+        return tmp;
+       }
+
+     self& operator--() 
+       {
+        cache.free();
+        if (node && node->prev)
+          node=node->prev;
+        return *this;
+       }
+
+     self operator--(int) 
+       { 
+        self tmp = *this;
+        --*this;
+        return tmp;
+       }
+
+   };
+
+/*
+List_Iterator<GdkWidget*,Widget> iter;
+(*iter)  should be a Widget
+
+Example usage:
+
+  class Foo()
+    {
+     public: 
+       typedef List_Iterator<GdkWidget*,Widget> Iterator;
+       typedef List<Foo,Iterator,Child_Access) Child_List; 
+     private:
+       struct Child_Access
+         {
+          static Iterator begin(Foo& foo)
+            {return foo.get_children_begin();}
+          static Iterator end(Foo& foo)
+            {return foo.get_children_end();}
+         };
+     public:
+//       GList* get_children();
+       Iterator get_children_begin()
+         {return Iterator(gdk_foo_get_children(*this);}
+       Iterator get_children_end()
+         {
+          GList* list=gdk_foo_get_children(*this);
+          return Iterator(g_list_last(list);
+         }
+       Child_List get_children()
+         {
+          return Child_List(this);
+         }
+       
+    };
+*/
+
+#endif
+
+} /* namespace Gdk */
+
+
+#endif // _GDKMM_LIST_H_
diff --git a/libs/gtkmm2/gdk/gdkmm/pixbuf.cc b/libs/gtkmm2/gdk/gdkmm/pixbuf.cc
new file mode 100644
index 0000000000..8a486d3cc9
--- /dev/null
+++ b/libs/gtkmm2/gdk/gdkmm/pixbuf.cc
@@ -0,0 +1,503 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gdkmm/pixbuf.h>
+#include <gdkmm/private/pixbuf_p.h>
+
+#include <gdk-pixbuf/gdk-pixbuf-enum-types.h>
+// -*- c++ -*-
+/* $Id$ */
+
+/* Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gdk/gdkcolor.h>
+#include <gdk/gdkpixbuf.h>
+#include <gdk-pixbuf/gdk-pixbuf.h>
+
+
+namespace
+{
+
+void pixbuf_destroy_data_callback(guint8* pixels, void* user_data)
+{
+  Gdk::Pixbuf::SlotDestroyData *const slot = static_cast<Gdk::Pixbuf::SlotDestroyData*>(user_data);
+  g_return_if_fail(slot != 0);
+
+  try
+  {
+    (*slot)(pixels); // invoke callback
+  }
+  catch(...)
+  {
+    Glib::exception_handlers_invoke();
+  }
+
+  delete slot;
+}
+
+} // anonymous namespace
+
+
+namespace Gdk
+{
+
+Pixbuf::Pixbuf(const Glib::RefPtr<Image>& src,
+               const Glib::RefPtr<Colormap>& cmap,
+               int src_x, int src_y,
+               int dest_x, int dest_y,
+               int width, int height)
+:
+  Object((GObject*) gdk_pixbuf_get_from_image(
+      0, src->gobj(), cmap->gobj(), src_x, src_y, dest_x, dest_y, width, height))
+{}
+
+Pixbuf::Pixbuf(const Glib::RefPtr<Drawable>& src,
+               const Glib::RefPtr<Colormap>& cmap,
+               int src_x, int src_y,
+               int dest_x, int dest_y,
+               int width, int height)
+:
+  Object((GObject*) gdk_pixbuf_get_from_drawable(
+      0, src->gobj(), cmap->gobj(), src_x, src_y, dest_x, dest_y, width, height))
+{}
+
+Glib::RefPtr<Pixbuf> Pixbuf::create_from_file(const std::string& filename)
+{
+  GError* error = 0;
+  GdkPixbuf *const pixbuf = gdk_pixbuf_new_from_file(filename.c_str(), &error);
+
+  if(error)
+    Glib::Error::throw_exception(error);
+
+  return Glib::wrap(pixbuf);
+}
+
+Glib::RefPtr<Pixbuf> Pixbuf::create_from_file(const std::string& filename, int width, int size, bool preserve_aspect_ratio)
+{
+  GError* error = 0;
+  GdkPixbuf *const pixbuf = gdk_pixbuf_new_from_file_at_scale(filename.c_str(), width, size, preserve_aspect_ratio, &error);
+  //gdk_pixbuf_new_from_file_at_size() just calls gdk_pixbuf_new_from_file_at_scale().
+
+  if(error)
+    Glib::Error::throw_exception(error);
+
+  return Glib::wrap(pixbuf);
+}
+
+Glib::RefPtr<Pixbuf> Pixbuf::create_from_data(const guint8* data, Colorspace colorspace,
+                                              bool has_alpha, int bits_per_sample,
+                                              int width, int height, int rowstride)
+{
+  GdkPixbuf *const pixbuf = gdk_pixbuf_new_from_data(
+      data, (GdkColorspace) colorspace, has_alpha, bits_per_sample, width, height, rowstride,
+      0, 0);
+
+  return Glib::wrap(pixbuf);
+}
+
+Glib::RefPtr<Pixbuf> Pixbuf::create_from_data(const guint8* data, Colorspace colorspace,
+                                              bool has_alpha, int bits_per_sample,
+                                              int width, int height, int rowstride,
+                                              const Pixbuf::SlotDestroyData& destroy_slot)
+{
+  GdkPixbuf *const pixbuf = gdk_pixbuf_new_from_data(
+      data, (GdkColorspace) colorspace, has_alpha, bits_per_sample, width, height, rowstride,
+      &pixbuf_destroy_data_callback, new SlotDestroyData(destroy_slot));
+
+  return Glib::wrap(pixbuf);
+}
+
+Glib::RefPtr<Pixbuf> Pixbuf::create_from_inline(int data_length, const guint8* data, bool copy_pixels)
+{
+  GError* error = 0;
+  GdkPixbuf *const pixbuf = gdk_pixbuf_new_from_inline(data_length, data, copy_pixels, &error);
+
+  if(error)
+    Glib::Error::throw_exception(error);
+
+  return Glib::wrap(pixbuf);
+}
+
+void Pixbuf::render_pixmap_and_mask_for_colormap(const Glib::RefPtr<Colormap>& colormap,
+                                                 Glib::RefPtr<Pixmap>& pixmap_return,
+                                                 Glib::RefPtr<Bitmap>& mask_return,
+                                                 int alpha_threshold)
+{
+  GdkPixmap* pPixmap = 0;
+  GdkBitmap* pBitmap = 0;
+
+  gdk_pixbuf_render_pixmap_and_mask_for_colormap(
+      gobj(), colormap->gobj(), &pPixmap, &pBitmap, alpha_threshold);
+
+  pixmap_return = Glib::wrap((GdkPixmapObject*) pPixmap);
+  mask_return   = Glib::RefPtr<Gdk::Bitmap>::cast_dynamic(Glib::wrap((GdkPixmapObject*) pBitmap));
+}
+
+void Pixbuf::render_pixmap_and_mask(Glib::RefPtr<Pixmap>& pixmap_return,
+                                    Glib::RefPtr<Bitmap>& mask_return,
+                                    int alpha_threshold)
+{
+  GdkPixmap* pPixmap = 0;
+  GdkBitmap* pBitmap = 0;
+
+  gdk_pixbuf_render_pixmap_and_mask(gobj(), &pPixmap, &pBitmap, alpha_threshold);
+
+  pixmap_return = Glib::wrap((GdkPixmapObject*) pPixmap);
+  mask_return   = Glib::RefPtr<Gdk::Bitmap>::cast_dynamic(Glib::wrap((GdkPixmapObject*) pBitmap));
+}
+
+void Pixbuf::save(const std::string& filename, const Glib::ustring& type)
+{
+  GError* error = 0;
+  gdk_pixbuf_savev(gobj(), filename.c_str(), type.c_str(), 0, 0, &error);
+
+  if(error)
+    Glib::Error::throw_exception(error);
+}
+
+void Pixbuf::save(const std::string& filename, const Glib::ustring& type,
+                  const Glib::StringArrayHandle& option_keys,
+                  const Glib::StringArrayHandle& option_values)
+{
+  GError* error = 0;
+
+  gdk_pixbuf_savev(
+      gobj(), filename.c_str(), type.c_str(),
+      const_cast<char**>(option_keys.data()), const_cast<char**>(option_values.data()),
+      &error);
+
+  if(error)
+    Glib::Error::throw_exception(error);
+}
+
+void Pixbuf::save_to_buffer(gchar*& buffer, gsize& buffer_size,
+                            const Glib::ustring& type,
+                            const Glib::StringArrayHandle& option_keys,
+                            const Glib::StringArrayHandle& option_values)
+{
+  GError* error = 0;
+
+  gdk_pixbuf_save_to_bufferv(
+      gobj(), &buffer, &buffer_size,
+      type.c_str(),
+      const_cast<char**>(option_keys.data()), const_cast<char**>(option_values.data()),
+      &error);
+
+  if(error)
+    Glib::Error::throw_exception(error);
+}
+
+Pixbuf::SListHandle_PixbufFormat Pixbuf::get_formats()
+{
+  //TODO: Check that this ownership is appropriate. murrayc.
+  return SListHandle_PixbufFormat(gdk_pixbuf_get_formats(), Glib::OWNERSHIP_DEEP);
+}
+
+
+} // namespace Gdk
+
+
+namespace
+{
+} // anonymous namespace
+
+// static
+GType Glib::Value<Gdk::Colorspace>::value_type()
+{
+  return gdk_colorspace_get_type();
+}
+
+// static
+GType Glib::Value<Gdk::InterpType>::value_type()
+{
+  return gdk_interp_type_get_type();
+}
+
+// static
+GType Glib::Value<Gdk::PixbufAlphaMode>::value_type()
+{
+  return gdk_pixbuf_alpha_mode_get_type();
+}
+
+// static
+GType Glib::Value<Gdk::PixbufRotation>::value_type()
+{
+  return gdk_pixbuf_rotation_get_type();
+}
+
+
+Gdk::PixbufError::PixbufError(Gdk::PixbufError::Code error_code, const Glib::ustring& error_message)
+:
+  Glib::Error (GDK_PIXBUF_ERROR, error_code, error_message)
+{}
+
+Gdk::PixbufError::PixbufError(GError* gobject)
+:
+  Glib::Error (gobject)
+{}
+
+Gdk::PixbufError::Code Gdk::PixbufError::code() const
+{
+  return static_cast<Code>(Glib::Error::code());
+}
+
+void Gdk::PixbufError::throw_func(GError* gobject)
+{
+  throw Gdk::PixbufError(gobject);
+}
+
+// static
+GType Glib::Value<Gdk::PixbufError::Code>::value_type()
+{
+  return gdk_pixbuf_error_get_type();
+}
+
+
+namespace Glib
+{
+
+Glib::RefPtr<Gdk::Pixbuf> wrap(GdkPixbuf* object, bool take_copy)
+{
+  return Glib::RefPtr<Gdk::Pixbuf>( dynamic_cast<Gdk::Pixbuf*> (Glib::wrap_auto ((GObject*)(object), take_copy)) );
+  //We use dynamic_cast<> in case of multiple inheritance.
+}
+
+} /* namespace Glib */
+
+
+namespace Gdk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& Pixbuf_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &Pixbuf_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gdk_pixbuf_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void Pixbuf_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+}
+
+
+Glib::ObjectBase* Pixbuf_Class::wrap_new(GObject* object)
+{
+  return new Pixbuf((GdkPixbuf*)object);
+}
+
+
+/* The implementation: */
+
+GdkPixbuf* Pixbuf::gobj_copy()
+{
+  reference();
+  return gobj();
+}
+
+Pixbuf::Pixbuf(const Glib::ConstructParams& construct_params)
+:
+  Glib::Object(construct_params)
+{}
+
+Pixbuf::Pixbuf(GdkPixbuf* castitem)
+:
+  Glib::Object((GObject*)(castitem))
+{}
+
+Pixbuf::~Pixbuf()
+{}
+
+
+Pixbuf::CppClassType Pixbuf::pixbuf_class_; // initialize static member
+
+GType Pixbuf::get_type()
+{
+  return pixbuf_class_.init().get_type();
+}
+
+GType Pixbuf::get_base_type()
+{
+  return gdk_pixbuf_get_type();
+}
+
+
+Glib::RefPtr<Pixbuf> Pixbuf::create(const Glib::RefPtr<Drawable>& src, const Glib::RefPtr<Colormap>& cmap, int src_x, int src_y, int dest_x, int dest_y, int width, int height)
+{
+  return Glib::RefPtr<Pixbuf>( new Pixbuf(src, cmap, src_x, src_y, dest_x, dest_y, width, height) );
+}
+Glib::RefPtr<Pixbuf> Pixbuf::create(const Glib::RefPtr<Image>& src, const Glib::RefPtr<Colormap>& cmap, int src_x, int src_y, int dest_x, int dest_y, int width, int height)
+{
+  return Glib::RefPtr<Pixbuf>( new Pixbuf(src, cmap, src_x, src_y, dest_x, dest_y, width, height) );
+}
+Glib::RefPtr<Pixbuf> Pixbuf::copy() const
+{
+  return Glib::wrap(gdk_pixbuf_copy(const_cast<GdkPixbuf*>(gobj())));
+}
+
+Glib::RefPtr<Pixbuf> Pixbuf::create(Colorspace colorspace, bool has_alpha, int bits_per_sample, int width, int height)
+{
+  return Glib::wrap(gdk_pixbuf_new(((GdkColorspace)(colorspace)), static_cast<int>(has_alpha), bits_per_sample, width, height));
+}
+
+Glib::RefPtr<Pixbuf> Pixbuf::create_subpixbuf(const Glib::RefPtr<Pixbuf>& src_pixbuf, int src_x, int src_y, int width, int height)
+{
+  return Glib::wrap(gdk_pixbuf_new_subpixbuf(Glib::unwrap(src_pixbuf), src_x, src_y, width, height));
+}
+
+Glib::RefPtr<Pixbuf> Pixbuf::create_from_xpm_data(const char *const * data)
+{
+  return Glib::wrap(gdk_pixbuf_new_from_xpm_data(const_cast<const char**>(data)));
+}
+
+Colorspace Pixbuf::get_colorspace() const
+{
+  return ((Colorspace)(gdk_pixbuf_get_colorspace(const_cast<GdkPixbuf*>(gobj()))));
+}
+
+int Pixbuf::get_n_channels() const
+{
+  return gdk_pixbuf_get_n_channels(const_cast<GdkPixbuf*>(gobj()));
+}
+
+bool Pixbuf::get_has_alpha() const
+{
+  return gdk_pixbuf_get_has_alpha(const_cast<GdkPixbuf*>(gobj()));
+}
+
+int Pixbuf::get_bits_per_sample() const
+{
+  return gdk_pixbuf_get_bits_per_sample(const_cast<GdkPixbuf*>(gobj()));
+}
+
+guint8* Pixbuf::get_pixels() const
+{
+  return gdk_pixbuf_get_pixels(const_cast<GdkPixbuf*>(gobj()));
+}
+
+int Pixbuf::get_width() const
+{
+  return gdk_pixbuf_get_width(const_cast<GdkPixbuf*>(gobj()));
+}
+
+int Pixbuf::get_height() const
+{
+  return gdk_pixbuf_get_height(const_cast<GdkPixbuf*>(gobj()));
+}
+
+int Pixbuf::get_rowstride() const
+{
+  return gdk_pixbuf_get_rowstride(const_cast<GdkPixbuf*>(gobj()));
+}
+
+void Pixbuf::fill(guint32 pixel)
+{
+  gdk_pixbuf_fill(gobj(), pixel);
+}
+
+Glib::RefPtr<Gdk::Pixbuf> Pixbuf::add_alpha(bool substitute_color, guint8 r, guint8 g, guint8 b) const
+{
+  return Glib::wrap(gdk_pixbuf_add_alpha(const_cast<GdkPixbuf*>(gobj()), static_cast<int>(substitute_color), r, g, b));
+}
+
+void Pixbuf::copy_area(int src_x, int src_y, int width, int height, const Glib::RefPtr<Gdk::Pixbuf>& dest_pixbuf, int dest_x, int dest_y) const
+{
+  gdk_pixbuf_copy_area(const_cast<GdkPixbuf*>(gobj()), src_x, src_y, width, height, Glib::unwrap(dest_pixbuf), dest_x, dest_y);
+}
+
+void Pixbuf::saturate_and_pixelate(const Glib::RefPtr<Gdk::Pixbuf>& dest, float saturation, bool pixelate) const
+{
+  gdk_pixbuf_saturate_and_pixelate(const_cast<GdkPixbuf*>(gobj()), Glib::unwrap(dest), saturation, static_cast<int>(pixelate));
+}
+
+void Pixbuf::scale(const Glib::RefPtr<Gdk::Pixbuf>& dest, int dest_x, int dest_y, int dest_width, int dest_height, double offset_x, double offset_y, double scale_x, double scale_y, InterpType interp_type) const
+{
+  gdk_pixbuf_scale(const_cast<GdkPixbuf*>(gobj()), Glib::unwrap(dest), dest_x, dest_y, dest_width, dest_height, offset_x, offset_y, scale_x, scale_y, ((GdkInterpType)(interp_type)));
+}
+
+void Pixbuf::composite(const Glib::RefPtr<Gdk::Pixbuf>& dest, int dest_x, int dest_y, int dest_width, int dest_height, double offset_x, double offset_y, double scale_x, double scale_y, InterpType interp_type, int overall_alpha) const
+{
+  gdk_pixbuf_composite(const_cast<GdkPixbuf*>(gobj()), Glib::unwrap(dest), dest_x, dest_y, dest_width, dest_height, offset_x, offset_y, scale_x, scale_y, ((GdkInterpType)(interp_type)), overall_alpha);
+}
+
+void Pixbuf::composite_color(const Glib::RefPtr<Gdk::Pixbuf>& dest, int dest_x, int dest_y, int dest_width, int dest_height, double offset_x, double offset_y, double scale_x, double scale_y, InterpType interp_type, int overall_alpha, int check_x, int check_y, int check_size, guint32 color1, guint32 color2) const
+{
+  gdk_pixbuf_composite_color(const_cast<GdkPixbuf*>(gobj()), Glib::unwrap(dest), dest_x, dest_y, dest_width, dest_height, offset_x, offset_y, scale_x, scale_y, ((GdkInterpType)(interp_type)), overall_alpha, check_x, check_y, check_size, color1, color2);
+}
+
+Glib::RefPtr<Gdk::Pixbuf> Pixbuf::scale_simple(int dest_width, int dest_height, InterpType interp_type) const
+{
+  return Glib::wrap(gdk_pixbuf_scale_simple(const_cast<GdkPixbuf*>(gobj()), dest_width, dest_height, ((GdkInterpType)(interp_type))));
+}
+
+Glib::RefPtr<Gdk::Pixbuf> Pixbuf::composite_color_simple(int dest_width, int dest_height, InterpType interp_type, int overall_alpha, int check_size, guint32 color1, guint32 color2) const
+{
+  return Glib::wrap(gdk_pixbuf_composite_color_simple(const_cast<GdkPixbuf*>(gobj()), dest_width, dest_height, ((GdkInterpType)(interp_type)), overall_alpha, check_size, color1, color2));
+}
+
+Glib::RefPtr<Gdk::Pixbuf> Pixbuf::rotate_simple(PixbufRotation angle) const
+{
+  return Glib::wrap(gdk_pixbuf_rotate_simple(const_cast<GdkPixbuf*>(gobj()), ((GdkPixbufRotation)(angle))));
+}
+
+Glib::RefPtr<Gdk::Pixbuf> Pixbuf::flip(bool horizontal) const
+{
+  return Glib::wrap(gdk_pixbuf_flip(const_cast<GdkPixbuf*>(gobj()), static_cast<int>(horizontal)));
+}
+
+void Pixbuf::render_threshold_alpha(const Glib::RefPtr<Gdk::Bitmap>& bitmap, int src_x, int src_y, int dest_x, int dest_y, int width, int height, int alpha_threshold)
+{
+  gdk_pixbuf_render_threshold_alpha(gobj(), Glib::unwrap(bitmap), src_x, src_y, dest_x, dest_y, width, height, alpha_threshold);
+}
+
+void Pixbuf::render_to_drawable(const Glib::RefPtr<Drawable>& drawable, const Glib::RefPtr<Gdk::GC>& gc, int src_x, int src_y, int dest_x, int dest_y, int width, int height, RgbDither dither, int x_dither, int y_dither)
+{
+  gdk_pixbuf_render_to_drawable(gobj(), Glib::unwrap(drawable), Glib::unwrap(gc), src_x, src_y, dest_x, dest_y, width, height, ((GdkRgbDither)(dither)), x_dither, y_dither);
+}
+
+void Pixbuf::render_to_drawable_alpha(const Glib::RefPtr<Drawable>& drawable, int src_x, int src_y, int dest_x, int dest_y, int width, int height, PixbufAlphaMode alpha_mode, int alpha_threshold, RgbDither dither, int x_dither, int y_dither)
+{
+  gdk_pixbuf_render_to_drawable_alpha(gobj(), Glib::unwrap(drawable), src_x, src_y, dest_x, dest_y, width, height, ((GdkPixbufAlphaMode)(alpha_mode)), alpha_threshold, ((GdkRgbDither)(dither)), x_dither, y_dither);
+}
+
+Glib::ustring Pixbuf::get_option(const Glib::ustring& key) const
+{
+  return Glib::convert_const_gchar_ptr_to_ustring(gdk_pixbuf_get_option(const_cast<GdkPixbuf*>(gobj()), key.c_str()));
+}
+
+
+} // namespace Gdk
+
+
diff --git a/libs/gtkmm2/gdk/gdkmm/pixbuf.h b/libs/gtkmm2/gdk/gdkmm/pixbuf.h
new file mode 100644
index 0000000000..712020a8b1
--- /dev/null
+++ b/libs/gtkmm2/gdk/gdkmm/pixbuf.h
@@ -0,0 +1,884 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GDKMM_PIXBUF_H
+#define _GDKMM_PIXBUF_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* Copyright (C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gdkmm/drawable.h>
+#include <gdkmm/image.h>
+#include <gdkmm/pixmap.h>
+#include <gdkmm/bitmap.h>
+#include <gdkmm/pixbufformat.h>
+#include <gdkmm/types.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GdkPixbuf GdkPixbuf;
+typedef struct _GdkPixbufClass GdkPixbufClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gdk
+{ class Pixbuf_Class; } // namespace Gdk
+namespace Gdk
+{
+
+
+/** @addtogroup gdkmmEnums Enums and Flags */
+
+/**
+ * @ingroup gdkmmEnums
+ */
+enum Colorspace
+{
+  COLORSPACE_RGB
+};
+
+} // namespace Gdk
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Gdk::Colorspace> : public Glib::Value_Enum<Gdk::Colorspace>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gdk
+{
+
+/**
+ * @ingroup gdkmmEnums
+ */
+enum InterpType
+{
+  INTERP_NEAREST,
+  INTERP_TILES,
+  INTERP_BILINEAR,
+  INTERP_HYPER
+};
+
+} // namespace Gdk
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Gdk::InterpType> : public Glib::Value_Enum<Gdk::InterpType>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gdk
+{
+
+/**
+ * @ingroup gdkmmEnums
+ */
+enum PixbufAlphaMode
+{
+  PIXBUF_ALPHA_BILEVEL,
+  PIXBUF_ALPHA_FULL
+};
+
+} // namespace Gdk
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Gdk::PixbufAlphaMode> : public Glib::Value_Enum<Gdk::PixbufAlphaMode>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gdk
+{
+
+/**
+ * @ingroup gdkmmEnums
+ */
+enum PixbufRotation
+{
+  PIXBUF_ROTATE_NONE = 0,
+  PIXBUF_ROTATE_COUNTERCLOCKWISE = 90,
+  PIXBUF_ROTATE_UPSIDEDOWN = 180,
+  PIXBUF_ROTATE_CLOCKWISE = 270
+};
+
+} // namespace Gdk
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Gdk::PixbufRotation> : public Glib::Value_Enum<Gdk::PixbufRotation>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gdk
+{
+
+
+/** Exception class for Gdk::Pixbuf errors.
+ */
+class PixbufError : public Glib::Error
+{
+public:
+  enum Code
+  {
+    CORRUPT_IMAGE,
+    INSUFFICIENT_MEMORY,
+    BAD_OPTION,
+    UNKNOWN_TYPE,
+    UNSUPPORTED_OPERATION,
+    FAILED
+  };
+
+  PixbufError(Code error_code, const Glib::ustring& error_message);
+  explicit PixbufError(GError* gobject);
+  Code code() const;
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+private:
+  static void throw_func(GError* gobject);
+  friend void wrap_init(); // uses throw_func()
+#endif
+};
+
+} // namespace Gdk
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Gdk::PixbufError::Code> : public Glib::Value_Enum<Gdk::PixbufError::Code>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gdk
+{
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+struct PixbufFormatTraits
+{
+  typedef PixbufFormat  CppType;
+  typedef const GdkPixbufFormat*      CType;
+  typedef GdkPixbufFormat*            CTypeNonConst;
+
+  static CType   to_c_type      (const CppType& obj) { return obj.gobj();     }
+  static CType   to_c_type      (CType          ptr) { return ptr;                   }
+  static CppType to_cpp_type    (CType          ptr) { return PixbufFormat(ptr); /* Does not take ownership */ }
+  static void    release_c_type (CType          /* ptr */) { /* Doesn't happen */ }
+};
+#endif //DOXYGEN_SHOULD_SKIP_THIS
+  
+
+class Pixbuf : public Glib::Object
+{
+  
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+public:
+  typedef Pixbuf CppObjectType;
+  typedef Pixbuf_Class CppClassType;
+  typedef GdkPixbuf BaseObjectType;
+  typedef GdkPixbufClass BaseClassType;
+
+private:  friend class Pixbuf_Class;
+  static CppClassType pixbuf_class_;
+
+private:
+  // noncopyable
+  Pixbuf(const Pixbuf&);
+  Pixbuf& operator=(const Pixbuf&);
+
+protected:
+  explicit Pixbuf(const Glib::ConstructParams& construct_params);
+  explicit Pixbuf(GdkPixbuf* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+  virtual ~Pixbuf();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GObject.
+  GdkPixbuf*       gobj()       { return reinterpret_cast<GdkPixbuf*>(gobject_); }
+
+  ///Provides access to the underlying C GObject.
+  const GdkPixbuf* gobj() const { return reinterpret_cast<GdkPixbuf*>(gobject_); }
+
+  ///Provides access to the underlying C instance. The caller is responsible for unrefing it. Use when directly setting fields in structs.
+  GdkPixbuf* gobj_copy();
+
+private:
+
+  
+protected:
+
+  //TODO: Documente these, based on the docs for the C functions.
+  Pixbuf(const Glib::RefPtr<Drawable>& src, const Glib::RefPtr<Colormap>& cmap,
+         int src_x, int src_y, int dest_x, int dest_y, int width, int height);
+  Pixbuf(const Glib::RefPtr<Image>& src, const Glib::RefPtr<Colormap>& cmap,
+         int src_x, int src_y, int dest_x, int dest_y, int width, int height);
+
+public:
+  typedef sigc::slot<void, const guint8*> SlotDestroyData;
+
+  
+  static Glib::RefPtr<Pixbuf> create(const Glib::RefPtr<Drawable>& src, const Glib::RefPtr<Colormap>& cmap, int src_x, int src_y, int dest_x, int dest_y, int width, int height);
+
+  
+  static Glib::RefPtr<Pixbuf> create(const Glib::RefPtr<Image>& src, const Glib::RefPtr<Colormap>& cmap, int src_x, int src_y, int dest_x, int dest_y, int width, int height);
+
+
+  /** Creates a new Gdk::Pixbuf with a copy of the information in the specified
+   *  @a pixbuf .
+   * @return A newly-created pixbuf with a reference count of 1, or <tt>0</tt> if
+   * not enough memory could be allocated.
+   */
+  Glib::RefPtr<Pixbuf> copy() const;
+
+  
+  /** Creates a new Gdk::Pixbuf structure and allocates a buffer for it.  The 
+   * buffer has an optimal rowstride.  Note that the buffer is not cleared;
+   * you will have to fill it completely yourself.
+   * @param colorspace Color space for image.
+   * @param has_alpha Whether the image should have transparency information.
+   * @param bits_per_sample Number of bits per color sample.
+   * @param width Width of image in pixels.
+   * @param height Height of image in pixels.
+   * @return A newly-created Gdk::Pixbuf with a reference count of 1, or 
+   * <tt>0</tt> if not enough memory could be allocated for the image buffer.
+   */
+  static Glib::RefPtr<Pixbuf> create(
+                   Colorspace colorspace, bool has_alpha,
+                   int bits_per_sample, int width, int height);
+
+  
+  /** Creates a new pixbuf which represents a sub-region of
+   *  @a src_pixbuf . The new pixbuf shares its pixels with the
+   * original pixbuf, so writing to one affects both.
+   * The new pixbuf holds a reference to @a src_pixbuf , so
+   *  @a src_pixbuf  will not be finalized until the new pixbuf
+   * is finalized.
+   * @param src_pixbuf A Gdk::Pixbuf.
+   * @param src_x X coord in @a src_pixbuf .
+   * @param src_y Y coord in @a src_pixbuf .
+   * @param width Width of region in @a src_pixbuf .
+   * @param height Height of region in @a src_pixbuf .
+   * @return A new pixbuf.
+   */
+  static Glib::RefPtr<Pixbuf> create_subpixbuf(
+                  const Glib::RefPtr<Pixbuf>& src_pixbuf,
+                  int src_x, int src_y, int width, int height);
+
+  /** Creates a new pixbuf by loading an image from a file. The file format is detected automatically. 
+   * @param filename The path to the pixbuf file.
+   * 
+   * @throw Glib::FileError
+   * @throw Gdk::PixbufError
+   */
+  static Glib::RefPtr<Pixbuf> create_from_file(const std::string& filename);
+  
+  /** Creates a new pixbuf by loading an image from a file. The file format is detected automatically.
+   * The image will be scaled to fit in the requested size.
+   * @param filename The path to the pixbuf file.
+   * @param width The desired width
+   * @param height The desired height
+   * @param preserve_aspect_ratio: Whether the image's aspect ratio will be preserved when scaling.
+   *
+   * @throw Glib::FileError
+   * @throw Gdk::PixbufError
+   */
+  static Glib::RefPtr<Pixbuf> create_from_file(const std::string& filename, int width, int height, bool preserve_aspect_ratio = true);
+  
+
+  /** Creates a new Gdk::Pixbuf out of in-memory image data.
+   * Currently only RGB images with 8 bits per sample are supported.
+   *
+   * @param data %Image data in 8-bit/sample packed format.
+   * @param colorspace Colorspace for the image data.
+   * @param has_alpha Whether the data has an opacity channel.
+   * @param bits_per_sample Number of bits per sample.
+   * @param width Width of the image in pixels.
+   * @param height Height of the image in pixels.
+   * @param rowstride Distance in bytes between rows.
+   * @return A newly-created Gdk::Pixbuf object.
+   */
+  static Glib::RefPtr<Pixbuf> create_from_data(const guint8* data, Colorspace colorspace,
+                                               bool has_alpha, int bits_per_sample,
+                                               int width, int height, int rowstride);
+
+  /** Creates a new Gdk::Pixbuf out of in-memory image data.
+   * Currently only RGB images with 8 bits per sample are supported.
+   *
+   * @param data %Image data in 8-bit/sample packed format.
+   * @param colorspace Colorspace for the image data.
+   * @param has_alpha Whether the data has an opacity channel.
+   * @param bits_per_sample Number of bits per sample.
+   * @param width Width of the image in pixels.
+   * @param height Height of the image in pixels.
+   * @param rowstride Distance in bytes between rows.
+   * @param destroy_slot Slot used to free the data when the pixbuf's
+   * reference count drops to zero.
+   * @return A newly-created Gdk::Pixbuf object.
+   */
+  static Glib::RefPtr<Pixbuf> create_from_data(const guint8* data, Colorspace colorspace,
+                                               bool has_alpha, int bits_per_sample,
+                                               int width, int height, int rowstride,
+                                               const SlotDestroyData& destroy_slot);
+
+  
+  /** Creates a new pixbuf by parsing XPM data in memory.  This data is commonly
+   * the result of including an XPM file into a program's C source.
+   * @param data Pointer to inline XPM data.
+   * @return A newly-created pixbuf with a reference count of 1.
+   */
+  static Glib::RefPtr<Pixbuf> create_from_xpm_data(const char *const * data);
+
+  /** Create a Gdk::Pixbuf from a flat representation that is suitable for
+   * storing as inline data in a program.  This is useful if you want to ship a
+   * program with images, but don't want to depend on any external files.
+   *
+   * GTK+ ships with a program called <tt>gdk-pixbuf-csource</tt> which allows
+   * for conversion of GdkPixbufs into such a inline representation. In almost
+   * all cases, you should pass the <tt>--raw</tt> flag to
+   * <tt>gdk-pixbuf-csource</tt>. A sample invocation would be:
+   *
+   * <tt>gdk-pixbuf-csource --raw --name=myimage_inline myimage.png</tt>
+   *
+   * For the typical case where the inline pixbuf is read-only static data, you
+   * don't need to copy the pixel data unless you intend to write to it, so you
+   * can pass <tt>false</tt> for @a copy_pixels. (If you pass <tt>--rle</tt> to
+   * <tt>gdk-pixbuf-csource</tt>, a copy will be made even if @a copy_pixels is
+   * <tt>false</tt>, so using this option is generally a bad idea.)
+   *
+   * If you create a pixbuf from const inline data compiled into your program,
+   * it's probably safe to ignore errors, since things will always succeed. For
+   * non-const inline data, you could get out of memory. For untrusted inline
+   * data located at runtime, you could have corrupt inline data in addition.
+   *
+   * @param data_length Length in bytes of the @a data argument.
+   * @param data Byte data containing a serialized GdkPixdata structure.
+   * @param copy_pixels Whether to copy the pixel data, or use direct pointers
+   * to @a data for the resulting pixbuf.
+   * @throw Gdk::PixbufError
+   */
+  static Glib::RefPtr<Pixbuf> create_from_inline(int data_length, const guint8* data,
+                                                 bool copy_pixels = false);
+
+  
+  /** Queries the color space of a pixbuf.
+   * @return Color space.
+   */
+  Colorspace get_colorspace() const;
+
+  
+  /** Queries the number of channels of a pixbuf.
+   * @return Number of channels.
+   */
+  int get_n_channels() const;
+  
+  /** Queries whether a pixbuf has an alpha channel (opacity information).
+   * @return <tt>true</tt> if it has an alpha channel, <tt>false</tt> otherwise.
+   */
+  bool get_has_alpha() const;
+  
+  /** Queries the number of bits per color sample in a pixbuf.
+   * @return Number of bits per color sample.
+   */
+  int get_bits_per_sample() const;
+  
+  /** Queries a pointer to the pixel data of a pixbuf.
+   * @return A pointer to the pixbuf's pixel data.  Please see &lt;xref linkend="image-data"/&gt;
+   * for information about how the pixel data is stored in
+   * memory.
+   */
+  guint8* get_pixels() const;
+  
+  /** Queries the width of a pixbuf.
+   * @return Width in pixels.
+   */
+  int get_width() const;
+  
+  /** Queries the height of a pixbuf.
+   * @return Height in pixels.
+   */
+  int get_height() const;
+  
+  /** Queries the rowstride of a pixbuf, which is the number of bytes between the start of a row
+   * and the start of the next row.
+   * @return Distance between row starts.
+   */
+  int get_rowstride() const;
+
+  
+  /** Clears a pixbuf to the given RGBA value, converting the RGBA value into
+   * the pixbuf's pixel format. The alpha will be ignored if the pixbuf
+   * doesn't have an alpha channel.
+   * @param pixel RGBA pixel to clear to
+   * (0xffffffff is opaque white, 0x00000000 transparent black).
+   */
+  void fill(guint32 pixel);
+
+  /** Save an image file.
+   * @throw Glib::FileError
+   * @throw Gdk::PixbufError
+   */
+  void save(const std::string& filename, const Glib::ustring& type);
+  
+
+  /** Save an image file.
+   * @throw Glib::FileError
+   * @throw Gdk::PixbufError
+   */
+  void save(const std::string& filename, const Glib::ustring& type,
+            const Glib::StringArrayHandle& option_keys,
+            const Glib::StringArrayHandle& option_values);
+  
+  
+/* TODO:
+typedef gboolean (*GdkPixbufSaveFunc)   (const gchar *buf,
+					 gsize count,
+					 GError **error,
+					 gpointer data);
+
+gboolean gdk_pixbuf_save_to_callback    (GdkPixbuf  *pixbuf,
+					 GdkPixbufSaveFunc save_func,
+					 gpointer user_data,
+					 const char *type, 
+					 GError    **error,
+					 ...);
+
+gboolean gdk_pixbuf_save_to_callbackv   (GdkPixbuf  *pixbuf, 
+					 GdkPixbufSaveFunc save_func,
+					 gpointer user_data,
+					 const char *type,
+					 char      **option_keys,
+					 char      **option_values,
+					 GError    **error);
+
+*/
+
+  void save_to_buffer(gchar*& buffer, gsize& buffer_size,
+                      const Glib::ustring& type,
+                      const Glib::StringArrayHandle& option_keys,
+                      const Glib::StringArrayHandle& option_values);
+  
+                                         
+  /** Takes an existing pixbuf and adds an alpha channel to it.
+   * If the existing pixbuf already had an alpha channel, the channel
+   * values are copied from the original; otherwise, the alpha channel
+   * is initialized to 255 (full opacity).
+   * 
+   * If @a substitute_color  is <tt>true</tt>, then the color specified by ( @a r , @a g , @a b ) will be
+   * assigned zero opacity. That is, if you pass (255, 255, 255) for the
+   * substitute color, all white pixels will become fully transparent.
+   * @param substitute_color Whether to set a color to zero opacity.  If this
+   * is <tt>false</tt>, then the ( @a r , @a g , @a b ) arguments will be ignored.
+   * @param r Red value to substitute.
+   * @param g Green value to substitute.
+   * @param b Blue value to substitute.
+   * @return A newly-created pixbuf with a reference count of 1.
+   */
+  Glib::RefPtr<Gdk::Pixbuf> add_alpha(
+                   bool substitute_color, guint8 r, guint8 g, guint8 b) const;
+
+  
+  /** Copies a rectangular area from @a src_pixbuf  to @a dest_pixbuf .  Conversion of
+   * pixbuf formats is done automatically.
+   * @param src_x Source X coordinate within @a src_pixbuf .
+   * @param src_y Source Y coordinate within @a src_pixbuf .
+   * @param width Width of the area to copy.
+   * @param height Height of the area to copy.
+   * @param dest_pixbuf Destination pixbuf.
+   * @param dest_x X coordinate within @a dest_pixbuf .
+   * @param dest_y Y coordinate within @a dest_pixbuf .
+   */
+  void copy_area(
+                   int src_x, int src_y, int width, int height,
+                   const Glib::RefPtr<Gdk::Pixbuf>& dest_pixbuf,
+                   int dest_x, int dest_y) const;
+
+  
+  /** Modifies saturation and optionally pixelates @a src , placing the
+   * result in @a dest . @a src  and @a dest  may be the same pixbuf with no ill
+   * effects.  If @a saturation  is 1.0 then saturation is not changed. If
+   * it's less than 1.0, saturation is reduced (the image is darkened);
+   * if greater than 1.0, saturation is increased (the image is
+   * brightened). If @a pixelate  is <tt>true</tt>, then pixels are faded in a
+   * checkerboard pattern to create a pixelated image. @a src  and @a dest 
+   * must have the same image format, size, and rowstride.
+   * @param dest Place to write modified version of @a src .
+   * @param saturation Saturation factor.
+   * @param pixelate Whether to pixelate.
+   */
+  void saturate_and_pixelate(
+                   const Glib::RefPtr<Gdk::Pixbuf>& dest,
+                   float saturation, bool pixelate) const;
+
+
+  /** Creates a transformation of the source image @a src  by scaling by
+   *  @a scale_x  and @a scale_y  then translating by @a offset_x  and @a offset_y ,
+   * then renders the rectangle ( @a dest_x , @a dest_y , @a dest_width ,
+   *  @a dest_height ) of the resulting image onto the destination image
+   * replacing the previous contents.
+   * 
+   * Try to use scale_simple() first, this function is
+   * the industrial-strength power tool you can fall back to if
+   * scale_simple() isn't powerful enough.
+   * @param dest The Gdk::Pixbuf into which to render the results.
+   * @param dest_x The left coordinate for region to render.
+   * @param dest_y The top coordinate for region to render.
+   * @param dest_width The width of the region to render.
+   * @param dest_height The height of the region to render.
+   * @param offset_x The offset in the X direction (currently rounded to an integer).
+   * @param offset_y The offset in the Y direction (currently rounded to an integer).
+   * @param scale_x The scale factor in the X direction.
+   * @param scale_y The scale factor in the Y direction.
+   * @param interp_type The interpolation type for the transformation.
+   */
+  void scale(const Glib::RefPtr<Gdk::Pixbuf>& dest,
+                          int    dest_x,      int    dest_y,
+                          int    dest_width,  int    dest_height,
+                          double offset_x,    double offset_y,
+                          double scale_x,     double scale_y,
+                          InterpType interp_type) const;
+
+  
+  /** Creates a transformation of the source image @a src  by scaling by
+   *  @a scale_x  and @a scale_y  then translating by @a offset_x  and @a offset_y .
+   * This gives an image in the coordinates of the destination pixbuf.
+   * The rectangle ( @a dest_x , @a dest_y , @a dest_width , @a dest_height )
+   * is then composited onto the corresponding rectangle of the
+   * original destination image.
+   * 
+   * When the destination rectangle contains parts not in the source 
+   * image, the data at the edges of the source image is replicated
+   * to infinity. 
+   * 
+   * &lt;figure id="pixbuf-composite-diagram"&gt;
+   * &lt;title&gt;Compositing of pixbufs&lt;/title&gt;
+   * &lt;graphic fileref="composite.png" format="PNG"/&gt;
+   * &lt;/figure&gt;
+   * @param dest The Gdk::Pixbuf into which to render the results.
+   * @param dest_x The left coordinate for region to render.
+   * @param dest_y The top coordinate for region to render.
+   * @param dest_width The width of the region to render.
+   * @param dest_height The height of the region to render.
+   * @param offset_x The offset in the X direction (currently rounded to an integer).
+   * @param offset_y The offset in the Y direction (currently rounded to an integer).
+   * @param scale_x The scale factor in the X direction.
+   * @param scale_y The scale factor in the Y direction.
+   * @param interp_type The interpolation type for the transformation.
+   * @param overall_alpha Overall alpha for source image (0..255).
+   */
+  void composite(const Glib::RefPtr<Gdk::Pixbuf>& dest,
+                              int    dest_x,      int    dest_y,
+                              int    dest_width,  int    dest_height,
+                              double offset_x,    double offset_y,
+                              double scale_x,     double scale_y,
+                              InterpType interp_type,
+                              int overall_alpha) const;
+
+  
+  /** Creates a transformation of the source image @a src  by scaling by
+   *  @a scale_x  and @a scale_y  then translating by @a offset_x  and @a offset_y ,
+   * then composites the rectangle ( @a dest_x  , @a dest_y , @a dest_width ,
+   *  @a dest_height ) of the resulting image with a checkboard of the
+   * colors @a color1  and @a color2  and renders it onto the destination
+   * image.
+   * 
+   * See composite_color_simple() for a simpler variant of this
+   * function suitable for many tasks.
+   * @param dest The Gdk::Pixbuf into which to render the results.
+   * @param dest_x The left coordinate for region to render.
+   * @param dest_y The top coordinate for region to render.
+   * @param dest_width The width of the region to render.
+   * @param dest_height The height of the region to render.
+   * @param offset_x The offset in the X direction (currently rounded to an integer).
+   * @param offset_y The offset in the Y direction (currently rounded to an integer).
+   * @param scale_x The scale factor in the X direction.
+   * @param scale_y The scale factor in the Y direction.
+   * @param interp_type The interpolation type for the transformation.
+   * @param overall_alpha Overall alpha for source image (0..255).
+   * @param check_x The X offset for the checkboard (origin of checkboard is at - @a check_x , - @a check_y ).
+   * @param check_y The Y offset for the checkboard.
+   * @param check_size The size of checks in the checkboard (must be a power of two).
+   * @param color1 The color of check at upper left.
+   * @param color2 The color of the other check.
+   */
+  void composite_color(const Glib::RefPtr<Gdk::Pixbuf>& dest,
+                                    int    dest_x,      int    dest_y,
+                                    int    dest_width,  int    dest_height,
+                                    double offset_x,    double offset_y,
+                                    double scale_x,     double scale_y,
+                                    InterpType interp_type,
+                                    int overall_alpha,
+                                    int check_x, int check_y,
+                                    int check_size,
+                                    guint32 color1, guint32 color2) const;
+
+  
+  /** Create a new Gdk::Pixbuf containing a copy of @a src  scaled to
+   *  @a dest_width  x @a dest_height . Leaves @a src  unaffected.  @a interp_type 
+   * should be Gdk::INTERP_NEAREST if you want maximum speed (but when
+   * scaling down Gdk::INTERP_NEAREST is usually unusably ugly).  The
+   * default @a interp_type  should be Gdk::INTERP_BILINEAR which offers
+   * reasonable quality and speed.
+   * 
+   * You can scale a sub-portion of @a src  by creating a sub-pixbuf
+   * pointing into @a src ; see new_subpixbuf().
+   * 
+   * For more complicated scaling/compositing see scale()
+   * and composite().
+   * @param dest_width The width of destination image.
+   * @param dest_height The height of destination image.
+   * @param interp_type The interpolation type for the transformation.
+   * @return The new Gdk::Pixbuf, or <tt>0</tt> if not enough memory could be
+   * allocated for it.
+   */
+  Glib::RefPtr<Gdk::Pixbuf> scale_simple(
+                   int dest_width, int dest_height,
+                   InterpType interp_type) const;
+
+  
+  /** Creates a new Gdk::Pixbuf by scaling @a src  to @a dest_width  x
+   *  @a dest_height  and compositing the result with a checkboard of colors
+   *  @a color1  and @a color2 .
+   * @param dest_width The width of destination image.
+   * @param dest_height The height of destination image.
+   * @param interp_type The interpolation type for the transformation.
+   * @param overall_alpha Overall alpha for source image (0..255).
+   * @param check_size The size of checks in the checkboard (must be a power of two).
+   * @param color1 The color of check at upper left.
+   * @param color2 The color of the other check.
+   * @return The new Gdk::Pixbuf, or <tt>0</tt> if not enough memory could be
+   * allocated for it.
+   */
+  Glib::RefPtr<Gdk::Pixbuf> composite_color_simple(
+                   int dest_width, int dest_height,
+                   InterpType interp_type,
+                   int overall_alpha, int check_size,
+                   guint32 color1, guint32 color2) const;
+               
+  
+  /** Rotates a pixbuf by a multiple of 90 degrees, and returns the
+   * result in a new pixbuf.
+   * @param angle The angle to rotate by.
+   * @return A new pixbuf
+   * 
+   * Since: 2.6.
+   */
+  Glib::RefPtr<Gdk::Pixbuf> rotate_simple(PixbufRotation angle) const;
+  
+  /** Flips a pixbuf horizontally or vertically and returns the
+   * result in a new pixbuf.
+   * @param horizontal <tt>true</tt> to flip horizontally, <tt>false</tt> to flip vertically.
+   * @return A new pixbuf.
+   * 
+   * Since: 2.6.
+   */
+  Glib::RefPtr<Gdk::Pixbuf> flip(bool horizontal = true) const;
+
+  
+  /** Takes the opacity values in a rectangular portion of a pixbuf and thresholds
+   * them to produce a bi-level alpha mask that can be used as a clipping mask for
+   * a drawable.
+   * @param bitmap Bitmap where the bilevel mask will be painted to.
+   * @param src_x Source X coordinate.
+   * @param src_y Source Y coordinate.
+   * @param dest_x Destination X coordinate.
+   * @param dest_y Destination Y coordinate.
+   * @param width Width of region to threshold, or -1 to use pixbuf width.
+   * @param height Height of region to threshold, or -1 to use pixbuf height.
+   * @param alpha_threshold Opacity values below this will be painted as zero; all
+   * other values will be painted as one.
+   */
+  void render_threshold_alpha(const Glib::RefPtr<Gdk::Bitmap>& bitmap,
+                                          int src_x, int src_y,
+                                          int dest_x, int dest_y,
+                                          int width, int height,
+                                          int alpha_threshold);
+
+  
+  /** Renders a rectangular portion of a pixbuf to a drawable while using the
+   * specified GC.  This is done using GdkRGB, so the specified drawable must have
+   * the GdkRGB visual and colormap.  Note that this function will ignore the
+   * opacity information for images with an alpha channel; the GC must already
+   * have the clipping mask set if you want transparent regions to show through.
+   * 
+   * For an explanation of dither offsets, see the GdkRGB documentation.  In
+   * brief, the dither offset is important when re-rendering partial regions of an
+   * image to a rendered version of the full image, or for when the offsets to a
+   * base position change, as in scrolling.  The dither matrix has to be shifted
+   * for consistent visual results.  If you do not have any of these cases, the
+   * dither offsets can be both zero.
+   * 
+   * Deprecated: This function is obsolete. Use gdk_draw_pixbuf() instead.
+   * @param drawable Destination drawable.
+   * @param gc GC used for rendering.
+   * @param src_x Source X coordinate within pixbuf.
+   * @param src_y Source Y coordinate within pixbuf.
+   * @param dest_x Destination X coordinate within drawable.
+   * @param dest_y Destination Y coordinate within drawable.
+   * @param width Width of region to render, in pixels, or -1 to use pixbuf width.
+   * @param height Height of region to render, in pixels, or -1 to use pixbuf height.
+   * @param dither Dithering mode for GdkRGB.
+   * @param x_dither X offset for dither.
+   * @param y_dither Y offset for dither.
+   */
+  void render_to_drawable(const Glib::RefPtr<Drawable>& drawable,
+                                          const Glib::RefPtr<Gdk::GC>& gc,
+                                          int src_x, int src_y,
+                                          int dest_x, int dest_y,
+                                          int width, int height,
+                                          RgbDither dither,
+                                          int x_dither, int y_dither);
+  
+  /** Renders a rectangular portion of a pixbuf to a drawable.  The destination
+   * drawable must have a colormap. All windows have a colormap, however, pixmaps
+   * only have colormap by default if they were created with a non-<tt>0</tt> window argument.
+   * Otherwise a colormap must be set on them with gdk_drawable_set_colormap.
+   * 
+   * On older X servers, rendering pixbufs with an alpha channel involves round trips
+   * to the X server, and may be somewhat slow.
+   * 
+   * Deprecated: This function is obsolete. Use gdk_draw_pixbuf() instead.
+   * @param drawable Destination drawable.
+   * @param src_x Source X coordinate within pixbuf.
+   * @param src_y Source Y coordinates within pixbuf.
+   * @param dest_x Destination X coordinate within drawable.
+   * @param dest_y Destination Y coordinate within drawable.
+   * @param width Width of region to render, in pixels, or -1 to use pixbuf width.
+   * @param height Height of region to render, in pixels, or -1 to use pixbuf height.
+   * @param alpha_mode Ignored. Present for backwards compatibility.
+   * @param alpha_threshold Ignored. Present for backwards compatibility.
+   * @param dither Dithering mode for GdkRGB.
+   * @param x_dither X offset for dither.
+   * @param y_dither Y offset for dither.
+   */
+  void render_to_drawable_alpha(const Glib::RefPtr<Drawable>& drawable,
+                                          int src_x, int src_y,
+                                          int dest_x, int dest_y,
+                                          int width, int height,
+                                          PixbufAlphaMode alpha_mode,
+                                          int alpha_threshold,
+                                          RgbDither dither,
+                                          int x_dither, int y_dither);
+
+  void render_pixmap_and_mask_for_colormap(const Glib::RefPtr<Colormap>& colormap,
+                                           Glib::RefPtr<Pixmap>& pixmap_return,
+                                           Glib::RefPtr<Bitmap>& mask_return,
+                                           int alpha_threshold);
+
+  void render_pixmap_and_mask(Glib::RefPtr<Pixmap>& pixmap_return,
+                              Glib::RefPtr<Bitmap>& mask_return, int alpha_threshold);
+
+  
+  /** Looks up @a key  in the list of options that may have been attached to the
+   *  @a pixbuf  when it was loaded.
+   * @param key A nul-terminated string.
+   * @return The value associated with @a key . This is a nul-terminated 
+   * string that should not be freed or <tt>0</tt> if @a key  was not found.
+   */
+  Glib::ustring get_option(const Glib::ustring& key) const;
+
+
+  typedef Glib::SListHandle< Glib::RefPtr<PixbufFormat>, PixbufFormatTraits > SListHandle_PixbufFormat;
+  static SListHandle_PixbufFormat get_formats();
+  
+
+public:
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+};
+
+} // namespace Gdk
+
+
+namespace Glib
+{
+  /** @relates Gdk::Pixbuf
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Glib::RefPtr<Gdk::Pixbuf> wrap(GdkPixbuf* object, bool take_copy = false);
+}
+
+
+#endif /* _GDKMM_PIXBUF_H */
+
diff --git a/libs/gtkmm2/gdk/gdkmm/pixbufanimation.cc b/libs/gtkmm2/gdk/gdkmm/pixbufanimation.cc
new file mode 100644
index 0000000000..a558a55044
--- /dev/null
+++ b/libs/gtkmm2/gdk/gdkmm/pixbufanimation.cc
@@ -0,0 +1,172 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gdkmm/pixbufanimation.h>
+#include <gdkmm/private/pixbufanimation_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/*
+ *
+ * Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gdk/gdkcolor.h>
+
+namespace Gdk
+{
+
+Glib::RefPtr<PixbufAnimation> PixbufAnimation::create_from_file(const Glib::ustring& filename)
+{
+  GError* pError = 0;
+  return Glib::wrap(gdk_pixbuf_animation_new_from_file(filename.c_str(), &pError));
+}
+
+} //Gdk
+
+
+namespace
+{
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Glib::RefPtr<Gdk::PixbufAnimation> wrap(GdkPixbufAnimation* object, bool take_copy)
+{
+  return Glib::RefPtr<Gdk::PixbufAnimation>( dynamic_cast<Gdk::PixbufAnimation*> (Glib::wrap_auto ((GObject*)(object), take_copy)) );
+  //We use dynamic_cast<> in case of multiple inheritance.
+}
+
+} /* namespace Glib */
+
+
+namespace Gdk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& PixbufAnimation_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &PixbufAnimation_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gdk_pixbuf_animation_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void PixbufAnimation_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+}
+
+
+Glib::ObjectBase* PixbufAnimation_Class::wrap_new(GObject* object)
+{
+  return new PixbufAnimation((GdkPixbufAnimation*)object);
+}
+
+
+/* The implementation: */
+
+GdkPixbufAnimation* PixbufAnimation::gobj_copy()
+{
+  reference();
+  return gobj();
+}
+
+PixbufAnimation::PixbufAnimation(const Glib::ConstructParams& construct_params)
+:
+  Glib::Object(construct_params)
+{}
+
+PixbufAnimation::PixbufAnimation(GdkPixbufAnimation* castitem)
+:
+  Glib::Object((GObject*)(castitem))
+{}
+
+PixbufAnimation::~PixbufAnimation()
+{}
+
+
+PixbufAnimation::CppClassType PixbufAnimation::pixbufanimation_class_; // initialize static member
+
+GType PixbufAnimation::get_type()
+{
+  return pixbufanimation_class_.init().get_type();
+}
+
+GType PixbufAnimation::get_base_type()
+{
+  return gdk_pixbuf_animation_get_type();
+}
+
+
+int PixbufAnimation::get_width() const
+{
+  return gdk_pixbuf_animation_get_width(const_cast<GdkPixbufAnimation*>(gobj()));
+}
+
+int PixbufAnimation::get_height() const
+{
+  return gdk_pixbuf_animation_get_height(const_cast<GdkPixbufAnimation*>(gobj()));
+}
+
+bool PixbufAnimation::is_static_image() const
+{
+  return gdk_pixbuf_animation_is_static_image(const_cast<GdkPixbufAnimation*>(gobj()));
+}
+
+Glib::RefPtr<Pixbuf> PixbufAnimation::get_static_image()
+{
+
+  Glib::RefPtr<Pixbuf> retvalue = Glib::wrap(gdk_pixbuf_animation_get_static_image(gobj()));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::RefPtr<PixbufAnimationIter> PixbufAnimation::get_iter(const GTimeVal* start_time)
+{
+
+  Glib::RefPtr<PixbufAnimationIter> retvalue = Glib::wrap(gdk_pixbuf_animation_get_iter(gobj(), start_time));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+
+} // namespace Gdk
+
+
diff --git a/libs/gtkmm2/gdk/gdkmm/pixbufanimation.h b/libs/gtkmm2/gdk/gdkmm/pixbufanimation.h
new file mode 100644
index 0000000000..dd5afec672
--- /dev/null
+++ b/libs/gtkmm2/gdk/gdkmm/pixbufanimation.h
@@ -0,0 +1,194 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GDKMM_PIXBUFANIMATION_H
+#define _GDKMM_PIXBUFANIMATION_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* box.h
+ *
+ * Copyright (C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <glibmm/object.h>
+#include <gdkmm/pixbuf.h>
+#include <gdkmm/pixbufanimationiter.h>
+#include <gdk-pixbuf/gdk-pixbuf.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GdkPixbufAnimation GdkPixbufAnimation;
+typedef struct _GdkPixbufAnimationClass GdkPixbufAnimationClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gdk
+{ class PixbufAnimation_Class; } // namespace Gdk
+namespace Gdk
+{
+
+
+class PixbufAnimation : public Glib::Object
+{
+  
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+public:
+  typedef PixbufAnimation CppObjectType;
+  typedef PixbufAnimation_Class CppClassType;
+  typedef GdkPixbufAnimation BaseObjectType;
+  typedef GdkPixbufAnimationClass BaseClassType;
+
+private:  friend class PixbufAnimation_Class;
+  static CppClassType pixbufanimation_class_;
+
+private:
+  // noncopyable
+  PixbufAnimation(const PixbufAnimation&);
+  PixbufAnimation& operator=(const PixbufAnimation&);
+
+protected:
+  explicit PixbufAnimation(const Glib::ConstructParams& construct_params);
+  explicit PixbufAnimation(GdkPixbufAnimation* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+  virtual ~PixbufAnimation();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GObject.
+  GdkPixbufAnimation*       gobj()       { return reinterpret_cast<GdkPixbufAnimation*>(gobject_); }
+
+  ///Provides access to the underlying C GObject.
+  const GdkPixbufAnimation* gobj() const { return reinterpret_cast<GdkPixbufAnimation*>(gobject_); }
+
+  ///Provides access to the underlying C instance. The caller is responsible for unrefing it. Use when directly setting fields in structs.
+  GdkPixbufAnimation* gobj_copy();
+
+private:
+
+  
+protected:
+
+public:
+
+  static Glib::RefPtr<PixbufAnimation> create_from_file(const Glib::ustring& filename);
+
+  
+  /** Queries the width of the bounding box of a pixbuf animation.
+   * @return Width of the bounding box of the animation.
+   */
+  int get_width() const;
+  
+  /** Queries the height of the bounding box of a pixbuf animation.
+   * @return Height of the bounding box of the animation.
+   */
+  int get_height() const;
+  
+  /** If you load a file with new_from_file() and it turns
+   * out to be a plain, unanimated image, then this function will return
+   * <tt>true</tt>. Use get_static_image() to retrieve
+   * the image.
+   * @return <tt>true</tt> if the "animation" was really just an image.
+   */
+  bool is_static_image() const;
+  
+  /** If an animation is really just a plain image (has only one frame),
+   * this function returns that image. If the animation is an animation,
+   * this function returns a reasonable thing to display as a static
+   * unanimated image, which might be the first frame, or something more
+   * sophisticated. If an animation hasn't loaded any frames yet, this
+   * function will return <tt>0</tt>.
+   * @return Unanimated image representing the animation.
+   */
+  Glib::RefPtr<Pixbuf> get_static_image();
+  
+  /** Get an iterator for displaying an animation. The iterator provides
+   * the frames that should be displayed at a given time.
+   * It should be freed after use with Glib::object_unref().
+   * 
+   *  @a start_time  would normally come from Glib::get_current_time(), and
+   * marks the beginning of animation playback. After creating an
+   * iterator, you should immediately display the pixbuf returned by
+   * Gdk::PixbufAnimationIter::get_pixbuf(). Then, you should install a
+   * timeout (with Glib::timeout_add()) or by some other mechanism ensure
+   * that you'll update the image after
+   * Gdk::PixbufAnimationIter::get_delay_time() milliseconds. Each time
+   * the image is updated, you should reinstall the timeout with the new,
+   * possibly-changed delay time.
+   * 
+   * As a shortcut, if @a start_time  is <tt>0</tt>, the result of
+   * Glib::get_current_time() will be used automatically.
+   * 
+   * To update the image (i.e. possibly change the result of
+   * Gdk::PixbufAnimationIter::get_pixbuf() to a new frame of the animation),
+   * call Gdk::PixbufAnimationIter::advance().
+   * 
+   * If you're using Gdk::PixbufLoader, in addition to updating the image
+   * after the delay time, you should also update it whenever you
+   * receive the area_updated signal and
+   * Gdk::PixbufAnimationIter::on_currently_loading_frame() returns
+   * <tt>true</tt>. In this case, the frame currently being fed into the loader
+   * has received new data, so needs to be refreshed. The delay time for
+   * a frame may also be modified after an area_updated signal, for
+   * example if the delay time for a frame is encoded in the data after
+   * the frame itself. So your timeout should be reinstalled after any
+   * area_updated signal.
+   * 
+   * A delay time of -1 is possible, indicating "infinite."
+   * @param start_time Time when the animation starts playing.
+   * @return An iterator to move over the animation.
+   */
+  Glib::RefPtr<PixbufAnimationIter> get_iter(const GTimeVal* start_time);
+
+
+public:
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+};
+
+} /* namespace Gdk */
+
+
+namespace Glib
+{
+  /** @relates Gdk::PixbufAnimation
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Glib::RefPtr<Gdk::PixbufAnimation> wrap(GdkPixbufAnimation* object, bool take_copy = false);
+}
+
+
+#endif /* _GDKMM_PIXBUFANIMATION_H */
+
diff --git a/libs/gtkmm2/gdk/gdkmm/pixbufanimationiter.cc b/libs/gtkmm2/gdk/gdkmm/pixbufanimationiter.cc
new file mode 100644
index 0000000000..60046e4eff
--- /dev/null
+++ b/libs/gtkmm2/gdk/gdkmm/pixbufanimationiter.cc
@@ -0,0 +1,123 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gdkmm/pixbufanimationiter.h>
+#include <gdkmm/private/pixbufanimationiter_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/*
+ *
+ * Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+
+namespace
+{
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Glib::RefPtr<Gdk::PixbufAnimationIter> wrap(GdkPixbufAnimationIter* object, bool take_copy)
+{
+  return Glib::RefPtr<Gdk::PixbufAnimationIter>( dynamic_cast<Gdk::PixbufAnimationIter*> (Glib::wrap_auto ((GObject*)(object), take_copy)) );
+  //We use dynamic_cast<> in case of multiple inheritance.
+}
+
+} /* namespace Glib */
+
+
+namespace Gdk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& PixbufAnimationIter_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &PixbufAnimationIter_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gdk_pixbuf_animation_iter_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void PixbufAnimationIter_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+}
+
+
+Glib::ObjectBase* PixbufAnimationIter_Class::wrap_new(GObject* object)
+{
+  return new PixbufAnimationIter((GdkPixbufAnimationIter*)object);
+}
+
+
+/* The implementation: */
+
+GdkPixbufAnimationIter* PixbufAnimationIter::gobj_copy()
+{
+  reference();
+  return gobj();
+}
+
+PixbufAnimationIter::PixbufAnimationIter(const Glib::ConstructParams& construct_params)
+:
+  Glib::Object(construct_params)
+{}
+
+PixbufAnimationIter::PixbufAnimationIter(GdkPixbufAnimationIter* castitem)
+:
+  Glib::Object((GObject*)(castitem))
+{}
+
+PixbufAnimationIter::~PixbufAnimationIter()
+{}
+
+
+PixbufAnimationIter::CppClassType PixbufAnimationIter::pixbufanimationiter_class_; // initialize static member
+
+GType PixbufAnimationIter::get_type()
+{
+  return pixbufanimationiter_class_.init().get_type();
+}
+
+GType PixbufAnimationIter::get_base_type()
+{
+  return gdk_pixbuf_animation_iter_get_type();
+}
+
+
+} // namespace Gdk
+
+
diff --git a/libs/gtkmm2/gdk/gdkmm/pixbufanimationiter.h b/libs/gtkmm2/gdk/gdkmm/pixbufanimationiter.h
new file mode 100644
index 0000000000..ceba0da1e9
--- /dev/null
+++ b/libs/gtkmm2/gdk/gdkmm/pixbufanimationiter.h
@@ -0,0 +1,120 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GDKMM_PIXBUFANIMATIONITER_H
+#define _GDKMM_PIXBUFANIMATIONITER_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* pixbufanimationiter.h
+ *
+ * Copyright (C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <glibmm/object.h>
+#include <gdk-pixbuf/gdk-pixbuf.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GdkPixbufAnimationIter GdkPixbufAnimationIter;
+typedef struct _GdkPixbufAnimationIterClass GdkPixbufAnimationIterClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gdk
+{ class PixbufAnimationIter_Class; } // namespace Gdk
+namespace Gdk
+{
+
+
+class PixbufAnimationIter : public Glib::Object
+{
+  
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+public:
+  typedef PixbufAnimationIter CppObjectType;
+  typedef PixbufAnimationIter_Class CppClassType;
+  typedef GdkPixbufAnimationIter BaseObjectType;
+  typedef GdkPixbufAnimationIterClass BaseClassType;
+
+private:  friend class PixbufAnimationIter_Class;
+  static CppClassType pixbufanimationiter_class_;
+
+private:
+  // noncopyable
+  PixbufAnimationIter(const PixbufAnimationIter&);
+  PixbufAnimationIter& operator=(const PixbufAnimationIter&);
+
+protected:
+  explicit PixbufAnimationIter(const Glib::ConstructParams& construct_params);
+  explicit PixbufAnimationIter(GdkPixbufAnimationIter* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+  virtual ~PixbufAnimationIter();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GObject.
+  GdkPixbufAnimationIter*       gobj()       { return reinterpret_cast<GdkPixbufAnimationIter*>(gobject_); }
+
+  ///Provides access to the underlying C GObject.
+  const GdkPixbufAnimationIter* gobj() const { return reinterpret_cast<GdkPixbufAnimationIter*>(gobject_); }
+
+  ///Provides access to the underlying C instance. The caller is responsible for unrefing it. Use when directly setting fields in structs.
+  GdkPixbufAnimationIter* gobj_copy();
+
+private:
+
+protected:
+
+
+public:
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+};
+
+} /* namespace Gdk */
+
+
+namespace Glib
+{
+  /** @relates Gdk::PixbufAnimationIter
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Glib::RefPtr<Gdk::PixbufAnimationIter> wrap(GdkPixbufAnimationIter* object, bool take_copy = false);
+}
+
+
+#endif /* _GDKMM_PIXBUFANIMATIONITER_H */
+
diff --git a/libs/gtkmm2/gdk/gdkmm/pixbufformat.cc b/libs/gtkmm2/gdk/gdkmm/pixbufformat.cc
new file mode 100644
index 0000000000..63dc4c43a4
--- /dev/null
+++ b/libs/gtkmm2/gdk/gdkmm/pixbufformat.cc
@@ -0,0 +1,118 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gdkmm/pixbufformat.h>
+#include <gdkmm/private/pixbufformat_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* Copyright (C) 2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <glibmm/utility.h>
+#include <gdk-pixbuf/gdk-pixbuf.h>
+
+namespace Gdk
+{
+
+PixbufFormat::PixbufFormat()
+: gobject_ (0)
+{}
+
+PixbufFormat::PixbufFormat(const GdkPixbufFormat* gobject)
+: gobject_ (gobject)
+{}
+
+PixbufFormat::~PixbufFormat()
+{
+  //We don't free anything because we did not take ownership of the underlying C instance
+  //(because we can't.)
+}
+
+PixbufFormat::PixbufFormat(const PixbufFormat& src)
+: gobject_(src.gobject_)
+{
+}
+
+PixbufFormat& PixbufFormat::operator=(const PixbufFormat& src)
+{
+  gobject_ = src.gobject_;
+  return *this;
+}
+
+
+} // namespace Gdk
+
+
+namespace
+{
+} // anonymous namespace
+
+
+namespace Gdk
+{
+
+
+Glib::ustring PixbufFormat::get_name() const
+{
+  return Glib::convert_return_gchar_ptr_to_ustring(gdk_pixbuf_format_get_name(const_cast<GdkPixbufFormat*>(gobj())));
+}
+
+Glib::ustring PixbufFormat::get_description() const
+{
+  return Glib::convert_return_gchar_ptr_to_ustring(gdk_pixbuf_format_get_description(const_cast<GdkPixbufFormat*>(gobj())));
+}
+
+Glib::StringArrayHandle PixbufFormat::get_mime_types() const
+{
+  return Glib::StringArrayHandle(gdk_pixbuf_format_get_mime_types(const_cast<GdkPixbufFormat*>(gobj())));
+}
+
+Glib::StringArrayHandle PixbufFormat::get_extensions() const
+{
+  return Glib::StringArrayHandle(gdk_pixbuf_format_get_extensions(const_cast<GdkPixbufFormat*>(gobj())));
+}
+
+bool PixbufFormat::is_writable() const
+{
+  return gdk_pixbuf_format_is_writable(const_cast<GdkPixbufFormat*>(gobj()));
+}
+
+bool PixbufFormat::is_scalable() const
+{
+  return gdk_pixbuf_format_is_scalable(const_cast<GdkPixbufFormat*>(gobj()));
+}
+
+bool PixbufFormat::is_disabled() const
+{
+  return gdk_pixbuf_format_is_disabled(const_cast<GdkPixbufFormat*>(gobj()));
+}
+
+void PixbufFormat::set_disabled(bool disabled)
+{
+  gdk_pixbuf_format_set_disabled(gobj(), static_cast<int>(disabled));
+}
+
+Glib::ustring PixbufFormat::get_license() const
+{
+  return Glib::convert_return_gchar_ptr_to_ustring(gdk_pixbuf_format_get_license(const_cast<GdkPixbufFormat*>(gobj())));
+}
+
+
+} // namespace Gdk
+
+
diff --git a/libs/gtkmm2/gdk/gdkmm/pixbufformat.h b/libs/gtkmm2/gdk/gdkmm/pixbufformat.h
new file mode 100644
index 0000000000..b9adddf08d
--- /dev/null
+++ b/libs/gtkmm2/gdk/gdkmm/pixbufformat.h
@@ -0,0 +1,150 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GDKMM_PIXBUFFORMAT_H
+#define _GDKMM_PIXBUFFORMAT_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* Copyright (C) 2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+
+#include <gdkmmconfig.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+extern "C" { typedef struct _GdkPixbufFormat GdkPixbufFormat; }
+#endif
+
+namespace Gdk
+{
+
+class PixbufFormat
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef PixbufFormat CppObjectType;
+  typedef GdkPixbufFormat BaseObjectType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+private:
+
+
+public:
+  PixbufFormat();
+  explicit PixbufFormat(const GdkPixbufFormat* gobject);
+  virtual ~PixbufFormat();
+
+  PixbufFormat(const PixbufFormat& src);
+  PixbufFormat& operator=(const PixbufFormat& src);
+
+  
+  /** Returns the name of the format.
+   * @return The name of the format. 
+   * 
+   * Since: 2.2.
+   */
+  Glib::ustring get_name() const;
+  
+  /** Returns a description of the format.
+   * @return A description of the format.
+   * 
+   * Since: 2.2.
+   */
+  Glib::ustring get_description() const;
+  
+  /** Returns the mime types supported by the format.
+   * @return A <tt>0</tt>-terminated array of mime types which must be freed with 
+   * Glib::strfreev() when it is no longer needed.
+   * 
+   * Since: 2.2.
+   */
+  Glib::StringArrayHandle get_mime_types() const;
+  
+  /** Returns the filename extensions typically used for files in the 
+   * given format.
+   * @return A <tt>0</tt>-terminated array of filename extensions which must be
+   * freed with Glib::strfreev() when it is no longer needed.
+   * 
+   * Since: 2.2.
+   */
+  Glib::StringArrayHandle get_extensions() const;
+  
+  /** Returns whether pixbufs can be saved in the given format.
+   * @return Whether pixbufs can be saved in the given format.
+   * 
+   * Since: 2.2.
+   */
+  bool is_writable() const;
+  
+  
+  /** Returns whether this image format is scalable. If a file is in a 
+   * scalable format, it is preferable to load it at the desired size, 
+   * rather than loading it at the default size and scaling the 
+   * resulting pixbuf to the desired size.
+   * @return Whether this image format is scalable.
+   * 
+   * Since: 2.6.
+   */
+  bool is_scalable() const;
+  
+  /** Returns whether this image format is disabled. See
+   * gdk_pixbuf_format_set_disabled().
+   * @return Whether this image format is disabled.
+   * 
+   * Since: 2.6.
+   */
+  bool is_disabled() const;
+  
+  /** Disables or enables an image format. If a format is disabled, 
+   * gdk-pixbuf won't use the image loader for this format to load 
+   * images. Applications can use this to avoid using image loaders 
+   * with an inappropriate license, see gdk_pixbuf_format_get_license().
+   * 
+   * Since: 2.6
+   * @param disabled <tt>true</tt> to disable the format @a format .
+   */
+  void set_disabled(bool disabled = true);
+  
+  /** Returns information about the license of the image loader
+   * for the format. The returned string should be a shorthand for 
+   * a wellknown license, e.g. "LGPL", "GPL", "QPL", "GPL/QPL",
+   * or "other" to indicate some other license.
+   * @return A string describing the license of @a format . 
+   * 
+   * Since: 2.6.
+   */
+  Glib::ustring get_license() const;
+
+  /// Provides access to the underlying C GObject.
+  GdkPixbufFormat*       gobj()       { return const_cast<GdkPixbufFormat*>(gobject_); }
+  /// Provides access to the underlying C GObject.
+  const GdkPixbufFormat* gobj() const { return gobject_; }
+
+protected:
+  const GdkPixbufFormat* gobject_;
+
+
+};
+
+} // namespace Gdk
+
+
+#endif /* _GDKMM_PIXBUFFORMAT_H */
+
diff --git a/libs/gtkmm2/gdk/gdkmm/pixbufloader.cc b/libs/gtkmm2/gdk/gdkmm/pixbufloader.cc
new file mode 100644
index 0000000000..41af07e520
--- /dev/null
+++ b/libs/gtkmm2/gdk/gdkmm/pixbufloader.cc
@@ -0,0 +1,465 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gdkmm/pixbufloader.h>
+#include <gdkmm/private/pixbufloader_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gdk/gdkcolor.h>
+#include <gdk-pixbuf/gdk-pixbuf.h>
+
+
+namespace
+{
+
+/* We use this helper function in the constructor to be able to throw
+ * before the base class' (Glib::Object) constructor is called.
+ */
+GdkPixbufLoader* pixbuf_loader_create_with_type(const Glib::ustring& image_type, bool mime_type)
+{
+  GError* error = 0;
+  GdkPixbufLoader *const loader = 0;
+  
+  if(mime_type)
+    gdk_pixbuf_loader_new_with_mime_type(image_type.c_str(), &error);
+  else
+    gdk_pixbuf_loader_new_with_type(image_type.c_str(), &error);
+
+  if(error)
+    Glib::Error::throw_exception(error);
+
+  return loader;
+}
+
+} // anonymous namespace
+
+
+namespace Gdk
+{
+
+PixbufLoader::PixbufLoader(const Glib::ustring& image_type, bool mime_type)
+:
+  Glib::ObjectBase(0),
+  Glib::Object((GObject*) pixbuf_loader_create_with_type(image_type, mime_type))
+{}
+
+void PixbufLoader::write(const guint8* buf, gsize count)
+{
+  GError* error = 0;
+  gdk_pixbuf_loader_write(gobj(), buf, count, &error);
+
+  if(error)
+    Glib::Error::throw_exception(error);
+}
+
+void PixbufLoader::close()
+{
+  GError* error = 0;
+  gdk_pixbuf_loader_close(gobj(), &error);
+
+  if(error)
+    Glib::Error::throw_exception(error);
+}
+
+} // namespace Gdk
+
+
+namespace
+{
+
+const Glib::SignalProxyInfo PixbufLoader_signal_area_prepared_info =
+{
+  "area_prepared",
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
+};
+
+
+void PixbufLoader_signal_area_updated_callback(GdkPixbufLoader* self, gint p0,gint p1,gint p2,gint p3,void* data)
+{
+  using namespace Gdk;
+  typedef sigc::slot< void,int,int,int,int > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(p0
+, p1
+, p2
+, p3
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+}
+
+const Glib::SignalProxyInfo PixbufLoader_signal_area_updated_info =
+{
+  "area_updated",
+  (GCallback) &PixbufLoader_signal_area_updated_callback,
+  (GCallback) &PixbufLoader_signal_area_updated_callback
+};
+
+
+const Glib::SignalProxyInfo PixbufLoader_signal_closed_info =
+{
+  "closed",
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
+};
+
+
+void PixbufLoader_signal_size_prepared_callback(GdkPixbufLoader* self, gint p0,gint p1,void* data)
+{
+  using namespace Gdk;
+  typedef sigc::slot< void,int,int > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(p0
+, p1
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+}
+
+const Glib::SignalProxyInfo PixbufLoader_signal_size_prepared_info =
+{
+  "size_prepared",
+  (GCallback) &PixbufLoader_signal_size_prepared_callback,
+  (GCallback) &PixbufLoader_signal_size_prepared_callback
+};
+
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Glib::RefPtr<Gdk::PixbufLoader> wrap(GdkPixbufLoader* object, bool take_copy)
+{
+  return Glib::RefPtr<Gdk::PixbufLoader>( dynamic_cast<Gdk::PixbufLoader*> (Glib::wrap_auto ((GObject*)(object), take_copy)) );
+  //We use dynamic_cast<> in case of multiple inheritance.
+}
+
+} /* namespace Glib */
+
+
+namespace Gdk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& PixbufLoader_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &PixbufLoader_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gdk_pixbuf_loader_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void PixbufLoader_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+  klass->area_prepared = &area_prepared_callback;
+  klass->area_updated = &area_updated_callback;
+  klass->closed = &closed_callback;
+}
+
+
+void PixbufLoader_Class::area_prepared_callback(GdkPixbufLoader* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_area_prepared();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->area_prepared)
+      (*base->area_prepared)(self);
+  }
+}
+
+void PixbufLoader_Class::area_updated_callback(GdkPixbufLoader* self, gint p0, gint p1, gint p2, gint p3)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_area_updated(p0
+, p1
+, p2
+, p3
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->area_updated)
+      (*base->area_updated)(self, p0, p1, p2, p3);
+  }
+}
+
+void PixbufLoader_Class::closed_callback(GdkPixbufLoader* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_closed();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->closed)
+      (*base->closed)(self);
+  }
+}
+
+
+Glib::ObjectBase* PixbufLoader_Class::wrap_new(GObject* object)
+{
+  return new PixbufLoader((GdkPixbufLoader*)object);
+}
+
+
+/* The implementation: */
+
+GdkPixbufLoader* PixbufLoader::gobj_copy()
+{
+  reference();
+  return gobj();
+}
+
+PixbufLoader::PixbufLoader(const Glib::ConstructParams& construct_params)
+:
+  Glib::Object(construct_params)
+{}
+
+PixbufLoader::PixbufLoader(GdkPixbufLoader* castitem)
+:
+  Glib::Object((GObject*)(castitem))
+{}
+
+PixbufLoader::~PixbufLoader()
+{}
+
+
+PixbufLoader::CppClassType PixbufLoader::pixbufloader_class_; // initialize static member
+
+GType PixbufLoader::get_type()
+{
+  return pixbufloader_class_.init().get_type();
+}
+
+GType PixbufLoader::get_base_type()
+{
+  return gdk_pixbuf_loader_get_type();
+}
+
+
+PixbufLoader::PixbufLoader()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Glib::Object(Glib::ConstructParams(pixbufloader_class_.init()))
+{
+  }
+
+Glib::RefPtr<PixbufLoader> PixbufLoader::create()
+{
+  return Glib::RefPtr<PixbufLoader>( new PixbufLoader() );
+}
+Glib::RefPtr<PixbufLoader> PixbufLoader::create(const Glib::ustring& image_type, bool mime_type)
+{
+  return Glib::RefPtr<PixbufLoader>( new PixbufLoader(image_type, mime_type) );
+}
+void PixbufLoader::set_size(int width, int height)
+{
+  gdk_pixbuf_loader_set_size(gobj(), width, height);
+}
+
+Glib::RefPtr<Gdk::Pixbuf> PixbufLoader::get_pixbuf()
+{
+
+  Glib::RefPtr<Gdk::Pixbuf> retvalue = Glib::wrap(gdk_pixbuf_loader_get_pixbuf(gobj()));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::RefPtr<Gdk::PixbufAnimation> PixbufLoader::get_animation()
+{
+
+  Glib::RefPtr<Gdk::PixbufAnimation> retvalue = Glib::wrap(gdk_pixbuf_loader_get_animation(gobj()));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+PixbufFormat PixbufLoader::get_format() const
+{
+  return PixbufFormat(gdk_pixbuf_loader_get_format(const_cast<GdkPixbufLoader*>(gobj())));
+}
+
+
+Glib::SignalProxy0< void > PixbufLoader::signal_area_prepared()
+{
+  return Glib::SignalProxy0< void >(this, &PixbufLoader_signal_area_prepared_info);
+}
+
+Glib::SignalProxy4< void,int,int,int,int > PixbufLoader::signal_area_updated()
+{
+  return Glib::SignalProxy4< void,int,int,int,int >(this, &PixbufLoader_signal_area_updated_info);
+}
+
+Glib::SignalProxy0< void > PixbufLoader::signal_closed()
+{
+  return Glib::SignalProxy0< void >(this, &PixbufLoader_signal_closed_info);
+}
+
+Glib::SignalProxy2< void,int,int > PixbufLoader::signal_size_prepared()
+{
+  return Glib::SignalProxy2< void,int,int >(this, &PixbufLoader_signal_size_prepared_info);
+}
+
+
+void Gdk::PixbufLoader::on_area_prepared()
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->area_prepared)
+    (*base->area_prepared)(gobj());
+}
+
+void Gdk::PixbufLoader::on_area_updated(int x, int y, int width, int height)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->area_updated)
+    (*base->area_updated)(gobj(),x,y,width,height);
+}
+
+void Gdk::PixbufLoader::on_closed()
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->closed)
+    (*base->closed)(gobj());
+}
+
+
+} // namespace Gdk
+
+
diff --git a/libs/gtkmm2/gdk/gdkmm/pixbufloader.h b/libs/gtkmm2/gdk/gdkmm/pixbufloader.h
new file mode 100644
index 0000000000..c89288740f
--- /dev/null
+++ b/libs/gtkmm2/gdk/gdkmm/pixbufloader.h
@@ -0,0 +1,269 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GDKMM_PIXBUFLOADER_H
+#define _GDKMM_PIXBUFLOADER_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* Copyright (C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <glibmm/object.h>
+#include <gdkmm/pixbuf.h>
+#include <gdkmm/pixbufanimation.h>
+#include <gdkmm/pixbufformat.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GdkPixbufLoader GdkPixbufLoader;
+typedef struct _GdkPixbufLoaderClass GdkPixbufLoaderClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gdk
+{ class PixbufLoader_Class; } // namespace Gdk
+namespace Gdk
+{
+
+
+class PixbufLoader : public Glib::Object
+{
+  
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+public:
+  typedef PixbufLoader CppObjectType;
+  typedef PixbufLoader_Class CppClassType;
+  typedef GdkPixbufLoader BaseObjectType;
+  typedef GdkPixbufLoaderClass BaseClassType;
+
+private:  friend class PixbufLoader_Class;
+  static CppClassType pixbufloader_class_;
+
+private:
+  // noncopyable
+  PixbufLoader(const PixbufLoader&);
+  PixbufLoader& operator=(const PixbufLoader&);
+
+protected:
+  explicit PixbufLoader(const Glib::ConstructParams& construct_params);
+  explicit PixbufLoader(GdkPixbufLoader* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+  virtual ~PixbufLoader();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GObject.
+  GdkPixbufLoader*       gobj()       { return reinterpret_cast<GdkPixbufLoader*>(gobject_); }
+
+  ///Provides access to the underlying C GObject.
+  const GdkPixbufLoader* gobj() const { return reinterpret_cast<GdkPixbufLoader*>(gobject_); }
+
+  ///Provides access to the underlying C instance. The caller is responsible for unrefing it. Use when directly setting fields in structs.
+  GdkPixbufLoader* gobj_copy();
+
+private:
+
+protected:
+
+  /** Constructs a pixbuf loader object.
+   */
+  PixbufLoader();
+
+  /** Constructs a pixbuf loader object for a specific image type.
+   * Constructs a new pixbuf loader object that always attempts to parse image
+   * data as if it were an image of type @a image_type, instead of identifying
+   * the type automatically. Useful if you want an error if the image isn't the
+   * expected type, for loading image formats that can't be reliably identified
+   * by looking at the data, or if the user manually forces a specific type.
+   *
+   * The image_type can be one of the types returned by Gdk::Pixbuf::get_formats(), or a MIME type.
+   *
+   * Common MIME Types are listed here
+   * http://www.iana.org/assignments/media-types/
+   * and here:
+   * http://www.freedesktop.org/Software/shared-mime-info
+   *
+   * @param image_type Name of the image format to be loaded with the image.
+   * @param mime_type If this is true then the image_type is a MIME type.
+   * @throw Gdk::PixbufError
+   */
+  explicit PixbufLoader(const Glib::ustring& image_type, bool mime_type = false);
+  //TODO: What non-mime-types names are possible?
+
+public:
+
+  /** Creates a new pixbuf loader object.
+   * @return A newly-created pixbuf loader.
+   */
+  
+  static Glib::RefPtr<PixbufLoader> create();
+
+
+   /** Constructs a pixbuf loader object for a specific image type.
+   * Constructs a new pixbuf loader object that always attempts to parse image
+   * data as if it were an image of type @a image_type, instead of identifying
+   * the type automatically. Useful if you want an error if the image isn't the
+   * expected type, for loading image formats that can't be reliably identified
+   * by looking at the data, or if the user manually forces a specific type.
+   *
+   * The image_type can be one of the types returned by Gdk::Pixbuf::get_formats(), or a MIME type.
+   *
+   * Common MIME Types are listed here
+   * http://www.iana.org/assignments/media-types/
+   * and here:
+   * http://www.freedesktop.org/Software/shared-mime-info
+   *
+   * @param image_type Name of the image format to be loaded with the image.
+   * @param mime_type If this is true then the image_type is a MIME type.
+   * @throw Gdk::PixbufError
+   */
+  
+  static Glib::RefPtr<PixbufLoader> create(const Glib::ustring& image_type, bool mime_type =  false);
+
+
+  /** Causes the image to be scaled while it is loaded. The desired
+   * image size can be determined relative to the original size of
+   * the image by calling set_size() from a
+   * signal handler for the ::size_prepared signal.
+   * 
+   * Attempts to set the desired image size  are ignored after the 
+   * emission of the ::size_prepared signal.
+   * 
+   * Since: 2.2
+   * @param width The desired width of the image being loaded.
+   * @param height The desired height of the image being loaded.
+   */
+  void set_size(int width, int height);
+          
+  /** Causes the pixbuf loader to parse the next @a count bytes of an image.
+   * It will return if the data was loaded successfully, and throw an exception
+   * if an error occurred. In the latter case, the loader will be closed, and
+   * will not accept further writes.
+   * @param buf Pointer to image data.
+   * @param count Length of the @a buf buffer in bytes.
+   * @throw Gdk::PixbufError
+   * @throw Glib::FileError
+   */
+  void write(const guint8* buf, gsize count);
+  
+
+  /** Informs a pixbuf loader that no further writes with PixbufLoader::write()
+   * will occur, so that it can free its internal loading structures.  Also,
+   * tries to parse any data that hasn't yet been parsed; if the remaining data
+   * is partial or corrupt, an exception will be thrown. If you're just
+   * cancelling a load rather than expecting it to be finished, writing an
+   * empty <tt>catch()</tt> block to ignore errors is reasonable.
+   * @throw Gdk::PixbufError
+   * @throw Glib::FileError
+   */
+  void close();
+  
+
+  /** Queries the Gdk::Pixbuf that a pixbuf loader is currently creating.
+   * In general it only makes sense to call this function after the
+   * "area_prepared" signal has been emitted by the loader; this means
+   * that enough data has been read to know the size of the image that
+   * will be allocated.  If the loader has not received enough data via
+   * write(), then this function returns <tt>0</tt>.  The
+   * returned pixbuf will be the same in all future calls to the loader,
+   * so simply calling Glib::object_ref() should be sufficient to continue
+   * using it.  Additionally, if the loader is an animation, it will
+   * return the "static image" of the animation
+   * (see Gdk::PixbufAnimation::get_static_image()).
+   * @return The Gdk::Pixbuf that the loader is creating, or <tt>0</tt> if not
+   * enough data has been read to determine how to create the image buffer.
+   */
+  Glib::RefPtr<Gdk::Pixbuf> get_pixbuf();
+  
+  /** Queries the Gdk::PixbufAnimation that a pixbuf loader is currently creating.
+   * In general it only makes sense to call this function after the "area_prepared"
+   * signal has been emitted by the loader. If the loader doesn't have enough
+   * bytes yet (hasn't emitted the "area_prepared" signal) this function will 
+   * return <tt>0</tt>.
+   * @return The Gdk::PixbufAnimation that the loader is loading, or <tt>0</tt> if
+   *  not enough data has been read to determine the information.
+   */
+  Glib::RefPtr<Gdk::PixbufAnimation> get_animation();
+
+  
+  /** Obtains the available information about the format of the 
+   * currently loading image file.
+   * @return A Gdk::PixbufFormat or <tt>0</tt>. The return value is owned 
+   * by GdkPixbuf and should not be freed.
+   * 
+   * Since: 2.2.
+   */
+  PixbufFormat get_format() const;
+
+  
+  Glib::SignalProxy0< void > signal_area_prepared();
+
+  
+  Glib::SignalProxy4< void,int,int,int,int > signal_area_updated();
+
+  
+  Glib::SignalProxy0< void > signal_closed();
+
+  
+  //We use no_default_handler for this, because we can not add a new vfunc to 2.5 without breaking ABI.
+  //TODO: Remove no_default_handler when we do an ABI-break-with-parallel-install.
+  
+
+  Glib::SignalProxy2< void,int,int > signal_size_prepared();
+
+
+public:
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+  virtual void on_area_prepared();
+  virtual void on_area_updated(int x, int y, int width, int height);
+  virtual void on_closed();
+
+
+};
+
+} // namespace Gdk
+
+
+namespace Glib
+{
+  /** @relates Gdk::PixbufLoader
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Glib::RefPtr<Gdk::PixbufLoader> wrap(GdkPixbufLoader* object, bool take_copy = false);
+}
+
+
+#endif /* _GDKMM_PIXBUFLOADER_H */
+
diff --git a/libs/gtkmm2/gdk/gdkmm/pixmap.cc b/libs/gtkmm2/gdk/gdkmm/pixmap.cc
new file mode 100644
index 0000000000..a64cfb6aed
--- /dev/null
+++ b/libs/gtkmm2/gdk/gdkmm/pixmap.cc
@@ -0,0 +1,320 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gdkmm/pixmap.h>
+#include <gdkmm/private/pixmap_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gdkmm/window.h>
+#include <gdkmm/display.h>
+#include <gdk/gdkpixmap.h>
+
+
+namespace Gdk
+{
+
+Glib::ObjectBase* Pixmap_Class::wrap_new(GObject* object)
+{
+  GdkPixmapObject *const pixmap_object = GDK_PIXMAP_OBJECT(object);
+
+  g_return_val_if_fail(pixmap_object != 0, 0);
+
+  // GdkPixmap and GdkBitmap are actually both of type GdkPixmapObject.
+  // A Bitmap is is a Pixmap with a depth of 1.  Since these are distinct
+  // types in gtkmm, we dynamically create either a Pixmap or a Bitmap,
+  // depending on the depth field.
+
+  if(pixmap_object->depth != 1)
+    return new Gdk::Pixmap((GdkPixmap*) pixmap_object);
+  else
+    return new Gdk::Bitmap((GdkBitmap*) pixmap_object);
+}
+
+
+Pixmap::Pixmap(const Glib::RefPtr<Drawable>& drawable, int width, int height, int depth)
+:
+  Drawable((GdkDrawable*) gdk_pixmap_new(Glib::unwrap(drawable), width, height, depth))
+{
+  //gdk_pixmap_new() is implemented differently for x11, win32, etc,
+  //so we can't really derived a new GType for GdkPixmap.
+}
+
+Pixmap::Pixmap(const Glib::RefPtr<Drawable>& drawable, const char* data, int width, int height, int depth,
+               const Color& fg, const Color& bg)
+:
+  Drawable((GdkDrawable*) gdk_pixmap_create_from_data(
+      Glib::unwrap(drawable), data, width, height, depth,
+      const_cast<GdkColor*>(fg.gobj()), const_cast<GdkColor*>(bg.gobj())))
+{
+  //gdk_pixmap_new() is implemented differently for x11, win32, etc,
+  //so we can't really derived a new GType for GdkPixmap.
+}
+
+Pixmap::Pixmap(const Glib::RefPtr<Display>& display, NativeWindow anid)
+:
+  Drawable( (GdkDrawable*) gdk_pixmap_foreign_new_for_display(display->gobj(), anid) )
+{
+  //gdk_pixmap_new() is implemented differently for x11, win32, etc,
+  //so we can't really derived a new GType for GdkPixmap.
+}
+
+Glib::RefPtr<Pixmap> Pixmap::create_from_data(const Glib::RefPtr<const Drawable>& drawable,
+                                              const char* data, int width, int height, int depth,
+                                              const Color& fg, const Color& bg)
+{
+  GdkPixmap *const pixmap = gdk_pixmap_create_from_data(
+      const_cast<GdkDrawable*>(Glib::unwrap<Drawable>(drawable)),
+      const_cast<char*>(data), width, height, depth,
+      const_cast<GdkColor*>(fg.gobj()),
+      const_cast<GdkColor*>(bg.gobj()));
+
+  return Glib::wrap((GdkPixmapObject*) pixmap);
+}
+
+
+Glib::RefPtr<Pixmap> Pixmap::create_from_xpm(const Glib::RefPtr<const Drawable>& drawable,
+                                             const Color& transparent_color,
+                                             const std::string& filename)
+{
+  GdkPixmap *const pixmap = gdk_pixmap_create_from_xpm(
+      const_cast<GdkDrawable*>(Glib::unwrap<Drawable>(drawable)), 0,
+      const_cast<GdkColor*>(transparent_color.gobj()),
+      const_cast<char*>(filename.c_str()));
+
+  return Glib::wrap((GdkPixmapObject*) pixmap);
+}
+
+Glib::RefPtr<Pixmap> Pixmap::create_from_xpm(const Glib::RefPtr<const Drawable>& drawable,
+                                             Glib::RefPtr<Bitmap>& mask,
+                                             const Color& transparent_color,
+                                             const std::string& filename)
+{
+  GdkBitmap* bitmap = 0;
+
+  GdkPixmap *const pixmap = gdk_pixmap_create_from_xpm(
+      const_cast<GdkDrawable*>(Glib::unwrap<Drawable>(drawable)), &bitmap,
+      const_cast<GdkColor*>(transparent_color.gobj()),
+      const_cast<char*>(filename.c_str()));
+
+  mask = Glib::RefPtr<Bitmap>::cast_dynamic(Glib::wrap((GdkPixmapObject*) bitmap));
+  return Glib::wrap((GdkPixmapObject*) pixmap);
+}
+
+Glib::RefPtr<Pixmap> Pixmap::create_from_xpm(const Glib::RefPtr<const Drawable>& drawable,
+                                             const Glib::RefPtr<Colormap>& colormap,
+                                             Glib::RefPtr<Bitmap>& mask,
+                                             const Color& transparent_color,
+                                             const std::string& filename)
+{
+  GdkBitmap* bitmap = 0;
+
+  GdkPixmap *const pixmap = gdk_pixmap_colormap_create_from_xpm(
+      const_cast<GdkDrawable*>(Glib::unwrap<Drawable>(drawable)),
+      Glib::unwrap(colormap), &bitmap,
+      const_cast<GdkColor*>(transparent_color.gobj()),
+      const_cast<char*>(filename.c_str()));
+
+  mask = Glib::RefPtr<Bitmap>::cast_dynamic(Glib::wrap((GdkPixmapObject*) bitmap));
+  return Glib::wrap((GdkPixmapObject*) pixmap);
+}
+
+
+Glib::RefPtr<Pixmap> Pixmap::create_from_xpm(const Glib::RefPtr<const Drawable>& drawable,
+                                             Glib::RefPtr<Bitmap>& mask,
+                                             const Color& transparent_color,
+                                             const char* const* data)
+{
+  GdkBitmap* bitmap = 0;
+
+  GdkPixmap *const pixmap = gdk_pixmap_create_from_xpm_d(
+      const_cast<GdkDrawable*>(Glib::unwrap<Drawable>(drawable)),
+      &bitmap,
+      const_cast<GdkColor*>(transparent_color.gobj()),
+      const_cast<char**>(data));
+
+  mask = Glib::RefPtr<Bitmap>::cast_dynamic(Glib::wrap((GdkPixmapObject*) bitmap));
+  return Glib::wrap((GdkPixmapObject*) pixmap);
+}
+
+Glib::RefPtr<Pixmap> Pixmap::create_from_xpm(const Glib::RefPtr<const Drawable>& drawable,
+                                             const Glib::RefPtr<Colormap>& colormap,
+                                             Glib::RefPtr<Bitmap>& mask,
+                                             const Color& transparent_color,
+                                             const char* const* data)
+{
+  GdkBitmap* bitmap = 0;
+
+  GdkPixmap *const pixmap = gdk_pixmap_colormap_create_from_xpm_d(
+      const_cast<GdkDrawable*>(Glib::unwrap<Drawable>(drawable)),
+      Glib::unwrap(colormap), &bitmap,
+      const_cast<GdkColor*>(transparent_color.gobj()),
+      const_cast<char**>(data));
+
+  mask = Glib::RefPtr<Bitmap>::cast_dynamic(Glib::wrap((GdkPixmapObject*) bitmap));
+  return Glib::wrap((GdkPixmapObject*) pixmap);
+}
+
+Glib::RefPtr<Pixmap> Pixmap::create_from_xpm(const Glib::RefPtr<Colormap>& colormap,
+                                             Glib::RefPtr<Bitmap>& mask,
+                                             const Color& transparent_color,
+                                             const char* const* data)
+{
+  GdkBitmap* bitmap = 0;
+
+  GdkPixmap *const pixmap = gdk_pixmap_colormap_create_from_xpm_d(
+      0, // drawable
+      Glib::unwrap(colormap), &bitmap,
+      const_cast<GdkColor*>(transparent_color.gobj()),
+      const_cast<char**>(data));
+
+  mask = Glib::RefPtr<Bitmap>::cast_dynamic(Glib::wrap((GdkPixmapObject*) bitmap));
+  return Glib::wrap((GdkPixmapObject*) pixmap);
+}
+
+Glib::RefPtr<Pixmap> Pixmap::create_from_xpm(const Glib::RefPtr<Colormap>& colormap,
+                                             Glib::RefPtr<Bitmap>& mask,
+                                             const char* const* data)
+{
+  GdkBitmap* bitmap = 0;
+
+  GdkPixmap *const pixmap = gdk_pixmap_colormap_create_from_xpm_d(
+      0, // drawable
+      Glib::unwrap(colormap), &bitmap,
+      0, // transparent_color
+      const_cast<char**>(data));
+
+  mask = Glib::RefPtr<Bitmap>::cast_dynamic(Glib::wrap((GdkPixmapObject*) bitmap));
+  return Glib::wrap((GdkPixmapObject*) pixmap);
+}
+
+} // namespace Gdk
+
+
+namespace
+{
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Glib::RefPtr<Gdk::Pixmap> wrap(GdkPixmapObject* object, bool take_copy)
+{
+  return Glib::RefPtr<Gdk::Pixmap>( dynamic_cast<Gdk::Pixmap*> (Glib::wrap_auto ((GObject*)(object), take_copy)) );
+  //We use dynamic_cast<> in case of multiple inheritance.
+}
+
+} /* namespace Glib */
+
+
+namespace Gdk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& Pixmap_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &Pixmap_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gdk_pixmap_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void Pixmap_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+}
+
+
+/* The implementation: */
+
+GdkPixmap* Pixmap::gobj_copy()
+{
+  reference();
+  return gobj();
+}
+
+Pixmap::Pixmap(const Glib::ConstructParams& construct_params)
+:
+  Gdk::Drawable(construct_params)
+{}
+
+Pixmap::Pixmap(GdkPixmap* castitem)
+:
+  Gdk::Drawable((GdkDrawable*)(castitem))
+{}
+
+Pixmap::~Pixmap()
+{}
+
+
+Pixmap::CppClassType Pixmap::pixmap_class_; // initialize static member
+
+GType Pixmap::get_type()
+{
+  return pixmap_class_.init().get_type();
+}
+
+GType Pixmap::get_base_type()
+{
+  return gdk_pixmap_get_type();
+}
+
+
+Pixmap::Pixmap()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gdk::Drawable(Glib::ConstructParams(pixmap_class_.init()))
+{
+  }
+
+Glib::RefPtr<Pixmap> Pixmap::create(const Glib::RefPtr<Drawable>& drawable, int width, int height, int depth)
+{
+  return Glib::RefPtr<Pixmap>( new Pixmap(drawable, width, height, depth) );
+}
+Glib::RefPtr<Pixmap> Pixmap::create(const Glib::RefPtr<Drawable>& drawable, const char* data, int width, int height, int depth, const Color& fg, const Color& bg)
+{
+  return Glib::RefPtr<Pixmap>( new Pixmap(drawable, data, width, height, depth, fg, bg) );
+}
+Glib::RefPtr<Pixmap> Pixmap::create(const Glib::RefPtr<Display>& display, NativeWindow anid)
+{
+  return Glib::RefPtr<Pixmap>( new Pixmap(display, anid) );
+}
+
+
+} // namespace Gdk
+
+
diff --git a/libs/gtkmm2/gdk/gdkmm/pixmap.h b/libs/gtkmm2/gdk/gdkmm/pixmap.h
new file mode 100644
index 0000000000..6a7a1d978d
--- /dev/null
+++ b/libs/gtkmm2/gdk/gdkmm/pixmap.h
@@ -0,0 +1,202 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GDKMM_PIXMAP_H
+#define _GDKMM_PIXMAP_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* Copyright (C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gdkmm/drawable.h>
+#include <gdkmm/color.h>
+#include <gdkmm/colormap.h>
+#include <gdkmm/types.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+extern "C" {
+//Custom stuct prototypes, because they aren't what the code-generator expects:
+typedef struct _GdkDrawable GdkPixmap;
+typedef struct _GdkPixmapClass GdkPixmapClass;
+} // extern "C"
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gdk
+{ class Pixmap_Class; } // namespace Gdk
+namespace Gdk
+{
+
+class Window;
+
+/** Pixmaps are offscreen drawables. They can be drawn upon with the standard drawing primitives, then copied to another
+ * drawable (such as a Gdk::Window) with Gdk::Drawable::draw_drawable(). The depth of a pixmap is the number of bits per
+ * pixels.
+ * Bitmaps are simply pixmaps with a depth of 1. (That is, they are monochrome bitmaps - each pixel can be either on or off).
+ */
+
+class Pixmap : public Gdk::Drawable
+{
+  // GdkPixmap is a typedef to GdkDrawable, but it's actually a GdkPixmapObject.
+  
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+public:
+  typedef Pixmap CppObjectType;
+  typedef Pixmap_Class CppClassType;
+  typedef GdkPixmap BaseObjectType;
+  typedef GdkPixmapObjectClass BaseClassType;
+
+private:  friend class Pixmap_Class;
+  static CppClassType pixmap_class_;
+
+private:
+  // noncopyable
+  Pixmap(const Pixmap&);
+  Pixmap& operator=(const Pixmap&);
+
+protected:
+  explicit Pixmap(const Glib::ConstructParams& construct_params);
+  explicit Pixmap(GdkPixmap* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+  virtual ~Pixmap();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GObject.
+  GdkPixmap*       gobj()       { return reinterpret_cast<GdkPixmap*>(gobject_); }
+
+  ///Provides access to the underlying C GObject.
+  const GdkPixmap* gobj() const { return reinterpret_cast<GdkPixmap*>(gobject_); }
+
+  ///Provides access to the underlying C instance. The caller is responsible for unrefing it. Use when directly setting fields in structs.
+  GdkPixmap* gobj_copy();
+
+private:
+
+   // see wrap_new() implementation in pixmap.ccg
+  
+
+protected:
+  Pixmap();
+
+  Pixmap(const Glib::RefPtr<Drawable>& drawable, int width, int height, int depth = -1);
+
+  /// Initialize a Pixmap from data.
+  Pixmap(const Glib::RefPtr<Drawable>& drawable,
+         const char* data, int width, int height, int depth,
+         const Color& fg, const Color& bg);
+
+  Pixmap(const Glib::RefPtr<Display>& display, NativeWindow anid);
+
+public:
+
+  
+  static Glib::RefPtr<Pixmap> create(const Glib::RefPtr<Drawable>& drawable, int width, int height, int depth =  -1);
+
+  
+  static Glib::RefPtr<Pixmap> create(const Glib::RefPtr<Drawable>& drawable, const char* data, int width, int height, int depth, const Color& fg, const Color& bg);
+
+
+  static Glib::RefPtr<Pixmap> create(const Glib::RefPtr<Display>& display, NativeWindow anid);
+
+  
+  static Glib::RefPtr<Pixmap> create_from_data(const Glib::RefPtr<const Drawable>& drawable,
+                                               const char* data, int width, int height, int depth,
+                                               const Color& fg, const Color& bg);
+
+  /// Create a Pixmap from a xpm file.
+  static Glib::RefPtr<Pixmap> create_from_xpm(const Glib::RefPtr<const Drawable>& drawable,
+                                              const Color& transparent_color,
+                                              const std::string& filename);
+
+  // Create a Pixmap from a xpm file.
+  static Glib::RefPtr<Pixmap> create_from_xpm(const Glib::RefPtr<const Drawable>& drawable,
+                                              Glib::RefPtr<Bitmap>& mask,
+                                              const Color& transparent_color,
+                                              const std::string& filename);
+
+  /// Create a Pixmap from a xpm file with colormap.
+  static Glib::RefPtr<Pixmap> create_from_xpm(const Glib::RefPtr<const Drawable>& drawable,
+                                              const Glib::RefPtr<Colormap>& colormap,
+                                              Glib::RefPtr<Bitmap>& mask,
+                                              const Color& transparent_color,
+                                              const std::string& filename);
+
+  static Glib::RefPtr<Pixmap> create_from_xpm(const Glib::RefPtr<const Drawable>& drawable,
+                                              Glib::RefPtr<Bitmap>& mask,
+                                              const Color& transparent_color,
+                                              const char* const* data);
+
+  static Glib::RefPtr<Pixmap> create_from_xpm(const Glib::RefPtr<const Drawable>& drawable,
+                                              const Glib::RefPtr<Colormap>& colormap,
+                                              Glib::RefPtr<Bitmap>& mask,
+                                              const Color& transparent_color,
+                                              const char* const* data);
+
+  static Glib::RefPtr<Pixmap> create_from_xpm(const Glib::RefPtr<Colormap>& colormap,
+                                              Glib::RefPtr<Bitmap>& mask,
+                                              const Color& transparent_color,
+                                              const char* const* data);
+
+  static Glib::RefPtr<Pixmap> create_from_xpm(const Glib::RefPtr<Colormap>& colormap,
+                                              Glib::RefPtr<Bitmap>& mask,
+                                              const char* const* data);
+
+
+public:
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+};
+
+} // namespace Gdk
+
+
+namespace Glib
+{
+  /** @relates Gdk::Pixmap
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Glib::RefPtr<Gdk::Pixmap> wrap(GdkPixmapObject* object, bool take_copy = false);
+}
+
+
+#endif /* _GDKMM_PIXMAP_H */
+
diff --git a/libs/gtkmm2/gdk/gdkmm/private/bitmap_p.h b/libs/gtkmm2/gdk/gdkmm/private/bitmap_p.h
new file mode 100644
index 0000000000..13a2e31932
--- /dev/null
+++ b/libs/gtkmm2/gdk/gdkmm/private/bitmap_p.h
@@ -0,0 +1,7 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GDKMM_BITMAP_P_H
+#define _GDKMM_BITMAP_P_H
+#include <gdkmm/private/pixmap_p.h>
+#endif /* _GDKMM_BITMAP_P_H */
+
diff --git a/libs/gtkmm2/gdk/gdkmm/private/color_p.h b/libs/gtkmm2/gdk/gdkmm/private/color_p.h
new file mode 100644
index 0000000000..10e8370c05
--- /dev/null
+++ b/libs/gtkmm2/gdk/gdkmm/private/color_p.h
@@ -0,0 +1,6 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GDKMM_COLOR_P_H
+#define _GDKMM_COLOR_P_H
+#endif /* _GDKMM_COLOR_P_H */
+
diff --git a/libs/gtkmm2/gdk/gdkmm/private/colormap_p.h b/libs/gtkmm2/gdk/gdkmm/private/colormap_p.h
new file mode 100644
index 0000000000..3ceb776d16
--- /dev/null
+++ b/libs/gtkmm2/gdk/gdkmm/private/colormap_p.h
@@ -0,0 +1,44 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GDKMM_COLORMAP_P_H
+#define _GDKMM_COLORMAP_P_H
+#include <glibmm/private/object_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gdk
+{
+
+class Colormap_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Colormap CppObjectType;
+  typedef GdkColormap BaseObjectType;
+  typedef GdkColormapClass BaseClassType;
+  typedef Glib::Object_Class CppClassParent;
+  typedef GObjectClass BaseClassParent;
+
+  friend class Colormap;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gdk
+
+#endif /* _GDKMM_COLORMAP_P_H */
+
diff --git a/libs/gtkmm2/gdk/gdkmm/private/cursor_p.h b/libs/gtkmm2/gdk/gdkmm/private/cursor_p.h
new file mode 100644
index 0000000000..5400e45e0a
--- /dev/null
+++ b/libs/gtkmm2/gdk/gdkmm/private/cursor_p.h
@@ -0,0 +1,7 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GDKMM_CURSOR_P_H
+#define _GDKMM_CURSOR_P_H
+#include <glibmm/private/object_p.h>
+#endif /* _GDKMM_CURSOR_P_H */
+
diff --git a/libs/gtkmm2/gdk/gdkmm/private/device_p.h b/libs/gtkmm2/gdk/gdkmm/private/device_p.h
new file mode 100644
index 0000000000..f19b9c8ccd
--- /dev/null
+++ b/libs/gtkmm2/gdk/gdkmm/private/device_p.h
@@ -0,0 +1,44 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GDKMM_DEVICE_P_H
+#define _GDKMM_DEVICE_P_H
+#include <glibmm/private/object_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gdk
+{
+
+class Device_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Device CppObjectType;
+  typedef GdkDevice BaseObjectType;
+  typedef GdkDeviceClass BaseClassType;
+  typedef Glib::Object_Class CppClassParent;
+  typedef GObjectClass BaseClassParent;
+
+  friend class Device;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gdk
+
+#endif /* _GDKMM_DEVICE_P_H */
+
diff --git a/libs/gtkmm2/gdk/gdkmm/private/display_p.h b/libs/gtkmm2/gdk/gdkmm/private/display_p.h
new file mode 100644
index 0000000000..0b5ba089e0
--- /dev/null
+++ b/libs/gtkmm2/gdk/gdkmm/private/display_p.h
@@ -0,0 +1,45 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GDKMM_DISPLAY_P_H
+#define _GDKMM_DISPLAY_P_H
+#include <glibmm/private/object_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gdk
+{
+
+class Display_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Display CppObjectType;
+  typedef GdkDisplay BaseObjectType;
+  typedef GdkDisplayClass BaseClassType;
+  typedef Glib::Object_Class CppClassParent;
+  typedef GObjectClass BaseClassParent;
+
+  friend class Display;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+  static void closed_callback(GdkDisplay* self, gboolean p0);
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gdk
+
+#endif /* _GDKMM_DISPLAY_P_H */
+
diff --git a/libs/gtkmm2/gdk/gdkmm/private/displaymanager_p.h b/libs/gtkmm2/gdk/gdkmm/private/displaymanager_p.h
new file mode 100644
index 0000000000..25ff018c44
--- /dev/null
+++ b/libs/gtkmm2/gdk/gdkmm/private/displaymanager_p.h
@@ -0,0 +1,45 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GDKMM_DISPLAYMANAGER_P_H
+#define _GDKMM_DISPLAYMANAGER_P_H
+#include <glibmm/private/object_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gdk
+{
+
+class DisplayManager_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef DisplayManager CppObjectType;
+  typedef GdkDisplayManager BaseObjectType;
+  typedef GdkDisplayManagerClass BaseClassType;
+  typedef Glib::Object_Class CppClassParent;
+  typedef GObjectClass BaseClassParent;
+
+  friend class DisplayManager;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+  static void display_opened_callback(GdkDisplayManager* self, GdkDisplay* p0);
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gdk
+
+#endif /* _GDKMM_DISPLAYMANAGER_P_H */
+
diff --git a/libs/gtkmm2/gdk/gdkmm/private/dragcontext_p.h b/libs/gtkmm2/gdk/gdkmm/private/dragcontext_p.h
new file mode 100644
index 0000000000..13dfd57ccc
--- /dev/null
+++ b/libs/gtkmm2/gdk/gdkmm/private/dragcontext_p.h
@@ -0,0 +1,44 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GDKMM_DRAGCONTEXT_P_H
+#define _GDKMM_DRAGCONTEXT_P_H
+#include <glibmm/private/object_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gdk
+{
+
+class DragContext_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef DragContext CppObjectType;
+  typedef GdkDragContext BaseObjectType;
+  typedef GdkDragContextClass BaseClassType;
+  typedef Glib::Object_Class CppClassParent;
+  typedef GObjectClass BaseClassParent;
+
+  friend class DragContext;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gdk
+
+#endif /* _GDKMM_DRAGCONTEXT_P_H */
+
diff --git a/libs/gtkmm2/gdk/gdkmm/private/drawable_p.h b/libs/gtkmm2/gdk/gdkmm/private/drawable_p.h
new file mode 100644
index 0000000000..59e22d083e
--- /dev/null
+++ b/libs/gtkmm2/gdk/gdkmm/private/drawable_p.h
@@ -0,0 +1,44 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GDKMM_DRAWABLE_P_H
+#define _GDKMM_DRAWABLE_P_H
+#include <glibmm/private/object_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gdk
+{
+
+class Drawable_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Drawable CppObjectType;
+  typedef GdkDrawable BaseObjectType;
+  typedef GdkDrawableClass BaseClassType;
+  typedef Glib::Object_Class CppClassParent;
+  typedef GObjectClass BaseClassParent;
+
+  friend class Drawable;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gdk
+
+#endif /* _GDKMM_DRAWABLE_P_H */
+
diff --git a/libs/gtkmm2/gdk/gdkmm/private/event_p.h b/libs/gtkmm2/gdk/gdkmm/private/event_p.h
new file mode 100644
index 0000000000..999db9b7fc
--- /dev/null
+++ b/libs/gtkmm2/gdk/gdkmm/private/event_p.h
@@ -0,0 +1,6 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GDKMM_EVENT_P_H
+#define _GDKMM_EVENT_P_H
+#endif /* _GDKMM_EVENT_P_H */
+
diff --git a/libs/gtkmm2/gdk/gdkmm/private/gc_p.h b/libs/gtkmm2/gdk/gdkmm/private/gc_p.h
new file mode 100644
index 0000000000..82725a3a1a
--- /dev/null
+++ b/libs/gtkmm2/gdk/gdkmm/private/gc_p.h
@@ -0,0 +1,44 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GDKMM_GC_P_H
+#define _GDKMM_GC_P_H
+#include <glibmm/private/object_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gdk
+{
+
+class GC_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef GC CppObjectType;
+  typedef GdkGC BaseObjectType;
+  typedef GdkGCClass BaseClassType;
+  typedef Glib::Object_Class CppClassParent;
+  typedef GObjectClass BaseClassParent;
+
+  friend class GC;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gdk
+
+#endif /* _GDKMM_GC_P_H */
+
diff --git a/libs/gtkmm2/gdk/gdkmm/private/image_p.h b/libs/gtkmm2/gdk/gdkmm/private/image_p.h
new file mode 100644
index 0000000000..2b6fe88d3d
--- /dev/null
+++ b/libs/gtkmm2/gdk/gdkmm/private/image_p.h
@@ -0,0 +1,44 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GDKMM_IMAGE_P_H
+#define _GDKMM_IMAGE_P_H
+#include <glibmm/private/object_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gdk
+{
+
+class Image_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Image CppObjectType;
+  typedef GdkImage BaseObjectType;
+  typedef GdkImageClass BaseClassType;
+  typedef Glib::Object_Class CppClassParent;
+  typedef GObjectClass BaseClassParent;
+
+  friend class Image;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gdk
+
+#endif /* _GDKMM_IMAGE_P_H */
+
diff --git a/libs/gtkmm2/gdk/gdkmm/private/pixbuf_p.h b/libs/gtkmm2/gdk/gdkmm/private/pixbuf_p.h
new file mode 100644
index 0000000000..659bd0d8d7
--- /dev/null
+++ b/libs/gtkmm2/gdk/gdkmm/private/pixbuf_p.h
@@ -0,0 +1,44 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GDKMM_PIXBUF_P_H
+#define _GDKMM_PIXBUF_P_H
+#include <glibmm/private/object_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gdk
+{
+
+class Pixbuf_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Pixbuf CppObjectType;
+  typedef GdkPixbuf BaseObjectType;
+  typedef GdkPixbufClass BaseClassType;
+  typedef Glib::Object_Class CppClassParent;
+  typedef GObjectClass BaseClassParent;
+
+  friend class Pixbuf;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gdk
+
+#endif /* _GDKMM_PIXBUF_P_H */
+
diff --git a/libs/gtkmm2/gdk/gdkmm/private/pixbufanimation_p.h b/libs/gtkmm2/gdk/gdkmm/private/pixbufanimation_p.h
new file mode 100644
index 0000000000..ca03e440c2
--- /dev/null
+++ b/libs/gtkmm2/gdk/gdkmm/private/pixbufanimation_p.h
@@ -0,0 +1,44 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GDKMM_PIXBUFANIMATION_P_H
+#define _GDKMM_PIXBUFANIMATION_P_H
+#include <glibmm/private/object_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gdk
+{
+
+class PixbufAnimation_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef PixbufAnimation CppObjectType;
+  typedef GdkPixbufAnimation BaseObjectType;
+  typedef GdkPixbufAnimationClass BaseClassType;
+  typedef Glib::Object_Class CppClassParent;
+  typedef GObjectClass BaseClassParent;
+
+  friend class PixbufAnimation;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gdk
+
+#endif /* _GDKMM_PIXBUFANIMATION_P_H */
+
diff --git a/libs/gtkmm2/gdk/gdkmm/private/pixbufanimationiter_p.h b/libs/gtkmm2/gdk/gdkmm/private/pixbufanimationiter_p.h
new file mode 100644
index 0000000000..f7de22ffd8
--- /dev/null
+++ b/libs/gtkmm2/gdk/gdkmm/private/pixbufanimationiter_p.h
@@ -0,0 +1,44 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GDKMM_PIXBUFANIMATIONITER_P_H
+#define _GDKMM_PIXBUFANIMATIONITER_P_H
+#include <glibmm/private/object_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gdk
+{
+
+class PixbufAnimationIter_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef PixbufAnimationIter CppObjectType;
+  typedef GdkPixbufAnimationIter BaseObjectType;
+  typedef GdkPixbufAnimationIterClass BaseClassType;
+  typedef Glib::Object_Class CppClassParent;
+  typedef GObjectClass BaseClassParent;
+
+  friend class PixbufAnimationIter;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gdk
+
+#endif /* _GDKMM_PIXBUFANIMATIONITER_P_H */
+
diff --git a/libs/gtkmm2/gdk/gdkmm/private/pixbufformat_p.h b/libs/gtkmm2/gdk/gdkmm/private/pixbufformat_p.h
new file mode 100644
index 0000000000..6a0b196620
--- /dev/null
+++ b/libs/gtkmm2/gdk/gdkmm/private/pixbufformat_p.h
@@ -0,0 +1,6 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GDKMM_PIXBUFFORMAT_P_H
+#define _GDKMM_PIXBUFFORMAT_P_H
+#endif /* _GDKMM_PIXBUFFORMAT_P_H */
+
diff --git a/libs/gtkmm2/gdk/gdkmm/private/pixbufloader_p.h b/libs/gtkmm2/gdk/gdkmm/private/pixbufloader_p.h
new file mode 100644
index 0000000000..7bceceef72
--- /dev/null
+++ b/libs/gtkmm2/gdk/gdkmm/private/pixbufloader_p.h
@@ -0,0 +1,47 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GDKMM_PIXBUFLOADER_P_H
+#define _GDKMM_PIXBUFLOADER_P_H
+#include <glibmm/private/object_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gdk
+{
+
+class PixbufLoader_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef PixbufLoader CppObjectType;
+  typedef GdkPixbufLoader BaseObjectType;
+  typedef GdkPixbufLoaderClass BaseClassType;
+  typedef Glib::Object_Class CppClassParent;
+  typedef GObjectClass BaseClassParent;
+
+  friend class PixbufLoader;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+  static void area_prepared_callback(GdkPixbufLoader* self);
+  static void area_updated_callback(GdkPixbufLoader* self, gint p0, gint p1, gint p2, gint p3);
+  static void closed_callback(GdkPixbufLoader* self);
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gdk
+
+#endif /* _GDKMM_PIXBUFLOADER_P_H */
+
diff --git a/libs/gtkmm2/gdk/gdkmm/private/pixmap_p.h b/libs/gtkmm2/gdk/gdkmm/private/pixmap_p.h
new file mode 100644
index 0000000000..149ed76a07
--- /dev/null
+++ b/libs/gtkmm2/gdk/gdkmm/private/pixmap_p.h
@@ -0,0 +1,44 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GDKMM_PIXMAP_P_H
+#define _GDKMM_PIXMAP_P_H
+#include <gdkmm/private/drawable_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gdk
+{
+
+class Pixmap_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Pixmap CppObjectType;
+  typedef GdkPixmapObject BaseObjectType;
+  typedef GdkPixmapObjectClass BaseClassType;
+  typedef Gdk::Drawable_Class CppClassParent;
+  typedef GdkDrawableClass BaseClassParent;
+
+  friend class Pixmap;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gdk
+
+#endif /* _GDKMM_PIXMAP_P_H */
+
diff --git a/libs/gtkmm2/gdk/gdkmm/private/rectangle_p.h b/libs/gtkmm2/gdk/gdkmm/private/rectangle_p.h
new file mode 100644
index 0000000000..51088336bb
--- /dev/null
+++ b/libs/gtkmm2/gdk/gdkmm/private/rectangle_p.h
@@ -0,0 +1,6 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GDKMM_RECTANGLE_P_H
+#define _GDKMM_RECTANGLE_P_H
+#endif /* _GDKMM_RECTANGLE_P_H */
+
diff --git a/libs/gtkmm2/gdk/gdkmm/private/region_p.h b/libs/gtkmm2/gdk/gdkmm/private/region_p.h
new file mode 100644
index 0000000000..b0a7f8cdf2
--- /dev/null
+++ b/libs/gtkmm2/gdk/gdkmm/private/region_p.h
@@ -0,0 +1,6 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GDKMM_REGION_P_H
+#define _GDKMM_REGION_P_H
+#endif /* _GDKMM_REGION_P_H */
+
diff --git a/libs/gtkmm2/gdk/gdkmm/private/rgbcmap_p.h b/libs/gtkmm2/gdk/gdkmm/private/rgbcmap_p.h
new file mode 100644
index 0000000000..d5845141c4
--- /dev/null
+++ b/libs/gtkmm2/gdk/gdkmm/private/rgbcmap_p.h
@@ -0,0 +1,6 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GDKMM_RGBCMAP_P_H
+#define _GDKMM_RGBCMAP_P_H
+#endif /* _GDKMM_RGBCMAP_P_H */
+
diff --git a/libs/gtkmm2/gdk/gdkmm/private/screen_p.h b/libs/gtkmm2/gdk/gdkmm/private/screen_p.h
new file mode 100644
index 0000000000..9888f6c9db
--- /dev/null
+++ b/libs/gtkmm2/gdk/gdkmm/private/screen_p.h
@@ -0,0 +1,45 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GDKMM_SCREEN_P_H
+#define _GDKMM_SCREEN_P_H
+#include <glibmm/private/object_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gdk
+{
+
+class Screen_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Screen CppObjectType;
+  typedef GdkScreen BaseObjectType;
+  typedef GdkScreenClass BaseClassType;
+  typedef Glib::Object_Class CppClassParent;
+  typedef GObjectClass BaseClassParent;
+
+  friend class Screen;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+  static void size_changed_callback(GdkScreen* self);
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gdk
+
+#endif /* _GDKMM_SCREEN_P_H */
+
diff --git a/libs/gtkmm2/gdk/gdkmm/private/types_p.h b/libs/gtkmm2/gdk/gdkmm/private/types_p.h
new file mode 100644
index 0000000000..474d473ad8
--- /dev/null
+++ b/libs/gtkmm2/gdk/gdkmm/private/types_p.h
@@ -0,0 +1,6 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GDKMM_TYPES_P_H
+#define _GDKMM_TYPES_P_H
+#endif /* _GDKMM_TYPES_P_H */
+
diff --git a/libs/gtkmm2/gdk/gdkmm/private/visual_p.h b/libs/gtkmm2/gdk/gdkmm/private/visual_p.h
new file mode 100644
index 0000000000..b11005c9db
--- /dev/null
+++ b/libs/gtkmm2/gdk/gdkmm/private/visual_p.h
@@ -0,0 +1,44 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GDKMM_VISUAL_P_H
+#define _GDKMM_VISUAL_P_H
+#include <glibmm/private/object_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gdk
+{
+
+class Visual_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Visual CppObjectType;
+  typedef GdkVisual BaseObjectType;
+  typedef GdkVisualClass BaseClassType;
+  typedef Glib::Object_Class CppClassParent;
+  typedef GObjectClass BaseClassParent;
+
+  friend class Visual;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gdk
+
+#endif /* _GDKMM_VISUAL_P_H */
+
diff --git a/libs/gtkmm2/gdk/gdkmm/private/window_p.h b/libs/gtkmm2/gdk/gdkmm/private/window_p.h
new file mode 100644
index 0000000000..c9fc8a9e85
--- /dev/null
+++ b/libs/gtkmm2/gdk/gdkmm/private/window_p.h
@@ -0,0 +1,44 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GDKMM_WINDOW_P_H
+#define _GDKMM_WINDOW_P_H
+#include <gdkmm/private/drawable_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gdk
+{
+
+class Window_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Window CppObjectType;
+  typedef GdkWindowObject BaseObjectType;
+  typedef GdkWindowObjectClass BaseClassType;
+  typedef Gdk::Drawable_Class CppClassParent;
+  typedef GdkDrawableClass BaseClassParent;
+
+  friend class Window;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gdk
+
+#endif /* _GDKMM_WINDOW_P_H */
+
diff --git a/libs/gtkmm2/gdk/gdkmm/rectangle.cc b/libs/gtkmm2/gdk/gdkmm/rectangle.cc
new file mode 100644
index 0000000000..a59a22bd75
--- /dev/null
+++ b/libs/gtkmm2/gdk/gdkmm/rectangle.cc
@@ -0,0 +1,160 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gdkmm/rectangle.h>
+#include <gdkmm/private/rectangle_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/*
+ *
+ * Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+namespace Gdk
+{
+
+Rectangle::Rectangle(int x, int y, int width, int height)
+{
+  gobject_.x = x;
+  gobject_.y = y;
+  gobject_.width  = width;
+  gobject_.height = height;
+}
+
+// gdk_rectangle_union() and gdk_rectangle_intersect() work fine even if
+// the destination points to one of the input rectangles.  The join() and
+// intersect() implementations rely on this ability.
+
+Rectangle& Rectangle::join(const Rectangle& src2)
+{
+  gdk_rectangle_union(
+      &gobject_, const_cast<GdkRectangle*>(&src2.gobject_), &gobject_);
+  return *this;
+}
+
+Rectangle& Rectangle::intersect(const Rectangle& src2)
+{
+  gdk_rectangle_intersect(
+      &gobject_, const_cast<GdkRectangle*>(&src2.gobject_), &gobject_);
+  return *this;
+}
+
+Rectangle& Rectangle::intersect(const Rectangle& src2, bool& rectangles_intersect)
+{
+  rectangles_intersect = gdk_rectangle_intersect(
+      &gobject_, const_cast<GdkRectangle*>(&src2.gobject_), &gobject_);
+  return *this;
+}
+
+bool Rectangle::has_zero_area() const
+{
+  return (gobject_.width == 0 || gobject_.height == 0);
+}
+
+} // namespace Gdk
+
+
+namespace
+{
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Gdk::Rectangle& wrap(GdkRectangle* object)
+{
+  return *reinterpret_cast<Gdk::Rectangle*>(object);
+}
+
+const Gdk::Rectangle& wrap(const GdkRectangle* object)
+{
+  return *reinterpret_cast<const Gdk::Rectangle*>(object);
+}
+
+} // namespace Glib
+
+
+namespace Gdk
+{
+
+
+// static
+GType Rectangle::get_type()
+{
+  return gdk_rectangle_get_type();
+}
+
+Rectangle::Rectangle()
+{
+  GLIBMM_INITIALIZE_STRUCT(gobject_, GdkRectangle);
+}
+
+Rectangle::Rectangle(const GdkRectangle* gobject)
+{
+  if(gobject)
+    gobject_ = *gobject;
+  else
+    GLIBMM_INITIALIZE_STRUCT(gobject_, GdkRectangle);
+}
+
+
+int Rectangle::get_x() const
+{
+  return gobj()->x;
+}
+
+void Rectangle::set_x(const int& value)
+{
+  gobj()->x = value;
+}
+
+int Rectangle::get_y() const
+{
+  return gobj()->y;
+}
+
+void Rectangle::set_y(const int& value)
+{
+  gobj()->y = value;
+}
+
+int Rectangle::get_width() const
+{
+  return gobj()->width;
+}
+
+void Rectangle::set_width(const int& value)
+{
+  gobj()->width = value;
+}
+
+int Rectangle::get_height() const
+{
+  return gobj()->height;
+}
+
+void Rectangle::set_height(const int& value)
+{
+  gobj()->height = value;
+}
+
+
+} // namespace Gdk
+
+
diff --git a/libs/gtkmm2/gdk/gdkmm/rectangle.h b/libs/gtkmm2/gdk/gdkmm/rectangle.h
new file mode 100644
index 0000000000..5a92e1b22d
--- /dev/null
+++ b/libs/gtkmm2/gdk/gdkmm/rectangle.h
@@ -0,0 +1,113 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GDKMM_RECTANGLE_H
+#define _GDKMM_RECTANGLE_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* rectangle.h
+ *
+ * Copyright (C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gdk/gdk.h>
+
+
+namespace Gdk
+{
+
+/** Gdk::Rectangle is a structure holding the position and size of a rectangle.
+ * The intersection of two rectangles can be computed with intersect(). To find the union of two rectangles use union().
+ */
+class Rectangle
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Rectangle CppObjectType;
+  typedef GdkRectangle BaseObjectType;
+
+  static GType get_type() G_GNUC_CONST;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  Rectangle();
+
+  explicit Rectangle(const GdkRectangle* gobject); // always takes a copy
+
+  ///Provides access to the underlying C instance.
+  GdkRectangle*       gobj()       { return &gobject_; }
+
+  ///Provides access to the underlying C instance.
+  const GdkRectangle* gobj() const { return &gobject_; }
+
+protected:
+  GdkRectangle gobject_;
+
+private:
+  
+public:
+//_CUSTOM_DEFAULT_CTOR
+//Rectangle();
+  Rectangle(int x, int y, int width, int height);
+
+  Rectangle& join(const Rectangle& src2);
+  Rectangle& intersect(const Rectangle& src2);
+  Rectangle& intersect(const Rectangle& src2, bool& rectangles_intersect);
+
+  bool has_zero_area() const;
+
+  int get_x() const;
+  void set_x(const int& value);
+  int get_y() const;
+  void set_y(const int& value);
+  int get_width() const;
+  void set_width(const int& value);
+  int get_height() const;
+  void set_height(const int& value);
+
+
+};
+
+} // namespace Gdk
+
+
+namespace Glib
+{
+
+/** @relates Gdk::Rectangle
+ * @param object The C instance
+ * @result A C++ instance that wraps this C instance.
+ */
+Gdk::Rectangle& wrap(GdkRectangle* object);
+
+/** @relates Gdk::Rectangle
+ * @param object The C instance
+ * @result A C++ instance that wraps this C instance.
+ */
+const Gdk::Rectangle& wrap(const GdkRectangle* object);
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+template <>
+class Value<Gdk::Rectangle> : public Glib::Value_Boxed<Gdk::Rectangle>
+{};
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+} // namespace Glib
+
+#endif /* _GDKMM_RECTANGLE_H */
+
diff --git a/libs/gtkmm2/gdk/gdkmm/region.cc b/libs/gtkmm2/gdk/gdkmm/region.cc
new file mode 100644
index 0000000000..7206c1e239
--- /dev/null
+++ b/libs/gtkmm2/gdk/gdkmm/region.cc
@@ -0,0 +1,226 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gdkmm/region.h>
+#include <gdkmm/private/region_p.h>
+
+#include <gdk/gdkenumtypes.h>
+// -*- c++ -*-
+/* $Id$ */
+
+/*
+ *
+ * Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gdk/gdkregion.h>
+
+namespace Gdk
+{
+
+Region::Region(const Glib::ArrayHandle<Gdk::Point>& points, FillRule fill_rule)
+:
+  // The dangerous-looking cast to GdkPoint* works, because Gdk::Point
+  // has only one member variable of type GdkPoint, and no vtable.  Please
+  // don't copy this code, casts like that won't work with most other types.
+
+  gobject_ (gdk_region_polygon(
+      reinterpret_cast<GdkPoint*>(const_cast<Gdk::Point*>(points.data())),
+      points.size(), (GdkFillRule)(fill_rule)))
+{}
+
+Region::Region(const Rectangle& rectangle)
+:
+  gobject_ (gdk_region_rectangle(const_cast<GdkRectangle*>(rectangle.gobj())))
+{}
+
+Glib::ArrayHandle<Rectangle> Region::get_rectangles() const
+{
+  GdkRectangle* rectangles = 0;
+  int n_rectangles = 0;
+
+  gdk_region_get_rectangles(gobject_, &rectangles, &n_rectangles);
+
+  // The dangerous-looking cast to Rectangle* works, because Gdk::Rectangle
+  // has only one member variable of type GdkRectangle, and no vtable.  Please
+  // don't copy this code, casts like that won't work with most other types.
+
+  return Glib::ArrayHandle<Rectangle>(
+      reinterpret_cast<Rectangle*>(rectangles), n_rectangles, Glib::OWNERSHIP_SHALLOW);
+}
+
+} // namespace Gdk
+
+
+namespace
+{
+} // anonymous namespace
+
+// static
+GType Glib::Value<Gdk::FillRule>::value_type()
+{
+  return gdk_fill_rule_get_type();
+}
+
+// static
+GType Glib::Value<Gdk::OverlapType>::value_type()
+{
+  return gdk_overlap_type_get_type();
+}
+
+
+namespace Glib
+{
+
+Gdk::Region wrap(GdkRegion* object, bool take_copy /* = false */)
+{
+  return Gdk::Region(object, take_copy);
+}
+
+} // namespace Glib
+
+
+namespace Gdk
+{
+
+
+Region::Region()
+:
+  gobject_ (gdk_region_new())
+{}
+
+Region::Region(const Region& src)
+:
+  gobject_ ((src.gobject_) ? gdk_region_copy(src.gobject_) : 0)
+{}
+
+Region::Region(GdkRegion* castitem, bool make_a_copy /* = false */)
+{
+  if(!make_a_copy)
+  {
+    // It was given to us by a function which has already made a copy for us to keep.
+    gobject_ = castitem;
+  }
+  else
+  {
+    // We are probably getting it via direct access to a struct,
+    // so we can not just take it - we have to take a copy of it.
+    if(castitem)
+      gobject_ = gdk_region_copy(castitem);
+    else
+      gobject_ = 0;
+  }
+}
+
+Region& Region::operator=(const Region& src)
+{
+  GdkRegion *const new_gobject = (src.gobject_) ? gdk_region_copy(src.gobject_) : 0;
+
+  if(gobject_)
+    gdk_region_destroy(gobject_);
+
+  gobject_ = new_gobject;
+
+  return *this;
+}
+
+Region::~Region()
+{
+  if(gobject_)
+    gdk_region_destroy(gobject_);
+}
+
+GdkRegion* Region::gobj_copy() const
+{
+  return gdk_region_copy(gobject_);
+}
+
+
+void Region::get_clipbox(const Rectangle& rectangle)
+{
+  gdk_region_get_clipbox(gobj(), const_cast<GdkRectangle*>(rectangle.gobj()));
+}
+
+bool Region::empty()
+{
+  return gdk_region_empty(gobj());
+}
+
+bool Region::point_in(int x, int y)
+{
+  return gdk_region_point_in(gobj(), x, y);
+}
+
+OverlapType Region::rect_in(const Rectangle& rect)
+{
+  return ((OverlapType)(gdk_region_rect_in(gobj(), const_cast<GdkRectangle*>(rect.gobj()))));
+}
+
+void Region::offset(int dx, int dy)
+{
+  gdk_region_offset(gobj(), dx, dy);
+}
+
+void Region::shrink(int dx, int dy)
+{
+  gdk_region_shrink(gobj(), dx, dy);
+}
+
+void Region::union_with_rect(const Rectangle& rect)
+{
+  gdk_region_union_with_rect(gobj(), const_cast<GdkRectangle*>(rect.gobj()));
+}
+
+void Region::intersect(const Region& source2)
+{
+  gdk_region_intersect(gobj(), const_cast<GdkRegion*>((source2).gobj()));
+}
+
+void Region::union_(const Region& source2)
+{
+  gdk_region_union(gobj(), const_cast<GdkRegion*>((source2).gobj()));
+}
+
+void Region::subtract(const Region& source2)
+{
+  gdk_region_subtract(gobj(), const_cast<GdkRegion*>((source2).gobj()));
+}
+
+void Region::xor_(const Region& source2)
+{
+  gdk_region_xor(gobj(), const_cast<GdkRegion*>((source2).gobj()));
+}
+
+void Region::spans_intersect_foreach(GdkSpan* spans, int n_spans, bool sorted, GdkSpanFunc function, gpointer data)
+{
+  gdk_region_spans_intersect_foreach(gobj(), spans, n_spans, static_cast<int>(sorted), function, data);
+}
+
+
+bool operator==(const Region& lhs, const Region& rhs)
+{
+  return (gdk_region_equal(const_cast<GdkRegion*>(lhs.gobj()), const_cast<GdkRegion*>(rhs.gobj())) != 0);
+}
+
+bool operator!=(const Region& lhs, const Region& rhs)
+{
+  return (gdk_region_equal(const_cast<GdkRegion*>(lhs.gobj()), const_cast<GdkRegion*>(rhs.gobj())) == 0);
+}
+
+
+} // namespace Gdk
+
+
diff --git a/libs/gtkmm2/gdk/gdkmm/region.h b/libs/gtkmm2/gdk/gdkmm/region.h
new file mode 100644
index 0000000000..bcea009aa7
--- /dev/null
+++ b/libs/gtkmm2/gdk/gdkmm/region.h
@@ -0,0 +1,234 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GDKMM_REGION_H
+#define _GDKMM_REGION_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* region.h
+ *
+ * Copyright (C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+extern "C" { typedef struct _GdkRegion GdkRegion; }
+
+#include <glibmm/arrayhandle.h>
+#include <gdkmm/types.h>
+#include <gdkmm/rectangle.h>
+
+
+namespace Gdk
+{
+
+
+/** @addtogroup gdkmmEnums Enums and Flags */
+
+/**
+ * @ingroup gdkmmEnums
+ */
+enum FillRule
+{
+  EVEN_ODD_RULE,
+  WINDING_RULE
+};
+
+} // namespace Gdk
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Gdk::FillRule> : public Glib::Value_Enum<Gdk::FillRule>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gdk
+{
+
+/**
+ * @ingroup gdkmmEnums
+ */
+enum OverlapType
+{
+  OVERLAP_RECTANGLE_IN,
+  OVERLAP_RECTANGLE_OUT,
+  OVERLAP_RECTANGLE_PART
+};
+
+} // namespace Gdk
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Gdk::OverlapType> : public Glib::Value_Enum<Gdk::OverlapType>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gdk
+{
+
+
+/** This is an opaque data type holding a set of arbitrary pixels, and is usually used for clipping graphical operations
+ * (see Gdk::GC::set_clip_region()).
+ */
+class Region
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Region CppObjectType;
+  typedef GdkRegion BaseObjectType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  Region();
+
+  // Use make_a_copy=true when getting it directly from a struct.
+  explicit Region(GdkRegion* castitem, bool make_a_copy = false);
+
+  Region(const Region& src);
+  Region& operator=(const Region& src);
+
+  ~Region();
+
+  GdkRegion*       gobj()       { return gobject_; }
+  const GdkRegion* gobj() const { return gobject_; }
+
+  ///Provides access to the underlying C instance. The caller is responsible for freeing it. Use when directly setting fields in structs.
+  GdkRegion* gobj_copy() const;
+
+protected:
+  GdkRegion* gobject_;
+
+private:
+
+  
+public:
+
+  Region(const Glib::ArrayHandle<Gdk::Point>& points, FillRule fill_rule);
+  explicit Region(const Rectangle& rectangle);
+
+  
+  void get_clipbox(const Rectangle& rectangle);
+  Glib::ArrayHandle<Rectangle> get_rectangles() const;
+
+  
+  bool empty();
+  
+  bool point_in(int x, int y);
+  
+  OverlapType rect_in(const Rectangle& rect);
+
+  
+  void offset(int dx, int dy);
+  
+  void shrink(int dx, int dy);
+  
+  /** Sets the area of @a region  to the union of the areas of @a region  and
+   *  @a rect . The resulting area is the set of pixels contained in
+   * either @a region  or @a rect .
+   * @param rect A Gdk::Rectangle.
+   */
+  void union_with_rect(const Rectangle& rect);
+  
+  /** Sets the area of @a source1  to the intersection of the areas of @a source1 
+   * and @a source2 . The resulting area is the set of pixels contained in
+   * both @a source1  and @a source2 .
+   * @param source2 Another Gdk::Region.
+   */
+  void intersect(const Region& source2);
+  
+  /** Sets the area of @a source1  to the union of the areas of @a source1  and
+   *  @a source2 . The resulting area is the set of pixels contained in
+   * either @a source1  or @a source2 .
+   * @param source2 A Gdk::Region.
+   */
+  void union_(const Region& source2); //union is a keyword.
+  
+  /** Subtracts the area of @a source2  from the area @a source1 . The resulting
+   * area is the set of pixels contained in @a source1  but not in @a source2 .
+   * @param source2 Another Gdk::Region.
+   */
+  void subtract(const Region& source2);
+  
+  /** Sets the area of @a source1  to the exclusive-OR of the areas of @a source1 
+   * and @a source2 . The resulting area is the set of pixels contained in one
+   * or the other of the two sources but not in both.
+   * @param source2 Another Gdk::Region.
+   */
+  void xor_(const Region& source2); //xor is a keyword
+  
+  void spans_intersect_foreach(GdkSpan* spans, int n_spans, bool sorted, GdkSpanFunc function, gpointer data);
+  
+
+};
+
+} //namespace Gdk
+
+
+namespace Gdk
+{
+
+/** @relates Gdk::Region
+ * @param lhs The left-hand side
+ * @param rhs The right-hand side
+ * @result The result
+ */
+bool operator==(const Region& lhs, const Region& rhs);
+
+/** @relates Gdk::Region
+ * @param lhs The left-hand side
+ * @param rhs The right-hand side
+ * @result The result
+ */
+bool operator!=(const Region& lhs, const Region& rhs);
+
+
+} // namespace Gdk
+
+
+namespace Glib
+{
+
+  /** @relates Gdk::Region
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+Gdk::Region wrap(GdkRegion* object, bool take_copy = false);
+
+} // namespace Glib
+
+#endif /* _GDKMM_REGION_H */
+
diff --git a/libs/gtkmm2/gdk/gdkmm/rgb.cc b/libs/gtkmm2/gdk/gdkmm/rgb.cc
new file mode 100644
index 0000000000..08c8cd58a2
--- /dev/null
+++ b/libs/gtkmm2/gdk/gdkmm/rgb.cc
@@ -0,0 +1,43 @@
+// -*- c++ -*-
+/* $Id$ */
+
+/* Copyright 2004      The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gdkmm/rgb.h>
+#include <gdk/gdk.h>
+
+namespace Gdk
+{
+
+Glib::RefPtr<Colormap> rgb_get_colormap()
+{
+  return Glib::wrap( gdk_rgb_get_colormap() );
+}
+
+Glib::RefPtr<Visual> rgb_get_visual()
+{
+  return Glib::wrap( gdk_rgb_get_visual() );
+}
+
+bool rgb_ditherable()
+{
+  return gdk_rgb_ditherable();
+}
+
+} //namespace Gdk
+
diff --git a/libs/gtkmm2/gdk/gdkmm/rgb.h b/libs/gtkmm2/gdk/gdkmm/rgb.h
new file mode 100644
index 0000000000..fa504ae68c
--- /dev/null
+++ b/libs/gtkmm2/gdk/gdkmm/rgb.h
@@ -0,0 +1,55 @@
+/* $Id$ */
+
+/* Copyright 2004      The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#ifndef _GDKMM_RGB_H
+#define _GDKMM_RGB_H
+
+#include <gdkmm/colormap.h>  
+#include <gdkmm/visual.h>
+
+namespace Gdk
+{
+
+/** Get the preferred colormap for rendering image data.
+ * Not a very useful function; historically, GDK could only render RGB image data to one colormap and visual,
+ * but in the current version it can render to any colormap and visual. So there's no need to call this function.
+ *
+ * @result The preferred colormap
+ */
+Glib::RefPtr<Colormap> rgb_get_colormap();
+
+/** Gets a "preferred visual" chosen by GdkRGB for rendering image data on the default screen.
+ * In previous versions of GDK, this was the only visual GdkRGB could use for rendering. In current versions,
+ * it's simply the visual GdkRGB would have chosen as the optimal one in those previous versions.
+ * GdkRGB can now render to drawables with any visual.
+ * @result The Gdk::Visual chosen by GdkRGB.
+ */
+Glib::RefPtr<Visual> rgb_get_visual();
+
+/** Determines whether the visual is ditherable.
+ * This function may be useful for presenting a user interface choice to the user about which dither mode is desired;
+ * if the display is not ditherable, it may make sense to gray out or hide the corresponding UI widget.
+ * result true if the visual is ditherable.
+ */
+bool rgb_ditherable();
+
+} //namespace Gdk
+
+#endif //_GDKMM_RGB_H
+
diff --git a/libs/gtkmm2/gdk/gdkmm/rgbcmap.cc b/libs/gtkmm2/gdk/gdkmm/rgbcmap.cc
new file mode 100644
index 0000000000..84a87d5439
--- /dev/null
+++ b/libs/gtkmm2/gdk/gdkmm/rgbcmap.cc
@@ -0,0 +1,72 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gdkmm/rgbcmap.h>
+#include <gdkmm/private/rgbcmap_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* Copyright (C) 2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <glibmm/utility.h>
+#include <gdk/gdkrgb.h>
+
+namespace Gdk
+{
+
+RgbCmap::RgbCmap(const Glib::ArrayHandle<guint32>& colors)
+: gobject_ (gdk_rgb_cmap_new(const_cast<guint32*>(colors.data()), colors.size()))
+{}
+
+RgbCmap::~RgbCmap()
+{
+  if(gobject_)
+    gdk_rgb_cmap_free(gobject_);
+}
+
+guint32& RgbCmap::operator[](unsigned long index)
+{
+	return gobject_->colors[index];
+}
+
+const guint32& RgbCmap::operator[](unsigned long index) const
+{
+	return gobject_->colors[index];
+}
+
+
+unsigned long RgbCmap::size() const
+{
+	return gobject_->n_colors;
+}
+
+} // namespace Gdk
+
+
+namespace
+{
+} // anonymous namespace
+
+
+namespace Gdk
+{
+
+
+} // namespace Gdk
+
+
diff --git a/libs/gtkmm2/gdk/gdkmm/rgbcmap.h b/libs/gtkmm2/gdk/gdkmm/rgbcmap.h
new file mode 100644
index 0000000000..0f01f1e619
--- /dev/null
+++ b/libs/gtkmm2/gdk/gdkmm/rgbcmap.h
@@ -0,0 +1,82 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GDKMM_RGBCMAP_H
+#define _GDKMM_RGBCMAP_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* Copyright (C) 2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+
+#include <gdkmmconfig.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+extern "C" { typedef struct _GdkRgbCmap GdkRgbCmap; }
+#endif
+
+namespace Gdk
+{
+
+class RgbCmap
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef RgbCmap CppObjectType;
+  typedef GdkRgbCmap BaseObjectType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+private:
+
+  
+public:
+  explicit RgbCmap(const Glib::ArrayHandle<guint32>& colors);
+  virtual ~RgbCmap();
+
+  ///Number of colors.
+  unsigned long size() const;
+
+  ///Access the colors.
+  guint32& operator[](unsigned long index);
+
+  ///Access the colors.
+  const guint32& operator[](unsigned long index) const;
+
+  /// Provides access to the underlying C GObject.
+  GdkRgbCmap*       gobj()       { return gobject_; }
+  /// Provides access to the underlying C GObject.  
+  const GdkRgbCmap* gobj() const { return gobject_; }
+
+protected:
+  GdkRgbCmap* gobject_;
+
+private:
+  // noncopyable
+  RgbCmap(const RgbCmap&);
+  RgbCmap& operator=(const RgbCmap&);
+
+
+};
+
+} // namespace Gdk
+
+
+#endif /* _GDKMM_RGBCMAP_H */
+
diff --git a/libs/gtkmm2/gdk/gdkmm/screen.cc b/libs/gtkmm2/gdk/gdkmm/screen.cc
new file mode 100644
index 0000000000..0b64a27a59
--- /dev/null
+++ b/libs/gtkmm2/gdk/gdkmm/screen.cc
@@ -0,0 +1,416 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gdkmm/screen.h>
+#include <gdkmm/private/screen_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/*
+ *
+ * Copyright 2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gdkmm/display.h>
+#include <gdkmm/visual.h>
+#include <gdkmm/window.h>
+#include <gdkmm/rectangle.h>
+#include <gdk/gdkscreen.h>
+
+namespace Gdk
+{
+
+} //Gdk
+
+
+namespace
+{
+
+const Glib::SignalProxyInfo Screen_signal_size_changed_info =
+{
+  "size-changed",
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
+};
+
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Glib::RefPtr<Gdk::Screen> wrap(GdkScreen* object, bool take_copy)
+{
+  return Glib::RefPtr<Gdk::Screen>( dynamic_cast<Gdk::Screen*> (Glib::wrap_auto ((GObject*)(object), take_copy)) );
+  //We use dynamic_cast<> in case of multiple inheritance.
+}
+
+} /* namespace Glib */
+
+
+namespace Gdk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& Screen_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &Screen_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gdk_screen_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void Screen_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+  klass->size_changed = &size_changed_callback;
+}
+
+
+void Screen_Class::size_changed_callback(GdkScreen* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_size_changed();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->size_changed)
+      (*base->size_changed)(self);
+  }
+}
+
+
+Glib::ObjectBase* Screen_Class::wrap_new(GObject* object)
+{
+  return new Screen((GdkScreen*)object);
+}
+
+
+/* The implementation: */
+
+GdkScreen* Screen::gobj_copy()
+{
+  reference();
+  return gobj();
+}
+
+Screen::Screen(const Glib::ConstructParams& construct_params)
+:
+  Glib::Object(construct_params)
+{}
+
+Screen::Screen(GdkScreen* castitem)
+:
+  Glib::Object((GObject*)(castitem))
+{}
+
+Screen::~Screen()
+{}
+
+
+Screen::CppClassType Screen::screen_class_; // initialize static member
+
+GType Screen::get_type()
+{
+  return screen_class_.init().get_type();
+}
+
+GType Screen::get_base_type()
+{
+  return gdk_screen_get_type();
+}
+
+
+Glib::RefPtr<Colormap> Screen::get_default_colormap()
+{
+
+  Glib::RefPtr<Colormap> retvalue = Glib::wrap(gdk_screen_get_default_colormap(gobj()));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::RefPtr<const Colormap> Screen::get_default_colormap() const
+{
+
+  Glib::RefPtr<const Colormap> retvalue = Glib::wrap(gdk_screen_get_default_colormap(const_cast<GdkScreen*>(gobj())));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+void Screen::set_default_colormap(const Glib::RefPtr<const Colormap>& colormap)
+{
+  gdk_screen_set_default_colormap(gobj(), const_cast<GdkColormap*>(Glib::unwrap<Colormap>(colormap)));
+}
+
+Glib::RefPtr<Colormap> Screen::get_system_colormap()
+{
+
+  Glib::RefPtr<Colormap> retvalue = Glib::wrap(gdk_screen_get_system_colormap(gobj()));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::RefPtr<const Colormap> Screen::get_system_colormap() const
+{
+
+  Glib::RefPtr<const Colormap> retvalue = Glib::wrap(gdk_screen_get_system_colormap(const_cast<GdkScreen*>(gobj())));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::RefPtr<Visual> Screen::get_system_visual()
+{
+
+  Glib::RefPtr<Visual> retvalue = Glib::wrap(gdk_screen_get_system_visual(gobj()));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::RefPtr<const Visual> Screen::get_system_visual() const
+{
+
+  Glib::RefPtr<const Visual> retvalue = Glib::wrap(gdk_screen_get_system_visual(const_cast<GdkScreen*>(gobj())));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::RefPtr<Colormap> Screen::get_rgb_colormap()
+{
+
+  Glib::RefPtr<Colormap> retvalue = Glib::wrap(gdk_screen_get_rgb_colormap(gobj()));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::RefPtr<const Colormap> Screen::get_rgb_colormap() const
+{
+
+  Glib::RefPtr<const Colormap> retvalue = Glib::wrap(gdk_screen_get_rgb_colormap(const_cast<GdkScreen*>(gobj())));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::RefPtr<Visual> Screen::get_rgb_visual()
+{
+
+  Glib::RefPtr<Visual> retvalue = Glib::wrap(gdk_screen_get_rgb_visual(gobj()));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::RefPtr<const Visual> Screen::get_rgb_visual() const
+{
+
+  Glib::RefPtr<const Visual> retvalue = Glib::wrap(gdk_screen_get_rgb_visual(const_cast<GdkScreen*>(gobj())));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::RefPtr<Window> Screen::get_root_window()
+{
+
+  Glib::RefPtr<Window> retvalue = Glib::wrap((GdkWindowObject*)(gdk_screen_get_root_window(gobj())));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::RefPtr<const Window> Screen::get_root_window() const
+{
+
+  Glib::RefPtr<const Window> retvalue = Glib::wrap((GdkWindowObject*)(gdk_screen_get_root_window(const_cast<GdkScreen*>(gobj()))));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::RefPtr<Display> Screen::get_display()
+{
+
+  Glib::RefPtr<Display> retvalue = Glib::wrap(gdk_screen_get_display(gobj()));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::RefPtr<const Display> Screen::get_display() const
+{
+
+  Glib::RefPtr<const Display> retvalue = Glib::wrap(gdk_screen_get_display(const_cast<GdkScreen*>(gobj())));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+int Screen::get_number() const
+{
+  return gdk_screen_get_number(const_cast<GdkScreen*>(gobj()));
+}
+
+int Screen::get_width() const
+{
+  return gdk_screen_get_width(const_cast<GdkScreen*>(gobj()));
+}
+
+int Screen::get_height() const
+{
+  return gdk_screen_get_height(const_cast<GdkScreen*>(gobj()));
+}
+
+int Screen::get_width_mm() const
+{
+  return gdk_screen_get_width_mm(const_cast<GdkScreen*>(gobj()));
+}
+
+int Screen::get_height_mm() const
+{
+  return gdk_screen_get_height_mm(const_cast<GdkScreen*>(gobj()));
+}
+
+Glib::ListHandle< Glib::RefPtr<Visual> > Screen::list_visuals()
+{
+  return Glib::ListHandle< Glib::RefPtr<Visual> >(gdk_screen_list_visuals(gobj()), Glib::OWNERSHIP_SHALLOW);
+}
+
+Glib::ListHandle< Glib::RefPtr<Window> > Screen::get_toplevel_windows()
+{
+  return Glib::ListHandle< Glib::RefPtr<Window> >(gdk_screen_get_toplevel_windows(gobj()), Glib::OWNERSHIP_SHALLOW);
+}
+
+Glib::ustring Screen::make_display_name()
+{
+  return Glib::convert_return_gchar_ptr_to_ustring(gdk_screen_make_display_name(gobj()));
+}
+
+int Screen::get_n_monitors() const
+{
+  return gdk_screen_get_n_monitors(const_cast<GdkScreen*>(gobj()));
+}
+
+void Screen::get_monitor_geometry(int monitor_num, Rectangle& dest) const
+{
+  gdk_screen_get_monitor_geometry(const_cast<GdkScreen*>(gobj()), monitor_num, (dest).gobj());
+}
+
+int Screen::get_monitor_at_point(int x, int y) const
+{
+  return gdk_screen_get_monitor_at_point(const_cast<GdkScreen*>(gobj()), x, y);
+}
+
+int Screen::get_monitor_at_window(const Glib::RefPtr<Window>& window) const
+{
+  return gdk_screen_get_monitor_at_window(const_cast<GdkScreen*>(gobj()), Glib::unwrap(window));
+}
+
+void Screen::broadcast_client_message(GdkEvent* event)
+{
+  gdk_screen_broadcast_client_message(gobj(), event);
+}
+
+Glib::RefPtr<Screen> Screen::get_default()
+{
+
+  Glib::RefPtr<Screen> retvalue = Glib::wrap(gdk_screen_get_default());
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+
+Glib::SignalProxy0< void > Screen::signal_size_changed()
+{
+  return Glib::SignalProxy0< void >(this, &Screen_signal_size_changed_info);
+}
+
+
+void Gdk::Screen::on_size_changed()
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->size_changed)
+    (*base->size_changed)(gobj());
+}
+
+
+} // namespace Gdk
+
+
diff --git a/libs/gtkmm2/gdk/gdkmm/screen.h b/libs/gtkmm2/gdk/gdkmm/screen.h
new file mode 100644
index 0000000000..29ae15d54f
--- /dev/null
+++ b/libs/gtkmm2/gdk/gdkmm/screen.h
@@ -0,0 +1,423 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GDKMM_SCREEN_H
+#define _GDKMM_SCREEN_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* screen.h
+ *
+ * Copyright (C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+//#include <gdkmm/visual.h>
+//#include <gdkmm/window.h>
+#include <gdkmm/rectangle.h>
+#include <glibmm/object.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GdkScreen GdkScreen;
+typedef struct _GdkScreenClass GdkScreenClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gdk
+{ class Screen_Class; } // namespace Gdk
+namespace Gdk
+{
+
+class Display;
+class Colormap;
+class Visual;
+class Window;
+
+/** Object representing a physical screen
+ * Gdk::Screen objects are the GDK representation of a physical screen. It is used throughout GDK and GTK+ to specify
+ * which screen the top level windows are to be displayed on. It is also used to query the screen specification and
+ * default settings such as the default colormap (get_default_colormap()), the screen width (get_width()), etc.
+ * Note that a screen may consist of multiple monitors which are merged to form a large screen area. 
+ */
+
+class Screen : public Glib::Object
+{
+  
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+public:
+  typedef Screen CppObjectType;
+  typedef Screen_Class CppClassType;
+  typedef GdkScreen BaseObjectType;
+  typedef GdkScreenClass BaseClassType;
+
+private:  friend class Screen_Class;
+  static CppClassType screen_class_;
+
+private:
+  // noncopyable
+  Screen(const Screen&);
+  Screen& operator=(const Screen&);
+
+protected:
+  explicit Screen(const Glib::ConstructParams& construct_params);
+  explicit Screen(GdkScreen* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+  virtual ~Screen();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GObject.
+  GdkScreen*       gobj()       { return reinterpret_cast<GdkScreen*>(gobject_); }
+
+  ///Provides access to the underlying C GObject.
+  const GdkScreen* gobj() const { return reinterpret_cast<GdkScreen*>(gobject_); }
+
+  ///Provides access to the underlying C instance. The caller is responsible for unrefing it. Use when directly setting fields in structs.
+  GdkScreen* gobj_copy();
+
+private:
+
+protected:
+
+public:
+  
+  /** Gets the default colormap for @a screen .
+   * @return The default Gdk::Colormap.
+   * 
+   * Since: 2.2.
+   */
+  Glib::RefPtr<Colormap> get_default_colormap();
+  
+  /** Gets the default colormap for @a screen .
+   * @return The default Gdk::Colormap.
+   * 
+   * Since: 2.2.
+   */
+  Glib::RefPtr<const Colormap> get_default_colormap() const;
+
+  
+  /** Sets the default @a colormap  for @a screen .
+   * 
+   * Since: 2.2
+   * @param colormap A Gdk::Colormap.
+   */
+  void set_default_colormap(const Glib::RefPtr<const Colormap>& colormap);
+  
+  /** Gets the system's default colormap for @a screen 
+   * @return The default colormap for @a screen .
+   * 
+   * Since: 2.2.
+   */
+  Glib::RefPtr<Colormap> get_system_colormap();
+  
+  /** Gets the system's default colormap for @a screen 
+   * @return The default colormap for @a screen .
+   * 
+   * Since: 2.2.
+   */
+  Glib::RefPtr<const Colormap> get_system_colormap() const;
+
+  
+  /** Get the system's default visual for @a screen .
+   * This is the visual for the root window of the display.
+   * The return value should not be freed.
+   * @return The system visual
+   * 
+   * Since: 2.2.
+   */
+  Glib::RefPtr<Visual> get_system_visual();
+  
+  /** Get the system's default visual for @a screen .
+   * This is the visual for the root window of the display.
+   * The return value should not be freed.
+   * @return The system visual
+   * 
+   * Since: 2.2.
+   */
+  Glib::RefPtr<const Visual> get_system_visual() const;
+
+  
+  /** Gets the preferred colormap for rendering image data on @a screen .
+   * Not a very useful function; historically, GDK could only render RGB
+   * image data to one colormap and visual, but in the current version
+   * it can render to any colormap and visual. So there's no need to
+   * call this function.
+   * @return The preferred colormap
+   * 
+   * Since: 2.2.
+   */
+  Glib::RefPtr<Colormap> get_rgb_colormap();
+  
+  /** Gets the preferred colormap for rendering image data on @a screen .
+   * Not a very useful function; historically, GDK could only render RGB
+   * image data to one colormap and visual, but in the current version
+   * it can render to any colormap and visual. So there's no need to
+   * call this function.
+   * @return The preferred colormap
+   * 
+   * Since: 2.2.
+   */
+  Glib::RefPtr<const Colormap> get_rgb_colormap() const;
+
+  
+  /** Gets a "preferred visual" chosen by GdkRGB for rendering image data
+   * on @a screen . In previous versions of
+   * GDK, this was the only visual GdkRGB could use for rendering. In
+   * current versions, it's simply the visual GdkRGB would have chosen as 
+   * the optimal one in those previous versions. GdkRGB can now render to 
+   * drawables with any visual.
+   * @return The Gdk::Visual chosen by GdkRGB.
+   * 
+   * Since: 2.2.
+   */
+  Glib::RefPtr<Visual> get_rgb_visual();
+  
+  /** Gets a "preferred visual" chosen by GdkRGB for rendering image data
+   * on @a screen . In previous versions of
+   * GDK, this was the only visual GdkRGB could use for rendering. In
+   * current versions, it's simply the visual GdkRGB would have chosen as 
+   * the optimal one in those previous versions. GdkRGB can now render to 
+   * drawables with any visual.
+   * @return The Gdk::Visual chosen by GdkRGB.
+   * 
+   * Since: 2.2.
+   */
+  Glib::RefPtr<const Visual> get_rgb_visual() const;
+
+  
+  /** Gets the root window of @a screen .
+   * @return The root window
+   * 
+   * Since: 2.2.
+   */
+  Glib::RefPtr<Window> get_root_window();
+  
+  /** Gets the root window of @a screen .
+   * @return The root window
+   * 
+   * Since: 2.2.
+   */
+  Glib::RefPtr<const Window> get_root_window() const;
+
+  
+  /** Gets the display to which the @a screen  belongs.
+   * @return The display to which @a screen  belongs
+   * 
+   * Since: 2.2.
+   */
+  Glib::RefPtr<Display> get_display();
+  
+  /** Gets the display to which the @a screen  belongs.
+   * @return The display to which @a screen  belongs
+   * 
+   * Since: 2.2.
+   */
+  Glib::RefPtr<const Display> get_display() const;
+
+  
+  /** Gets the index of @a screen  among the screens in the display
+   * to which it belongs. (See get_display())
+   * @return The index
+   * 
+   * Since: 2.2.
+   */
+  int get_number() const;
+  
+  /** Gets the width of @a screen  in pixels
+   * @return The width of @a screen  in pixels.
+   * 
+   * Since: 2.2.
+   */
+  int get_width() const;
+  
+  /** Gets the height of @a screen  in pixels
+   * @return The height of @a screen  in pixels.
+   * 
+   * Since: 2.2.
+   */
+  int get_height() const;
+  
+  /** Gets the width of @a screen  in millimeters. 
+   * Note that on some X servers this value will not be correct.
+   * @return The width of @a screen  in pixels.
+   * 
+   * Since: 2.2.
+   */
+  int get_width_mm() const;
+  
+  /** Returns the height of @a screen  in millimeters. 
+   * Note that on some X servers this value will not be correct.
+   * @return The heigth of @a screen  in pixels.
+   * 
+   * Since: 2.2.
+   */
+  int get_height_mm() const;
+
+  
+  /** Lists the available visuals for the specified @a screen .
+   * A visual describes a hardware image data format.
+   * For example, a visual might support 24-bit color, or 8-bit color,
+   * and might expect pixels to be in a certain format.
+   * @return A list of visuals.
+   * 
+   * Since: 2.2.
+   */
+  Glib::ListHandle< Glib::RefPtr<Visual> > list_visuals();
+  
+  /** Obtains a list of all toplevel windows known to GDK on the screen @a screen .
+   * A toplevel window is a child of the root window (see
+   * gdk_get_default_root_window()).
+   * @return List of toplevel windows.
+   * 
+   * Since: 2.2.
+   */
+  Glib::ListHandle< Glib::RefPtr<Window> > get_toplevel_windows();
+  
+  /** Determines the name to pass to Gdk::Display::open() to get
+   * a Gdk::Display with this screen as the default screen.
+   * @return The name.
+   * 
+   * Since: 2.2.
+   */
+  Glib::ustring make_display_name();
+
+  
+  /** Returns the number of monitors which @a screen  consists of.
+   * @return Number of monitors which @a screen  consists of.
+   * 
+   * Since: 2.2.
+   */
+  int get_n_monitors() const;
+  
+  /** Retrieves the Gdk::Rectangle representing the size and position of 
+   * the individual monitor within the the entire screen area.
+   * 
+   * Note that the size of the entire screen area can be retrieved via 
+   * get_width() and get_height().
+   * 
+   * Since: 2.2
+   * @param monitor_num The monitor number.
+   * @param dest A Gdk::Rectangle to be filled with the monitor geometry.
+   */
+  void get_monitor_geometry(int monitor_num, Rectangle& dest) const;
+  
+  /** Returns the monitor number in which the point ( @a x , @a y ) is located.
+   * @param x The x coordinate in the virtual screen.
+   * @param y The y coordinate in the virtual screen.
+   * @return The monitor number in which the point ( @a x , @a y ) lies, or
+   * a monitor close to ( @a x , @a y ) if the point is not in any monitor.
+   * 
+   * Since: 2.2.
+   */
+  int get_monitor_at_point(int x, int y) const;
+  
+  /** 
+   * @param window A Gdk::Window.
+   * @return The monitor number in which most of @a window  is located,
+   * or if @a window  does not intersect any monitors, a monitor,
+   * close to @a window .
+   * the number of the monitor in which the largest area of the 
+   * bounding rectangle of @a window  resides.
+   * 
+   * Since: 2.2.
+   */
+  int get_monitor_at_window(const Glib::RefPtr<Window>& window) const;
+
+  
+  /** On X11, sends an X ClientMessage event to all toplevel windows on
+   *  @a screen . 
+   * 
+   * Toplevel windows are determined by checking for the WM_STATE property, 
+   * as described in the Inter-Client Communication Conventions Manual (ICCCM).
+   * If no windows are found with the WM_STATE property set, the message is 
+   * sent to all children of the root window.
+   * 
+   * On Windows, broadcasts a message registered with the name
+   * GDK_WIN32_CLIENT_MESSAGE to all top-level windows. The amount of
+   * data is limited to one long, i.e. four bytes.
+   * 
+   * Since: 2.2
+   * @param event The Gdk::Event.
+   */
+  void broadcast_client_message(GdkEvent* event);
+
+  
+  /** Gets the default screen for the default display. (See
+   * Gdk::Display::get_default()).
+   * @return A Gdk::Screen, or <tt>0</tt> if there is no default display.
+   * 
+   * Since: 2.2.
+   */
+  static Glib::RefPtr<Screen> get_default();
+
+  template <class ValueType>
+  bool get_setting(const Glib::ustring& name, ValueType& value) const;
+  
+
+  Glib::SignalProxy0< void > signal_size_changed();
+
+
+public:
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+  virtual void on_size_changed();
+
+
+};
+
+template <class ValueType>
+bool Screen::get_setting(const Glib::ustring& name, ValueType& value) const
+{
+  Glib::Value<ValueType> glibmmvalue;
+  glibmmvalue.init(Glib::Value<ValueType>::value_type());
+
+  gboolean result = gdk_screen_get_setting(const_cast<GdkScreen*>(gobj()), name.c_str(), glibmmvalue.gobj());
+
+  value = glibmmvalue.get();
+  return result;
+}
+
+} /* namespace Gdk */
+
+
+namespace Glib
+{
+  /** @relates Gdk::Screen
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Glib::RefPtr<Gdk::Screen> wrap(GdkScreen* object, bool take_copy = false);
+}
+
+
+#endif /* _GDKMM_SCREEN_H */
+
diff --git a/libs/gtkmm2/gdk/gdkmm/types.cc b/libs/gtkmm2/gdk/gdkmm/types.cc
new file mode 100644
index 0000000000..e15170aadb
--- /dev/null
+++ b/libs/gtkmm2/gdk/gdkmm/types.cc
@@ -0,0 +1,116 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gdkmm/types.h>
+#include <gdkmm/private/types_p.h>
+
+#include <gdk/gdkenumtypes.h>
+// -*- c++ -*-
+/* $Id$ */
+
+/* Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+namespace Gdk
+{
+
+Point::Point()
+{
+  gobject_.x = 0;
+  gobject_.y = 0;
+}
+
+Point::Point(int x, int y)
+{
+  gobject_.x = x;
+  gobject_.y = y;
+}
+
+bool Point::equal(const Gdk::Point& rhs) const
+{
+  return (gobject_.x == rhs.gobject_.x) && (gobject_.y == rhs.gobject_.y);
+}
+
+// static
+GdkAtom AtomStringTraits::to_c_type(const std::string& atom_name)
+{
+  return gdk_atom_intern(atom_name.c_str(), 0);
+}
+
+// static
+std::string AtomStringTraits::to_cpp_type(GdkAtom atom)
+{
+  if(char *const atom_name = gdk_atom_name(atom))
+    return std::string(Glib::ScopedPtr<char>(atom_name).get());
+  else
+    return std::string();
+}
+
+} // namespace Gdk
+
+
+namespace Glib
+{
+
+Gdk::Point& wrap(GdkPoint* object)
+{
+  return *reinterpret_cast<Gdk::Point*>(object);
+}
+
+const Gdk::Point& wrap(const GdkPoint* object)
+{
+  return *reinterpret_cast<const Gdk::Point*>(object);
+}
+
+} // namespace Glib
+
+
+namespace
+{
+} // anonymous namespace
+
+// static
+GType Glib::Value<Gdk::ByteOrder>::value_type()
+{
+  return gdk_byte_order_get_type();
+}
+
+// static
+GType Glib::Value<Gdk::ModifierType>::value_type()
+{
+  return gdk_modifier_type_get_type();
+}
+
+// static
+GType Glib::Value<Gdk::Status>::value_type()
+{
+  return gdk_status_get_type();
+}
+
+// static
+GType Glib::Value<Gdk::InputCondition>::value_type()
+{
+  return gdk_input_condition_get_type();
+}
+
+
+namespace Gdk
+{
+
+
+} // namespace Gdk
+
+
diff --git a/libs/gtkmm2/gdk/gdkmm/types.h b/libs/gtkmm2/gdk/gdkmm/types.h
new file mode 100644
index 0000000000..1f0c0fafd4
--- /dev/null
+++ b/libs/gtkmm2/gdk/gdkmm/types.h
@@ -0,0 +1,370 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GDKMM_TYPES_H
+#define _GDKMM_TYPES_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* Copyright (C) 2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+
+#include <gdk/gdk.h>
+#include <gdkmmconfig.h>
+
+/* Shadow ERROR macro (from wingdi.h).
+ */
+#if defined(ERROR) && !defined(GTKMM_MACRO_SHADOW_ERROR)
+enum { GTKMM_MACRO_DEFINITION_ERROR = ERROR };
+#undef ERROR
+enum { ERROR = GTKMM_MACRO_DEFINITION_ERROR };
+#define ERROR ERROR
+#define GTKMM_MACRO_SHADOW_ERROR 1
+#endif
+
+/*********************************************************************
+***** Version macros
+*********************************************************************/
+
+/* macro for controlling version numbers */
+#ifndef _GDK_VERSION
+
+#define GDK_VERSION_GT(major,minor) ((GTK_MAJOR_VERSION>major)||(GTK_MAJOR_VERSION==major)&&(GTK_MINOR_VERSION>minor))
+#define GDK_VERSION_GE(major,minor) ((GTK_MAJOR_VERSION>major)||(GTK_MAJOR_VERSION==major)&&(GTK_MINOR_VERSION>=minor))
+#define GDK_VERSION_EQ(major,minor) ((GTK_MAJOR_VERSION==major)&&(GTK_MINOR_VERSION==minor))
+#define GDK_VERSION_NE(major,minor) ((GTK_MAJOR_VERSION!=major)||(GTK_MINOR_VERSION!=minor))
+#define GDK_VERSION_LE(major,minor) ((GTK_MAJOR_VERSION<major)||(GTK_MAJOR_VERSION==major)&&(GTK_MINOR_VERSION<=minor))
+#define GDK_VERSION_LT(major,minor) ((GTK_MAJOR_VERSION<major)||(GTK_MAJOR_VERSION==major)&&(GTK_MINOR_VERSION<minor))
+
+//Note: Use GTK_CHECK_VERSION to check that a version is equal or more than (the micro version).
+
+#endif /* _GDK_VERSION */
+
+namespace Gdk
+{
+
+class Bitmap;
+class Colormap;
+class Pixmap;
+class Window;
+class Font;
+class GC;
+class Color;
+class Image;
+
+
+/** @addtogroup gdkmmEnums Enums and Flags */
+
+/**
+ * @ingroup gdkmmEnums
+ */
+enum ByteOrder
+{
+  LSB_FIRST,
+  MSB_FIRST
+};
+
+} // namespace Gdk
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Gdk::ByteOrder> : public Glib::Value_Enum<Gdk::ByteOrder>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gdk
+{
+
+/**
+ * @ingroup gdkmmEnums
+ * @par Bitwise operators:
+ * <tt>%ModifierType operator|(ModifierType, ModifierType)</tt><br>
+ * <tt>%ModifierType operator&(ModifierType, ModifierType)</tt><br>
+ * <tt>%ModifierType operator^(ModifierType, ModifierType)</tt><br>
+ * <tt>%ModifierType operator~(ModifierType)</tt><br>
+ * <tt>%ModifierType& operator|=(ModifierType&, ModifierType)</tt><br>
+ * <tt>%ModifierType& operator&=(ModifierType&, ModifierType)</tt><br>
+ * <tt>%ModifierType& operator^=(ModifierType&, ModifierType)</tt><br>
+ */
+enum ModifierType
+{
+  SHIFT_MASK = 1 << 0,
+  LOCK_MASK = 1 << 1,
+  CONTROL_MASK = 1 << 2,
+  MOD1_MASK = 1 << 3,
+  MOD2_MASK = 1 << 4,
+  MOD3_MASK = 1 << 5,
+  MOD4_MASK = 1 << 6,
+  MOD5_MASK = 1 << 7,
+  BUTTON1_MASK = 1 << 8,
+  BUTTON2_MASK = 1 << 9,
+  BUTTON3_MASK = 1 << 10,
+  BUTTON4_MASK = 1 << 11,
+  BUTTON5_MASK = 1 << 12,
+  RELEASE_MASK = 1 << 30,
+  MODIFIER_MASK = 0x40001FFF
+};
+
+/** @ingroup gdkmmEnums */
+inline ModifierType operator|(ModifierType lhs, ModifierType rhs)
+  { return static_cast<ModifierType>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs)); }
+
+/** @ingroup gdkmmEnums */
+inline ModifierType operator&(ModifierType lhs, ModifierType rhs)
+  { return static_cast<ModifierType>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs)); }
+
+/** @ingroup gdkmmEnums */
+inline ModifierType operator^(ModifierType lhs, ModifierType rhs)
+  { return static_cast<ModifierType>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs)); }
+
+/** @ingroup gdkmmEnums */
+inline ModifierType operator~(ModifierType flags)
+  { return static_cast<ModifierType>(~static_cast<unsigned>(flags)); }
+
+/** @ingroup gdkmmEnums */
+inline ModifierType& operator|=(ModifierType& lhs, ModifierType rhs)
+  { return (lhs = static_cast<ModifierType>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs))); }
+
+/** @ingroup gdkmmEnums */
+inline ModifierType& operator&=(ModifierType& lhs, ModifierType rhs)
+  { return (lhs = static_cast<ModifierType>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs))); }
+
+/** @ingroup gdkmmEnums */
+inline ModifierType& operator^=(ModifierType& lhs, ModifierType rhs)
+  { return (lhs = static_cast<ModifierType>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs))); }
+
+} // namespace Gdk
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Gdk::ModifierType> : public Glib::Value_Flags<Gdk::ModifierType>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gdk
+{
+
+/**
+ * @ingroup gdkmmEnums
+ */
+enum Status
+{
+  OK = 0,
+  ERROR = -1,
+  ERROR_PARAM = -2,
+  ERROR_FILE = -3,
+  ERROR_MEM = -4
+};
+
+} // namespace Gdk
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Gdk::Status> : public Glib::Value_Enum<Gdk::Status>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gdk
+{
+
+/**
+ * @ingroup gdkmmEnums
+ * @par Bitwise operators:
+ * <tt>%InputCondition operator|(InputCondition, InputCondition)</tt><br>
+ * <tt>%InputCondition operator&(InputCondition, InputCondition)</tt><br>
+ * <tt>%InputCondition operator^(InputCondition, InputCondition)</tt><br>
+ * <tt>%InputCondition operator~(InputCondition)</tt><br>
+ * <tt>%InputCondition& operator|=(InputCondition&, InputCondition)</tt><br>
+ * <tt>%InputCondition& operator&=(InputCondition&, InputCondition)</tt><br>
+ * <tt>%InputCondition& operator^=(InputCondition&, InputCondition)</tt><br>
+ */
+enum InputCondition
+{
+  INPUT_READ = 1 << 0,
+  INPUT_WRITE = 1 << 1,
+  INPUT_EXCEPTION = 1 << 2
+};
+
+/** @ingroup gdkmmEnums */
+inline InputCondition operator|(InputCondition lhs, InputCondition rhs)
+  { return static_cast<InputCondition>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs)); }
+
+/** @ingroup gdkmmEnums */
+inline InputCondition operator&(InputCondition lhs, InputCondition rhs)
+  { return static_cast<InputCondition>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs)); }
+
+/** @ingroup gdkmmEnums */
+inline InputCondition operator^(InputCondition lhs, InputCondition rhs)
+  { return static_cast<InputCondition>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs)); }
+
+/** @ingroup gdkmmEnums */
+inline InputCondition operator~(InputCondition flags)
+  { return static_cast<InputCondition>(~static_cast<unsigned>(flags)); }
+
+/** @ingroup gdkmmEnums */
+inline InputCondition& operator|=(InputCondition& lhs, InputCondition rhs)
+  { return (lhs = static_cast<InputCondition>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs))); }
+
+/** @ingroup gdkmmEnums */
+inline InputCondition& operator&=(InputCondition& lhs, InputCondition rhs)
+  { return (lhs = static_cast<InputCondition>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs))); }
+
+/** @ingroup gdkmmEnums */
+inline InputCondition& operator^=(InputCondition& lhs, InputCondition rhs)
+  { return (lhs = static_cast<InputCondition>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs))); }
+
+} // namespace Gdk
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Gdk::InputCondition> : public Glib::Value_Flags<Gdk::InputCondition>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gdk
+{
+
+
+typedef GdkGeometry Geometry; //It's not used enough to justify having a wrapper.
+typedef GdkNativeWindow NativeWindow;
+
+/** This is a simple structure containing an x and y coordinate of a point.
+ */
+class Point
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Point CppObjectType;
+  typedef GdkPoint BaseObjectType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+private:
+
+
+public:
+  Point();
+  Point(int x, int y);
+
+  void set_x(int x) { gobject_.x = x; }
+  void set_y(int y) { gobject_.y = y; }
+
+  int get_x() const { return gobject_.x; }
+  int get_y() const { return gobject_.y; }
+
+  bool equal(const Gdk::Point& rhs) const;
+
+  /// Provides access to the underlying C GObject.  
+  GdkPoint*       gobj()       { return &gobject_; }
+  /// Provides access to the underlying C GObject.  
+  const GdkPoint* gobj() const { return &gobject_; }
+
+protected:
+  GdkPoint gobject_;
+
+
+};
+
+/** @relates Gdk::Point */
+inline bool operator==(const Point& lhs, const Point& rhs)
+  { return lhs.equal(rhs); }
+
+/** @relates Gdk::Point */
+inline bool operator!=(const Point& lhs, const Point& rhs)
+  { return !lhs.equal(rhs); }
+
+
+struct AtomStringTraits
+{
+  typedef std::string CppType;
+  typedef GdkAtom     CType;
+  typedef GdkAtom     CTypeNonConst;
+
+  static GdkAtom to_c_type(GdkAtom atom) { return atom; }
+  static void    release_c_type(GdkAtom) {}
+
+  // These aren't worth to be inlined since doing so
+  // would expose way too much of the implementation.
+  static GdkAtom     to_c_type  (const std::string& atom_name);
+  static std::string to_cpp_type(GdkAtom atom);
+};
+
+// I'm typedef'ing this because when we call to_c_type or to_c_type,
+// we don't want it to look like we're calling a template trait, but
+// a utility function. -Bryan
+typedef AtomStringTraits AtomString;
+
+typedef Glib::ArrayHandle<std::string,AtomStringTraits> ArrayHandle_AtomString;
+
+} // namespace Gdk
+
+
+namespace Glib
+{
+
+/** @relates Gdk::Point */
+Gdk::Point& wrap(GdkPoint* object);
+
+/** @relates Gdk::Point */
+const Gdk::Point& wrap(const GdkPoint* object);
+
+} // namespace Glib
+
+
+#endif /* _GDKMM_TYPES_H */
+
diff --git a/libs/gtkmm2/gdk/gdkmm/visual.cc b/libs/gtkmm2/gdk/gdkmm/visual.cc
new file mode 100644
index 0000000000..4d4e84774c
--- /dev/null
+++ b/libs/gtkmm2/gdk/gdkmm/visual.cc
@@ -0,0 +1,226 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gdkmm/visual.h>
+#include <gdkmm/private/visual_p.h>
+
+#include <gdk/gdkenumtypes.h>
+// -*- c++ -*-
+/* $Id$ */
+
+/*
+ *
+ * Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gdk/gdkvisual.h>
+
+namespace Gdk
+{
+
+
+} //namespace
+
+
+namespace
+{
+} // anonymous namespace
+
+// static
+GType Glib::Value<Gdk::VisualType>::value_type()
+{
+  return gdk_visual_type_get_type();
+}
+
+
+namespace Glib
+{
+
+Glib::RefPtr<Gdk::Visual> wrap(GdkVisual* object, bool take_copy)
+{
+  return Glib::RefPtr<Gdk::Visual>( dynamic_cast<Gdk::Visual*> (Glib::wrap_auto ((GObject*)(object), take_copy)) );
+  //We use dynamic_cast<> in case of multiple inheritance.
+}
+
+} /* namespace Glib */
+
+
+namespace Gdk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& Visual_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &Visual_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gdk_visual_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void Visual_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+}
+
+
+Glib::ObjectBase* Visual_Class::wrap_new(GObject* object)
+{
+  return new Visual((GdkVisual*)object);
+}
+
+
+/* The implementation: */
+
+GdkVisual* Visual::gobj_copy()
+{
+  reference();
+  return gobj();
+}
+
+Visual::Visual(const Glib::ConstructParams& construct_params)
+:
+  Glib::Object(construct_params)
+{}
+
+Visual::Visual(GdkVisual* castitem)
+:
+  Glib::Object((GObject*)(castitem))
+{}
+
+Visual::~Visual()
+{}
+
+
+Visual::CppClassType Visual::visual_class_; // initialize static member
+
+GType Visual::get_type()
+{
+  return visual_class_.init().get_type();
+}
+
+GType Visual::get_base_type()
+{
+  return gdk_visual_get_type();
+}
+
+
+Visual::Visual()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Glib::Object(Glib::ConstructParams(visual_class_.init()))
+{
+  }
+
+Glib::RefPtr<Visual> Visual::get_system()
+{
+
+  Glib::RefPtr<Visual> retvalue = Glib::wrap(gdk_visual_get_system());
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::RefPtr<Visual> Visual::get_best()
+{
+
+  Glib::RefPtr<Visual> retvalue = Glib::wrap(gdk_visual_get_best());
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::RefPtr<Visual> Visual::get_best(int depth)
+{
+
+  Glib::RefPtr<Visual> retvalue = Glib::wrap(gdk_visual_get_best_with_depth(depth));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::RefPtr<Visual> Visual::get_best(VisualType visual_type)
+{
+
+  Glib::RefPtr<Visual> retvalue = Glib::wrap(gdk_visual_get_best_with_type(((GdkVisualType)(visual_type))));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::RefPtr<Visual> Visual::get_best(int depth, VisualType visual_type)
+{
+
+  Glib::RefPtr<Visual> retvalue = Glib::wrap(gdk_visual_get_best_with_both(depth, ((GdkVisualType)(visual_type))));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+int Visual::get_best_depth()
+{
+  return gdk_visual_get_best_depth();
+}
+
+VisualType Visual::get_best_type()
+{
+  return ((VisualType)(gdk_visual_get_best_type()));
+}
+
+Glib::RefPtr<Screen> Visual::get_screen()
+{
+
+  Glib::RefPtr<Screen> retvalue = Glib::wrap(gdk_visual_get_screen(gobj()));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::RefPtr<const Screen> Visual::get_screen() const
+{
+
+  Glib::RefPtr<const Screen> retvalue = Glib::wrap(gdk_visual_get_screen(const_cast<GdkVisual*>(gobj())));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+
+} // namespace Gdk
+
+
diff --git a/libs/gtkmm2/gdk/gdkmm/visual.h b/libs/gtkmm2/gdk/gdkmm/visual.h
new file mode 100644
index 0000000000..66f3cd5807
--- /dev/null
+++ b/libs/gtkmm2/gdk/gdkmm/visual.h
@@ -0,0 +1,253 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GDKMM_VISUAL_H
+#define _GDKMM_VISUAL_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* bitmap.h
+ *
+ * Copyright (C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <glibmm/object.h>
+#include <gdkmm/screen.h>
+#include <gdk/gdkvisual.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GdkVisual GdkVisual;
+typedef struct _GdkVisualClass GdkVisualClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gdk
+{ class Visual_Class; } // namespace Gdk
+namespace Gdk
+{
+
+class Screen;
+
+
+/** @addtogroup gdkmmEnums Enums and Flags */
+
+/**
+ * @ingroup gdkmmEnums
+ */
+enum VisualType
+{
+  VISUAL_STATIC_GRAY,
+  VISUAL_GRAYSCALE,
+  VISUAL_STATIC_COLOR,
+  VISUAL_PSEUDO_COLOR,
+  VISUAL_TRUE_COLOR,
+  VISUAL_DIRECT_COLOR
+};
+
+} // namespace Gdk
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Gdk::VisualType> : public Glib::Value_Enum<Gdk::VisualType>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gdk
+{
+
+
+/** A Gdk::Visual describes a particular video hardware display format.
+ * It includes information about the number of bits used for each color, the way the bits are translated into an RGB value
+ * for display, and the way the bits are stored in memory. For example, a piece of display hardware might support 24-bit
+ * color, 16-bit color, or 8-bit color; meaning 24/16/8-bit pixel sizes. For a given pixel size, pixels can be in different
+ * formats; for example the "red" element of an RGB pixel may be in the top 8 bits of the pixel, or may be in the lower 4
+ * bits.
+ *
+ * Usually you can avoid thinking about visuals in GTK+. Visuals are useful to interpret the contents of a GdkImage, but
+ * you should avoid Gdk::Image precisely because its contents depend on the display hardware; use Gdk::Pixbuf instead, for
+ * all but the most low-level purposes. Also, anytime you provide a Gdk::Colormap, the visual is implied as part of the
+ * colormap (Gdk::Colormap::get_visual()), so you won't have to provide a visual in addition.
+ *
+ * There are several standard visuals. The visual returned by get_system() is the system's default visual. get_visual()
+ * returns the visual most suited to displaying full-color image data. If you use the calls in Gdk::RGB, you should create
+ * your windows using this visual (and the colormap returned by Gdk::Rgb::get_colormap()).
+ *
+ * A number of methods are provided for determining the "best" available visual. For the purposes of making this
+ * determination, higher bit depths are considered better, and for visuals of the same bit depth, GDK_VISUAL_PSEUDO_COLOR
+ * is preferred at 8bpp, otherwise, the visual types are ranked in the order of (highest to lowest) GDK_VISUAL_DIRECT_COLOR,
+ * GDK_VISUAL_TRUE_COLOR, GDK_VISUAL_PSEUDO_COLOR, GDK_VISUAL_STATIC_COLOR, GDK_VISUAL_GRAYSCALE, then
+ * GDK_VISUAL_STATIC_GRAY.
+ */
+
+class Visual : public Glib::Object
+{
+  
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+public:
+  typedef Visual CppObjectType;
+  typedef Visual_Class CppClassType;
+  typedef GdkVisual BaseObjectType;
+  typedef GdkVisualClass BaseClassType;
+
+private:  friend class Visual_Class;
+  static CppClassType visual_class_;
+
+private:
+  // noncopyable
+  Visual(const Visual&);
+  Visual& operator=(const Visual&);
+
+protected:
+  explicit Visual(const Glib::ConstructParams& construct_params);
+  explicit Visual(GdkVisual* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+  virtual ~Visual();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GObject.
+  GdkVisual*       gobj()       { return reinterpret_cast<GdkVisual*>(gobject_); }
+
+  ///Provides access to the underlying C GObject.
+  const GdkVisual* gobj() const { return reinterpret_cast<GdkVisual*>(gobject_); }
+
+  ///Provides access to the underlying C instance. The caller is responsible for unrefing it. Use when directly setting fields in structs.
+  GdkVisual* gobj_copy();
+
+private:
+
+protected:
+
+  Visual();
+
+public:
+   
+  /** Get the system'sdefault visual for the default GDK screen.
+   * This is the visual for the root window of the display.
+   * The return value should not be freed.
+   * @return System visual.
+   */
+  static Glib::RefPtr<Visual> get_system();
+   
+  /** Get the visual with the most available colors for the default
+   * GDK screen. The return value should not be freed.
+   * @return Best visual.
+   */
+  static Glib::RefPtr<Visual> get_best();
+   
+  /** Get the best visual with depth @a depth  for the default GDK screen.
+   * Color visuals and visuals with mutable colormaps are preferred
+   * over grayscale or fixed-colormap visuals. The return value should not
+   * be freed. <tt>0</tt> may be returned if no visual supports @a depth .
+   * @param depth A bit depth.
+   * @return Best visual for the given depth.
+   */
+  static Glib::RefPtr<Visual> get_best(int depth);
+   
+  /** Get the best visual of the given @a visual_type  for the default GDK screen.
+   * Visuals with higher color depths are considered better. The return value
+   * should not be freed. <tt>0</tt> may be returned if no visual has type
+   *  @a visual_type .
+   * @param visual_type A visual type.
+   * @return Best visual of the given type.
+   */
+  static Glib::RefPtr<Visual> get_best(VisualType visual_type);
+   
+  /** Combines gdk_visual_get_best_with_depth() and gdk_visual_get_best_with_type().
+   * @param depth A bit depth.
+   * @param visual_type A visual type.
+   * @return Best visual with both @a depth  and @a visual_type , or <tt>0</tt> if none.
+   */
+  static Glib::RefPtr<Visual> get_best(int depth, VisualType visual_type);
+
+   
+  /** Get the best available depth for the default GDK screen.  "Best"
+   * means "largest," i.e. 32 preferred over 24 preferred over 8 bits
+   * per pixel.
+   * @return Best available depth.
+   */
+  static int get_best_depth();
+   
+  /** Return the best available visual type for the default GDK screen.
+   * @return Best visual type.
+   */
+  static VisualType get_best_type();
+
+   
+  /** Gets the screen to which this visual belongs
+   * @return The screen to which this visual belongs.
+   * 
+   * Since: 2.2.
+   */
+  Glib::RefPtr<Screen> get_screen();
+   
+  /** Gets the screen to which this visual belongs
+   * @return The screen to which this visual belongs.
+   * 
+   * Since: 2.2.
+   */
+  Glib::RefPtr<const Screen> get_screen() const;
+
+
+public:
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+};
+
+} //namespace Gdk
+
+
+namespace Glib
+{
+  /** @relates Gdk::Visual
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Glib::RefPtr<Gdk::Visual> wrap(GdkVisual* object, bool take_copy = false);
+}
+
+
+#endif /* _GDKMM_VISUAL_H */
+
diff --git a/libs/gtkmm2/gdk/gdkmm/window.cc b/libs/gtkmm2/gdk/gdkmm/window.cc
new file mode 100644
index 0000000000..9419c5b01b
--- /dev/null
+++ b/libs/gtkmm2/gdk/gdkmm/window.cc
@@ -0,0 +1,769 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gdkmm/window.h>
+#include <gdkmm/private/window_p.h>
+
+#include <gdk/gdkenumtypes.h>
+// -*- c++ -*-
+/* $Id$ */
+
+/* Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gdk/gdkwindow.h>
+#include <gdkmm/pixmap.h>
+#include <gdkmm/cursor.h>
+#include <gdkmm/types.h>
+
+
+namespace Gdk
+{
+
+Window::Window(const Glib::RefPtr<Window>& parent, GdkWindowAttr* attributes, int attributes_mask)
+:
+  Drawable((GdkDrawable*) gdk_window_new(parent->gobj(), attributes, attributes_mask))
+{
+  //GdkWindow is X11/win32-specific, so we probably can't derived our own GType.
+}
+
+void Window::set_cursor()
+{
+  gdk_window_set_cursor(gobj(), 0);
+}
+
+GrabStatus Window::pointer_grab(bool owner_events, EventMask event_mask, const Cursor& cursor, guint32 timestamp)
+{
+  return ((GrabStatus)(gdk_pointer_grab(gobj(), static_cast<int>(owner_events), ((GdkEventMask)(event_mask)), 0, (cursor).gobj_copy(), timestamp)));
+}
+
+GrabStatus Window::pointer_grab(bool owner_events, EventMask event_mask, guint32 timestamp)
+{
+  return ((GrabStatus)(gdk_pointer_grab(gobj(), static_cast<int>(owner_events), ((GdkEventMask)(event_mask)), 0, 0, timestamp)));
+}
+
+//static
+void Window::unset_sm_client_id()
+{
+  gdk_set_sm_client_id(0 /* see GDK docs */);
+}
+
+void Window::set_icon(const Glib::RefPtr<Window>& icon_window, const Glib::RefPtr<Pixmap>& pixmap)
+{
+  gdk_window_set_icon(gobj(), icon_window->gobj(), pixmap->gobj(), 0); /* See GDK docs */  
+}
+  
+void Window::unset_icon()
+{
+  gdk_window_set_icon(gobj(), 0, 0, 0); /* See GDK docs */
+}
+
+void Window::unset_shape_combine_mask()
+{
+  gdk_window_shape_combine_mask(gobj(), 0, 0, 0); //See GDK docs.
+} 
+
+void Window::get_internal_paint_info(Glib::RefPtr<Drawable>& real_drawable, int& x_offset, int& y_offset) const
+{
+  GdkDrawable* temp_drawable = 0;
+  gdk_window_get_internal_paint_info(const_cast<GdkWindow*>(gobj()), &temp_drawable, &x_offset, &y_offset);
+  real_drawable = Glib::wrap(temp_drawable);
+}
+
+} // namespace Gdk
+
+
+namespace
+{
+} // anonymous namespace
+
+// static
+GType Glib::Value<Gdk::EventMask>::value_type()
+{
+  return gdk_event_mask_get_type();
+}
+
+// static
+GType Glib::Value<Gdk::WindowState>::value_type()
+{
+  return gdk_window_state_get_type();
+}
+
+// static
+GType Glib::Value<Gdk::WindowType>::value_type()
+{
+  return gdk_window_type_get_type();
+}
+
+// static
+GType Glib::Value<Gdk::WindowAttributesType>::value_type()
+{
+  return gdk_window_attributes_type_get_type();
+}
+
+// static
+GType Glib::Value<Gdk::WindowHints>::value_type()
+{
+  return gdk_window_hints_get_type();
+}
+
+// static
+GType Glib::Value<Gdk::WindowTypeHint>::value_type()
+{
+  return gdk_window_type_hint_get_type();
+}
+
+// static
+GType Glib::Value<Gdk::WMDecoration>::value_type()
+{
+  return gdk_wm_decoration_get_type();
+}
+
+// static
+GType Glib::Value<Gdk::WMFunction>::value_type()
+{
+  return gdk_wm_function_get_type();
+}
+
+// static
+GType Glib::Value<Gdk::WindowEdge>::value_type()
+{
+  return gdk_window_edge_get_type();
+}
+
+// static
+GType Glib::Value<Gdk::Gravity>::value_type()
+{
+  return gdk_gravity_get_type();
+}
+
+// static
+GType Glib::Value<Gdk::GrabStatus>::value_type()
+{
+  return gdk_grab_status_get_type();
+}
+
+
+namespace Glib
+{
+
+Glib::RefPtr<Gdk::Window> wrap(GdkWindowObject* object, bool take_copy)
+{
+  return Glib::RefPtr<Gdk::Window>( dynamic_cast<Gdk::Window*> (Glib::wrap_auto ((GObject*)(object), take_copy)) );
+  //We use dynamic_cast<> in case of multiple inheritance.
+}
+
+} /* namespace Glib */
+
+
+namespace Gdk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& Window_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &Window_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gdk_window_object_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void Window_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+}
+
+
+Glib::ObjectBase* Window_Class::wrap_new(GObject* object)
+{
+  return new Window((GdkWindow*)object);
+}
+
+
+/* The implementation: */
+
+GdkWindow* Window::gobj_copy()
+{
+  reference();
+  return gobj();
+}
+
+Window::Window(const Glib::ConstructParams& construct_params)
+:
+  Gdk::Drawable(construct_params)
+{}
+
+Window::Window(GdkWindow* castitem)
+:
+  Gdk::Drawable((GdkDrawable*)(castitem))
+{}
+
+Window::~Window()
+{}
+
+
+Window::CppClassType Window::window_class_; // initialize static member
+
+GType Window::get_type()
+{
+  return window_class_.init().get_type();
+}
+
+GType Window::get_base_type()
+{
+  return gdk_window_object_get_type();
+}
+
+
+Glib::RefPtr<Window> Window::create(const Glib::RefPtr<Window>& parent, GdkWindowAttr* attributes, int attributes_mask)
+{
+  return Glib::RefPtr<Window>( new Window(parent, attributes, attributes_mask) );
+}
+WindowType Window::get_window_type() const
+{
+  return ((WindowType)(gdk_window_get_window_type(const_cast<GdkWindow*>(gobj()))));
+}
+
+void Window::show()
+{
+  gdk_window_show(gobj());
+}
+
+void Window::hide()
+{
+  gdk_window_hide(gobj());
+}
+
+void Window::withdraw()
+{
+  gdk_window_withdraw(gobj());
+}
+
+void Window::show_unraised()
+{
+  gdk_window_show_unraised(gobj());
+}
+
+void Window::move(int x, int y)
+{
+  gdk_window_move(gobj(), x, y);
+}
+
+void Window::resize(int width, int height)
+{
+  gdk_window_resize(gobj(), width, height);
+}
+
+void Window::move_resize(int x, int y, int width, int height)
+{
+  gdk_window_move_resize(gobj(), x, y, width, height);
+}
+
+void Window::reparent(const Glib::RefPtr<Window>& new_parent, int x, int y)
+{
+  gdk_window_reparent(gobj(), Glib::unwrap(new_parent), x, y);
+}
+
+void Window::clear()
+{
+  gdk_window_clear(gobj());
+}
+
+void Window::clear_area(int x, int y, int width, int height)
+{
+  gdk_window_clear_area(gobj(), x, y, width, height);
+}
+
+void Window::clear_area_e(int x, int y, int width, int height)
+{
+  gdk_window_clear_area_e(gobj(), x, y, width, height);
+}
+
+void Window::raise()
+{
+  gdk_window_raise(gobj());
+}
+
+void Window::lower()
+{
+  gdk_window_lower(gobj());
+}
+
+void Window::focus(guint32 timestamp)
+{
+  gdk_window_focus(gobj(), timestamp);
+}
+
+void Window::set_user_data(gpointer user_data)
+{
+  gdk_window_set_user_data(gobj(), user_data);
+}
+
+void Window::set_override_redirect(bool override_redirect)
+{
+  gdk_window_set_override_redirect(gobj(), static_cast<int>(override_redirect));
+}
+
+void Window::add_filter(GdkFilterFunc function, gpointer data)
+{
+  gdk_window_add_filter(gobj(), function, data);
+}
+
+void Window::remove_filter(GdkFilterFunc function, gpointer data)
+{
+  gdk_window_remove_filter(gobj(), function, data);
+}
+
+void Window::scroll(int dx, int dy)
+{
+  gdk_window_scroll(gobj(), dx, dy);
+}
+
+void Window::shape_combine_mask(const Glib::RefPtr<Bitmap>& mask, int x, int y)
+{
+  gdk_window_shape_combine_mask(gobj(), Glib::unwrap(mask), x, y);
+}
+
+void Window::shape_combine_region(const Region& shape_region, int offset_x, int offset_y)
+{
+  gdk_window_shape_combine_region(gobj(), const_cast<GdkRegion*>((shape_region).gobj()), offset_x, offset_y);
+}
+
+void Window::set_child_shapes()
+{
+  gdk_window_set_child_shapes(gobj());
+}
+
+void Window::merge_child_shapes()
+{
+  gdk_window_merge_child_shapes(gobj());
+}
+
+bool Window::is_visible() const
+{
+  return gdk_window_is_visible(const_cast<GdkWindow*>(gobj()));
+}
+
+bool Window::is_viewable() const
+{
+  return gdk_window_is_viewable(const_cast<GdkWindow*>(gobj()));
+}
+
+WindowState Window::get_state() const
+{
+  return ((WindowState)(gdk_window_get_state(const_cast<GdkWindow*>(gobj()))));
+}
+
+bool Window::set_static_gravities(bool use_static)
+{
+  return gdk_window_set_static_gravities(gobj(), static_cast<int>(use_static));
+}
+
+void Window::set_type_hint(WindowTypeHint hint)
+{
+  gdk_window_set_type_hint(gobj(), ((GdkWindowTypeHint)(hint)));
+}
+
+void Window::set_modal_hint(bool modal)
+{
+  gdk_window_set_modal_hint(gobj(), static_cast<int>(modal));
+}
+
+void Window::set_geometry_hints(const Geometry& geometry, WindowHints geom_mask)
+{
+  gdk_window_set_geometry_hints(gobj(), const_cast<GdkGeometry*>(&(geometry)), ((GdkWindowHints)(geom_mask)));
+}
+
+void Window::set_sm_client_id(const Glib::ustring& sm_client_id)
+{
+  gdk_set_sm_client_id(sm_client_id.c_str());
+}
+
+void Window::begin_paint_rect(Rectangle& rectangle)
+{
+  gdk_window_begin_paint_rect(gobj(), (rectangle).gobj());
+}
+
+void Window::begin_paint_region(const Region& region)
+{
+  gdk_window_begin_paint_region(gobj(), const_cast<GdkRegion*>((region).gobj()));
+}
+
+void Window::end_paint()
+{
+  gdk_window_end_paint(gobj());
+}
+
+void Window::set_title(const Glib::ustring& title)
+{
+  gdk_window_set_title(gobj(), title.c_str());
+}
+
+void Window::set_role(const Glib::ustring& role)
+{
+  gdk_window_set_role(gobj(), role.c_str());
+}
+
+void Window::set_transient_for(const Glib::RefPtr<Window>& parent)
+{
+  gdk_window_set_transient_for(gobj(), Glib::unwrap(parent));
+}
+
+void Window::set_background(const Color& color)
+{
+  gdk_window_set_background(gobj(), (color).gobj());
+}
+
+void Window::set_back_pixmap(const Glib::RefPtr<Pixmap>& pixmap, bool parent_relative)
+{
+  gdk_window_set_back_pixmap(gobj(), Glib::unwrap(pixmap), static_cast<int>(parent_relative));
+}
+
+void Window::set_cursor(const Cursor& cursor)
+{
+  gdk_window_set_cursor(gobj(), (cursor).gobj_copy());
+}
+
+void Window::get_user_data(gpointer* data)
+{
+  gdk_window_get_user_data(gobj(), data);
+}
+
+void Window::get_geometry(int& x, int& y, int& width, int& height, int& depth) const
+{
+  gdk_window_get_geometry(const_cast<GdkWindow*>(gobj()), &x, &y, &width, &height, &depth);
+}
+
+void Window::get_position(int& x, int& y) const
+{
+  gdk_window_get_position(const_cast<GdkWindow*>(gobj()), &x, &y);
+}
+
+int Window::get_origin(int& x, int& y) const
+{
+  return gdk_window_get_origin(const_cast<GdkWindow*>(gobj()), &x, &y);
+}
+
+void Window::get_root_origin(int& x, int& y) const
+{
+  gdk_window_get_root_origin(const_cast<GdkWindow*>(gobj()), &x, &y);
+}
+
+void Window::get_frame_extents(Rectangle& rect)
+{
+  gdk_window_get_frame_extents(gobj(), (rect).gobj());
+}
+
+Glib::RefPtr<Window> Window::get_pointer(int& x, int& y, ModifierType& mask)
+{
+
+  Glib::RefPtr<Window> retvalue = Glib::wrap((GdkWindowObject*)(gdk_window_get_pointer(gobj(), &x, &y, ((GdkModifierType*) &(mask)))));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::RefPtr<Window> Window::get_parent()
+{
+
+  Glib::RefPtr<Window> retvalue = Glib::wrap((GdkWindowObject*)(gdk_window_get_parent(gobj())));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::RefPtr<const Window> Window::get_parent() const
+{
+
+  Glib::RefPtr<const Window> retvalue = Glib::wrap((GdkWindowObject*)(gdk_window_get_parent(const_cast<GdkWindow*>(gobj()))));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::RefPtr<Window> Window::get_toplevel()
+{
+
+  Glib::RefPtr<Window> retvalue = Glib::wrap((GdkWindowObject*)(gdk_window_get_toplevel(gobj())));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::RefPtr<const Window> Window::get_toplevel() const
+{
+
+  Glib::RefPtr<const Window> retvalue = Glib::wrap((GdkWindowObject*)(gdk_window_get_toplevel(const_cast<GdkWindow*>(gobj()))));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::ListHandle< Glib::RefPtr<Window> > Window::get_children()
+{
+  return Glib::ListHandle< Glib::RefPtr<Window> >(gdk_window_get_children(gobj()), Glib::OWNERSHIP_SHALLOW);
+}
+
+Glib::ListHandle< Glib::RefPtr<const Window> > Window::get_children() const
+{
+  return Glib::ListHandle< Glib::RefPtr<const Window> >(gdk_window_get_children(const_cast<GdkWindow*>(gobj())), Glib::OWNERSHIP_SHALLOW);
+}
+
+EventMask Window::get_events() const
+{
+  return ((EventMask)(gdk_window_get_events(const_cast<GdkWindow*>(gobj()))));
+}
+
+void Window::set_events(EventMask event_mask)
+{
+  gdk_window_set_events(gobj(), ((GdkEventMask)(event_mask)));
+}
+
+void Window::set_icon_list(const Glib::ListHandle< Glib::RefPtr<Gdk::Pixbuf> >& pixbufs)
+{
+  gdk_window_set_icon_list(gobj(), pixbufs.data());
+}
+
+void Window::set_icon(const Glib::RefPtr<Window>& icon_window, const Glib::RefPtr<Pixmap>& pixmap, const Glib::RefPtr<Bitmap>& mask)
+{
+  gdk_window_set_icon(gobj(), Glib::unwrap(icon_window), Glib::unwrap(pixmap), Glib::unwrap(mask));
+}
+
+void Window::set_icon_name(const Glib::ustring& name)
+{
+  gdk_window_set_icon_name(gobj(), name.c_str());
+}
+
+void Window::set_group(const Glib::RefPtr<Window>& leader)
+{
+  gdk_window_set_group(gobj(), Glib::unwrap(leader));
+}
+
+Glib::RefPtr<Window> Window::get_group()
+{
+  return Glib::wrap((GdkWindowObject*)(gdk_window_get_group(gobj())));
+}
+
+Glib::RefPtr<const Window> Window::get_group() const
+{
+  return Glib::wrap((GdkWindowObject*)(gdk_window_get_group(const_cast<GdkWindow*>(gobj()))));
+}
+
+void Window::set_decorations(WMDecoration decorations)
+{
+  gdk_window_set_decorations(gobj(), ((GdkWMDecoration)(decorations)));
+}
+
+bool Window::get_decorations(WMDecoration& decorations) const
+{
+  return gdk_window_get_decorations(const_cast<GdkWindow*>(gobj()), ((GdkWMDecoration*) &(decorations)));
+}
+
+void Window::set_functions(WMFunction functions)
+{
+  gdk_window_set_functions(gobj(), ((GdkWMFunction)(functions)));
+}
+
+Glib::ListHandle< Glib::RefPtr<Window> > Window::get_toplevels()
+{
+  return Glib::ListHandle< Glib::RefPtr<Window> >(gdk_window_get_toplevels(), Glib::OWNERSHIP_SHALLOW);
+}
+
+void Window::iconify()
+{
+  gdk_window_iconify(gobj());
+}
+
+void Window::deiconify()
+{
+  gdk_window_deiconify(gobj());
+}
+
+void Window::stick()
+{
+  gdk_window_stick(gobj());
+}
+
+void Window::unstick()
+{
+  gdk_window_unstick(gobj());
+}
+
+void Window::maximize()
+{
+  gdk_window_maximize(gobj());
+}
+
+void Window::unmaximize()
+{
+  gdk_window_unmaximize(gobj());
+}
+
+void Window::register_dnd()
+{
+  gdk_window_register_dnd(gobj());
+}
+
+void Window::begin_resize_drag(WindowEdge edge, int button, int root_x, int root_y, guint32 timestamp)
+{
+  gdk_window_begin_resize_drag(gobj(), ((GdkWindowEdge)(edge)), button, root_x, root_y, timestamp);
+}
+
+void Window::begin_move_drag(int button, int root_x, int root_y, guint32 timestamp)
+{
+  gdk_window_begin_move_drag(gobj(), button, root_x, root_y, timestamp);
+}
+
+void Window::invalidate_rect(const Rectangle& rect, bool invalidate_children)
+{
+  gdk_window_invalidate_rect(gobj(), const_cast<GdkRectangle*>(rect.gobj()), static_cast<int>(invalidate_children));
+}
+
+void Window::invalidate_region(const Region& region, bool invalidate_children)
+{
+  gdk_window_invalidate_region(gobj(), const_cast<GdkRegion*>((region).gobj()), static_cast<int>(invalidate_children));
+}
+
+Region Window::get_update_area()
+{
+  return Region(gdk_window_get_update_area(gobj()));
+}
+
+void Window::freeze_updates()
+{
+  gdk_window_freeze_updates(gobj());
+}
+
+void Window::thaw_updates()
+{
+  gdk_window_thaw_updates(gobj());
+}
+
+void Window::process_all_updates()
+{
+  gdk_window_process_all_updates();
+}
+
+void Window::process_updates(bool update_children)
+{
+  gdk_window_process_updates(gobj(), static_cast<int>(update_children));
+}
+
+void Window::set_debug_updates(bool setting)
+{
+  gdk_window_set_debug_updates(static_cast<int>(setting));
+}
+
+void Window::constrain_size(const Geometry& geometry, guint flags, int width, int height, int& new_width, int& new_height)
+{
+  gdk_window_constrain_size(const_cast<GdkGeometry*>(&(geometry)), flags, width, height, &new_width, &new_height);
+}
+
+void Window::enable_synchronized_configure()
+{
+  gdk_window_enable_synchronized_configure(gobj());
+}
+
+void Window::configure_finished()
+{
+  gdk_window_configure_finished(gobj());
+}
+
+void Window::set_skip_taskbar_hint(bool skips_taskbar)
+{
+  gdk_window_set_skip_taskbar_hint(gobj(), static_cast<int>(skips_taskbar));
+}
+
+void Window::set_skip_pager_hint(bool skips_pager)
+{
+  gdk_window_set_skip_pager_hint(gobj(), static_cast<int>(skips_pager));
+}
+
+void Window::fullscreen()
+{
+  gdk_window_fullscreen(gobj());
+}
+
+void Window::unfullscreen()
+{
+  gdk_window_unfullscreen(gobj());
+}
+
+GrabStatus Window::pointer_grab(bool owner_events, EventMask event_mask, const Glib::RefPtr<const Window>& confine_to, const Cursor& cursor, guint32 time_)
+{
+  return ((GrabStatus)(gdk_pointer_grab(gobj(), static_cast<int>(owner_events), ((GdkEventMask)(event_mask)), const_cast<GdkWindow*>(Glib::unwrap<Gdk::Window>(confine_to)), (cursor).gobj_copy(), time_)));
+}
+
+void Window::pointer_ungrab(guint32 timestamp)
+{
+  gdk_pointer_ungrab(timestamp);
+}
+
+GrabStatus Window::keyboard_grab(bool owner_events, guint32 timestamp)
+{
+  return ((GrabStatus)(gdk_keyboard_grab(gobj(), static_cast<int>(owner_events), timestamp)));
+}
+
+void Window::keyboard_ungrab(guint32 timestamp)
+{
+  gdk_keyboard_ungrab(timestamp);
+}
+
+void Window::set_keep_above(bool setting)
+{
+  gdk_window_set_keep_above(gobj(), static_cast<int>(setting));
+}
+
+void Window::set_keep_below(bool setting)
+{
+  gdk_window_set_keep_below(gobj(), static_cast<int>(setting));
+}
+
+void Window::set_accept_focus(bool accept_focus)
+{
+  gdk_window_set_accept_focus(gobj(), static_cast<int>(accept_focus));
+}
+
+void Window::set_focus_on_map(bool focus_on_map)
+{
+  gdk_window_set_focus_on_map(gobj(), static_cast<int>(focus_on_map));
+}
+
+
+} // namespace Gdk
+
+
diff --git a/libs/gtkmm2/gdk/gdkmm/window.h b/libs/gtkmm2/gdk/gdkmm/window.h
new file mode 100644
index 0000000000..7b8d9c614d
--- /dev/null
+++ b/libs/gtkmm2/gdk/gdkmm/window.h
@@ -0,0 +1,1906 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GDKMM_WINDOW_H
+#define _GDKMM_WINDOW_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* Copyright(C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not write to the Free
+ * Software Foundation Inc. 675 Mass Ave Cambridge MA 02139 USA.
+ */
+
+#include <gdkmm/drawable.h>
+#include <gdkmm/bitmap.h>
+//#include <gdkmm/cursor.h>
+#include <gdkmm/types.h>
+#include <gdkmm/region.h>
+#include <gdk/gdkwindow.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+extern "C" {
+// Custom struct prototype, because this isn't what the code-generator expects:
+typedef struct _GdkDrawable GdkWindow;
+} // extern "C"
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gdk
+{ class Window_Class; } // namespace Gdk
+namespace Gdk
+{
+
+
+/** @addtogroup gdkmmEnums Enums and Flags */
+
+/**
+ * @ingroup gdkmmEnums
+ * @par Bitwise operators:
+ * <tt>%EventMask operator|(EventMask, EventMask)</tt><br>
+ * <tt>%EventMask operator&(EventMask, EventMask)</tt><br>
+ * <tt>%EventMask operator^(EventMask, EventMask)</tt><br>
+ * <tt>%EventMask operator~(EventMask)</tt><br>
+ * <tt>%EventMask& operator|=(EventMask&, EventMask)</tt><br>
+ * <tt>%EventMask& operator&=(EventMask&, EventMask)</tt><br>
+ * <tt>%EventMask& operator^=(EventMask&, EventMask)</tt><br>
+ */
+enum EventMask
+{
+  EXPOSURE_MASK = 1 << 1,
+  POINTER_MOTION_MASK = 1 << 2,
+  POINTER_MOTION_HINT_MASK = 1 << 3,
+  BUTTON_MOTION_MASK = 1 << 4,
+  BUTTON1_MOTION_MASK = 1 << 5,
+  BUTTON2_MOTION_MASK = 1 << 6,
+  BUTTON3_MOTION_MASK = 1 << 7,
+  BUTTON_PRESS_MASK = 1 << 8,
+  BUTTON_RELEASE_MASK = 1 << 9,
+  KEY_PRESS_MASK = 1 << 10,
+  KEY_RELEASE_MASK = 1 << 11,
+  ENTER_NOTIFY_MASK = 1 << 12,
+  LEAVE_NOTIFY_MASK = 1 << 13,
+  FOCUS_CHANGE_MASK = 1 << 14,
+  STRUCTURE_MASK = 1 << 15,
+  PROPERTY_CHANGE_MASK = 1 << 16,
+  VISIBILITY_NOTIFY_MASK = 1 << 17,
+  PROXIMITY_IN_MASK = 1 << 18,
+  PROXIMITY_OUT_MASK = 1 << 19,
+  SUBSTRUCTURE_MASK = 1 << 20,
+  SCROLL_MASK = 1 << 21,
+  ALL_EVENTS_MASK = 0x3FFFFE
+};
+
+/** @ingroup gdkmmEnums */
+inline EventMask operator|(EventMask lhs, EventMask rhs)
+  { return static_cast<EventMask>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs)); }
+
+/** @ingroup gdkmmEnums */
+inline EventMask operator&(EventMask lhs, EventMask rhs)
+  { return static_cast<EventMask>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs)); }
+
+/** @ingroup gdkmmEnums */
+inline EventMask operator^(EventMask lhs, EventMask rhs)
+  { return static_cast<EventMask>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs)); }
+
+/** @ingroup gdkmmEnums */
+inline EventMask operator~(EventMask flags)
+  { return static_cast<EventMask>(~static_cast<unsigned>(flags)); }
+
+/** @ingroup gdkmmEnums */
+inline EventMask& operator|=(EventMask& lhs, EventMask rhs)
+  { return (lhs = static_cast<EventMask>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs))); }
+
+/** @ingroup gdkmmEnums */
+inline EventMask& operator&=(EventMask& lhs, EventMask rhs)
+  { return (lhs = static_cast<EventMask>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs))); }
+
+/** @ingroup gdkmmEnums */
+inline EventMask& operator^=(EventMask& lhs, EventMask rhs)
+  { return (lhs = static_cast<EventMask>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs))); }
+
+} // namespace Gdk
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Gdk::EventMask> : public Glib::Value_Flags<Gdk::EventMask>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gdk
+{
+
+/**
+ * @ingroup gdkmmEnums
+ * @par Bitwise operators:
+ * <tt>%WindowState operator|(WindowState, WindowState)</tt><br>
+ * <tt>%WindowState operator&(WindowState, WindowState)</tt><br>
+ * <tt>%WindowState operator^(WindowState, WindowState)</tt><br>
+ * <tt>%WindowState operator~(WindowState)</tt><br>
+ * <tt>%WindowState& operator|=(WindowState&, WindowState)</tt><br>
+ * <tt>%WindowState& operator&=(WindowState&, WindowState)</tt><br>
+ * <tt>%WindowState& operator^=(WindowState&, WindowState)</tt><br>
+ */
+enum WindowState
+{
+  WINDOW_STATE_WITHDRAWN = 1 << 0,
+  WINDOW_STATE_ICONIFIED = 1 << 1,
+  WINDOW_STATE_MAXIMIZED = 1 << 2,
+  WINDOW_STATE_STICKY = 1 << 3,
+  WINDOW_STATE_FULLSCREEN = 1 << 4,
+  WINDOW_STATE_ABOVE = 1 << 5,
+  WINDOW_STATE_BELOW = 1 << 6
+};
+
+/** @ingroup gdkmmEnums */
+inline WindowState operator|(WindowState lhs, WindowState rhs)
+  { return static_cast<WindowState>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs)); }
+
+/** @ingroup gdkmmEnums */
+inline WindowState operator&(WindowState lhs, WindowState rhs)
+  { return static_cast<WindowState>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs)); }
+
+/** @ingroup gdkmmEnums */
+inline WindowState operator^(WindowState lhs, WindowState rhs)
+  { return static_cast<WindowState>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs)); }
+
+/** @ingroup gdkmmEnums */
+inline WindowState operator~(WindowState flags)
+  { return static_cast<WindowState>(~static_cast<unsigned>(flags)); }
+
+/** @ingroup gdkmmEnums */
+inline WindowState& operator|=(WindowState& lhs, WindowState rhs)
+  { return (lhs = static_cast<WindowState>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs))); }
+
+/** @ingroup gdkmmEnums */
+inline WindowState& operator&=(WindowState& lhs, WindowState rhs)
+  { return (lhs = static_cast<WindowState>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs))); }
+
+/** @ingroup gdkmmEnums */
+inline WindowState& operator^=(WindowState& lhs, WindowState rhs)
+  { return (lhs = static_cast<WindowState>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs))); }
+
+} // namespace Gdk
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Gdk::WindowState> : public Glib::Value_Flags<Gdk::WindowState>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gdk
+{
+
+/**
+ * @ingroup gdkmmEnums
+ */
+enum WindowType
+{
+  WINDOW_ROOT,
+  WINDOW_TOPLEVEL,
+  WINDOW_CHILD,
+  WINDOW_DIALOG,
+  WINDOW_TEMP,
+  WINDOW_FOREIGN
+};
+
+} // namespace Gdk
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Gdk::WindowType> : public Glib::Value_Enum<Gdk::WindowType>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gdk
+{
+
+/**
+ * @ingroup gdkmmEnums
+ * @par Bitwise operators:
+ * <tt>%WindowAttributesType operator|(WindowAttributesType, WindowAttributesType)</tt><br>
+ * <tt>%WindowAttributesType operator&(WindowAttributesType, WindowAttributesType)</tt><br>
+ * <tt>%WindowAttributesType operator^(WindowAttributesType, WindowAttributesType)</tt><br>
+ * <tt>%WindowAttributesType operator~(WindowAttributesType)</tt><br>
+ * <tt>%WindowAttributesType& operator|=(WindowAttributesType&, WindowAttributesType)</tt><br>
+ * <tt>%WindowAttributesType& operator&=(WindowAttributesType&, WindowAttributesType)</tt><br>
+ * <tt>%WindowAttributesType& operator^=(WindowAttributesType&, WindowAttributesType)</tt><br>
+ */
+enum WindowAttributesType
+{
+  WA_TITLE = 1 << 1,
+  WA_X = 1 << 2,
+  WA_Y = 1 << 3,
+  WA_CURSOR = 1 << 4,
+  WA_COLORMAP = 1 << 5,
+  WA_VISUAL = 1 << 6,
+  WA_WMCLASS = 1 << 7,
+  WA_NOREDIR = 1 << 8
+};
+
+/** @ingroup gdkmmEnums */
+inline WindowAttributesType operator|(WindowAttributesType lhs, WindowAttributesType rhs)
+  { return static_cast<WindowAttributesType>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs)); }
+
+/** @ingroup gdkmmEnums */
+inline WindowAttributesType operator&(WindowAttributesType lhs, WindowAttributesType rhs)
+  { return static_cast<WindowAttributesType>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs)); }
+
+/** @ingroup gdkmmEnums */
+inline WindowAttributesType operator^(WindowAttributesType lhs, WindowAttributesType rhs)
+  { return static_cast<WindowAttributesType>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs)); }
+
+/** @ingroup gdkmmEnums */
+inline WindowAttributesType operator~(WindowAttributesType flags)
+  { return static_cast<WindowAttributesType>(~static_cast<unsigned>(flags)); }
+
+/** @ingroup gdkmmEnums */
+inline WindowAttributesType& operator|=(WindowAttributesType& lhs, WindowAttributesType rhs)
+  { return (lhs = static_cast<WindowAttributesType>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs))); }
+
+/** @ingroup gdkmmEnums */
+inline WindowAttributesType& operator&=(WindowAttributesType& lhs, WindowAttributesType rhs)
+  { return (lhs = static_cast<WindowAttributesType>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs))); }
+
+/** @ingroup gdkmmEnums */
+inline WindowAttributesType& operator^=(WindowAttributesType& lhs, WindowAttributesType rhs)
+  { return (lhs = static_cast<WindowAttributesType>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs))); }
+
+} // namespace Gdk
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Gdk::WindowAttributesType> : public Glib::Value_Flags<Gdk::WindowAttributesType>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gdk
+{
+
+/**
+ * @ingroup gdkmmEnums
+ * @par Bitwise operators:
+ * <tt>%WindowHints operator|(WindowHints, WindowHints)</tt><br>
+ * <tt>%WindowHints operator&(WindowHints, WindowHints)</tt><br>
+ * <tt>%WindowHints operator^(WindowHints, WindowHints)</tt><br>
+ * <tt>%WindowHints operator~(WindowHints)</tt><br>
+ * <tt>%WindowHints& operator|=(WindowHints&, WindowHints)</tt><br>
+ * <tt>%WindowHints& operator&=(WindowHints&, WindowHints)</tt><br>
+ * <tt>%WindowHints& operator^=(WindowHints&, WindowHints)</tt><br>
+ */
+enum WindowHints
+{
+  HINT_POS = 1 << 0,
+  HINT_MIN_SIZE = 1 << 1,
+  HINT_MAX_SIZE = 1 << 2,
+  HINT_BASE_SIZE = 1 << 3,
+  HINT_ASPECT = 1 << 4,
+  HINT_RESIZE_INC = 1 << 5,
+  HINT_WIN_GRAVITY = 1 << 6,
+  HINT_USER_POS = 1 << 7,
+  HINT_USER_SIZE = 1 << 8
+};
+
+/** @ingroup gdkmmEnums */
+inline WindowHints operator|(WindowHints lhs, WindowHints rhs)
+  { return static_cast<WindowHints>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs)); }
+
+/** @ingroup gdkmmEnums */
+inline WindowHints operator&(WindowHints lhs, WindowHints rhs)
+  { return static_cast<WindowHints>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs)); }
+
+/** @ingroup gdkmmEnums */
+inline WindowHints operator^(WindowHints lhs, WindowHints rhs)
+  { return static_cast<WindowHints>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs)); }
+
+/** @ingroup gdkmmEnums */
+inline WindowHints operator~(WindowHints flags)
+  { return static_cast<WindowHints>(~static_cast<unsigned>(flags)); }
+
+/** @ingroup gdkmmEnums */
+inline WindowHints& operator|=(WindowHints& lhs, WindowHints rhs)
+  { return (lhs = static_cast<WindowHints>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs))); }
+
+/** @ingroup gdkmmEnums */
+inline WindowHints& operator&=(WindowHints& lhs, WindowHints rhs)
+  { return (lhs = static_cast<WindowHints>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs))); }
+
+/** @ingroup gdkmmEnums */
+inline WindowHints& operator^=(WindowHints& lhs, WindowHints rhs)
+  { return (lhs = static_cast<WindowHints>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs))); }
+
+} // namespace Gdk
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Gdk::WindowHints> : public Glib::Value_Flags<Gdk::WindowHints>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gdk
+{
+
+/**
+ * @ingroup gdkmmEnums
+ */
+enum WindowTypeHint
+{
+  WINDOW_TYPE_HINT_NORMAL,
+  WINDOW_TYPE_HINT_DIALOG,
+  WINDOW_TYPE_HINT_MENU,
+  WINDOW_TYPE_HINT_TOOLBAR,
+  WINDOW_TYPE_HINT_SPLASHSCREEN,
+  WINDOW_TYPE_HINT_UTILITY,
+  WINDOW_TYPE_HINT_DOCK,
+  WINDOW_TYPE_HINT_DESKTOP
+};
+
+} // namespace Gdk
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Gdk::WindowTypeHint> : public Glib::Value_Enum<Gdk::WindowTypeHint>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gdk
+{
+
+/**
+ * @ingroup gdkmmEnums
+ * @par Bitwise operators:
+ * <tt>%WMDecoration operator|(WMDecoration, WMDecoration)</tt><br>
+ * <tt>%WMDecoration operator&(WMDecoration, WMDecoration)</tt><br>
+ * <tt>%WMDecoration operator^(WMDecoration, WMDecoration)</tt><br>
+ * <tt>%WMDecoration operator~(WMDecoration)</tt><br>
+ * <tt>%WMDecoration& operator|=(WMDecoration&, WMDecoration)</tt><br>
+ * <tt>%WMDecoration& operator&=(WMDecoration&, WMDecoration)</tt><br>
+ * <tt>%WMDecoration& operator^=(WMDecoration&, WMDecoration)</tt><br>
+ */
+enum WMDecoration
+{
+  DECOR_ALL = 1 << 0,
+  DECOR_BORDER = 1 << 1,
+  DECOR_RESIZEH = 1 << 2,
+  DECOR_TITLE = 1 << 3,
+  DECOR_MENU = 1 << 4,
+  DECOR_MINIMIZE = 1 << 5,
+  DECOR_MAXIMIZE = 1 << 6
+};
+
+/** @ingroup gdkmmEnums */
+inline WMDecoration operator|(WMDecoration lhs, WMDecoration rhs)
+  { return static_cast<WMDecoration>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs)); }
+
+/** @ingroup gdkmmEnums */
+inline WMDecoration operator&(WMDecoration lhs, WMDecoration rhs)
+  { return static_cast<WMDecoration>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs)); }
+
+/** @ingroup gdkmmEnums */
+inline WMDecoration operator^(WMDecoration lhs, WMDecoration rhs)
+  { return static_cast<WMDecoration>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs)); }
+
+/** @ingroup gdkmmEnums */
+inline WMDecoration operator~(WMDecoration flags)
+  { return static_cast<WMDecoration>(~static_cast<unsigned>(flags)); }
+
+/** @ingroup gdkmmEnums */
+inline WMDecoration& operator|=(WMDecoration& lhs, WMDecoration rhs)
+  { return (lhs = static_cast<WMDecoration>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs))); }
+
+/** @ingroup gdkmmEnums */
+inline WMDecoration& operator&=(WMDecoration& lhs, WMDecoration rhs)
+  { return (lhs = static_cast<WMDecoration>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs))); }
+
+/** @ingroup gdkmmEnums */
+inline WMDecoration& operator^=(WMDecoration& lhs, WMDecoration rhs)
+  { return (lhs = static_cast<WMDecoration>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs))); }
+
+} // namespace Gdk
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Gdk::WMDecoration> : public Glib::Value_Flags<Gdk::WMDecoration>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gdk
+{
+
+/**
+ * @ingroup gdkmmEnums
+ * @par Bitwise operators:
+ * <tt>%WMFunction operator|(WMFunction, WMFunction)</tt><br>
+ * <tt>%WMFunction operator&(WMFunction, WMFunction)</tt><br>
+ * <tt>%WMFunction operator^(WMFunction, WMFunction)</tt><br>
+ * <tt>%WMFunction operator~(WMFunction)</tt><br>
+ * <tt>%WMFunction& operator|=(WMFunction&, WMFunction)</tt><br>
+ * <tt>%WMFunction& operator&=(WMFunction&, WMFunction)</tt><br>
+ * <tt>%WMFunction& operator^=(WMFunction&, WMFunction)</tt><br>
+ */
+enum WMFunction
+{
+  FUNC_ALL = 1 << 0,
+  FUNC_RESIZE = 1 << 1,
+  FUNC_MOVE = 1 << 2,
+  FUNC_MINIMIZE = 1 << 3,
+  FUNC_MAXIMIZE = 1 << 4,
+  FUNC_CLOSE = 1 << 5
+};
+
+/** @ingroup gdkmmEnums */
+inline WMFunction operator|(WMFunction lhs, WMFunction rhs)
+  { return static_cast<WMFunction>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs)); }
+
+/** @ingroup gdkmmEnums */
+inline WMFunction operator&(WMFunction lhs, WMFunction rhs)
+  { return static_cast<WMFunction>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs)); }
+
+/** @ingroup gdkmmEnums */
+inline WMFunction operator^(WMFunction lhs, WMFunction rhs)
+  { return static_cast<WMFunction>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs)); }
+
+/** @ingroup gdkmmEnums */
+inline WMFunction operator~(WMFunction flags)
+  { return static_cast<WMFunction>(~static_cast<unsigned>(flags)); }
+
+/** @ingroup gdkmmEnums */
+inline WMFunction& operator|=(WMFunction& lhs, WMFunction rhs)
+  { return (lhs = static_cast<WMFunction>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs))); }
+
+/** @ingroup gdkmmEnums */
+inline WMFunction& operator&=(WMFunction& lhs, WMFunction rhs)
+  { return (lhs = static_cast<WMFunction>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs))); }
+
+/** @ingroup gdkmmEnums */
+inline WMFunction& operator^=(WMFunction& lhs, WMFunction rhs)
+  { return (lhs = static_cast<WMFunction>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs))); }
+
+} // namespace Gdk
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Gdk::WMFunction> : public Glib::Value_Flags<Gdk::WMFunction>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gdk
+{
+
+/**
+ * @ingroup gdkmmEnums
+ */
+enum WindowEdge
+{
+  WINDOW_EDGE_NORTH_WEST,
+  WINDOW_EDGE_NORTH,
+  WINDOW_EDGE_NORTH_EAST,
+  WINDOW_EDGE_WEST,
+  WINDOW_EDGE_EAST,
+  WINDOW_EDGE_SOUTH_WEST,
+  WINDOW_EDGE_SOUTH,
+  WINDOW_EDGE_SOUTH_EAST
+};
+
+} // namespace Gdk
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Gdk::WindowEdge> : public Glib::Value_Enum<Gdk::WindowEdge>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gdk
+{
+
+/**
+ * @ingroup gdkmmEnums
+ */
+enum Gravity
+{
+  GRAVITY_NORTH_WEST = 1,
+  GRAVITY_NORTH,
+  GRAVITY_NORTH_EAST,
+  GRAVITY_WEST,
+  GRAVITY_CENTER,
+  GRAVITY_EAST,
+  GRAVITY_SOUTH_WEST,
+  GRAVITY_SOUTH,
+  GRAVITY_SOUTH_EAST,
+  GRAVITY_STATIC
+};
+
+} // namespace Gdk
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Gdk::Gravity> : public Glib::Value_Enum<Gdk::Gravity>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gdk
+{
+
+/**
+ * @ingroup gdkmmEnums
+ */
+enum GrabStatus
+{
+  GRAB_SUCCESS,
+  GRAB_ALREADY_GRABBED,
+  GRAB_INVALID_TIME,
+  GRAB_NOT_VIEWABLE,
+  GRAB_FROZEN
+};
+
+} // namespace Gdk
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Gdk::GrabStatus> : public Glib::Value_Enum<Gdk::GrabStatus>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gdk
+{
+
+
+class Cursor;
+
+/** A Gdk::Window is a rectangular region on the screen. It's a low-level object, used to implement high-level objects such
+ * as Gtk::Widget and Gtk::Window on the GTK+ level. A Gtk::Window is a toplevel window, the thing a user might think of as
+ * a "window" with a titlebar and so on; a Gtk::Window may contain many Gdk::Windows. For example, each Gtk::Button has a
+ * Gdk::Window associated with it.
+ */
+
+class Window : public Gdk::Drawable
+{
+  // GdkWindow is a typedef to GdkDrawable, but it's actually a GdkWindowObject.
+  
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+public:
+  typedef Window CppObjectType;
+  typedef Window_Class CppClassType;
+  typedef GdkWindow BaseObjectType;
+  typedef GdkWindowObjectClass BaseClassType;
+
+private:  friend class Window_Class;
+  static CppClassType window_class_;
+
+private:
+  // noncopyable
+  Window(const Window&);
+  Window& operator=(const Window&);
+
+protected:
+  explicit Window(const Glib::ConstructParams& construct_params);
+  explicit Window(GdkWindow* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+  virtual ~Window();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GObject.
+  GdkWindow*       gobj()       { return reinterpret_cast<GdkWindow*>(gobject_); }
+
+  ///Provides access to the underlying C GObject.
+  const GdkWindow* gobj() const { return reinterpret_cast<GdkWindow*>(gobject_); }
+
+  ///Provides access to the underlying C instance. The caller is responsible for unrefing it. Use when directly setting fields in structs.
+  GdkWindow* gobj_copy();
+
+private:
+
+  
+protected:
+  Window(const Glib::RefPtr<Window>& parent, GdkWindowAttr* attributes, int attributes_mask);
+
+public:
+  
+  static Glib::RefPtr<Window> create(const Glib::RefPtr<Window>& parent, GdkWindowAttr* attributes, int attributes_mask);
+
+
+  /** Gets the type of the window. See Gdk::WindowType.
+   * @return Type of window.
+   */
+  WindowType get_window_type() const;
+  
+  /** Like gdk_window_show_unraised(), but also raises the window to the
+   * top of the window stack (moves the window to the front of the
+   * Z-order).
+   * 
+   * This function maps a window so it's visible onscreen. Its opposite
+   * is gdk_window_hide().
+   * 
+   * When implementing a Gtk::Widget, you should call this function on the widget's
+   * Gdk::Window as part of the "map" method.
+   */
+  void show();
+  
+  /** For toplevel windows, withdraws them, so they will no longer be
+   * known to the window manager; for all windows, unmaps them, so
+   * they won't be displayed. Normally done automatically as
+   * part of gtk_widget_hide().
+   */
+  void hide();
+  
+  /** Withdraws a window (unmaps it and asks the window manager to forget about it).
+   * This function is not really useful as gdk_window_hide() automatically
+   * withdraws toplevel windows before hiding them.
+   */
+  void withdraw();
+  
+  /** Shows a Gdk::Window onscreen, but does not modify its stacking
+   * order. In contrast, gdk_window_show() will raise the window
+   * to the top of the window stack.
+   * 
+   * On the X11 platform, in Xlib terms, this function calls
+   * XMapWindow() (it also updates some internal GDK state, which means
+   * that you can't really use XMapWindow() directly on a GDK window).
+   */
+  void show_unraised();
+  
+  /** Repositions a window relative to its parent window.
+   * For toplevel windows, window managers may ignore or modify the move;
+   * you should probably use gtk_window_move() on a Gtk::Window widget
+   * anyway, instead of using GDK functions. For child windows,
+   * the move will reliably succeed.
+   * 
+   * If you're also planning to resize the window, use gdk_window_move_resize()
+   * to both move and resize simultaneously, for a nicer visual effect.
+   * @param x X coordinate relative to window's parent.
+   * @param y Y coordinate relative to window's parent.
+   */
+  void move(int x, int y);
+  
+  /** Resizes @a window ; for toplevel windows, asks the window manager to resize
+   * the window. The window manager may not allow the resize. When using GTK+,
+   * use gtk_window_resize() instead of this low-level GDK function.
+   * 
+   * Windows may not be resized below 1x1.
+   * 
+   * If you're also planning to move the window, use gdk_window_move_resize()
+   * to both move and resize simultaneously, for a nicer visual effect.
+   * @param width New width of the window.
+   * @param height New height of the window.
+   */
+  void resize(int width, int height);
+  
+  /** Equivalent to calling gdk_window_move() and gdk_window_resize(),
+   * except that both operations are performed at once, avoiding strange
+   * visual effects. (i.e. the user may be able to see the window first
+   * move, then resize, if you don't use gdk_window_move_resize().)
+   * @param x New X position relative to window's parent.
+   * @param y New Y position relative to window's parent.
+   * @param width New width.
+   * @param height New height.
+   */
+  void move_resize(int x, int y, int width, int height);
+  
+  /** Reparents @a window  into the given @a new_parent . The window being
+   * reparented will be unmapped as a side effect.
+   * @param new_parent New parent to move @a window  into.
+   * @param x X location inside the new parent.
+   * @param y Y location inside the new parent.
+   */
+  void reparent(const Glib::RefPtr<Window>& new_parent, int x, int y);
+  
+  /** Clears an entire @a window  to the background color or background pixmap.
+   */
+  void clear();
+  
+  /** Clears an area of @a window  to the background color or background pixmap.
+   * @param x X coordinate of rectangle to clear.
+   * @param y Y coordinate of rectangle to clear.
+   * @param width Width of rectangle to clear.
+   * @param height Height of rectangle to clear.
+   */
+  void clear_area(int x, int y, int width, int height);
+  
+  /** Like gdk_window_clear_area(), but also generates an expose event for
+   * the cleared area.
+   * 
+   * This function has a stupid name because it dates back to the mists
+   * time, pre-GDK-1.0.
+   * @param x X coordinate of rectangle to clear.
+   * @param y Y coordinate of rectangle to clear.
+   * @param width Width of rectangle to clear.
+   * @param height Height of rectangle to clear.
+   */
+  void clear_area_e(int x, int y, int width, int height);
+  
+  /** Raises @a window  to the top of the Z-order (stacking order), so that
+   * other windows with the same parent window appear below @a window .
+   * This is true whether or not the windows are visible.
+   * 
+   * If @a window  is a toplevel, the window manager may choose to deny the
+   * request to move the window in the Z-order, gdk_window_raise() only
+   * requests the restack, does not guarantee it.
+   */
+  void raise();
+  
+  /** Lowers @a window  to the bottom of the Z-order (stacking order), so that
+   * other windows with the same parent window appear above @a window .
+   * This is true whether or not the other windows are visible.
+   * 
+   * If @a window  is a toplevel, the window manager may choose to deny the
+   * request to move the window in the Z-order, gdk_window_lower() only
+   * requests the restack, does not guarantee it.
+   * 
+   * Note that gdk_window_show() raises the window again, so don't call this
+   * function before gdk_window_show(). (Try gdk_window_show_unraised().)
+   */
+  void lower();
+  
+  /** Sets keyboard focus to @a window . If @a window  is not onscreen this
+   * will not work. In most cases, gtk_window_present() should be used on
+   * a Gtk::Window, rather than calling this function.
+   * @param timestamp Timestamp of the event triggering the window focus.
+   */
+  void focus(guint32 timestamp);
+  
+  /** For most purposes this function is deprecated in favor of
+   * Glib::object_set_data(). However, for historical reasons GTK+ stores
+   * the Gtk::Widget that owns a Gdk::Window as user data on the
+   * Gdk::Window. So, custom widget implementations should use
+   * this function for that. If GTK+ receives an event for a Gdk::Window,
+   * and the user data for the window is non-<tt>0</tt>, GTK+ will assume the
+   * user data is a Gtk::Widget, and forward the event to that widget.
+   * @param user_data User data.
+   */
+  void set_user_data(gpointer user_data);
+  
+  /** An override redirect window is not under the control of the window manager.
+   * This means it won't have a titlebar, won't be minimizable, etc. - it will
+   * be entirely under the control of the application. The window manager
+   * can't see the override redirect window at all.
+   * 
+   * Override redirect should only be used for short-lived temporary
+   * windows, such as popup menus. Gtk::Menu uses an override redirect
+   * window in its implementation, for example.
+   * @param override_redirect <tt>true</tt> if window should be override redirect.
+   */
+  void set_override_redirect(bool override_redirect = true);
+
+  //We could wrap these with a Slot instead of a C callback, but these methods are very low-level anyway.
+  
+  /** Adds an event filter to @a window , allowing you to intercept events
+   * before they reach GDK. This is a low-level operation and makes it
+   * easy to break GDK and/or GTK+, so you have to know what you're
+   * doing. Pass <tt>0</tt> for @a window  to get all events for all windows,
+   * instead of events for a specific window.
+   * @param function Filter callback.
+   * @param data Data to pass to filter callback.
+   */
+  void add_filter(GdkFilterFunc function, gpointer data);
+  
+  /** Remove a filter previously added with gdk_window_add_filter().
+   * @param function Previously-added filter function.
+   * @param data User data for previously-added filter function.
+   */
+  void remove_filter(GdkFilterFunc function, gpointer data);
+  
+  
+  /** Scroll the contents of @a window , both pixels and children, by the given
+   * amount. @a window  itself does not move.  Portions of the window that the scroll
+   * operation brings in from offscreen areas are invalidated. The invalidated
+   * region may be bigger than what would strictly be necessary.  (For X11, a
+   * minimum area will be invalidated if the window has no subwindows, or if the
+   * edges of the window's parent do not extend beyond the edges of the window. In
+   * other cases, a multi-step process is used to scroll the window which may
+   * produce temporary visual artifacts and unnecessary invalidations.)
+   * @param dx Amount to scroll in the X direction.
+   * @param dy Amount to scroll in the Y direction.
+   */
+  void scroll(int dx, int dy);
+  
+  /** Applies a shape mask to @a window . Pixels in @a window  corresponding to
+   * set bits in the @a mask  will be visible; pixels in @a window 
+   * corresponding to unset bits in the @a mask  will be transparent. This
+   * gives a non-rectangular window.
+   * 
+   * If @a mask  is <tt>0</tt>, the shape mask will be unset, and the @a x / @a y 
+   * parameters are not used.
+   * 
+   * On the X11 platform, this uses an X server extension which is
+   * widely available on most common platforms, but not available on
+   * very old X servers, and occasionally the implementation will be
+   * buggy. On servers without the shape extension, this function
+   * will do nothing.
+   * 
+   * This function works on both toplevel and child windows.
+   * @param mask Shape mask.
+   * @param x X position of shape mask with respect to @a window .
+   * @param y Y position of shape mask with respect to @a window .
+   */
+  void shape_combine_mask(const Glib::RefPtr<Bitmap>& mask, int	x, int y);
+  void unset_shape_combine_mask();
+
+  
+  /** Makes pixels in @a window  outside @a shape_region  be transparent,
+   * so that the window may be nonrectangular. See also
+   * gdk_window_shape_combine_mask() to use a bitmap as the mask.
+   * 
+   * If @a shape_region  is <tt>0</tt>, the shape will be unset, so the whole
+   * window will be opaque again. @a offset_x  and @a offset_y  are ignored
+   * if @a shape_region  is <tt>0</tt>.
+   * 
+   * On the X11 platform, this uses an X server extension which is
+   * widely available on most common platforms, but not available on
+   * very old X servers, and occasionally the implementation will be
+   * buggy. On servers without the shape extension, this function
+   * will do nothing.
+   * 
+   * This function works on both toplevel and child windows.
+   * @param shape_region Region of window to be non-transparent.
+   * @param offset_x X position of @a shape_region  in @a window  coordinates.
+   * @param offset_y Y position of @a shape_region  in @a window  coordinates.
+   */
+  void shape_combine_region(const Region& shape_region, int offset_x, int offset_y);
+  
+  /** Sets the shape mask of @a window  to the union of shape masks
+   * for all children of @a window , ignoring the shape mask of @a window 
+   * itself. Contrast with gdk_window_merge_child_shapes() which includes
+   * the shape mask of @a window  in the masks to be merged.
+   */
+  void set_child_shapes();
+  
+  /** Merges the shape masks for any child windows into the
+   * shape mask for @a window . i.e. the union of all masks
+   * for @a window  and its children will become the new mask
+   * for @a window . See gdk_window_shape_combine_mask().
+   * 
+   * This function is distinct from gdk_window_set_child_shapes()
+   * because it includes @a window 's shape mask in the set of shapes to
+   * be merged.
+   */
+  void merge_child_shapes();
+  
+  /** Checks whether the window has been mapped (with gdk_window_show() or
+   * gdk_window_show_unraised()).
+   * @return <tt>true</tt> if the window is mapped.
+   */
+  bool is_visible() const;
+  
+  /** Check if the window and all ancestors of the window are
+   * mapped. (This is not necessarily "viewable" in the X sense, since
+   * we only check as far as we have GDK window parents, not to the root
+   * window.)
+   * @return <tt>true</tt> if the window is viewable.
+   */
+  bool is_viewable() const;
+  
+  /** Gets the bitwise OR of the currently active window state flags,
+   * from the Gdk::WindowState enumeration.
+   * @return Window state bitfield.
+   */
+  WindowState get_state() const;
+  
+  /** Set the bit gravity of the given window to static, and flag it so
+   * all children get static subwindow gravity. This is used if you are
+   * implementing scary features that involve deep knowledge of the
+   * windowing system. Don't worry about it unless you have to.
+   * @param use_static <tt>true</tt> to turn on static gravity.
+   * @return <tt>true</tt> if the server supports static gravity.
+   */
+  bool set_static_gravities(bool use_static = true);
+  
+  /** The application can use this call to provide a hint to the window
+   * manager about the functionality of a window. The window manager
+   * can use this information when determining the decoration and behaviour
+   * of the window.
+   * 
+   * The hint must be set before the window is mapped.
+   * @param hint A hint of the function this window will have.
+   */
+  void set_type_hint(WindowTypeHint hint);
+  
+  /** The application can use this hint to tell the window manager
+   * that a certain window has modal behaviour. The window manager
+   * can use this information to handle modal windows in a special
+   * way.
+   * 
+   * You should only use this on windows for which you have
+   * previously called #gdk_window_set_transient_for()
+   * @param modal <tt>true</tt> if the window is modal, <tt>false</tt> otherwise.
+   */
+  void set_modal_hint(bool modal = true);
+  
+  /** Sets the geometry hints for @a window . Hints flagged in @a geom_mask 
+   * are set, hints not flagged in @a geom_mask  are unset.
+   * To unset all hints, use a @a geom_mask  of 0 and a @a geometry  of <tt>0</tt>.
+   * 
+   * This function provides hints to the windowing system about
+   * acceptable sizes for a toplevel window. The purpose of 
+   * this is to constrain user resizing, but the windowing system
+   * will typically  (but is not required to) also constrain the
+   * current size of the window to the provided values and
+   * constrain programatic resizing via gdk_window_resize() or
+   * gdk_window_move_resize().
+   * 
+   * Note that on X11, this effect has no effect on windows
+   * of type GDK_WINDOW_TEMP or windows where override_redirect
+   * has been turned on via gdk_window_set_override_redirect()
+   * since these windows are not resizable by the user.
+   * 
+   * Since you can't count on the windowing system doing the
+   * constraints for programmatic resizes, you should generally
+   * call gdk_window_constrain_size() yourself to determine
+   * appropriate sizes.
+   * @param geometry Geometry hints.
+   * @param geom_mask Bitmask indicating fields of @a geometry  to pay attention to.
+   */
+  void set_geometry_hints(const Geometry& geometry, WindowHints geom_mask);
+  
+  /** Sets the <tt>SM_CLIENT_ID</tt> property on the application's leader window so that
+   * the window manager can save the application's state using the X11R6 ICCCM
+   * session management protocol.
+   * 
+   * See the X Session Management Library documentation for more information on
+   * session management and the Inter-Client Communication Conventions Manual
+   * (ICCCM) for information on the <tt>WM_CLIENT_LEADER</tt> property.
+   * (Both documents are part of the X&nbsp;%Window System distribution.)
+   * @param sm_client_id The client id assigned by the session manager when the
+   * connection was opened.
+   */
+  static void set_sm_client_id(const Glib::ustring& sm_client_id);
+  static void unset_sm_client_id();
+  
+  
+  /** A convenience wrapper around gdk_window_begin_paint_region() which
+   * creates a rectangular region for you. See
+   * gdk_window_begin_paint_region() for details.
+   * @param rectangle Rectangle you intend to draw to.
+   */
+  void begin_paint_rect(Rectangle&rectangle);
+  
+  /** Indicates that you are beginning the process of redrawing @a region .
+   * A backing store (offscreen buffer) large enough to contain @a region 
+   * will be created. The backing store will be initialized with the
+   * background color or background pixmap for @a window . Then, all
+   * drawing operations performed on @a window  will be diverted to the
+   * backing store.  When you call gdk_window_end_paint(), the backing
+   * store will be copied to @a window , making it visible onscreen. Only
+   * the part of @a window  contained in @a region  will be modified; that is,
+   * drawing operations are clipped to @a region .
+   * 
+   * The net result of all this is to remove flicker, because the user
+   * sees the finished product appear all at once when you call
+   * gdk_window_end_paint(). If you draw to @a window  directly without
+   * calling gdk_window_begin_paint_region(), the user may see flicker
+   * as individual drawing operations are performed in sequence.  The
+   * clipping and background-initializing features of
+   * gdk_window_begin_paint_region() are conveniences for the
+   * programmer, so you can avoid doing that work yourself.
+   * 
+   * When using GTK+, the widget system automatically places calls to
+   * gdk_window_begin_paint_region() and gdk_window_end_paint() around
+   * emissions of the expose_event signal. That is, if you're writing an
+   * expose event handler, you can assume that the exposed area in
+   * Gdk::EventExpose has already been cleared to the window background,
+   * is already set as the clip region, and already has a backing store.
+   * Therefore in most cases, application code need not call
+   * gdk_window_begin_paint_region(). (You can disable the automatic
+   * calls around expose events on a widget-by-widget basis by calling
+   * gtk_widget_set_double_buffered().)
+   * 
+   * If you call this function multiple times before calling the
+   * matching gdk_window_end_paint(), the backing stores are pushed onto
+   * a stack. gdk_window_end_paint() copies the topmost backing store
+   * onscreen, subtracts the topmost region from all other regions in
+   * the stack, and pops the stack. All drawing operations affect only
+   * the topmost backing store in the stack. One matching call to
+   * gdk_window_end_paint() is required for each call to
+   * gdk_window_begin_paint_region().
+   * @param region Region you intend to draw to.
+   */
+  void begin_paint_region(const Region& region);
+  
+  /** Indicates that the backing store created by the most recent call to
+   * gdk_window_begin_paint_region() should be copied onscreen and
+   * deleted, leaving the next-most-recent backing store or no backing
+   * store at all as the active paint region. See
+   * gdk_window_begin_paint_region() for full details. It is an error to
+   * call this function without a matching
+   * gdk_window_begin_paint_region() first.
+   */
+  void end_paint();
+  
+  /** Sets the title of a toplevel window, to be displayed in the titlebar.
+   * If you haven't explicitly set the icon name for the window
+   * (using gdk_window_set_icon_name()), the icon name will be set to
+   *  @a title  as well. @a title  must be in UTF-8 encoding (as with all
+   * user-readable strings in GDK/GTK+). @a title  may not be <tt>0</tt>.
+   * @param title Title of @a window .
+   */
+  void set_title(const Glib::ustring& title);
+  
+  /** When using GTK+, typically you should use gtk_window_set_role() instead
+   * of this low-level function.
+   * 
+   * The window manager and session manager use a window's role to
+   * distinguish it from other kinds of window in the same application.
+   * When an application is restarted after being saved in a previous
+   * session, all windows with the same title and role are treated as
+   * interchangeable.  So if you have two windows with the same title
+   * that should be distinguished for session management purposes, you
+   * should set the role on those windows. It doesn't matter what string
+   * you use for the role, as long as you have a different role for each
+   * non-interchangeable kind of window.
+   * @param role A string indicating its role.
+   */
+  void set_role(const Glib::ustring& role);
+  
+  /** Indicates to the window manager that @a window  is a transient dialog
+   * associated with the application window @a parent . This allows the
+   * window manager to do things like center @a window  on @a parent  and
+   * keep @a window  above @a parent .
+   * 
+   * See gtk_window_set_transient_for() if you're using Gtk::Window or
+   * Gtk::Dialog.
+   * @param parent Another toplevel Gdk::Window.
+   */
+  void set_transient_for(const Glib::RefPtr<Window>& parent);
+  
+  /** Sets the background color of @a window . (However, when using GTK+,
+   * set the background of a widget with gtk_widget_modify_bg() - if
+   * you're an application - or gtk_style_set_background() - if you're
+   * implementing a custom widget.)
+   * 
+   * The @a color  must be allocated; gdk_rgb_find_color() is the best way
+   * to allocate a color.
+   * 
+   * See also gdk_window_set_back_pixmap().
+   * @param color An allocated Gdk::Color.
+   */
+  void set_background(const Color& color);
+  
+  /** Sets the background pixmap of @a window . May also be used to set a background of
+   * "None" on @a window , by setting a background pixmap of <tt>0</tt>.
+   * A background pixmap will be tiled, positioning the first tile at the origin of
+   *  @a window , or if @a parent_relative  is <tt>true</tt>, the tiling will be done based on the
+   * origin of the parent window (useful to align tiles in a parent with tiles
+   * in a child).
+   * 
+   * A background pixmap of <tt>0</tt> means that the window will have no
+   * background.  A window with no background will never have its
+   * background filled by the windowing system, instead the window will
+   * contain whatever pixels were already in the corresponding area of
+   * the display.
+   * 
+   * The windowing system will normally fill a window with its background
+   * when the window is obscured then exposed, and when you call
+   * gdk_window_clear().
+   * @param pixmap A Gdk::Pixmap, or <tt>0</tt>.
+   * @param parent_relative Whether the tiling origin is at the origin of @a window 's parent.
+   */
+  void set_back_pixmap(const Glib::RefPtr<Pixmap>&pixmap, bool parent_relative);
+  
+  /** Sets the mouse pointer for a Gdk::Window. 
+   * To make the cursor invisible, use gdk_cursor_new_from_pixmap() to create
+   * a cursor with no pixels in it.
+   * @param cursor A cursor.
+   */
+  void set_cursor(const Cursor& cursor);
+  
+  /** Use the parent window's cursor.
+   * For top-level windows this means that it will use the default cursor for the ROOT window.
+   */
+  void set_cursor();
+  
+  
+  /** Retrieves the user data for @a window , which is normally the widget
+   * that @a window  belongs to. See gdk_window_set_user_data().
+   * @param data Return location for user data.
+   */
+  void get_user_data(gpointer* data);
+  
+  /** Any of the return location arguments to this function may be <tt>0</tt>,
+   * if you aren't interested in getting the value of that field.
+   * 
+   * The X and Y coordinates returned are relative to the parent window
+   * of @a window , which for toplevels usually means relative to the
+   * window decorations (titlebar, etc.) rather than relative to the
+   * root window (screen-size background window).
+   * 
+   * On the X11 platform, the geometry is obtained from the X server,
+   * so reflects the latest position of @a window ; this may be out-of-sync
+   * with the position of @a window  delivered in the most-recently-processed
+   * Gdk::EventConfigure. gdk_window_get_position() in contrast gets the
+   * position from the most recent configure event.
+   * 
+   * &lt;note&gt;
+   * If @a window  is not a toplevel, it is <em>much</em> better 
+   * to call gdk_window_get_position() and Gdk::Drawable::get_size() instead, 
+   * because it avoids the roundtrip to the X server and because 
+   * Gdk::Drawable::get_size() supports the full 32-bit coordinate space,
+   * whereas gdk_window_get_geometry() is restricted to the 16-bit
+   * coordinates of X11.
+   * &lt;/note&gt;
+   * @param x Return location for X coordinate of window (relative to its parent).
+   * @param y Return location for Y coordinate of window (relative to its parent).
+   * @param width Return location for width of window.
+   * @param height Return location for height of window.
+   * @param depth Return location for bit depth of window.
+   */
+  void get_geometry(int& x, int& y, int& width, int& height, int& depth) const;
+  
+  /** Obtains the position of the window as reported in the
+   * most-recently-processed Gdk::EventConfigure. Contrast with
+   * gdk_window_get_geometry() which queries the X server for the
+   * current window position, regardless of which events have been
+   * received or processed.
+   * 
+   * The position coordinates are relative to the window's parent window.
+   * @param x X coordinate of window.
+   * @param y Y coordinate of window.
+   */
+  void get_position(int& x, int& y) const;
+  
+  /** Obtains the position of a window in root window coordinates.
+   * (Compare with gdk_window_get_position() and
+   * gdk_window_get_geometry() which return the position of a window
+   * relative to its parent window.)
+   * @param x Return location for X coordinate.
+   * @param y Return location for Y coordinate.
+   * @return Not meaningful, ignore.
+   */
+  int get_origin(int& x, int& y) const;
+  //_WRAP_METHOD(bool get_deskrelative_origin(int& x, int& y), gdk_window_get_deskrelative_origin)
+  
+  /** Obtains the top-left corner of the window manager frame in root
+   * window coordinates.
+   * @param x Return location for X position of window frame.
+   * @param y Return location for Y position of window frame.
+   */
+  void get_root_origin(int& x, int& y) const;
+  
+  /** Obtains the bounding box of the window, including window manager
+   * titlebar/borders if any. The frame position is given in root window
+   * coordinates. To get the position of the window itself (rather than
+   * the frame) in root window coordinates, use gdk_window_get_origin().
+   * @param rect Rectangle to fill with bounding box of the window frame.
+   */
+  void get_frame_extents(Rectangle& rect);
+  
+  /** Obtains the current pointer position and modifier state.
+   * The position is given in coordinates relative to @a window .
+   * @param x Return location for X coordinate of pointer.
+   * @param y Return location for Y coordinate of pointer.
+   * @param mask Return location for modifier mask.
+   * @return The window containing the pointer (as with
+   * gdk_window_at_pointer()), or <tt>0</tt> if the window containing the
+   * pointer isn't known to GDK.
+   */
+  Glib::RefPtr<Window> get_pointer(int& x, int& y, ModifierType& mask);
+  
+  /** Obtains the parent of @a window , as known to GDK. Does not query the
+   * X server; thus this returns the parent as passed to gdk_window_new(),
+   * not the actual parent. This should never matter unless you're using
+   * Xlib calls mixed with GDK calls on the X11 platform. It may also
+   * matter for toplevel windows, because the window manager may choose
+   * to reparent them.
+   * @return Parent of @a window .
+   */
+  Glib::RefPtr<Window> get_parent();
+  
+  /** Obtains the parent of @a window , as known to GDK. Does not query the
+   * X server; thus this returns the parent as passed to gdk_window_new(),
+   * not the actual parent. This should never matter unless you're using
+   * Xlib calls mixed with GDK calls on the X11 platform. It may also
+   * matter for toplevel windows, because the window manager may choose
+   * to reparent them.
+   * @return Parent of @a window .
+   */
+  Glib::RefPtr<const Window> get_parent() const;
+  
+  /** Gets the toplevel window that's an ancestor of @a window .
+   * @return The toplevel window containing @a window .
+   */
+  Glib::RefPtr<Window> get_toplevel();
+  
+  /** Gets the toplevel window that's an ancestor of @a window .
+   * @return The toplevel window containing @a window .
+   */
+  Glib::RefPtr<const Window> get_toplevel() const;
+  
+  
+  /** Gets the list of children of @a window  known to GDK.
+   * This function only returns children created via GDK,
+   * so for example it's useless when used with the root window;
+   * it only returns windows an application created itself.
+   * 
+   * The returned list must be freed, but the elements in the
+   * list need not be.
+   * @return List of child windows inside @a window .
+   */
+  Glib::ListHandle< Glib::RefPtr<Window> > get_children();
+  
+  /** Gets the list of children of @a window  known to GDK.
+   * This function only returns children created via GDK,
+   * so for example it's useless when used with the root window;
+   * it only returns windows an application created itself.
+   * 
+   * The returned list must be freed, but the elements in the
+   * list need not be.
+   * @return List of child windows inside @a window .
+   */
+  Glib::ListHandle< Glib::RefPtr<const Window> > get_children() const;
+   //gdk_window_peek_children() is the same as gdk_window_get_children() with different memory mangement of the list.
+
+  
+  /** Gets the event mask for @a window . See gdk_window_set_events().
+   * @return Event mask for @a window .
+   */
+  EventMask get_events() const;
+  
+  /** The event mask for a window determines which events will be reported
+   * for that window. For example, an event mask including Gdk::BUTTON_PRESS_MASK
+   * means the window should report button press events. The event mask
+   * is the bitwise OR of values from the Gdk::EventMask enumeration.
+   * @param event_mask Event mask for @a window .
+   */
+  void set_events(EventMask event_mask);
+
+  
+  /** Sets a list of icons for the window. One of these will be used
+   * to represent the window when it has been iconified. The icon is
+   * usually shown in an icon box or some sort of task bar. Which icon
+   * size is shown depends on the window manager. The window manager
+   * can scale the icon  but setting several size icons can give better
+   * image quality since the window manager may only need to scale the
+   * icon by a small amount or not at all.
+   * @param pixbufs A list of pixbufs, of different sizes.
+   */
+  void set_icon_list(const Glib::ListHandle< Glib::RefPtr<Gdk::Pixbuf> >& pixbufs);
+  
+  /** Sets the icon of @a window  as a pixmap or window. If using GTK+, investigate
+   * gtk_window_set_default_icon_list() first, and then gtk_window_set_icon_list()
+   * and gtk_window_set_icon(). If those don't meet your needs, look at
+   * gdk_window_set_icon_list(). Only if all those are too high-level do you
+   * want to fall back to gdk_window_set_icon().
+   * @param icon_window A Gdk::Window to use for the icon.
+   * @param pixmap A Gdk::Pixmap to use as the icon,.
+   * @param mask A 1-bit pixmap (Gdk::Bitmap) to use as mask for @a pixmap .
+   */
+  void set_icon(const Glib::RefPtr<Window>& icon_window, const Glib::RefPtr<Pixmap>& pixmap, const Glib::RefPtr<Bitmap>& mask);
+  void set_icon(const Glib::RefPtr<Window>& icon_window, const Glib::RefPtr<Pixmap>& pixmap);
+  void unset_icon();
+  
+  /** Windows may have a name used while minimized, distinct from the
+   * name they display in their titlebar. Most of the time this is a bad
+   * idea from a user interface standpoint. But you can set such a name
+   * with this function, if you like.
+   * @param name Name of window while iconified (minimized).
+   */
+  void set_icon_name(const Glib::ustring& name);
+
+  
+  /** Sets the group leader window for @a window . By default,
+   * GDK sets the group leader for all toplevel windows
+   * to a global window implicitly created by GDK. With this function
+   * you can override this default.
+   * 
+   * The group leader window allows the window manager to distinguish
+   * all windows that belong to a single application. It may for example
+   * allow users to minimize/unminimize all windows belonging to an
+   * application at once. You should only set a non-default group window
+   * if your application pretends to be multiple applications.
+   * @param leader Group leader window, or <tt>0</tt> to restore the default group leader window.
+   */
+  void set_group(const Glib::RefPtr<Window>& leader);  
+  
+  /** Returns the group leader window for @a window . See gdk_window_set_group().
+   * @return The group leader window for @a window 
+   * 
+   * Since: 2.4.
+   */
+  Glib::RefPtr<Window> get_group();
+  
+  /** Returns the group leader window for @a window . See gdk_window_set_group().
+   * @return The group leader window for @a window 
+   * 
+   * Since: 2.4.
+   */
+  Glib::RefPtr<const Window> get_group() const;
+
+  
+  /** "Decorations" are the features the window manager adds to a toplevel Gdk::Window.
+   * This function sets the traditional Motif window manager hints that tell the
+   * window manager which decorations you would like your window to have.
+   * Usually you should use gtk_window_set_decorated() on a Gtk::Window instead of
+   * using the GDK function directly.
+   * 
+   * The @a decorations  argument is the logical OR of the fields in
+   * the Gdk::WMDecoration enumeration. If Gdk::DECOR_ALL is included in the
+   * mask, the other bits indicate which decorations should be turned off.
+   * If Gdk::DECOR_ALL is not included, then the other bits indicate
+   * which decorations should be turned on.
+   * 
+   * Most window managers honor a decorations hint of 0 to disable all decorations,
+   * but very few honor all possible combinations of bits.
+   * @param decorations Decoration hint mask.
+   */
+  void set_decorations(WMDecoration decorations);
+  
+  /** Returns the decorations set on the GdkWindow with #gdk_window_set_decorations
+   * @param decorations The window decorations will be written here.
+   * @return <tt>true</tt> if the window has decorations set, <tt>false</tt> otherwise.
+   */
+  bool get_decorations(WMDecoration& decorations) const;
+  
+  /** This function isn't really good for much. It sets the traditional
+   * Motif window manager hint for which operations the window manager
+   * should allow on a toplevel window. However, few window managers do
+   * anything reliable or interesting with this hint. Many ignore it
+   * entirely.
+   * 
+   * The @a functions  argument is the logical OR of values from the
+   * Gdk::WMFunction enumeration. If the bitmask includes Gdk::FUNC_ALL,
+   * then the other bits indicate which functions to disable; if
+   * it doesn't include Gdk::FUNC_ALL, it indicates which functions to
+   * enable.
+   * @param functions Bitmask of operations to allow on @a window .
+   */
+  void set_functions(WMFunction functions);
+  
+  
+  /** Obtains a list of all toplevel windows known to GDK on the default
+   * screen (see gdk_window_get_toplevels_for_screen()).
+   * A toplevel window is a child of the root window (see
+   * gdk_get_default_root_window()).
+   * @return List of toplevel windows.
+   */
+  static Glib::ListHandle< Glib::RefPtr<Window> > get_toplevels();
+    
+  
+  /** Asks to iconify (minimize) @a window . The window manager may choose
+   * to ignore the request, but normally will honor it. Using
+   * gtk_window_iconify() is preferred, if you have a Gtk::Window widget.
+   * 
+   * This function only makes sense when @a window  is a toplevel window.
+   */
+  void iconify();
+  
+  /** Attempt to deiconify (unminimize) @a window . On X11 the window manager may
+   * choose to ignore the request to deiconify. When using GTK+,
+   * use gtk_window_deiconify() instead of the Gdk::Window variant. Or better yet,
+   * you probably want to use gtk_window_present(), which raises the window, focuses it,
+   * unminimizes it, and puts it on the current desktop.
+   */
+  void deiconify();
+  
+  /** "Pins" a window such that it's on all workspaces and does not scroll
+   * with viewports, for window managers that have scrollable viewports.
+   * (When using Gtk::Window, gtk_window_stick() may be more useful.)
+   * 
+   * On the X11 platform, this function depends on window manager
+   * support, so may have no effect with many window managers. However,
+   * GDK will do the best it can to convince the window manager to stick
+   * the window. For window managers that don't support this operation,
+   * there's nothing you can do to force it to happen.
+   */
+  void stick();
+  
+  /** Reverse operation for gdk_window_stick(); see gdk_window_stick(),
+   * and gtk_window_unstick().
+   */
+  void unstick();
+  
+  /** Maximizes the window. If the window was already maximized, then
+   * this function does nothing.
+   * 
+   * On X11, asks the window manager to maximize @a window , if the window
+   * manager supports this operation. Not all window managers support
+   * this, and some deliberately ignore it or don't have a concept of
+   * "maximized"; so you can't rely on the maximization actually
+   * happening. But it will happen with most standard window managers,
+   * and GDK makes a best effort to get it to happen.
+   * 
+   * On Windows, reliably maximizes the window.
+   */
+  void maximize();
+  
+  /** Unmaximizes the window. If the window wasn't maximized, then this
+   * function does nothing.
+   * 
+   * On X11, asks the window manager to unmaximize @a window , if the
+   * window manager supports this operation. Not all window managers
+   * support this, and some deliberately ignore it or don't have a
+   * concept of "maximized"; so you can't rely on the unmaximization
+   * actually happening. But it will happen with most standard window
+   * managers, and GDK makes a best effort to get it to happen.
+   * 
+   * On Windows, reliably unmaximizes the window.
+   */
+  void unmaximize();
+  
+  void register_dnd();
+  
+  /** Begins a window resize operation (for a toplevel window).
+   * You might use this function to implement a "window resize grip," for
+   * example; in fact Gtk::Statusbar uses it. The function works best
+   * with window managers that support the Extended Window Manager Hints spec
+   * (see http://www.freedesktop.org), but has a fallback implementation
+   * for other window managers.
+   * @param edge The edge or corner from which the drag is started.
+   * @param button The button being used to drag.
+   * @param root_x Root window X coordinate of mouse click that began the drag.
+   * @param root_y Root window Y coordinate of mouse click that began the drag.
+   * @param timestamp Timestamp of mouse click that began the drag (use gdk_event_get_time()).
+   */
+  void begin_resize_drag(WindowEdge  edge, int button, int root_x, int root_y, guint32 timestamp);
+  
+  /** Begins a window move operation (for a toplevel window).  You might
+   * use this function to implement a "window move grip," for
+   * example. The function works best with window managers that support
+   * the Extended Window Manager Hints spec (see
+   * http://www.freedesktop.org), but has a fallback implementation for
+   * other window managers.
+   * @param button The button being used to drag.
+   * @param root_x Root window X coordinate of mouse click that began the drag.
+   * @param root_y Root window Y coordinate of mouse click that began the drag.
+   * @param timestamp Timestamp of mouse click that began the drag.
+   */
+  void begin_move_drag(int button, int root_x, int root_y, guint32 timestamp);
+  
+  /** A convenience wrapper around gdk_window_invalidate_region() which
+   * invalidates a rectangular region. See
+   * gdk_window_invalidate_region() for details.
+   * @param rect Rectangle to invalidate.
+   * @param invalidate_children Whether to also invalidate child windows.
+   */
+  void invalidate_rect(const Rectangle& rect, bool invalidate_children);
+
+  
+  /** Adds @a region  to the update area for @a window . The update area is the
+   * region that needs to be redrawn, or "dirty region." The call
+   * gdk_window_process_updates() sends one or more expose events to the
+   * window, which together cover the entire update area. An
+   * application would normally redraw the contents of @a window  in
+   * response to those expose events.
+   * 
+   * GDK will call gdk_window_process_all_updates() on your behalf
+   * whenever your program returns to the main loop and becomes idle, so
+   * normally there's no need to do that manually, you just need to
+   * invalidate regions that you know should be redrawn.
+   * 
+   * The @a invalidate_children  parameter controls whether the region of
+   * each child window that intersects @a region  will also be invalidated.
+   * If <tt>false</tt>, then the update area for child windows will remain
+   * unaffected. See gdk_window_invalidate_maybe_recurse if you need
+   * fine grained control over which children are invalidated.
+   * @param region A Gdk::Region.
+   * @param invalidate_children <tt>true</tt> to also invalidate child windows.
+   */
+  void invalidate_region(const Region& region, bool invalidate_children = true);
+
+  //TODO: Rewrite the docs, to be more C++-like.
+  
+  /** Transfers ownership of the update area from @a window  to the caller
+   * of the function. That is, after calling this function, @a window  will
+   * no longer have an invalid/dirty region; the update area is removed
+   * from @a window  and handed to you. If a window has no update area,
+   * gdk_window_get_update_area() returns <tt>0</tt>. You are responsible for
+   * calling gdk_region_destroy() on the returned region if it's non-<tt>0</tt>.
+   * @return The update area for @a window .
+   */
+  Region get_update_area();
+  //This method should not have a const version - see the docs.
+  
+  
+  /** Temporarily freezes a window such that it won't receive expose
+   * events.  The window will begin receiving expose events again when
+   * Gdk::Window::thaw_updates() is called. If Gdk::Window::freeze_updates()
+   * has been called more than once, Gdk::Window::thaw_updates() must be called
+   * an equal number of times to begin processing exposes.
+   */
+  void freeze_updates();
+  
+  /** Thaws a window frozen with Gdk::Window::freeze_updates().
+   */
+  void thaw_updates();
+  
+  /** Calls gdk_window_process_updates() for all windows (see Gdk::Window)
+   * in the application.
+   */
+  static void process_all_updates();
+  
+  /** Sends one or more expose events to @a window . The areas in each 
+   * expose event will cover the entire update area for the window (see
+   * gdk_window_invalidate_region() for details). Normally GDK calls
+   * gdk_window_process_all_updates() on your behalf, so there's no
+   * need to call this function unless you want to force expose events
+   * to be delivered immediately and synchronously (vs. the usual
+   * case, where GDK delivers them in an idle handler). Occasionally
+   * this is useful to produce nicer scrolling behavior, for example.
+   * @param update_children Whether to also process updates for child windows.
+   */
+  void process_updates(bool update_children);
+  
+  /** With update debugging enabled, calls to
+   * gdk_window_invalidate_region() clear the invalidated region of the
+   * screen to a noticeable color, and GDK pauses for a short time
+   * before sending exposes to windows during
+   * gdk_window_process_updates().  The net effect is that you can see
+   * the invalid region for each window and watch redraws as they
+   * occur. This allows you to diagnose inefficiencies in your application.
+   * 
+   * In essence, because the GDK rendering model prevents all flicker,
+   * if you are redrawing the same region 400 times you may never
+   * notice, aside from noticing a speed problem. Enabling update
+   * debugging causes GTK to flicker slowly and noticeably, so you can
+   * see exactly what's being redrawn when, in what order.
+   * 
+   * The --gtk-debug=updates command line option passed to GTK+ programs
+   * enables this debug option at application startup time. That's
+   * usually more useful than calling gdk_window_set_debug_updates()
+   * yourself, though you might want to use this function to enable
+   * updates sometime after application startup time.
+   * @param setting <tt>true</tt> to turn on update debugging.
+   */
+  static void set_debug_updates(bool setting = true);
+  
+  /** Constrains a desired width and height according to a 
+   * set of geometry hints (such as minimum and maximum size).
+   * @param geometry A Gdk::Geometry structure.
+   * @param flags A mask indicating what portions of @a geometry  are set.
+   * @param width Desired width of window.
+   * @param height Desired height of the window.
+   * @param new_width Location to store resulting width.
+   * @param new_height Location to store resulting height.
+   */
+  static void constrain_size(const Geometry& geometry, guint flags, int width, int height, int& new_width, int& new_height);
+  void get_internal_paint_info(Glib::RefPtr<Drawable>& real_drawable, int& x_offset, int& y_offset) const;
+  
+  
+  /** Indicates that the application will cooperate with the window
+   * system in synchronizing the window repaint with the window
+   * manager during resizing operations. After an application calls
+   * this function, it must call gdk_window_configure_finished() every
+   * time it has finished all processing associated with a set of
+   * Configure events. Toplevel GTK+ windows automatically use this
+   * protocol.
+   * 
+   * On X, calling this function makes @a window  participate in the
+   * _NET_WM_SYNC_REQUEST window manager protocol.
+   * 
+   * Since: 2.6
+   */
+  void enable_synchronized_configure();
+  
+  /** Signal to the window system that the application has finished
+   * handling Configure events it has received. Window Managers can
+   * use this to better synchronize the frame repaint with the
+   * application. GTK+ applications will automatically call this
+   * function when appropriate.
+   * 
+   * This function can only be called if gdk_window_use_configure()
+   * was called previously.
+   * 
+   * Since: 2.6
+   */
+  void configure_finished();
+
+  
+  /** Toggles whether a window should appear in a task list or window
+   * list. If a window's semantic type as specified with
+   * gdk_window_set_type_hint() already fully describes the window, this
+   * function should NOT be called in addition, instead you should allow
+   * the window to be treated according to standard policy for its
+   * semantic type.
+   * 
+   * Since: 2.2
+   * @param skips_taskbar <tt>true</tt> to skip the taskbar.
+   */
+  void set_skip_taskbar_hint(bool skips_taskbar = true);
+  
+  /** Toggles whether a window should appear in a pager (workspace
+   * switcher, or other desktop utility program that displays a small
+   * thumbnail representation of the windows on the desktop). If a
+   * window's semantic type as specified with gdk_window_set_type_hint()
+   * already fully describes the window, this function should NOT be
+   * called in addition, instead you should allow the window to be
+   * treated according to standard policy for its semantic type.
+   * 
+   * Since: 2.2
+   * @param skips_pager <tt>true</tt> to skip the pager.
+   */
+  void set_skip_pager_hint(bool skips_pager = true);
+
+  
+  /** Moves the window into fullscreen mode. This means the
+   * window covers the entire screen and is above any panels
+   * or task bars.
+   * 
+   * If the window was already fullscreen, then this function does nothing.
+   * 
+   * On X11, asks the window manager to put @a window  in a fullscreen
+   * state, if the window manager supports this operation. Not all
+   * window managers support this, and some deliberately ignore it or
+   * don't have a concept of "fullscreen"; so you can't rely on the
+   * fullscreenification actually happening. But it will happen with
+   * most standard window managers, and GDK makes a best effort to get
+   * it to happen.
+   * 
+   * Since: 2.2
+   */
+  void fullscreen();
+  
+  /** Moves the window out of fullscreen mode. If the window was not
+   * fullscreen, does nothing.
+   * 
+   * On X11, asks the window manager to move @a window  out of the fullscreen
+   * state, if the window manager supports this operation. Not all
+   * window managers support this, and some deliberately ignore it or
+   * don't have a concept of "fullscreen"; so you can't rely on the
+   * unfullscreenification actually happening. But it will happen with
+   * most standard window managers, and GDK makes a best effort to get
+   * it to happen. 
+   * 
+   * Since: 2.2
+   */
+  void unfullscreen();
+
+  
+  GrabStatus pointer_grab(bool owner_events, EventMask event_mask, const Glib::RefPtr<const Window>& confine_to, const Cursor& cursor, guint32 time_);
+
+  /** Grabs the pointer to a specific window.
+   * Requires a corresponding call to pointer_ungrab().
+   *
+   * Arguments:
+   * @param owner_events Specifies whether events will be reported as is, or relative to the window.
+   * @param event_mask Masks only interesting events.
+   * @param cursor Changes the cursor for the duration of the grab.
+   * @param timestamp Specifies the time.
+   */
+  GrabStatus pointer_grab(bool owner_events, EventMask event_mask, const Cursor& cursor, guint32 timestamp);
+
+  /** Grabs the pointer to a specific window.
+   * Requires a corresponding call to pointer_ungrab().
+   *
+   * Arguments:
+   * @param owner_events Specifies whether events will be reported as is, or relative to the window.
+   * @param event_mask Masks only interesting events.
+   * @param timestamp Specifies the time.
+   */
+  GrabStatus pointer_grab(bool owner_events, EventMask event_mask, guint32 timestamp);
+
+  
+  /** Ungrabs the pointer, if it is grabbed by this application.
+   * @param timestamp A timestamp from a Gdk::Event, or Gdk::CURRENT_TIME if no 
+   * timestamp is available.
+   */
+  static void pointer_ungrab(guint32 timestamp);
+  
+  GrabStatus keyboard_grab(bool owner_events, guint32 timestamp);
+  
+  /** Ungrabs the keyboard, if it is grabbed by this application.
+   * @param timestamp A timestamp from a Gdk::Event, or Gdk::CURRENT_TIME if no
+   * timestamp is available.
+   */
+  static void keyboard_ungrab(guint32 timestamp);
+
+  
+  /** Set if @a window  must be kept above other windows. If the
+   * window was already above, then this function does nothing.
+   * 
+   * On X11, asks the window manager to keep @a window  above, if the window
+   * manager supports this operation. Not all window managers support
+   * this, and some deliberately ignore it or don't have a concept of
+   * "keep above"; so you can't rely on the window being kept above.
+   * But it will happen with most standard window managers,
+   * and GDK makes a best effort to get it to happen.
+   * 
+   * Since: 2.4
+   * @param setting Whether to keep @a window  above other windows.
+   */
+  void set_keep_above(bool setting = true);
+  
+  /** Set if @a window  must be kept below other windows. If the
+   * window was already below, then this function does nothing.
+   * 
+   * On X11, asks the window manager to keep @a window  below, if the window
+   * manager supports this operation. Not all window managers support
+   * this, and some deliberately ignore it or don't have a concept of
+   * "keep below"; so you can't rely on the window being kept below.
+   * But it will happen with most standard window managers,
+   * and GDK makes a best effort to get it to happen.
+   * 
+   * Since: 2.4
+   * @param setting Whether to keep @a window  below other windows.
+   */
+  void set_keep_below(bool setting = true);
+
+  
+  /** Setting @a accept_focus  to <tt>false</tt> hints the desktop environment that the
+   * window doesn't want to receive input focus. 
+   * 
+   * On X, it is the responsibility of the window manager to interpret this 
+   * hint. ICCCM-compliant window manager usually respect it.
+   * 
+   * Since: 2.4
+   * @param accept_focus <tt>true</tt> if the window should receive input focus.
+   */
+  void set_accept_focus(bool accept_focus = true);
+  
+  
+  /** Setting @a focus_on_map  to <tt>false</tt> hints the desktop environment that the
+   * window doesn't want to receive input focus when it is mapped.  
+   * focus_on_map should be turned off for windows that aren't triggered
+   * interactively (such as popups from network activity).
+   * 
+   * On X, it is the responsibility of the window manager to interpret
+   * this hint. %Window managers following the freedesktop.org window
+   * manager extension specification should respect it.
+   * 
+   * Since: 2.6
+   * @param focus_on_map <tt>true</tt> if the window should receive input focus when mapped.
+   */
+  void set_focus_on_map(bool focus_on_map);
+
+
+public:
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+};
+
+} /* namespace Gdk */
+
+
+namespace Glib
+{
+  /** @relates Gdk::Window
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Glib::RefPtr<Gdk::Window> wrap(GdkWindowObject* object, bool take_copy = false);
+}
+
+
+#endif /* _GDKMM_WINDOW_H */
+
diff --git a/libs/gtkmm2/gdk/gdkmm/wrap_init.cc b/libs/gtkmm2/gdk/gdkmm/wrap_init.cc
new file mode 100644
index 0000000000..e859fb7e76
--- /dev/null
+++ b/libs/gtkmm2/gdk/gdkmm/wrap_init.cc
@@ -0,0 +1,135 @@
+
+#include <glib.h>
+
+// Disable the 'const' function attribute of the get_type() functions.
+// GCC would optimize them out because we don't use the return value.
+#undef  G_GNUC_CONST
+#define G_GNUC_CONST /* empty */
+
+#include <gdkmm/wrap_init.h>
+#include <glibmm/error.h>
+#include <glibmm/object.h>
+
+// #include the widget headers so that we can call the get_type() static methods:
+
+#include "bitmap.h"
+#include "color.h"
+#include "colormap.h"
+#include "cursor.h"
+#include "device.h"
+#include "display.h"
+#include "displaymanager.h"
+#include "dragcontext.h"
+#include "drawable.h"
+#include "event.h"
+#include "gc.h"
+#include "image.h"
+#include "pixbuf.h"
+#include "pixbufanimation.h"
+#include "pixbufanimationiter.h"
+#include "pixmap.h"
+#include "pixbufformat.h"
+#include "pixbufloader.h"
+#include "rectangle.h"
+#include "region.h"
+#include "rgbcmap.h"
+#include "screen.h"
+#include "types.h"
+#include "visual.h"
+#include "window.h"
+
+extern "C"
+{
+
+//Declarations of the *_get_type() functions:
+
+GType gdk_colormap_get_type(void);
+GType gdk_device_get_type(void);
+GType gdk_display_get_type(void);
+GType gdk_display_manager_get_type(void);
+GType gdk_drag_context_get_type(void);
+GType gdk_drawable_get_type(void);
+GType gdk_gc_get_type(void);
+GType gdk_image_get_type(void);
+GType gdk_pixbuf_get_type(void);
+GType gdk_pixbuf_animation_get_type(void);
+GType gdk_pixbuf_animation_iter_get_type(void);
+GType gdk_pixbuf_loader_get_type(void);
+GType gdk_pixmap_get_type(void);
+GType gdk_screen_get_type(void);
+GType gdk_visual_get_type(void);
+GType gdk_window_object_get_type(void);
+
+//Declarations of the *_error_quark() functions:
+
+GQuark gdk_pixbuf_error_quark(void);
+} // extern "C"
+
+
+//Declarations of the *_Class::wrap_new() methods, instead of including all the private headers:
+
+namespace Gdk {  class Colormap_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gdk {  class Device_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gdk {  class Display_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gdk {  class DisplayManager_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gdk {  class DragContext_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gdk {  class Drawable_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gdk {  class GC_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gdk {  class Image_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gdk {  class Pixbuf_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gdk {  class PixbufAnimation_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gdk {  class PixbufAnimationIter_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gdk {  class PixbufLoader_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gdk {  class Pixmap_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gdk {  class Screen_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gdk {  class Visual_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gdk {  class Window_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+
+namespace Gdk { 
+
+void wrap_init()
+{
+  // Register Error domains:
+  Glib::Error::register_domain(gdk_pixbuf_error_quark(), &Gdk::PixbufError::throw_func);
+
+// Map gtypes to gtkmm wrapper-creation functions:
+  Glib::wrap_register(gdk_colormap_get_type(), &Gdk::Colormap_Class::wrap_new);
+  Glib::wrap_register(gdk_device_get_type(), &Gdk::Device_Class::wrap_new);
+  Glib::wrap_register(gdk_display_get_type(), &Gdk::Display_Class::wrap_new);
+  Glib::wrap_register(gdk_display_manager_get_type(), &Gdk::DisplayManager_Class::wrap_new);
+  Glib::wrap_register(gdk_drag_context_get_type(), &Gdk::DragContext_Class::wrap_new);
+  Glib::wrap_register(gdk_drawable_get_type(), &Gdk::Drawable_Class::wrap_new);
+  Glib::wrap_register(gdk_gc_get_type(), &Gdk::GC_Class::wrap_new);
+  Glib::wrap_register(gdk_image_get_type(), &Gdk::Image_Class::wrap_new);
+  Glib::wrap_register(gdk_pixbuf_get_type(), &Gdk::Pixbuf_Class::wrap_new);
+  Glib::wrap_register(gdk_pixbuf_animation_get_type(), &Gdk::PixbufAnimation_Class::wrap_new);
+  Glib::wrap_register(gdk_pixbuf_animation_iter_get_type(), &Gdk::PixbufAnimationIter_Class::wrap_new);
+  Glib::wrap_register(gdk_pixbuf_loader_get_type(), &Gdk::PixbufLoader_Class::wrap_new);
+  Glib::wrap_register(gdk_pixmap_get_type(), &Gdk::Pixmap_Class::wrap_new);
+  Glib::wrap_register(gdk_screen_get_type(), &Gdk::Screen_Class::wrap_new);
+  Glib::wrap_register(gdk_visual_get_type(), &Gdk::Visual_Class::wrap_new);
+  Glib::wrap_register(gdk_window_object_get_type(), &Gdk::Window_Class::wrap_new);
+
+  // Register the gtkmm gtypes:
+  Gdk::Colormap::get_type();
+  Gdk::Device::get_type();
+  Gdk::Display::get_type();
+  Gdk::DisplayManager::get_type();
+  Gdk::DragContext::get_type();
+  Gdk::Drawable::get_type();
+  Gdk::GC::get_type();
+  Gdk::Image::get_type();
+  Gdk::Pixbuf::get_type();
+  Gdk::PixbufAnimation::get_type();
+  Gdk::PixbufAnimationIter::get_type();
+  Gdk::PixbufLoader::get_type();
+  Gdk::Pixmap::get_type();
+  Gdk::Screen::get_type();
+  Gdk::Visual::get_type();
+  Gdk::Window::get_type();
+
+} // wrap_init()
+
+} //Gdk
+
+
diff --git a/libs/gtkmm2/gdk/gdkmm/wrap_init.h b/libs/gtkmm2/gdk/gdkmm/wrap_init.h
new file mode 100644
index 0000000000..e27d2122a7
--- /dev/null
+++ b/libs/gtkmm2/gdk/gdkmm/wrap_init.h
@@ -0,0 +1,32 @@
+#ifndef _GDKMM_WRAP_INIT_H
+#define _GDKMM_WRAP_INIT_H
+
+/* wrap_init.h
+ *
+ * Copyright (C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+// wrap_init.cc is generated by tools/generate_wrap_init.pl
+
+namespace Gdk
+{
+
+void wrap_init();
+
+} /* namespace Gdk */
+
+#endif // _GDKMM_WRAP_INIT_H
diff --git a/libs/gtkmm2/gdk/gdkmmconfig.h b/libs/gtkmm2/gdk/gdkmmconfig.h
new file mode 100644
index 0000000000..cbfb1a34da
--- /dev/null
+++ b/libs/gtkmm2/gdk/gdkmmconfig.h
@@ -0,0 +1,8 @@
+/* gdk/gdkmmconfig.h.  Generated by configure.  */
+#ifndef _GDKMM_CONFIG_H
+#define _GDKMM_CONFIG_H 1
+
+#include <glibmmconfig.h>
+
+#endif /* _GDKMM_CONFIG_H */
+
diff --git a/libs/gtkmm2/gtk/SConscript b/libs/gtkmm2/gtk/SConscript
new file mode 100644
index 0000000000..ecf8417230
--- /dev/null
+++ b/libs/gtkmm2/gtk/SConscript
@@ -0,0 +1,10 @@
+import glob
+
+gtkmm2_files = glob.glob('gtkmm/*.cc')
+
+Import('env libraries')
+gtkmm2 = env.Copy()
+gtkmm2.Merge([libraries['glibmm2'], libraries['gtk2'], libraries['sigc2'], libraries['pangomm'], libraries['atkmm'], libraries['gdkmm2'] ])
+
+libgtkmm2 = gtkmm2.StaticLibrary('gtkmm2', gtkmm2_files)
+Default(libgtkmm2)
diff --git a/libs/gtkmm2/gtk/gtkmm.h b/libs/gtkmm2/gtk/gtkmm.h
new file mode 100644
index 0000000000..cb8411a3e3
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm.h
@@ -0,0 +1,156 @@
+/* $Id$ */
+/* gtkmm - a C++ wrapper for the Gtk toolkit
+ *
+ * Copyright 1999-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#ifndef _GTKMM_H
+#define _GTKMM_H
+
+/* Gtkmm version.  */
+extern const int gtkmm_major_version;
+extern const int gtkmm_minor_version;
+extern const int gtkmm_micro_version;
+
+#include <glibmm.h>
+#include <gdkmm.h>
+
+#include <gtkmm/object.h>
+#include <gtkmm/aboutdialog.h>
+#include <gtkmm/accelkey.h>
+#include <gtkmm/accelgroup.h>
+#include <gtkmm/adjustment.h>
+#include <gtkmm/alignment.h>
+#include <gtkmm/arrow.h>
+#include <gtkmm/aspectframe.h>
+#include <gtkmm/base.h>
+#include <gtkmm/bin.h>
+#include <gtkmm/box.h>
+#include <gtkmm/button.h>
+#include <gtkmm/buttonbox.h>
+#include <gtkmm/checkbutton.h>
+#include <gtkmm/checkmenuitem.h>
+#include <gtkmm/cellrenderer.h>
+#include <gtkmm/cellrenderercombo.h>
+#include <gtkmm/cellrendererpixbuf.h>
+#include <gtkmm/cellrendererprogress.h>
+#include <gtkmm/cellrenderertext.h>
+#include <gtkmm/cellrenderertoggle.h>
+#include <gtkmm/colorbutton.h>
+#include <gtkmm/colorselection.h>
+#include <gtkmm/combo.h> //TODO: Deprecated.
+#include <gtkmm/combobox.h>
+#include <gtkmm/comboboxentry.h>
+#include <gtkmm/comboboxentrytext.h>
+#include <gtkmm/comboboxtext.h>
+#include <gtkmm/container.h>
+#include <gtkmm/curve.h>
+#include <gtkmm/dialog.h>
+#include <gtkmm/drawingarea.h>
+#include <gtkmm/editable.h>
+#include <gtkmm/entry.h>
+#include <gtkmm/expander.h>
+#include <gtkmm/enums.h>
+#include <gtkmm/eventbox.h>
+#include <gtkmm/filechooser.h>
+#include <gtkmm/filechooserbutton.h>
+#include <gtkmm/filechooserdialog.h>
+#include <gtkmm/filechooserwidget.h>
+#include <gtkmm/filefilter.h>
+#include <gtkmm/fileselection.h> //TODO: Deprecated.
+#include <gtkmm/fixed.h>
+#include <gtkmm/fontbutton.h>
+#include <gtkmm/fontselection.h>
+#include <gtkmm/frame.h>
+//#include <gtkmm/rc.h>
+#include <gtkmm/handlebox.h>
+#include <gtkmm/iconset.h>
+#include <gtkmm/iconfactory.h>
+#include <gtkmm/iconsource.h>
+#include <gtkmm/iconview.h>
+#include <gtkmm/image.h>
+#include <gtkmm/imagemenuitem.h>
+#include <gtkmm/inputdialog.h>
+#include <gtkmm/item.h>
+#include <gtkmm/calendar.h>
+#include <gtkmm/invisible.h>
+#include <gtkmm/label.h>
+#include <gtkmm/liststore.h>
+#include <gtkmm/main.h>
+#include <gtkmm/menu.h>
+#include <gtkmm/menu_elems.h>
+#include <gtkmm/menubar.h>
+#include <gtkmm/menuitem.h>
+#include <gtkmm/menushell.h>
+#include <gtkmm/messagedialog.h>
+#include <gtkmm/misc.h>
+#include <gtkmm/notebook.h>
+#include <gtkmm/object.h>
+#include <gtkmm/optionmenu.h>
+#include <gtkmm/paned.h>
+#include <gtkmm/progressbar.h>
+#include <gtkmm/radioaction.h>
+#include <gtkmm/radiobutton.h>
+#include <gtkmm/radiomenuitem.h>
+#include <gtkmm/radiotoolbutton.h>
+#include <gtkmm/range.h>
+#include <gtkmm/ruler.h>
+#include <gtkmm/scale.h>
+#include <gtkmm/scrollbar.h>
+#include <gtkmm/scrolledwindow.h>
+#include <gtkmm/separator.h>
+#include <gtkmm/separatormenuitem.h>
+#include <gtkmm/separatortoolitem.h>
+#include <gtkmm/settings.h>
+#include <gtkmm/sizegroup.h>
+#include <gtkmm/spinbutton.h>
+#include <gtkmm/statusbar.h>
+#include <gtkmm/stock.h>
+#include <gtkmm/stockid.h>
+#include <gtkmm/stockitem.h>
+#include <gtkmm/style.h>
+#include <gtkmm/table.h>
+#include <gtkmm/textbuffer.h>
+#include <gtkmm/textchildanchor.h>
+#include <gtkmm/textiter.h>
+#include <gtkmm/textmark.h>
+#include <gtkmm/texttag.h>
+#include <gtkmm/texttagtable.h>
+#include <gtkmm/textview.h>
+#include <gtkmm/toggleaction.h>
+#include <gtkmm/togglebutton.h>
+#include <gtkmm/toolbar.h>
+#include <gtkmm/toolitem.h>
+#include <gtkmm/toolbutton.h>
+#include <gtkmm/toggletoolbutton.h>
+#include <gtkmm/tooltips.h>
+#include <gtkmm/treemodel.h>
+#include <gtkmm/treemodelfilter.h>
+#include <gtkmm/treemodelsort.h>
+#include <gtkmm/treepath.h>
+#include <gtkmm/treerowreference.h>
+#include <gtkmm/treeselection.h>
+#include <gtkmm/treestore.h>
+#include <gtkmm/treeview.h>
+#include <gtkmm/treeviewcolumn.h>
+#include <gtkmm/uimanager.h>
+#include <gtkmm/viewport.h>
+#include <gtkmm/widget.h>
+#include <gtkmm/window.h>
+
+#endif /* #ifndef GTKMM_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/aboutdialog.cc b/libs/gtkmm2/gtk/gtkmm/aboutdialog.cc
new file mode 100644
index 0000000000..24b97e3b39
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/aboutdialog.cc
@@ -0,0 +1,477 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/aboutdialog.h>
+#include <gtkmm/private/aboutdialog_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* 
+ *
+ * Copyright 2004 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtk/gtkaboutdialog.h>
+#include <gtk/gtklabel.h>
+
+
+namespace //anonymous
+{
+
+// This Signal Proxy allows the C++ coder to specify
+// a sigc::slot instead of a static function.
+class SignalProxy_ActivateLink
+{
+public:
+  typedef Gtk::AboutDialog::SlotActivateLink SlotType;
+
+  SignalProxy_ActivateLink(const SlotType& slot)
+  : slot_(slot) {}
+
+  ~SignalProxy_ActivateLink();
+
+  static void gtk_callback(GtkAboutDialog* about, const gchar* link, gpointer data);
+  static void gtk_callback_destroy(void* data);
+
+private:
+  SlotType slot_;
+};
+
+SignalProxy_ActivateLink::~SignalProxy_ActivateLink()
+{}
+
+void SignalProxy_ActivateLink::gtk_callback(GtkAboutDialog* about, const gchar* link, gpointer data)
+{
+  SignalProxy_ActivateLink *const self = static_cast<SignalProxy_ActivateLink*>(data);
+
+  try
+  {
+    Gtk::AboutDialog* pCppAbout = Glib::wrap(about);
+    (self->slot_)( *pCppAbout, Glib::convert_const_gchar_ptr_to_ustring(link) );
+  }
+  catch(...)
+  {
+    Glib::exception_handlers_invoke();
+  }
+
+}
+
+void SignalProxy_ActivateLink::gtk_callback_destroy(void* data)
+{
+  delete static_cast<SignalProxy_ActivateLink*>(data);
+}
+
+} // anonymous namespace
+
+
+namespace Gtk
+{
+
+//static:
+void AboutDialog::set_email_hook(const SlotActivateLink& slot)
+{
+  // Create a signal proxy.  A pointer to this will be passed
+  // through the callback's data parameter.  It will be deleted
+  // when SignalProxy_ActivateLink::gtk_callback_destroy() is called.
+  SignalProxy_ActivateLink *const pSignalProxy = new SignalProxy_ActivateLink(slot);
+
+  gtk_about_dialog_set_email_hook(
+      &SignalProxy_ActivateLink::gtk_callback, pSignalProxy,
+      &SignalProxy_ActivateLink::gtk_callback_destroy);
+}
+  
+//static:
+void AboutDialog::set_url_hook(const SlotActivateLink& slot)
+{
+  // Create a signal proxy.  A pointer to this will be passed
+  // through the callback's data parameter.  It will be deleted
+  // when SignalProxy_ActivateLink::gtk_callback_destroy() is called.
+  SignalProxy_ActivateLink *const pSignalProxy = new SignalProxy_ActivateLink(slot);
+
+  gtk_about_dialog_set_url_hook(
+      &SignalProxy_ActivateLink::gtk_callback, pSignalProxy,
+      &SignalProxy_ActivateLink::gtk_callback_destroy);
+} 
+
+} // namespace Gtk
+
+
+namespace
+{
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Gtk::AboutDialog* wrap(GtkAboutDialog* object, bool take_copy)
+{
+  return dynamic_cast<Gtk::AboutDialog *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& AboutDialog_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &AboutDialog_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_about_dialog_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void AboutDialog_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+}
+
+
+Glib::ObjectBase* AboutDialog_Class::wrap_new(GObject* o)
+{
+  return new AboutDialog((GtkAboutDialog*)(o)); //top-level windows can not be manage()ed.
+
+}
+
+
+/* The implementation: */
+
+AboutDialog::AboutDialog(const Glib::ConstructParams& construct_params)
+:
+  Gtk::Dialog(construct_params)
+{
+  }
+
+AboutDialog::AboutDialog(GtkAboutDialog* castitem)
+:
+  Gtk::Dialog((GtkDialog*)(castitem))
+{
+  }
+
+AboutDialog::~AboutDialog()
+{
+  destroy_();
+}
+
+AboutDialog::CppClassType AboutDialog::aboutdialog_class_; // initialize static member
+
+GType AboutDialog::get_type()
+{
+  return aboutdialog_class_.init().get_type();
+}
+
+GType AboutDialog::get_base_type()
+{
+  return gtk_about_dialog_get_type();
+}
+
+
+AboutDialog::AboutDialog()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Dialog(Glib::ConstructParams(aboutdialog_class_.init()))
+{
+  }
+
+Glib::ustring AboutDialog::get_name() const
+{
+  return Glib::convert_const_gchar_ptr_to_ustring(gtk_about_dialog_get_name(const_cast<GtkAboutDialog*>(gobj())));
+}
+
+void AboutDialog::set_name(const Glib::ustring& name)
+{
+  gtk_about_dialog_set_name(gobj(), name.c_str());
+}
+
+Glib::ustring AboutDialog::get_version() const
+{
+  return Glib::convert_const_gchar_ptr_to_ustring(gtk_about_dialog_get_version(const_cast<GtkAboutDialog*>(gobj())));
+}
+
+void AboutDialog::set_version(const Glib::ustring& version)
+{
+  gtk_about_dialog_set_version(gobj(), version.c_str());
+}
+
+Glib::ustring AboutDialog::get_copyright() const
+{
+  return Glib::convert_const_gchar_ptr_to_ustring(gtk_about_dialog_get_copyright(const_cast<GtkAboutDialog*>(gobj())));
+}
+
+void AboutDialog::set_copyright(const Glib::ustring& copyright)
+{
+  gtk_about_dialog_set_copyright(gobj(), copyright.c_str());
+}
+
+Glib::ustring AboutDialog::get_comments() const
+{
+  return Glib::convert_const_gchar_ptr_to_ustring(gtk_about_dialog_get_comments(const_cast<GtkAboutDialog*>(gobj())));
+}
+
+void AboutDialog::set_comments(const Glib::ustring& comments)
+{
+  gtk_about_dialog_set_comments(gobj(), comments.c_str());
+}
+
+Glib::ustring AboutDialog::get_license() const
+{
+  return Glib::convert_const_gchar_ptr_to_ustring(gtk_about_dialog_get_license(const_cast<GtkAboutDialog*>(gobj())));
+}
+
+void AboutDialog::set_license(const Glib::ustring& license)
+{
+  gtk_about_dialog_set_license(gobj(), license.c_str());
+}
+
+Glib::ustring AboutDialog::get_website() const
+{
+  return Glib::convert_const_gchar_ptr_to_ustring(gtk_about_dialog_get_website(const_cast<GtkAboutDialog*>(gobj())));
+}
+
+void AboutDialog::set_website(const Glib::ustring& website)
+{
+  gtk_about_dialog_set_website(gobj(), website.c_str());
+}
+
+Glib::ustring AboutDialog::get_website_label() const
+{
+  return Glib::convert_const_gchar_ptr_to_ustring(gtk_about_dialog_get_website_label(const_cast<GtkAboutDialog*>(gobj())));
+}
+
+void AboutDialog::set_website_label(const Glib::ustring& website_label)
+{
+  gtk_about_dialog_set_website_label(gobj(), website_label.c_str());
+}
+
+Glib::StringArrayHandle AboutDialog::get_authors() const
+{
+  return Glib::StringArrayHandle(gtk_about_dialog_get_authors(const_cast<GtkAboutDialog*>(gobj())));
+}
+
+void AboutDialog::set_authors(const Glib::StringArrayHandle& authors) const
+{
+  gtk_about_dialog_set_authors(const_cast<GtkAboutDialog*>(gobj()), const_cast<const gchar**>((authors).data()));
+}
+
+Glib::StringArrayHandle AboutDialog::get_documenters() const
+{
+  return Glib::StringArrayHandle(gtk_about_dialog_get_documenters(const_cast<GtkAboutDialog*>(gobj())));
+}
+
+void AboutDialog::set_documenters(const Glib::StringArrayHandle& documenters)
+{
+  gtk_about_dialog_set_documenters(gobj(), const_cast<const gchar**>((documenters).data()));
+}
+
+Glib::StringArrayHandle AboutDialog::get_artists() const
+{
+  return Glib::StringArrayHandle(gtk_about_dialog_get_artists(const_cast<GtkAboutDialog*>(gobj())));
+}
+
+void AboutDialog::set_artists(const Glib::StringArrayHandle& artists)
+{
+  gtk_about_dialog_set_artists(gobj(), const_cast<const gchar**>((artists).data()));
+}
+
+Glib::ustring AboutDialog::get_translator_credits() const
+{
+  return Glib::convert_const_gchar_ptr_to_ustring(gtk_about_dialog_get_translator_credits(const_cast<GtkAboutDialog*>(gobj())));
+}
+
+void AboutDialog::set_translator_credits(const Glib::ustring& translator_credits)
+{
+  gtk_about_dialog_set_translator_credits(gobj(), translator_credits.c_str());
+}
+
+Glib::RefPtr<Gdk::Pixbuf> AboutDialog::get_logo()
+{
+  return Glib::wrap(gtk_about_dialog_get_logo(gobj()));
+}
+
+Glib::RefPtr<const Gdk::Pixbuf> AboutDialog::get_logo() const
+{
+  return Glib::wrap(gtk_about_dialog_get_logo(const_cast<GtkAboutDialog*>(gobj())));
+}
+
+void AboutDialog::set_logo(const Glib::RefPtr<Gdk::Pixbuf>& logo)
+{
+  gtk_about_dialog_set_logo(gobj(), Glib::unwrap(logo));
+}
+
+Glib::ustring AboutDialog::get_logo_icon_name() const
+{
+  return Glib::convert_const_gchar_ptr_to_ustring(gtk_about_dialog_get_logo_icon_name(const_cast<GtkAboutDialog*>(gobj())));
+}
+
+void AboutDialog::set_logo_icon_name(const Glib::ustring& icon_name)
+{
+  gtk_about_dialog_set_logo_icon_name(gobj(), icon_name.c_str());
+}
+
+
+Glib::PropertyProxy<Glib::ustring> AboutDialog::property_name() 
+{
+  return Glib::PropertyProxy<Glib::ustring>(this, "name");
+}
+
+Glib::PropertyProxy_ReadOnly<Glib::ustring> AboutDialog::property_name() const
+{
+  return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "name");
+}
+
+Glib::PropertyProxy<Glib::ustring> AboutDialog::property_version() 
+{
+  return Glib::PropertyProxy<Glib::ustring>(this, "version");
+}
+
+Glib::PropertyProxy_ReadOnly<Glib::ustring> AboutDialog::property_version() const
+{
+  return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "version");
+}
+
+Glib::PropertyProxy<Glib::ustring> AboutDialog::property_copyright() 
+{
+  return Glib::PropertyProxy<Glib::ustring>(this, "copyright");
+}
+
+Glib::PropertyProxy_ReadOnly<Glib::ustring> AboutDialog::property_copyright() const
+{
+  return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "copyright");
+}
+
+Glib::PropertyProxy<Glib::ustring> AboutDialog::property_comments() 
+{
+  return Glib::PropertyProxy<Glib::ustring>(this, "comments");
+}
+
+Glib::PropertyProxy_ReadOnly<Glib::ustring> AboutDialog::property_comments() const
+{
+  return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "comments");
+}
+
+Glib::PropertyProxy<Glib::ustring> AboutDialog::property_website() 
+{
+  return Glib::PropertyProxy<Glib::ustring>(this, "website");
+}
+
+Glib::PropertyProxy_ReadOnly<Glib::ustring> AboutDialog::property_website() const
+{
+  return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "website");
+}
+
+Glib::PropertyProxy<Glib::ustring> AboutDialog::property_website_label() 
+{
+  return Glib::PropertyProxy<Glib::ustring>(this, "website-label");
+}
+
+Glib::PropertyProxy_ReadOnly<Glib::ustring> AboutDialog::property_website_label() const
+{
+  return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "website-label");
+}
+
+Glib::PropertyProxy<Glib::ustring> AboutDialog::property_license() 
+{
+  return Glib::PropertyProxy<Glib::ustring>(this, "license");
+}
+
+Glib::PropertyProxy_ReadOnly<Glib::ustring> AboutDialog::property_license() const
+{
+  return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "license");
+}
+
+Glib::PropertyProxy<Glib::StringArrayHandle> AboutDialog::property_authors() 
+{
+  return Glib::PropertyProxy<Glib::StringArrayHandle>(this, "authors");
+}
+
+Glib::PropertyProxy_ReadOnly<Glib::StringArrayHandle> AboutDialog::property_authors() const
+{
+  return Glib::PropertyProxy_ReadOnly<Glib::StringArrayHandle>(this, "authors");
+}
+
+Glib::PropertyProxy<Glib::StringArrayHandle> AboutDialog::property_documenters() 
+{
+  return Glib::PropertyProxy<Glib::StringArrayHandle>(this, "documenters");
+}
+
+Glib::PropertyProxy_ReadOnly<Glib::StringArrayHandle> AboutDialog::property_documenters() const
+{
+  return Glib::PropertyProxy_ReadOnly<Glib::StringArrayHandle>(this, "documenters");
+}
+
+Glib::PropertyProxy<Glib::StringArrayHandle> AboutDialog::property_translator_credits() 
+{
+  return Glib::PropertyProxy<Glib::StringArrayHandle>(this, "translator-credits");
+}
+
+Glib::PropertyProxy_ReadOnly<Glib::StringArrayHandle> AboutDialog::property_translator_credits() const
+{
+  return Glib::PropertyProxy_ReadOnly<Glib::StringArrayHandle>(this, "translator-credits");
+}
+
+Glib::PropertyProxy<Glib::StringArrayHandle> AboutDialog::property_artists() 
+{
+  return Glib::PropertyProxy<Glib::StringArrayHandle>(this, "artists");
+}
+
+Glib::PropertyProxy_ReadOnly<Glib::StringArrayHandle> AboutDialog::property_artists() const
+{
+  return Glib::PropertyProxy_ReadOnly<Glib::StringArrayHandle>(this, "artists");
+}
+
+Glib::PropertyProxy< Glib::RefPtr<Gdk::Pixbuf> > AboutDialog::property_logo() 
+{
+  return Glib::PropertyProxy< Glib::RefPtr<Gdk::Pixbuf> >(this, "logo");
+}
+
+Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::Pixbuf> > AboutDialog::property_logo() const
+{
+  return Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::Pixbuf> >(this, "logo");
+}
+
+Glib::PropertyProxy<Glib::ustring> AboutDialog::property_logo_icon_name() 
+{
+  return Glib::PropertyProxy<Glib::ustring>(this, "logo-icon-name");
+}
+
+Glib::PropertyProxy_ReadOnly<Glib::ustring> AboutDialog::property_logo_icon_name() const
+{
+  return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "logo-icon-name");
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/aboutdialog.h b/libs/gtkmm2/gtk/gtkmm/aboutdialog.h
new file mode 100644
index 0000000000..d36c8b2326
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/aboutdialog.h
@@ -0,0 +1,591 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_ABOUTDIALOG_H
+#define _GTKMM_ABOUTDIALOG_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* aboutdialog.h
+ *
+ * Copyright (C) 2004 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/dialog.h>
+//#include <glibmm/listhandle.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkAboutDialog GtkAboutDialog;
+typedef struct _GtkAboutDialogClass GtkAboutDialogClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class AboutDialog_Class; } // namespace Gtk
+namespace Gtk
+{
+
+/** TODO
+ *
+ * @ingroup Dialogs
+ */
+
+class AboutDialog : public Dialog
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef AboutDialog CppObjectType;
+  typedef AboutDialog_Class CppClassType;
+  typedef GtkAboutDialog BaseObjectType;
+  typedef GtkAboutDialogClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~AboutDialog();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class AboutDialog_Class;
+  static CppClassType aboutdialog_class_;
+
+  // noncopyable
+  AboutDialog(const AboutDialog&);
+  AboutDialog& operator=(const AboutDialog&);
+
+protected:
+  explicit AboutDialog(const Glib::ConstructParams& construct_params);
+  explicit AboutDialog(GtkAboutDialog* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GtkAboutDialog*       gobj()       { return reinterpret_cast<GtkAboutDialog*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GtkAboutDialog* gobj() const { return reinterpret_cast<GtkAboutDialog*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+private:
+
+  
+public:
+  AboutDialog();
+
+  
+  /** Returns the program name displayed in the about dialog.
+   * @return The program name. The string is owned by the about
+   * dialog and must not be modified.
+   * 
+   * Since: 2.6.
+   */
+  Glib::ustring get_name() const;
+  
+  /** Sets the name to display in the about dialog. 
+   * If this is not set, it defaults to Glib::get_application_name().
+   * 
+   * Since: 2.6
+   * @param name The program name.
+   */
+  void set_name(const Glib::ustring& name);
+  
+  /** Returns the version string.
+   * @return The version string. The string is owned by the about
+   * dialog and must not be modified.
+   * 
+   * Since: 2.6.
+   */
+  Glib::ustring get_version() const;
+  
+  /** Sets the version string to display in the about dialog.
+   * 
+   * Since: 2.6
+   * @param version The version string.
+   */
+  void set_version(const Glib::ustring& version);
+  
+  /** Returns the copyright string.
+   * @return The copyright string. The string is owned by the about
+   * dialog and must not be modified.
+   * 
+   * Since: 2.6.
+   */
+  Glib::ustring get_copyright() const;
+  
+  /** Sets the copyright string to display in the about dialog.
+   * This should be a short string of one or two lines. 
+   * 
+   * Since: 2.6
+   * @param copyright The copyright string.
+   */
+  void set_copyright(const Glib::ustring& copyright);
+  
+  /** Returns the comments string.
+   * @return The comments. The string is owned by the about
+   * dialog and must not be modified.
+   * 
+   * Since: 2.6.
+   */
+  Glib::ustring get_comments() const;
+  
+  /** Sets the comments string to display in the about 
+   * dialog. This should be a short string of one or
+   * two lines.
+   * 
+   * Since: 2.6
+   * @param comments A comments string.
+   */
+  void set_comments(const Glib::ustring& comments);
+  
+  /** Returns the license information.
+   * @return The license information. The string is owned by the about
+   * dialog and must not be modified.
+   * 
+   * Since: 2.6.
+   */
+  Glib::ustring get_license() const;
+  
+  /** Sets the license information to be displayed in the secondary
+   * license dialog. If @a license  is <tt>0</tt>, the license button is
+   * hidden.
+   * 
+   * Since: 2.6
+   * @param license The license information or <tt>0</tt>.
+   */
+  void set_license(const Glib::ustring& license);
+  
+  /** Returns the website URL.
+   * @return The website URL. The string is owned by the about
+   * dialog and must not be modified.
+   * 
+   * Since: 2.6.
+   */
+  Glib::ustring get_website() const;
+  
+  /** Sets the URL to use for the website link.
+   * 
+   * Since: 2.6
+   * @param website A URL string starting with "http://".
+   */
+  void set_website(const Glib::ustring& website);
+  
+  /** Returns the label used for the website link.
+   * @return The label used for the website link. The string is owned by the about
+   * dialog and must not be modified.
+   * 
+   * Since: 2.6.
+   */
+  Glib::ustring get_website_label() const;
+  
+  /** Sets the label to be used for the website link.
+   * It defaults to the website URL.
+   * 
+   * Since: 2.6
+   * @param website_label The label used for the website link.
+   */
+  void set_website_label(const Glib::ustring& website_label);
+  
+   
+  /** Returns the string which are displayed in the authors tab
+   * of the secondary credits dialog.
+   * @return A <tt>0</tt>-terminated string array containing
+   * the authors. The array is owned by the about dialog 
+   * and must not be modified.
+   * 
+   * Since: 2.6.
+   */
+  Glib::StringArrayHandle get_authors() const;
+  
+  
+  /** Sets the strings which are displayed in the authors tab
+   * of the secondary credits dialog. 
+   * 
+   * Since: 2.6
+   * @param authors A <tt>0</tt>-terminated array of strings.
+   */
+  void set_authors(const Glib::StringArrayHandle& authors) const;
+  
+  
+  /** Returns the string which are displayed in the documenters 
+   * tab of the secondary credits dialog.
+   * @return A <tt>0</tt>-terminated string array containing
+   * the documenters. The array is owned by the about dialog 
+   * and must not be modified.
+   * 
+   * Since: 2.6.
+   */
+  Glib::StringArrayHandle get_documenters() const;
+  
+   
+  /** Sets the strings which are displayed in the documenters tab
+   * of the secondary credits dialog. 
+   * 
+   * Since: 2.6
+   * @param documenters A <tt>0</tt>-terminated array of strings.
+   */
+  void set_documenters(const Glib::StringArrayHandle& documenters);
+  
+  /** Returns the string which are displayed in the artists tab
+   * of the secondary credits dialog.
+   * @return A <tt>0</tt>-terminated string array containing
+   * the artists. The array is owned by the about dialog 
+   * and must not be modified.
+   * 
+   * Since: 2.6.
+   */
+  Glib::StringArrayHandle get_artists() const;
+  
+  /** Sets the strings which are displayed in the artists tab
+   * of the secondary credits dialog. 
+   * 
+   * Since: 2.6
+   * @param artists A <tt>0</tt>-terminated array of strings.
+   */
+  void set_artists(const Glib::StringArrayHandle& artists);
+  
+  /** Returns the translator credits string which is displayed
+   * in the translators tab of the secondary credits dialog.
+   * @return The translator credits string. The string is
+   * owned by the about dialog and must not be modified.
+   * 
+   * Since: 2.6.
+   */
+  Glib::ustring get_translator_credits() const;
+  
+  /** Sets the translator credits string which is displayed in
+   * the translators tab of the secondary credits dialog.
+   * 
+   * The intended use for this string is to display the translator
+   * of the language which is currently used in the user interface.
+   * Using gettext(), a simple way to achieve that is to mark the
+   * string for translation:
+   * @code
+   * gtk_about_dialog_set_translator_credits (about, _("translator-credits"));
+   * @endcode
+   * It is a good idea to use the customary msgid "translator-credits" for this
+   * purpose, since translators will already know the purpose of that msgid, and
+   * since Gtk::AboutDialog will detect if "translator-credits" is untranslated
+   * and hide the tab.
+   * 
+   * Since: 2.6
+   * @param translator_credits The translator credits.
+   */
+  void set_translator_credits(const Glib::ustring& translator_credits);
+  
+  
+  /** Returns the pixbuf displayed as logo in the about dialog.
+   * @return The pixbuf displayed as logo. The pixbuf is
+   * owned by the about dialog. If you want to keep a reference
+   * to it, you have to call Glib::object_ref() on it.
+   * 
+   * Since: 2.6.
+   */
+  Glib::RefPtr<Gdk::Pixbuf> get_logo();
+  
+  /** Returns the pixbuf displayed as logo in the about dialog.
+   * @return The pixbuf displayed as logo. The pixbuf is
+   * owned by the about dialog. If you want to keep a reference
+   * to it, you have to call Glib::object_ref() on it.
+   * 
+   * Since: 2.6.
+   */
+  Glib::RefPtr<const Gdk::Pixbuf> get_logo() const;
+
+  
+  /** Sets the pixbuf to be displayed as logo in 
+   * the about dialog. If it is <tt>0</tt>, the default
+   * window icon set with Gtk::Window::set_default_icon()
+   * will be used.
+   * 
+   * Since: 2.6
+   * @param logo A Gdk::Pixbuf, or <tt>0</tt>.
+   */
+  void set_logo(const Glib::RefPtr<Gdk::Pixbuf>& logo);
+  
+  
+  /** Returns the icon name displayed as logo in the about dialog.
+   * @return The icon name displayed as logo. The string is
+   * owned by the about dialog. If you want to keep a reference
+   * to it, you have to call Glib::strdup() on it.
+   * 
+   * Since: 2.6.
+   */
+  Glib::ustring get_logo_icon_name() const;
+  
+  /** Sets the pixbuf to be displayed as logo in 
+   * the about dialog. If it is <tt>0</tt>, the default
+   * window icon set with Gtk::Window::set_default_icon()
+   * will be used.
+   * 
+   * Since: 2.6
+   * @param icon_name An icon name, or <tt>0</tt>.
+   */
+  void set_logo_icon_name(const Glib::ustring& icon_name);
+
+  /** For instance,
+   * void on_activate_link_url(AboutDialog& about_dialog, const Glib::ustring& link);
+   */
+  typedef sigc::slot<void, AboutDialog& /* about_dialog */, const Glib::ustring& /* link */> SlotActivateLink;
+  
+  //TODO: Document these methods.
+  static void set_email_hook(const SlotActivateLink& slot);
+  
+  
+  static void set_url_hook(const SlotActivateLink& slot);
+  
+  
+  /** The name of the program. If this is not set
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Glib::ustring> property_name() ;
+
+/** The name of the program. If this is not set
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Glib::ustring> property_name() const;
+
+  /** The version of the program.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Glib::ustring> property_version() ;
+
+/** The version of the program.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Glib::ustring> property_version() const;
+
+  /** Copyright information for the program.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Glib::ustring> property_copyright() ;
+
+/** Copyright information for the program.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Glib::ustring> property_copyright() const;
+
+  /** Comments about the program.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Glib::ustring> property_comments() ;
+
+/** Comments about the program.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Glib::ustring> property_comments() const;
+
+  /** The URL for the link to the website of the program.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Glib::ustring> property_website() ;
+
+/** The URL for the link to the website of the program.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Glib::ustring> property_website() const;
+
+  /** The label for the link to the website of the program. If this is not set
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Glib::ustring> property_website_label() ;
+
+/** The label for the link to the website of the program. If this is not set
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Glib::ustring> property_website_label() const;
+
+  /** The license of the program.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Glib::ustring> property_license() ;
+
+/** The license of the program.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Glib::ustring> property_license() const;
+
+  /** List of authors of the program.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Glib::StringArrayHandle> property_authors() ;
+
+/** List of authors of the program.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Glib::StringArrayHandle> property_authors() const;
+
+  /** List of people documenting the program.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Glib::StringArrayHandle> property_documenters() ;
+
+/** List of people documenting the program.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Glib::StringArrayHandle> property_documenters() const;
+
+  /** Credits to the translators. This string should be marked as translatable.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Glib::StringArrayHandle> property_translator_credits() ;
+
+/** Credits to the translators. This string should be marked as translatable.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Glib::StringArrayHandle> property_translator_credits() const;
+
+  /** List of people who have contributed artwork to the program.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Glib::StringArrayHandle> property_artists() ;
+
+/** List of people who have contributed artwork to the program.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Glib::StringArrayHandle> property_artists() const;
+
+  /** A logo for the about box. If this is not set
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy< Glib::RefPtr<Gdk::Pixbuf> > property_logo() ;
+
+/** A logo for the about box. If this is not set
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::Pixbuf> > property_logo() const;
+
+  /** A named icon to use as the logo for the about box.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Glib::ustring> property_logo_icon_name() ;
+
+/** A named icon to use as the logo for the about box.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Glib::ustring> property_logo_icon_name() const;
+  
+
+};
+
+} // namespace Gtk
+
+
+namespace Glib
+{
+  /** @relates Gtk::AboutDialog
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gtk::AboutDialog* wrap(GtkAboutDialog* object, bool take_copy = false);
+}
+#endif /* _GTKMM_ABOUTDIALOG_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/accelgroup.cc b/libs/gtkmm2/gtk/gtkmm/accelgroup.cc
new file mode 100644
index 0000000000..edb7170bf4
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/accelgroup.cc
@@ -0,0 +1,347 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/accelgroup.h>
+#include <gtkmm/private/accelgroup_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtk/gtkaccelgroup.h>
+
+
+namespace Gtk
+{
+
+bool AccelGroup::valid(guint keyval, Gdk::ModifierType modifiers) 
+{
+  return gtk_accelerator_valid(keyval, (GdkModifierType) modifiers);
+}
+
+void AccelGroup::parse(const Glib::ustring& accelerator,
+                       guint&               accelerator_key,
+                       Gdk::ModifierType&   accelerator_mods)
+{
+  GdkModifierType mods = GdkModifierType(0);
+  gtk_accelerator_parse(accelerator.c_str(), &accelerator_key, &mods);
+
+  accelerator_mods = (Gdk::ModifierType) mods;
+}
+
+Glib::ustring AccelGroup::name(guint accelerator_key, Gdk::ModifierType accelerator_mods) 
+{
+  return gtk_accelerator_name(accelerator_key, (GdkModifierType) accelerator_mods);
+}
+
+void AccelGroup::set_default_mod_mask(Gdk::ModifierType default_mod_mask) 
+{
+  gtk_accelerator_set_default_mod_mask((GdkModifierType) default_mod_mask);
+}
+
+Gdk::ModifierType AccelGroup::get_default_mod_mask() 
+{
+  return (Gdk::ModifierType) gtk_accelerator_get_default_mod_mask();
+}
+
+} // namespace Gtk
+
+
+namespace
+{
+
+gboolean AccelGroup_signal_accel_activate_callback(GtkAccelGroup* self, GObject* p0,guint p1,GdkModifierType p2,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< bool,const Glib::RefPtr<Glib::Object>&,guint,Gdk::ModifierType > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        return static_cast<int>((*static_cast<SlotType*>(slot))(Glib::wrap(p0, true)
+, p1, ((Gdk::ModifierType)(p2))
+));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+gboolean AccelGroup_signal_accel_activate_notify_callback(GtkAccelGroup* self, GObject* p0,guint p1,GdkModifierType p2, void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,const Glib::RefPtr<Glib::Object>&,guint,Gdk::ModifierType > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(Glib::wrap(p0, true)
+, p1, ((Gdk::ModifierType)(p2))
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+const Glib::SignalProxyInfo AccelGroup_signal_accel_activate_info =
+{
+  "accel_activate",
+  (GCallback) &AccelGroup_signal_accel_activate_callback,
+  (GCallback) &AccelGroup_signal_accel_activate_notify_callback
+};
+
+
+void AccelGroup_signal_accel_changed_callback(GtkAccelGroup* self, guint p0,GdkModifierType p1,GClosure* p2,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,guint,Gdk::ModifierType,GClosure* > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(p0, ((Gdk::ModifierType)(p1))
+, p2);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+}
+
+const Glib::SignalProxyInfo AccelGroup_signal_accel_changed_info =
+{
+  "accel_changed",
+  (GCallback) &AccelGroup_signal_accel_changed_callback,
+  (GCallback) &AccelGroup_signal_accel_changed_callback
+};
+
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Glib::RefPtr<Gtk::AccelGroup> wrap(GtkAccelGroup* object, bool take_copy)
+{
+  return Glib::RefPtr<Gtk::AccelGroup>( dynamic_cast<Gtk::AccelGroup*> (Glib::wrap_auto ((GObject*)(object), take_copy)) );
+  //We use dynamic_cast<> in case of multiple inheritance.
+}
+
+} /* namespace Glib */
+
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& AccelGroup_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &AccelGroup_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_accel_group_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void AccelGroup_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+  klass->accel_changed = &accel_changed_callback;
+}
+
+
+void AccelGroup_Class::accel_changed_callback(GtkAccelGroup* self, guint p0, GdkModifierType p1, GClosure* p2)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_accel_changed(p0, ((Gdk::ModifierType)(p1))
+, p2);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->accel_changed)
+      (*base->accel_changed)(self, p0, p1, p2);
+  }
+}
+
+
+Glib::ObjectBase* AccelGroup_Class::wrap_new(GObject* object)
+{
+  return new AccelGroup((GtkAccelGroup*)object);
+}
+
+
+/* The implementation: */
+
+GtkAccelGroup* AccelGroup::gobj_copy()
+{
+  reference();
+  return gobj();
+}
+
+AccelGroup::AccelGroup(const Glib::ConstructParams& construct_params)
+:
+  Glib::Object(construct_params)
+{}
+
+AccelGroup::AccelGroup(GtkAccelGroup* castitem)
+:
+  Glib::Object((GObject*)(castitem))
+{}
+
+AccelGroup::~AccelGroup()
+{}
+
+
+AccelGroup::CppClassType AccelGroup::accelgroup_class_; // initialize static member
+
+GType AccelGroup::get_type()
+{
+  return accelgroup_class_.init().get_type();
+}
+
+GType AccelGroup::get_base_type()
+{
+  return gtk_accel_group_get_type();
+}
+
+
+AccelGroup::AccelGroup()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Glib::Object(Glib::ConstructParams(accelgroup_class_.init()))
+{
+  }
+
+Glib::RefPtr<AccelGroup> AccelGroup::create()
+{
+  return Glib::RefPtr<AccelGroup>( new AccelGroup() );
+}
+void AccelGroup::lock()
+{
+  gtk_accel_group_lock(gobj());
+}
+
+void AccelGroup::unlock()
+{
+  gtk_accel_group_unlock(gobj());
+}
+
+bool AccelGroup::disconnect_key(guint accel_key, Gdk::ModifierType accel_mods)
+{
+  return gtk_accel_group_disconnect_key(gobj(), accel_key, ((GdkModifierType)(accel_mods)));
+}
+
+Glib::ustring AccelGroup::get_label(guint accelerator_key, Gdk::ModifierType accelerator_mods)
+{
+  return Glib::convert_return_gchar_ptr_to_ustring(gtk_accelerator_get_label(accelerator_key, ((GdkModifierType)(accelerator_mods))));
+}
+
+bool AccelGroup::activate(GQuark accel_quark, const Glib::RefPtr<Glib::Object>& acceleratable, guint accel_key, Gdk::ModifierType accel_mods)
+{
+  return gtk_accel_group_activate(gobj(), accel_quark, Glib::unwrap(acceleratable), accel_key, ((GdkModifierType)(accel_mods)));
+}
+
+bool AccelGroup::activate(Gtk::Object& object, guint accel_key, Gdk::ModifierType accel_mods)
+{
+  return gtk_accel_groups_activate((object).Glib::Object::gobj(), accel_key, ((GdkModifierType)(accel_mods)));
+}
+
+
+Glib::SignalProxy3< bool,const Glib::RefPtr<Glib::Object>&,guint,Gdk::ModifierType > AccelGroup::signal_accel_activate()
+{
+  return Glib::SignalProxy3< bool,const Glib::RefPtr<Glib::Object>&,guint,Gdk::ModifierType >(this, &AccelGroup_signal_accel_activate_info);
+}
+
+Glib::SignalProxy3< void,guint,Gdk::ModifierType,GClosure* > AccelGroup::signal_accel_changed()
+{
+  return Glib::SignalProxy3< void,guint,Gdk::ModifierType,GClosure* >(this, &AccelGroup_signal_accel_changed_info);
+}
+
+
+void Gtk::AccelGroup::on_accel_changed(guint keyval, Gdk::ModifierType modifier, GClosure* accel_closure)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->accel_changed)
+    (*base->accel_changed)(gobj(),keyval,((GdkModifierType)(modifier)),accel_closure);
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/accelgroup.h b/libs/gtkmm2/gtk/gtkmm/accelgroup.h
new file mode 100644
index 0000000000..1a6a8adc4d
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/accelgroup.h
@@ -0,0 +1,249 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_ACCELGROUP_H
+#define _GTKMM_ACCELGROUP_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* Copyright (C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+
+#include <gdkmm/types.h>
+#include <gtkmm/object.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkAccelGroup GtkAccelGroup;
+typedef struct _GtkAccelGroupClass GtkAccelGroupClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class AccelGroup_Class; } // namespace Gtk
+namespace Gtk
+{
+
+/** A Gtk::AccelGroup represents a group of keyboard accelerators, typically
+ * attached to a toplevel Gtk::Window (with Gtk::Window::add_accel_group()).
+ * Usually you won't need to create a Gtk::AccelGroup directly; instead, gtkmm
+ * automatically sets up the accelerators for your menus.  Note that
+ * accelerators are different from mnemonics.  Accelerators are shortcuts for
+ * activating a menu item; they appear alongside the menu item for which
+ * they're a shortcut. For example "Ctrl+Q" might appear alongside the "Quit"
+ * menu item.  Mnemonics are shortcuts for GUI elements such as text entries or
+ * buttons; they appear as underlined characters. See the Gtk::Label
+ * constructor. Menu items can have both accelerators and mnemonics, of course.
+ *
+ * You can use Gtk::Window::get_accel_group() to get an accel group for that window,
+ * then use it with other widgets too.
+ */
+
+class AccelGroup : public Glib::Object
+{
+   
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+public:
+  typedef AccelGroup CppObjectType;
+  typedef AccelGroup_Class CppClassType;
+  typedef GtkAccelGroup BaseObjectType;
+  typedef GtkAccelGroupClass BaseClassType;
+
+private:  friend class AccelGroup_Class;
+  static CppClassType accelgroup_class_;
+
+private:
+  // noncopyable
+  AccelGroup(const AccelGroup&);
+  AccelGroup& operator=(const AccelGroup&);
+
+protected:
+  explicit AccelGroup(const Glib::ConstructParams& construct_params);
+  explicit AccelGroup(GtkAccelGroup* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+  virtual ~AccelGroup();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GObject.
+  GtkAccelGroup*       gobj()       { return reinterpret_cast<GtkAccelGroup*>(gobject_); }
+
+  ///Provides access to the underlying C GObject.
+  const GtkAccelGroup* gobj() const { return reinterpret_cast<GtkAccelGroup*>(gobject_); }
+
+  ///Provides access to the underlying C instance. The caller is responsible for unrefing it. Use when directly setting fields in structs.
+  GtkAccelGroup* gobj_copy();
+
+private:
+
+   
+protected:
+  AccelGroup();
+
+public:
+  /** Creates a new Gtk::AccelGroup object.
+   * @return A Glib::RefPtr<> to a newly created Gtk::AccelGroup object.
+   */
+  
+  static Glib::RefPtr<AccelGroup> create();
+
+
+  /** Locks the given accelerator group.
+   * 
+   * Locking an acelerator group prevents the accelerators contained
+   * within it to be changed during runtime. Refer to
+   * gtk_accel_map_change_entry() about runtime accelerator changes.
+   * 
+   * If called more than once, @a accel_group  remains locked until
+   * unlock() has been called an equivalent number
+   * of times.
+   */
+  void lock();
+  
+  /** Undoes the last call to lock() on this @a accel_group .
+   */
+  void unlock();
+  
+  /** Removes an accelerator previously installed through
+   * connect().
+   * @param accel_key Key value of the accelerator.
+   * @param accel_mods Modifier combination of the accelerator.
+   * @return <tt>true</tt> if there was an accelerator which could be 
+   * removed, <tt>false</tt> otherwise.
+   */
+  bool disconnect_key(guint accel_key, Gdk::ModifierType accel_mods);
+
+  /** Determines whether a given keyval and modifier mask constitute
+  * a valid keyboard accelerator. For example, the 'a' keyval
+  * plus Gdk::CONTROL_MASK is valid - this is a "Ctrl+a" accelerator.
+  * But you can't, for instance, use the GDK_Control_L keyval
+  * as an accelerator.
+  */
+  static bool valid(guint keyval, Gdk::ModifierType modifiers);
+
+   /** Parse the accelerator string.
+   * @param accelerator See the Gtk::AccelKey constructor for the format.
+   * @param accelerator_key Output argument
+   * @param accelerator_mods Output argument
+   */
+  static void parse(const Glib::ustring& accelerator, guint& accelerator_key, Gdk::ModifierType& accelerator_mods);
+
+  /** Converts an accelerator keyval and modifier mask
+   * into a string parseable by parse().
+   * For example, if you pass in 'q' and Gdk::CONTROL_MASK, it returns "&lt;Control&gt;q".
+   */
+  static Glib::ustring name(guint accelerator_key, Gdk::ModifierType accelerator_mods);
+
+  
+  /** Converts an accelerator keyval and modifier mask into a string 
+   * which can be used to represent the accelerator to the user.
+   * @param accelerator_key Accelerator keyval.
+   * @param accelerator_mods Accelerator modifier mask.
+   * @return A newly-allocated string representing the accelerator.
+   * 
+   * Since: 2.6.
+   */
+  static Glib::ustring get_label(guint accelerator_key, Gdk::ModifierType accelerator_mods);
+
+  /** Sets the modifiers that will be considered significant for keyboard
+   * accelerators. The default mod mask is Gdk::CONTROL_MASK |
+   * Gdk::SHIFT_MASK | Gdk::MOD1_MASK, that is, Control, Shift, and Alt.
+   * Other modifiers will ignored by default.
+   * You must include at least the three default modifiers in any
+   * value you pass to this function.
+   *
+   * The default mod mask should be changed on application startup,
+   * before using any accelerator groups.
+   */
+  static void set_default_mod_mask(Gdk::ModifierType default_mod_mask);
+
+  /// See set_default_mod_mask().
+  static Gdk::ModifierType get_default_mod_mask();
+
+  //TODO: This is undocumented in GTK+ at the moment. When would it be used and where does the quark come from? murrayc.
+  
+  bool activate(GQuark accel_quark, const Glib::RefPtr<Glib::Object>& acceleratable, guint	accel_key, Gdk::ModifierType accel_mods);
+
+  
+  //Let's not wrap this, because the GtkAccelGroupFindFunc callback uses GClosures, and it's not clear that this is useful.
+  //AccelKey find(const SlotFind& slot);
+  //GtkAccelKey*	gtk_accel_group_find(GtkAccelGroup* accel_group, GtkAccelGroupFindFunc find_func, gpointer data);
+                            
+  
+  /** Finds the first accelerator in any Gtk::AccelGroup attached
+   * to @a object  that matches @a accel_key  and @a accel_mods , and
+   * activates that accelerator.
+   * If an accelerator was activated and handled this keypress, <tt>true</tt>
+   * is returned.
+   * @param object The G::Object, usually a Gtk::Window, on which
+   * to activate the accelerator.
+   * @param accel_key Accelerator keyval from a key event.
+   * @param accel_mods Keyboard state mask from a key event.
+   * @return <tt>true</tt> if the accelerator was handled, <tt>false</tt> otherwise.
+   */
+  static bool activate(Gtk::Object& object, guint accel_key, Gdk::ModifierType accel_mods);
+
+  //TODO: Discover real parameter names:
+  
+
+  Glib::SignalProxy3< bool,const Glib::RefPtr<Glib::Object>&,guint,Gdk::ModifierType > signal_accel_activate();
+   
+  //TODO: The C type is unpleasant:
+  
+
+  Glib::SignalProxy3< void,guint,Gdk::ModifierType,GClosure* > signal_accel_changed();
+
+
+public:
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+  virtual void on_accel_changed(guint keyval, Gdk::ModifierType modifier, GClosure* accel_closure);
+
+
+};
+
+} // namespace Gtk
+
+
+namespace Glib
+{
+  /** @relates Gtk::AccelGroup
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Glib::RefPtr<Gtk::AccelGroup> wrap(GtkAccelGroup* object, bool take_copy = false);
+}
+
+
+#endif /* _GTKMM_ACCELGROUP_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/accelkey.cc b/libs/gtkmm2/gtk/gtkmm/accelkey.cc
new file mode 100644
index 0000000000..ffd734c423
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/accelkey.cc
@@ -0,0 +1,93 @@
+// -*- c++ -*-
+/* $Id$ */
+
+/* 
+ *
+ * Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/accelkey.h>
+#include <gtkmm/accelgroup.h>
+
+namespace Gtk
+{
+
+AccelKey::AccelKey()
+: key_(GDK_VoidSymbol),
+  mod_((Gdk::ModifierType)0)
+{
+}
+
+AccelKey::AccelKey(guint accel_key, Gdk::ModifierType accel_mods,
+                   const Glib::ustring& accel_path)
+: key_(accel_key),
+  mod_(accel_mods),
+  path_(accel_path)
+{
+}
+
+AccelKey::AccelKey(const Glib::ustring& accelerator, const Glib::ustring& accel_path)
+: path_(accel_path)
+{
+  //Get the key and mod by parsing the accelerator string:
+  AccelGroup::parse (accelerator, key_, mod_);
+}
+
+AccelKey::AccelKey(const AccelKey& src)
+{
+  key_ = src.key_;
+  mod_ = src.mod_;
+  path_ = src.path_;
+}
+
+AccelKey& AccelKey::operator=(const AccelKey& src)
+{
+  key_ = src.key_;
+  mod_ = src.mod_;
+  path_ = src.path_;
+
+  return *this;
+}
+
+guint AccelKey::get_key() const
+{
+  return key_;
+}
+
+Gdk::ModifierType AccelKey::get_mod() const
+{
+  return mod_;
+}
+
+Glib::ustring AccelKey::get_path() const
+{
+  return path_;
+}
+
+bool AccelKey::is_null() const
+{
+  return ( (key_ == GDK_VoidSymbol) || !(get_key() > 0) ); //both seem to be invalid.
+}
+
+Glib::ustring AccelKey::get_abbrev() const
+{
+  return AccelGroup::name (key_, mod_);
+}
+
+
+} // namespace
+
diff --git a/libs/gtkmm2/gtk/gtkmm/accelkey.h b/libs/gtkmm2/gtk/gtkmm/accelkey.h
new file mode 100644
index 0000000000..21841b1a8e
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/accelkey.h
@@ -0,0 +1,94 @@
+/* $Id$ */
+#ifndef _GTKMM_ACCELKEY_H
+#define _GTKMM_ACCELKEY_H
+
+/* menu_elems.h
+ * 
+ * Copyright (C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gdk/gdkkeysyms.h>
+#include <gdkmm/types.h>
+
+
+namespace Gtk
+{
+
+/** Defines accelerator key combinations.
+ * For instance, pressing Control-Q to activate the File|Quit menu item.
+ * Typedefed as Gtk::Menu::AccelKey
+ *
+ * By defining accelerator paths you can allow the user of your application
+ * to change accelerators himself. An example of an accelerator might be
+ * "<MainWindow>/File/Open". Modified accelerators may be saved 
+ * @see Gtk::AccelMap
+ * @ingroup Menus
+ */
+class AccelKey
+{
+public:
+  AccelKey();
+
+ /** AccelKey constructor.
+  * @param accel_key For instance, 'q'
+  * @param accel_mods For instance, Gdk::CONTROL_MASK
+  * @param accel_path For instance, "<MainWindow>/File/Open"
+  */
+  AccelKey(guint accel_key, Gdk::ModifierType accel_mods, 
+           const Glib::ustring& accel_path = "");
+  
+  /** AccelKey constructor.
+   * @param accelerator For instance, &quot;&lt;control&gt;q&quot; - Use 
+   *     &lt;control&gt;, &lt;shift&gt;, &lt;alt&gt; and &lt;release&gt;. 
+   *     Use F1, F2, etc, for function keys.
+   * @param accel_path For instance, "<MainWindow>/File/Open"
+   */
+  AccelKey(const Glib::ustring& accelerator, 
+           const Glib::ustring& accel_path = Glib::ustring());
+
+  AccelKey(const AccelKey& src);
+
+  AccelKey& operator=(const AccelKey& src);
+
+  bool is_null() const;
+
+  /**
+   * Gets the accelerator key.
+   */
+  guint get_key() const;
+  /**
+   * Gets the accelerator modifier.
+   */
+  Gdk::ModifierType get_mod() const;
+  /**
+   * Gets the accelerator path.
+   */
+  Glib::ustring get_path() const;
+  /**
+   * Gets the accelerator representation for labels.
+   */
+  Glib::ustring get_abbrev() const;
+
+protected:
+  guint key_;
+  Gdk::ModifierType mod_;
+  Glib::ustring path_;
+};
+
+} /* namespace Gtk */
+
+#endif //_GTKMM_ACCELKEY_H
diff --git a/libs/gtkmm2/gtk/gtkmm/accellabel.cc b/libs/gtkmm2/gtk/gtkmm/accellabel.cc
new file mode 100644
index 0000000000..d62bc75418
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/accellabel.cc
@@ -0,0 +1,188 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/accellabel.h>
+#include <gtkmm/private/accellabel_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* 
+ *
+ * Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtk/gtkaccellabel.h>
+#include <glibmm/wrap.h>
+
+namespace Gtk
+{
+
+AccelLabel::AccelLabel(const Glib::ustring& label, bool mnemonic)
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Label(Glib::ConstructParams(accellabel_class_.init(), (char*) 0))
+{
+  if(mnemonic)
+    set_text_with_mnemonic(label);
+  else
+    set_text(label);
+}
+
+void AccelLabel::unset_accel_widget()
+{
+  //Not documented, at the moment, but this is what the source does:
+  gtk_accel_label_set_accel_widget(gobj(), 0);
+}
+
+} // namespace Gtk
+
+
+namespace
+{
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Gtk::AccelLabel* wrap(GtkAccelLabel* object, bool take_copy)
+{
+  return dynamic_cast<Gtk::AccelLabel *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& AccelLabel_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &AccelLabel_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_accel_label_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void AccelLabel_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+}
+
+
+Glib::ObjectBase* AccelLabel_Class::wrap_new(GObject* o)
+{
+  return manage(new AccelLabel((GtkAccelLabel*)(o)));
+
+}
+
+
+/* The implementation: */
+
+AccelLabel::AccelLabel(const Glib::ConstructParams& construct_params)
+:
+  Gtk::Label(construct_params)
+{
+  }
+
+AccelLabel::AccelLabel(GtkAccelLabel* castitem)
+:
+  Gtk::Label((GtkLabel*)(castitem))
+{
+  }
+
+AccelLabel::~AccelLabel()
+{
+  destroy_();
+}
+
+AccelLabel::CppClassType AccelLabel::accellabel_class_; // initialize static member
+
+GType AccelLabel::get_type()
+{
+  return accellabel_class_.init().get_type();
+}
+
+GType AccelLabel::get_base_type()
+{
+  return gtk_accel_label_get_type();
+}
+
+
+AccelLabel::AccelLabel()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Label(Glib::ConstructParams(accellabel_class_.init()))
+{
+  }
+
+void AccelLabel::set_accel_widget(const Widget& accel_widget)
+{
+  gtk_accel_label_set_accel_widget(gobj(), const_cast<GtkWidget*>((accel_widget).gobj()));
+}
+
+Widget* AccelLabel::get_accel_widget()
+{
+  return Glib::wrap(gtk_accel_label_get_accel_widget(gobj()));
+}
+
+const Widget* AccelLabel::get_accel_widget() const
+{
+  return Glib::wrap(gtk_accel_label_get_accel_widget(const_cast<GtkAccelLabel*>(gobj())));
+}
+
+guint AccelLabel::get_accel_width() const
+{
+  return gtk_accel_label_get_accel_width(const_cast<GtkAccelLabel*>(gobj()));
+}
+
+bool AccelLabel::refetch()
+{
+  return gtk_accel_label_refetch(gobj());
+}
+
+
+Glib::PropertyProxy<Gtk::Widget*> AccelLabel::property_accel_widget() 
+{
+  return Glib::PropertyProxy<Gtk::Widget*>(this, "accel-widget");
+}
+
+Glib::PropertyProxy_ReadOnly<Gtk::Widget*> AccelLabel::property_accel_widget() const
+{
+  return Glib::PropertyProxy_ReadOnly<Gtk::Widget*>(this, "accel-widget");
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/accellabel.h b/libs/gtkmm2/gtk/gtkmm/accellabel.h
new file mode 100644
index 0000000000..a4d6a32645
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/accellabel.h
@@ -0,0 +1,182 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_ACCELLABEL_H
+#define _GTKMM_ACCELLABEL_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* accellabel.h
+ * 
+ * Copyright (C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/label.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkAccelLabel GtkAccelLabel;
+typedef struct _GtkAccelLabelClass GtkAccelLabelClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class AccelLabel_Class; } // namespace Gtk
+namespace Gtk
+{
+
+/** A label which displays an accelerator key on the right of the text.
+ * Used for menu item labels, for instance.
+ *
+ * @ingroup Widgets
+ */
+
+class AccelLabel : public Label
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef AccelLabel CppObjectType;
+  typedef AccelLabel_Class CppClassType;
+  typedef GtkAccelLabel BaseObjectType;
+  typedef GtkAccelLabelClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~AccelLabel();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class AccelLabel_Class;
+  static CppClassType accellabel_class_;
+
+  // noncopyable
+  AccelLabel(const AccelLabel&);
+  AccelLabel& operator=(const AccelLabel&);
+
+protected:
+  explicit AccelLabel(const Glib::ConstructParams& construct_params);
+  explicit AccelLabel(GtkAccelLabel* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GtkAccelLabel*       gobj()       { return reinterpret_cast<GtkAccelLabel*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GtkAccelLabel* gobj() const { return reinterpret_cast<GtkAccelLabel*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+private:
+
+  
+public:
+
+  //The default ctor doesn't correspond to any _new function, but gtkmenuitem.cc does a simple g_object_new() with no properties.
+  /** Default constructor to create an AccelLabel object
+   */
+  AccelLabel();
+
+  /** Constructor to create an AccelLabel object with a default label
+   * @param label The label string.
+   * @param mnemonic If true, characters preceded by an underscore (_) will be underlined and used as a keyboard accelerator.
+   */
+  explicit AccelLabel(const Glib::ustring& label, bool mnemonic = false);
+
+  
+  /** Sets the widget to be monitored by this accelerator label.
+   * @param accel_widget The widget to be monitored.
+   */
+  void set_accel_widget(const Widget& accel_widget);
+  /// Forget the accel widget previously set by set_accel_widget().
+  void unset_accel_widget();
+
+  
+  /** Fetches the widget monitored by this accelerator label. See
+   * set_accel_widget().
+   * @return The object monitored by the accelerator label,
+   * or <tt>0</tt>.
+   */
+  Widget* get_accel_widget();
+  
+  /** Fetches the widget monitored by this accelerator label. See
+   * set_accel_widget().
+   * @return The object monitored by the accelerator label,
+   * or <tt>0</tt>.
+   */
+  const Widget* get_accel_widget() const;
+
+  
+  /** Gets the width needed to display this accelerator label. This is used by menus to align all of the Gtk::MenuItem widgets, and shouldn't be needed by applications.
+   * @return Width of this accelerator label.
+   */
+  guint get_accel_width() const;
+  
+  /** Recreates the string representing the accelerator keys.
+   * @return Always returns <tt>false</tt>.
+   */
+  bool refetch();
+
+  //_WRAP_PROPERTY("accel-closure", Glib::Object) //GClosure
+  /** The widget to be monitored for accelerator changes.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Gtk::Widget*> property_accel_widget() ;
+
+/** The widget to be monitored for accelerator changes.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Gtk::Widget*> property_accel_widget() const;
+
+
+};
+
+} /* namespace Gtk */
+
+
+namespace Glib
+{
+  /** @relates Gtk::AccelLabel
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gtk::AccelLabel* wrap(GtkAccelLabel* object, bool take_copy = false);
+}
+#endif /* _GTKMM_ACCELLABEL_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/accelmap.cc b/libs/gtkmm2/gtk/gtkmm/accelmap.cc
new file mode 100644
index 0000000000..1d87a7cd64
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/accelmap.cc
@@ -0,0 +1,70 @@
+// -*- c++ -*-
+/* $Id$ */
+
+/* Copyright (C) 2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/accelmap.h>
+#include <gtk/gtkaccelmap.h>
+
+namespace Gtk
+{
+
+namespace AccelMap
+{
+
+void add_entry(const std::string& accel_path, 
+               guint accel_key, 
+               Gdk::ModifierType accel_mods)
+{
+    gtk_accel_map_add_entry(accel_path.c_str(), accel_key,
+                            (GdkModifierType)accel_mods);
+}
+
+bool change_entry(const std::string& accel_path, 
+                  guint accel_key, 
+                  Gdk::ModifierType accel_mods,
+                  bool replace)
+{
+    return gtk_accel_map_change_entry(accel_path.c_str(), accel_key,
+                                      (GdkModifierType)accel_mods, replace);
+}
+
+void load(const std::string& filename)
+{
+  gtk_accel_map_load(filename.c_str());
+}
+
+void save(const std::string& filename)
+{
+  gtk_accel_map_save(filename.c_str());
+}
+
+void lock_path(const std::string& accel_path)
+{
+  gtk_accel_map_lock_path(accel_path.c_str());
+}
+
+void unlock_path(const std::string& accel_path)
+{
+  gtk_accel_map_unlock_path(accel_path.c_str());
+}
+
+} // namespace AccelMap
+
+} // namespace Gtk
+
diff --git a/libs/gtkmm2/gtk/gtkmm/accelmap.h b/libs/gtkmm2/gtk/gtkmm/accelmap.h
new file mode 100644
index 0000000000..00dd8b9a1f
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/accelmap.h
@@ -0,0 +1,129 @@
+// -*- c++ -*-
+#ifndef _GTKMM_ACCELMAP_H
+#define _GTKMM_ACCELMAP_H
+
+/* $Id$ */
+
+/* accelmap.h
+ *
+ * Copyright (C) 2002 The Gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <string>
+
+#include <gdkmm/types.h>
+
+namespace Gtk
+{
+
+namespace AccelMap
+{
+
+//TODO: Why is the accel_path a std::string, instead of a Glib::ustring? murrayc.
+
+/** Registers a new accelerator with the global accelerator map.
+ * This function should only be called once per accel_path
+ * with the canonical accel_key and accel_mods for this path.
+ * To change the accelerator during runtime programatically, use
+ * change_entry().
+ * The accelerator path must consist of "&lt;WINDOWTYPE&gt;/Category1/Category2/.../Action",
+ * where &lt;WINDOWTYPE&gt; should be a unique application-specific identifier, that
+ * corresponds to the kind of window the accelerator is being used in, e.g. "Gimp-Image",
+ * "Abiword-Document" or "Gnumeric-Settings".
+ * The Category1/.../Action portion is most appropriately chosen by the action the
+ * accelerator triggers, i.e. for accelerators on menu items, choose the item's menu path,
+ * e.g. "File/Save As", "Image/View/Zoom" or "Edit/Select All".
+ * So a full valid accelerator path may look like:
+ * "&lt;Gimp-Toolbox&gt;/File/Dialogs/Tool Options...".
+ *
+ * @param accel_path valid accelerator path
+ * @param accel_key the accelerator key
+ * @param accel_mods the accelerator modifiers
+ *
+ */
+void add_entry(const std::string& accel_path, 
+               guint accel_key, 
+               Gdk::ModifierType accel_mods);
+
+/** Changes the accel_key and accel_mods currently associated with accel_path.
+ * Due to conflicts with other accelerators, a change may not always be possible,
+ * replace indicates whether other accelerators may be deleted to resolve such
+ * conflicts. A change will only occur if all conflicts could be resolved (which
+ * might not be the case if conflicting accelerators are locked). Successful
+ * changes are indicated by a true return value.
+ *
+ * @param accel_path  a valid accelerator path
+ * @param accel_key   the new accelerator key
+ * @param accel_mods  the new accelerator modifiers
+ * @param replace     true if other accelerators may be deleted upon conflicts
+ * @result     true if the accelerator could be changed, false otherwise
+ */               
+bool change_entry(const std::string& accel_path, 
+                  guint accel_key, 
+                  Gdk::ModifierType accel_mods,
+                  bool replace);
+
+/** Parses a file previously saved with save() for
+ * accelerator specifications, and propagates them accordingly.
+ *
+ * @param filename a file containing accelerator specifications
+ */                  
+void load(const std::string& filename);
+
+/** Saves current accelerator specifications (accelerator path, key
+ * and modifiers) to filename.
+ * The file is written in a format suitable to be read back in by
+ * load().
+ *
+ * @param filename the file to contain accelerator specifications
+ */
+void save(const std::string& filename);
+
+/** Locks the given accelerator path.
+ *
+ * Locking an accelerator path prevents its accelerator from being changed
+ * during runtime. A locked accelerator path can be unlocked by
+ * unlock_path(). Refer to change_entry()
+ * about runtime accelerator changes.
+ *
+ * Note that locking of individual accelerator paths is independent from
+ * locking the #GtkAccelGroup containing them. For runtime accelerator
+ * changes to be possible both the accelerator path and its AccelGroup
+ * have to be unlocked.
+ *
+ * @param accel_path a valid accelerator path
+ *
+ * Since: 2.4
+ **/
+void lock_path(const std::string& accel_path);
+
+/** Unlocks the given accelerator path. Refer to gtk_accel_map_lock_path()
+ * about accelerator path locking.
+ *
+ * @param accel_path a valid accelerator path
+ *
+ * Since: 2.4
+ **/
+void unlock_path(const std::string& accel_path);
+
+} // namespace AccelMap
+
+} // namespace Gtk
+
+
+#endif /* _GTKMM_ACCELMAP_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/action.cc b/libs/gtkmm2/gtk/gtkmm/action.cc
new file mode 100644
index 0000000000..1504ee29c2
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/action.cc
@@ -0,0 +1,639 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/action.h>
+#include <gtkmm/private/action_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* Copyright 2003 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtk/gtkaction.h>
+
+#include <gtkmm/menuitem.h>
+#include <gtkmm/toolitem.h>
+#include <gtkmm/image.h>
+
+namespace Gtk
+{
+
+Action::Action(const Glib::ustring& name, const Gtk::StockID& stock_id, const Glib::ustring& label, const Glib::ustring& tooltip)
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Glib::Object(Glib::ConstructParams(action_class_.init(), "name",name.c_str(),"stock_id",stock_id.get_c_str(),"label",(label.empty() ? 0 : label.c_str()),"tooltip",(tooltip.empty() ? 0 : tooltip.c_str()), (char*) 0))
+{}
+
+Glib::RefPtr<Action> Action::create(const Glib::ustring& name, const Glib::ustring& label, const Glib::ustring& tooltip)
+{
+  return Glib::RefPtr<Action>( new Action(name, Gtk::StockID(), label, tooltip) );
+}
+
+Glib::RefPtr<Action> Action::create(const Glib::ustring& name, const Gtk::StockID& stock_id, const Glib::ustring& label, const Glib::ustring& tooltip)
+{
+  return Glib::RefPtr<Action>( new Action(name, stock_id, label, tooltip) );
+}
+
+
+void Action::set_tooltip(const Glib::ustring& tooltip)
+{
+  property_tooltip() = tooltip;
+}
+  
+
+} // namespace Gtk
+
+
+namespace
+{
+
+const Glib::SignalProxyInfo Action_signal_activate_info =
+{
+  "activate",
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
+};
+
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Glib::RefPtr<Gtk::Action> wrap(GtkAction* object, bool take_copy)
+{
+  return Glib::RefPtr<Gtk::Action>( dynamic_cast<Gtk::Action*> (Glib::wrap_auto ((GObject*)(object), take_copy)) );
+  //We use dynamic_cast<> in case of multiple inheritance.
+}
+
+} /* namespace Glib */
+
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& Action_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &Action_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_action_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void Action_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+  klass->create_menu_item = &create_menu_item_vfunc_callback;
+  klass->create_tool_item = &create_tool_item_vfunc_callback;
+  klass->connect_proxy = &connect_proxy_vfunc_callback;
+  klass->disconnect_proxy = &disconnect_proxy_vfunc_callback;
+  klass->activate = &activate_callback;
+}
+
+GtkWidget* Action_Class::create_menu_item_vfunc_callback(GtkAction* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return (GtkWidget*)Glib::unwrap(obj->create_menu_item_vfunc());
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->create_menu_item)
+      return (*base->create_menu_item)(self);
+  }
+
+  typedef GtkWidget* RType;
+  return RType();
+}
+
+GtkWidget* Action_Class::create_tool_item_vfunc_callback(GtkAction* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return (GtkWidget*)Glib::unwrap(obj->create_tool_item_vfunc());
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->create_tool_item)
+      return (*base->create_tool_item)(self);
+  }
+
+  typedef GtkWidget* RType;
+  return RType();
+}
+
+void Action_Class::connect_proxy_vfunc_callback(GtkAction* self, GtkWidget* proxy)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->connect_proxy_vfunc(Glib::wrap(proxy)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->connect_proxy)
+      (*base->connect_proxy)(self, proxy);
+  }
+}
+
+void Action_Class::disconnect_proxy_vfunc_callback(GtkAction* self, GtkWidget* proxy)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->disconnect_proxy_vfunc(Glib::wrap(proxy)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->disconnect_proxy)
+      (*base->disconnect_proxy)(self, proxy);
+  }
+}
+
+
+void Action_Class::activate_callback(GtkAction* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_activate();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->activate)
+      (*base->activate)(self);
+  }
+}
+
+
+Glib::ObjectBase* Action_Class::wrap_new(GObject* object)
+{
+  return new Action((GtkAction*)object);
+}
+
+
+/* The implementation: */
+
+GtkAction* Action::gobj_copy()
+{
+  reference();
+  return gobj();
+}
+
+Action::Action(const Glib::ConstructParams& construct_params)
+:
+  Glib::Object(construct_params)
+{}
+
+Action::Action(GtkAction* castitem)
+:
+  Glib::Object((GObject*)(castitem))
+{}
+
+Action::~Action()
+{}
+
+
+Action::CppClassType Action::action_class_; // initialize static member
+
+GType Action::get_type()
+{
+  return action_class_.init().get_type();
+}
+
+GType Action::get_base_type()
+{
+  return gtk_action_get_type();
+}
+
+
+Action::Action()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Glib::Object(Glib::ConstructParams(action_class_.init()))
+{
+  }
+
+Glib::RefPtr<Action> Action::create()
+{
+  return Glib::RefPtr<Action>( new Action() );
+}
+Glib::ustring Action::get_name() const
+{
+  return Glib::convert_const_gchar_ptr_to_ustring(gtk_action_get_name(const_cast<GtkAction*>(gobj())));
+}
+
+bool Action::is_sensitive() const
+{
+  return gtk_action_is_sensitive(const_cast<GtkAction*>(gobj()));
+}
+
+bool Action::get_sensitive() const
+{
+  return gtk_action_get_sensitive(const_cast<GtkAction*>(gobj()));
+}
+
+void Action::set_sensitive(bool sensitive)
+{
+  gtk_action_set_sensitive(gobj(), static_cast<int>(sensitive));
+}
+
+bool Action::is_visible() const
+{
+  return gtk_action_is_visible(const_cast<GtkAction*>(gobj()));
+}
+
+bool Action::get_visible() const
+{
+  return gtk_action_get_visible(const_cast<GtkAction*>(gobj()));
+}
+
+void Action::set_visible(bool visible)
+{
+  gtk_action_set_visible(gobj(), static_cast<int>(visible));
+}
+
+void Action::activate()
+{
+  gtk_action_activate(gobj());
+}
+
+Image* Action::create_icon(IconSize icon_size)
+{
+  return Glib::wrap((GtkImage*)(gtk_action_create_icon(gobj(), static_cast<GtkIconSize>(int(icon_size)))));
+}
+
+MenuItem* Action::create_menu_item()
+{
+  return Glib::wrap((GtkMenuItem*)(gtk_action_create_menu_item(gobj())));
+}
+
+ToolItem* Action::create_tool_item()
+{
+  return Glib::wrap((GtkToolItem*)(gtk_action_create_tool_item(gobj())));
+}
+
+void Action::connect_proxy(Widget& proxy)
+{
+  gtk_action_connect_proxy(gobj(), (proxy).gobj());
+}
+
+void Action::disconnect_proxy(Widget& proxy)
+{
+  gtk_action_disconnect_proxy(gobj(), (proxy).gobj());
+}
+
+Glib::SListHandle<Widget*> Action::get_proxies()
+{
+  return Glib::SListHandle<Widget*>(gtk_action_get_proxies(gobj()), Glib::OWNERSHIP_SHALLOW);
+}
+
+Glib::SListHandle<const Widget*> Action::get_proxies() const
+{
+  return Glib::SListHandle<const Widget*>(gtk_action_get_proxies(const_cast<GtkAction*>(gobj())), Glib::OWNERSHIP_SHALLOW);
+}
+
+void Action::connect_accelerator()
+{
+  gtk_action_connect_accelerator(gobj());
+}
+
+void Action::disconnect_accelerator()
+{
+  gtk_action_disconnect_accelerator(gobj());
+}
+
+Glib::ustring Action::get_accel_path() const
+{
+  return Glib::convert_const_gchar_ptr_to_ustring(gtk_action_get_accel_path(const_cast<GtkAction*>(gobj())));
+}
+
+void Action::set_accel_path(const Glib::ustring& accel_path)
+{
+  gtk_action_set_accel_path(gobj(), accel_path.c_str());
+}
+
+void Action::set_accel_group(const Glib::RefPtr<AccelGroup>& accel_group)
+{
+  gtk_action_set_accel_group(gobj(), Glib::unwrap(accel_group));
+}
+
+void Action::block_activate_from(Widget& proxy)
+{
+  gtk_action_block_activate_from(gobj(), (proxy).gobj());
+}
+
+void Action::unblock_activate_from(Widget& proxy)
+{
+  gtk_action_unblock_activate_from(gobj(), (proxy).gobj());
+}
+
+
+Glib::SignalProxy0< void > Action::signal_activate()
+{
+  return Glib::SignalProxy0< void >(this, &Action_signal_activate_info);
+}
+
+
+Glib::PropertyProxy_ReadOnly<Glib::ustring> Action::property_name() const
+{
+  return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "name");
+}
+
+Glib::PropertyProxy<Glib::ustring> Action::property_label() 
+{
+  return Glib::PropertyProxy<Glib::ustring>(this, "label");
+}
+
+Glib::PropertyProxy_ReadOnly<Glib::ustring> Action::property_label() const
+{
+  return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "label");
+}
+
+Glib::PropertyProxy<Glib::ustring> Action::property_short_label() 
+{
+  return Glib::PropertyProxy<Glib::ustring>(this, "short-label");
+}
+
+Glib::PropertyProxy_ReadOnly<Glib::ustring> Action::property_short_label() const
+{
+  return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "short-label");
+}
+
+Glib::PropertyProxy<Glib::ustring> Action::property_tooltip() 
+{
+  return Glib::PropertyProxy<Glib::ustring>(this, "tooltip");
+}
+
+Glib::PropertyProxy_ReadOnly<Glib::ustring> Action::property_tooltip() const
+{
+  return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "tooltip");
+}
+
+Glib::PropertyProxy<StockID> Action::property_stock_id() 
+{
+  return Glib::PropertyProxy<StockID>(this, "stock-id");
+}
+
+Glib::PropertyProxy_ReadOnly<StockID> Action::property_stock_id() const
+{
+  return Glib::PropertyProxy_ReadOnly<StockID>(this, "stock-id");
+}
+
+Glib::PropertyProxy<bool> Action::property_visible_horizontal() 
+{
+  return Glib::PropertyProxy<bool>(this, "visible-horizontal");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> Action::property_visible_horizontal() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "visible-horizontal");
+}
+
+Glib::PropertyProxy<bool> Action::property_visible_vertical() 
+{
+  return Glib::PropertyProxy<bool>(this, "visible-vertical");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> Action::property_visible_vertical() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "visible-vertical");
+}
+
+Glib::PropertyProxy<bool> Action::property_is_important() 
+{
+  return Glib::PropertyProxy<bool>(this, "is-important");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> Action::property_is_important() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "is-important");
+}
+
+Glib::PropertyProxy<bool> Action::property_hide_if_empty() 
+{
+  return Glib::PropertyProxy<bool>(this, "hide-if-empty");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> Action::property_hide_if_empty() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "hide-if-empty");
+}
+
+Glib::PropertyProxy<bool> Action::property_sensitive() 
+{
+  return Glib::PropertyProxy<bool>(this, "sensitive");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> Action::property_sensitive() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "sensitive");
+}
+
+Glib::PropertyProxy<bool> Action::property_visible() 
+{
+  return Glib::PropertyProxy<bool>(this, "visible");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> Action::property_visible() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "visible");
+}
+
+
+void Gtk::Action::on_activate()
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->activate)
+    (*base->activate)(gobj());
+}
+
+
+Widget* Gtk::Action::create_menu_item_vfunc() 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->create_menu_item)
+    return Glib::wrap((*base->create_menu_item)(gobj()));
+
+  typedef Widget* RType;
+  return RType();
+}
+
+Widget* Gtk::Action::create_tool_item_vfunc() 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->create_tool_item)
+    return Glib::wrap((*base->create_tool_item)(gobj()));
+
+  typedef Widget* RType;
+  return RType();
+}
+
+void Gtk::Action::connect_proxy_vfunc(Widget* proxy) 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->connect_proxy)
+    (*base->connect_proxy)(gobj(),(GtkWidget*)Glib::unwrap(proxy));
+}
+
+void Gtk::Action::disconnect_proxy_vfunc(Widget* proxy) 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->disconnect_proxy)
+    (*base->disconnect_proxy)(gobj(),(GtkWidget*)Glib::unwrap(proxy));
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/action.h b/libs/gtkmm2/gtk/gtkmm/action.h
new file mode 100644
index 0000000000..6c319c769a
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/action.h
@@ -0,0 +1,532 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_ACTION_H
+#define _GTKMM_ACTION_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* Copyright (C) 2003 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/widget.h>
+#include <gtkmm/accelgroup.h>
+#include <gtkmm/stockid.h>
+ 
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkAction GtkAction;
+typedef struct _GtkActionClass GtkActionClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class Action_Class; } // namespace Gtk
+namespace Gtk
+{
+
+class MenuItem;
+class ToolItem;
+class Image;
+
+
+class Action : public Glib::Object
+{
+  
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+public:
+  typedef Action CppObjectType;
+  typedef Action_Class CppClassType;
+  typedef GtkAction BaseObjectType;
+  typedef GtkActionClass BaseClassType;
+
+private:  friend class Action_Class;
+  static CppClassType action_class_;
+
+private:
+  // noncopyable
+  Action(const Action&);
+  Action& operator=(const Action&);
+
+protected:
+  explicit Action(const Glib::ConstructParams& construct_params);
+  explicit Action(GtkAction* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+  virtual ~Action();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GObject.
+  GtkAction*       gobj()       { return reinterpret_cast<GtkAction*>(gobject_); }
+
+  ///Provides access to the underlying C GObject.
+  const GtkAction* gobj() const { return reinterpret_cast<GtkAction*>(gobject_); }
+
+  ///Provides access to the underlying C instance. The caller is responsible for unrefing it. Use when directly setting fields in structs.
+  GtkAction* gobj_copy();
+
+private:
+
+ 
+protected:
+ Action();
+  explicit Action(const Glib::ustring& name, const StockID& stock_id, const Glib::ustring& label = Glib::ustring(), const Glib::ustring& tooltip = Glib::ustring());
+
+public:
+  
+  static Glib::RefPtr<Action> create();
+
+  static Glib::RefPtr<Action> create(const Glib::ustring& name, const Glib::ustring& label =  Glib::ustring(), const Glib::ustring& tooltip =  Glib::ustring());
+  static Glib::RefPtr<Action> create(const Glib::ustring& name, const Gtk::StockID& stock_id, const Glib::ustring& label =  Glib::ustring(), const Glib::ustring& tooltip =  Glib::ustring());
+
+  
+  /** Returns the name of the action.
+   * @return The name of the action. The string belongs to GTK+ and should not
+   * be freed.
+   * 
+   * Since: 2.4.
+   */
+  Glib::ustring get_name() const;
+
+  
+  /** Returns whether the action is effectively sensitive.
+   * @return <tt>true</tt> if the action and its associated action group 
+   * are both sensitive.
+   * 
+   * Since: 2.4.
+   */
+  bool is_sensitive() const;
+  
+  /** Returns whether the action itself is sensitive. Note that this doesn't 
+   * necessarily mean effective sensitivity. See is_sensitive() 
+   * for that.
+   * @return <tt>true</tt> if the action itself is sensitive.
+   * 
+   * Since: 2.4.
+   */
+  bool get_sensitive() const;
+
+   //TODO: Just wrap gtk_action_set_sensitive() when they put it in GTK+.
+   void set_tooltip(const Glib::ustring& tooltip);
+
+  
+  /** Sets the ::sensitive property of the action to @a sensitive . Note that 
+   * this doesn't necessarily mean effective sensitivity. See 
+   * is_sensitive() 
+   * for that.
+   * 
+   * Since: 2.6
+   * @param sensitive <tt>true</tt> to make the action sensitive.
+   */
+  void set_sensitive(bool sensitive = true);
+  
+  
+  /** Returns whether the action is effectively visible.
+   * @return <tt>true</tt> if the action and its associated action group 
+   * are both visible.
+   * 
+   * Since: 2.4.
+   */
+  bool is_visible() const;
+  
+  /** Returns whether the action itself is visible. Note that this doesn't 
+   * necessarily mean effective visibility. See is_sensitive() 
+   * for that.
+   * @return <tt>true</tt> if the action itself is visible.
+   * 
+   * Since: 2.4.
+   */
+  bool get_visible() const;
+  
+  /** Sets the ::visible property of the action to @a visible . Note that 
+   * this doesn't necessarily mean effective visibility. See 
+   * is_visible() 
+   * for that.
+   * 
+   * Since: 2.6
+   * @param visible <tt>true</tt> to make the action visible.
+   */
+  void set_visible(bool visible = true);
+
+  
+  /** Emits the "activate" signal on the specified action, if it isn't 
+   * insensitive. This gets called by the proxy widgets when they get 
+   * activated.
+   * 
+   * It can also be used to manually activate an action.
+   * 
+   * Since: 2.4
+   */
+  void activate();
+  
+  /** This function is intended for use by action implementations to
+   * create icons displayed in the proxy widgets.
+   * @param icon_size The size of the icon that should be created.
+   * @return A widget that displays the icon for this action.
+   * 
+   * Since: 2.4.
+   */
+  Image* create_icon(IconSize icon_size);
+  
+  /** Creates a menu item widget that proxies for the given action.
+   * @return A menu item connected to the action.
+   * 
+   * Since: 2.4.
+   */
+  MenuItem* create_menu_item();
+  
+  /** Creates a toolbar item widget that proxies for the given action.
+   * @return A toolbar item connected to the action.
+   * 
+   * Since: 2.4.
+   */
+  ToolItem* create_tool_item();
+  
+  /** Connects a widget to an action object as a proxy.  Synchronises 
+   * various properties of the action with the widget (such as label 
+   * text, icon, tooltip, etc), and attaches a callback so that the 
+   * action gets activated when the proxy widget does.
+   * 
+   * If the widget is already connected to an action, it is disconnected
+   * first.
+   * 
+   * Since: 2.4
+   * @param proxy The proxy widget.
+   */
+  void connect_proxy(Widget& proxy);
+  
+  /** Disconnects a proxy widget from an action.  
+   * Does <em>not</em> destroy the widget, however.
+   * 
+   * Since: 2.4
+   * @param proxy The proxy widget.
+   */
+  void disconnect_proxy(Widget& proxy);
+  
+  /** Returns the proxy widgets for an action.
+   * @return A G::SList of proxy widgets. The list is owned by the action and
+   * must not be modified.
+   * 
+   * Since: 2.4.
+   */
+  Glib::SListHandle<Widget*> get_proxies();
+  
+  /** Returns the proxy widgets for an action.
+   * @return A G::SList of proxy widgets. The list is owned by the action and
+   * must not be modified.
+   * 
+   * Since: 2.4.
+   */
+  Glib::SListHandle<const Widget*> get_proxies() const;
+  
+  /** Installs the accelerator for @a action  if @a action  has an
+   * accel path and group. See set_accel_path() and 
+   * set_accel_group()
+   * 
+   * Since multiple proxies may independently trigger the installation
+   * of the accelerator, the @a action  counts the number of times this
+   * function has been called and doesn't remove the accelerator until
+   * disconnect_accelerator() has been called as many times.
+   * 
+   * Since: 2.4
+   */
+  void connect_accelerator();
+  
+  /** Undoes the effect of one call to connect_accelerator().
+   * 
+   * Since: 2.4
+   */
+  void disconnect_accelerator();
+  
+  
+  /** Returns the accel path for this action.  
+   * 
+   * Since: 2.6
+   * @return The accel path for this action, or <tt>0</tt>
+   * if none is set. The returned string is owned by GTK+
+   * and must not be freed or modified.
+   */
+  Glib::ustring get_accel_path() const;
+
+  /// For instance, void on_activate();
+  typedef sigc::slot<void> SlotActivate;
+  
+
+  Glib::SignalProxy0< void > signal_activate();
+
+
+  //Used by AccelGroup:
+  
+  /** Sets the accel path for this action.  All proxy widgets associated
+   * with the action will have this accel path, so that their
+   * accelerators are consistent.
+   * 
+   * Since: 2.4
+   * @param accel_path The accelerator path.
+   */
+  void set_accel_path(const Glib::ustring& accel_path);
+  
+  /** Sets the Gtk::AccelGroup in which the accelerator for this action
+   * will be installed.
+   * 
+   * Since: 2.4
+   * @param accel_group A Gtk::AccelGroup or <tt>0</tt>.
+   */
+  void set_accel_group(const Glib::RefPtr<AccelGroup>& accel_group);
+
+  /** A unique name for the action.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Glib::ustring> property_name() const;
+
+
+  /** The label used for menu items and buttons that activate this action.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Glib::ustring> property_label() ;
+
+/** The label used for menu items and buttons that activate this action.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Glib::ustring> property_label() const;
+
+  /** A shorter label that may be used on toolbar buttons.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Glib::ustring> property_short_label() ;
+
+/** A shorter label that may be used on toolbar buttons.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Glib::ustring> property_short_label() const;
+
+  /** A tooltip for this action.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Glib::ustring> property_tooltip() ;
+
+/** A tooltip for this action.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Glib::ustring> property_tooltip() const;
+
+  /** The stock icon displayed in widgets representing this action.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<StockID> property_stock_id() ;
+
+/** The stock icon displayed in widgets representing this action.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<StockID> property_stock_id() const;
+
+  /** Whether the toolbar item is visible when the toolbar is in a horizontal orientation.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_visible_horizontal() ;
+
+/** Whether the toolbar item is visible when the toolbar is in a horizontal orientation.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_visible_horizontal() const;
+
+  /** Whether the toolbar item is visible when the toolbar is in a vertical orientation.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_visible_vertical() ;
+
+/** Whether the toolbar item is visible when the toolbar is in a vertical orientation.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_visible_vertical() const;
+
+  /** Whether the action is considered important. When TRUE
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_is_important() ;
+
+/** Whether the action is considered important. When TRUE
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_is_important() const;
+
+  /** When TRUE
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_hide_if_empty() ;
+
+/** When TRUE
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_hide_if_empty() const;
+
+  /** Whether the action is enabled.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_sensitive() ;
+
+/** Whether the action is enabled.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_sensitive() const;
+
+  /** Whether the action is visible.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_visible() ;
+
+/** Whether the action is visible.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_visible() const;
+
+
+protected:
+  //For use by child actions:  
+  
+  /** Disables calls to the activate()
+   * function by signals on the given proxy widget.  This is used to
+   * break notification loops for things like check or radio actions.
+   * 
+   * This function is intended for use by action implementations.
+   * 
+   * Since: 2.4
+   * @param proxy A proxy widget.
+   */
+  void block_activate_from(Widget& proxy);
+  
+  /** Re-enables calls to the activate()
+   * function by signals on the given proxy widget.  This undoes the
+   * blocking done by block_activate_from().
+   * 
+   * This function is intended for use by action implementations.
+   * 
+   * Since: 2.4
+   * @param proxy A proxy widget.
+   */
+  void unblock_activate_from(Widget& proxy);
+
+
+protected: 
+  //Widget-creation routines:
+    virtual Widget* create_menu_item_vfunc();
+    virtual Widget* create_tool_item_vfunc();
+    virtual void connect_proxy_vfunc(Widget* proxy);
+    virtual void disconnect_proxy_vfunc(Widget* proxy);
+
+
+public:
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+  virtual void on_activate();
+
+
+};
+
+} // namespace Gtk
+
+
+namespace Glib
+{
+  /** @relates Gtk::Action
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Glib::RefPtr<Gtk::Action> wrap(GtkAction* object, bool take_copy = false);
+}
+
+
+#endif /* _GTKMM_ACTION_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/actiongroup.cc b/libs/gtkmm2/gtk/gtkmm/actiongroup.cc
new file mode 100644
index 0000000000..d539b9ab5e
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/actiongroup.cc
@@ -0,0 +1,419 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/actiongroup.h>
+#include <gtkmm/private/actiongroup_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* Copyright 2003 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtk/gtkactiongroup.h>
+#include <gtkmm/accelmap.h>
+
+
+namespace Gtk
+{
+
+void ActionGroup::add(const Glib::RefPtr<Action>& action)
+{
+  gtk_action_group_add_action_with_accel(gobj(), Glib::unwrap(action),
+    0 /* accelerator=0 means use the stock accelerator if this is a stock item */ );
+}
+
+void ActionGroup::add(const Glib::RefPtr<Action>& action, const AccelKey& accel_key)
+{
+  // We need to half-duplicate the gtk_action_group_add_action_with_accel() implementation, because we want to
+  // use AccelKey, not just the accelerator string format that is _one_ of the ways to create an AccelKey. murrayc.
+
+  //The AccelKey might have been constructed from key+mod or from an accelerator string,
+  //but it the end that just produces a key+mod.
+  guint key = accel_key.get_key();
+  Gdk::ModifierType mod = accel_key.get_mod();
+  if(key)
+  {
+    // The AccelKey constructor can take an accel path, so I suppose we should not ignore it,
+    // but I can't imagine how it would be useful with the UIManager. murrayc.
+    Glib::ustring accel_path = accel_key.get_path();
+    if(accel_path.empty())
+    {
+      //Copied from the gtk_action_group_add_action_with_accel() implementation:
+      accel_path =  "<Actions>/" + get_name() + "/" + action->property_name();
+    }
+    
+    AccelMap::add_entry(accel_path, key, mod);
+
+    action->set_accel_path(accel_path);
+  }
+
+  gtk_action_group_add_action(gobj(), action->gobj());
+}
+
+  
+void ActionGroup::add(const Glib::RefPtr<Action>& action, const Action::SlotActivate& slot)
+{
+  //This is meant to be similar to the gtk_action_group_add_actions() convenience method that is used from C.
+  //This also does the work of gtk_action_group_add_toggle_actions() and gtk_action_group_add_radio_actions_full(),
+  //because the extra stuff there is already done when the Action (or a derived type, such as ToggleAction) is create()ed.
+  
+  action->signal_activate().connect(slot);
+  
+  //We probably don't need to use translate_string(), because the label and tooltip will be regular translated strings in our C++ application code.
+  //But C needs it because gtk_action_group_add_actions() takes a static array of GtkActionEntrys  whose fields 
+  //can not be translated with gettext macros.
+  //But we should soon know if menus and toolbars are not translated in non-english locales. murrayc.
+  
+  add(action);
+}
+
+void ActionGroup::add(const Glib::RefPtr<Action>& action, const AccelKey& accel_key, const Action::SlotActivate& slot)
+{
+  //This is meant to be similar to the gtk_action_group_add_actions() convenience method that is used from C.
+  //This also does the work of gtk_action_group_add_toggle_actions() and gtk_action_group_add_radio_actions_full(),
+  //because the extra stuff there is already done when the Action (or a derived type, such as ToggleAction) is create()ed.
+
+  action->signal_activate().connect(slot);
+  add(action, accel_key);
+
+  /*
+  //Create the accel path (a kind of unique key):
+  Glib::ustring accel_path = "<Actions>/" + get_name() + "/" + action->get_name();
+
+  //Register the accel path:
+  Gtk::AccelMap::add_entry(accel_path, accel_key.get_key(), accel_key.get_mod());
+
+  //USe the accel path:
+  action->set_accel_path(accel_path);
+  */
+}  
+
+
+} // namespace Gtk
+
+
+namespace
+{
+
+void ActionGroup_signal_connect_proxy_callback(GtkActionGroup* self, GtkAction* p0,GtkWidget* p1,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,const Glib::RefPtr<Action>&,Widget* > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(Glib::wrap(p0, true)
+, Glib::wrap(p1)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+}
+
+const Glib::SignalProxyInfo ActionGroup_signal_connect_proxy_info =
+{
+  "connect_proxy",
+  (GCallback) &ActionGroup_signal_connect_proxy_callback,
+  (GCallback) &ActionGroup_signal_connect_proxy_callback
+};
+
+
+void ActionGroup_signal_disconnect_proxy_callback(GtkActionGroup* self, GtkAction* p0,GtkWidget* p1,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,const Glib::RefPtr<Action>&,Widget* > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(Glib::wrap(p0, true)
+, Glib::wrap(p1)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+}
+
+const Glib::SignalProxyInfo ActionGroup_signal_disconnect_proxy_info =
+{
+  "disconnect_proxy",
+  (GCallback) &ActionGroup_signal_disconnect_proxy_callback,
+  (GCallback) &ActionGroup_signal_disconnect_proxy_callback
+};
+
+
+void ActionGroup_signal_pre_activate_callback(GtkActionGroup* self, GtkAction* p0,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,const Glib::RefPtr<Action>& > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(Glib::wrap(p0, true)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+}
+
+const Glib::SignalProxyInfo ActionGroup_signal_pre_activate_info =
+{
+  "pre_activate",
+  (GCallback) &ActionGroup_signal_pre_activate_callback,
+  (GCallback) &ActionGroup_signal_pre_activate_callback
+};
+
+
+void ActionGroup_signal_post_activate_callback(GtkActionGroup* self, GtkAction* p0,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,const Glib::RefPtr<Action>& > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(Glib::wrap(p0, true)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+}
+
+const Glib::SignalProxyInfo ActionGroup_signal_post_activate_info =
+{
+  "post_activate",
+  (GCallback) &ActionGroup_signal_post_activate_callback,
+  (GCallback) &ActionGroup_signal_post_activate_callback
+};
+
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Glib::RefPtr<Gtk::ActionGroup> wrap(GtkActionGroup* object, bool take_copy)
+{
+  return Glib::RefPtr<Gtk::ActionGroup>( dynamic_cast<Gtk::ActionGroup*> (Glib::wrap_auto ((GObject*)(object), take_copy)) );
+  //We use dynamic_cast<> in case of multiple inheritance.
+}
+
+} /* namespace Glib */
+
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& ActionGroup_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &ActionGroup_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_action_group_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void ActionGroup_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+}
+
+
+Glib::ObjectBase* ActionGroup_Class::wrap_new(GObject* object)
+{
+  return new ActionGroup((GtkActionGroup*)object);
+}
+
+
+/* The implementation: */
+
+GtkActionGroup* ActionGroup::gobj_copy()
+{
+  reference();
+  return gobj();
+}
+
+ActionGroup::ActionGroup(const Glib::ConstructParams& construct_params)
+:
+  Glib::Object(construct_params)
+{}
+
+ActionGroup::ActionGroup(GtkActionGroup* castitem)
+:
+  Glib::Object((GObject*)(castitem))
+{}
+
+ActionGroup::~ActionGroup()
+{}
+
+
+ActionGroup::CppClassType ActionGroup::actiongroup_class_; // initialize static member
+
+GType ActionGroup::get_type()
+{
+  return actiongroup_class_.init().get_type();
+}
+
+GType ActionGroup::get_base_type()
+{
+  return gtk_action_group_get_type();
+}
+
+
+ActionGroup::ActionGroup(const Glib::ustring& name)
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Glib::Object(Glib::ConstructParams(actiongroup_class_.init(), "name", name.c_str(), (char*) 0))
+{
+  }
+
+Glib::RefPtr<ActionGroup> ActionGroup::create(const Glib::ustring& name)
+{
+  return Glib::RefPtr<ActionGroup>( new ActionGroup(name) );
+}
+Glib::ustring ActionGroup::get_name() const
+{
+  return Glib::convert_const_gchar_ptr_to_ustring(gtk_action_group_get_name(const_cast<GtkActionGroup*>(gobj())));
+}
+
+bool ActionGroup::get_sensitive() const
+{
+  return gtk_action_group_get_sensitive(const_cast<GtkActionGroup*>(gobj()));
+}
+
+void ActionGroup::set_sensitive(bool sensitive)
+{
+  gtk_action_group_set_sensitive(gobj(), static_cast<int>(sensitive));
+}
+
+bool ActionGroup::get_visible() const
+{
+  return gtk_action_group_get_visible(const_cast<GtkActionGroup*>(gobj()));
+}
+
+void ActionGroup::set_visible(bool visible)
+{
+  gtk_action_group_set_visible(gobj(), static_cast<int>(visible));
+}
+
+Glib::RefPtr<Action> ActionGroup::get_action(const Glib::ustring& action_name)
+{
+
+  Glib::RefPtr<Action> retvalue = Glib::wrap(gtk_action_group_get_action(gobj(), action_name.c_str()));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::RefPtr<const Action> ActionGroup::get_action(const Glib::ustring& action_name) const
+{
+
+  Glib::RefPtr<const Action> retvalue = Glib::wrap(gtk_action_group_get_action(const_cast<GtkActionGroup*>(gobj()), action_name.c_str()));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::ListHandle< Glib::RefPtr<Action> > ActionGroup::get_actions()
+{
+  return Glib::ListHandle< Glib::RefPtr<Action> >(gtk_action_group_list_actions(gobj()), Glib::OWNERSHIP_SHALLOW);
+}
+
+Glib::ListHandle< Glib::RefPtr<const Action> > ActionGroup::get_actions() const
+{
+  return Glib::ListHandle< Glib::RefPtr<const Action> >(gtk_action_group_list_actions(const_cast<GtkActionGroup*>(gobj())), Glib::OWNERSHIP_SHALLOW);
+}
+
+void ActionGroup::remove(const Glib::RefPtr<Action>& action)
+{
+  gtk_action_group_remove_action(gobj(), Glib::unwrap(action));
+}
+
+Glib::ustring ActionGroup::translate_string(const Glib::ustring& str) const
+{
+  return Glib::convert_const_gchar_ptr_to_ustring(gtk_action_group_translate_string(const_cast<GtkActionGroup*>(gobj()), str.c_str()));
+}
+
+
+Glib::SignalProxy2< void,const Glib::RefPtr<Action>&,Widget* > ActionGroup::signal_connect_proxy()
+{
+  return Glib::SignalProxy2< void,const Glib::RefPtr<Action>&,Widget* >(this, &ActionGroup_signal_connect_proxy_info);
+}
+
+Glib::SignalProxy2< void,const Glib::RefPtr<Action>&,Widget* > ActionGroup::signal_disconnect_proxy()
+{
+  return Glib::SignalProxy2< void,const Glib::RefPtr<Action>&,Widget* >(this, &ActionGroup_signal_disconnect_proxy_info);
+}
+
+Glib::SignalProxy1< void,const Glib::RefPtr<Action>& > ActionGroup::signal_pre_activate()
+{
+  return Glib::SignalProxy1< void,const Glib::RefPtr<Action>& >(this, &ActionGroup_signal_pre_activate_info);
+}
+
+Glib::SignalProxy1< void,const Glib::RefPtr<Action>& > ActionGroup::signal_post_activate()
+{
+  return Glib::SignalProxy1< void,const Glib::RefPtr<Action>& >(this, &ActionGroup_signal_post_activate_info);
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/actiongroup.h b/libs/gtkmm2/gtk/gtkmm/actiongroup.h
new file mode 100644
index 0000000000..8db2b42e80
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/actiongroup.h
@@ -0,0 +1,250 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_ACTIONGROUP_H
+#define _GTKMM_ACTIONGROUP_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* Copyright (C) 2003 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/widget.h>
+#include <gtkmm/action.h>
+#include <gtkmm/accelkey.h>
+ 
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkActionGroup GtkActionGroup;
+typedef struct _GtkActionGroupClass GtkActionGroupClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class ActionGroup_Class; } // namespace Gtk
+namespace Gtk
+{
+  
+
+class ActionGroup : public Glib::Object
+{
+  
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+public:
+  typedef ActionGroup CppObjectType;
+  typedef ActionGroup_Class CppClassType;
+  typedef GtkActionGroup BaseObjectType;
+  typedef GtkActionGroupClass BaseClassType;
+
+private:  friend class ActionGroup_Class;
+  static CppClassType actiongroup_class_;
+
+private:
+  // noncopyable
+  ActionGroup(const ActionGroup&);
+  ActionGroup& operator=(const ActionGroup&);
+
+protected:
+  explicit ActionGroup(const Glib::ConstructParams& construct_params);
+  explicit ActionGroup(GtkActionGroup* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+  virtual ~ActionGroup();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GObject.
+  GtkActionGroup*       gobj()       { return reinterpret_cast<GtkActionGroup*>(gobject_); }
+
+  ///Provides access to the underlying C GObject.
+  const GtkActionGroup* gobj() const { return reinterpret_cast<GtkActionGroup*>(gobject_); }
+
+  ///Provides access to the underlying C instance. The caller is responsible for unrefing it. Use when directly setting fields in structs.
+  GtkActionGroup* gobj_copy();
+
+private:
+
+
+protected:
+  explicit ActionGroup(const Glib::ustring& name = Glib::ustring());
+
+public:
+  
+  static Glib::RefPtr<ActionGroup> create(const Glib::ustring& name =  Glib::ustring());
+
+  
+  /** Gets the name of the action group.
+   * @return The name of the action group.
+   * 
+   * Since: 2.4.
+   */
+  Glib::ustring get_name() const;
+
+  
+  /** Returns <tt>true</tt> if the group is sensitive.  The constituent actions
+   * can only be logically sensitive (see is_sensitive()) if
+   * they are sensitive (see get_sensitive()) and their group
+   * is sensitive.
+   * @return <tt>true</tt> if the group is sensitive.
+   * 
+   * Since: 2.4.
+   */
+  bool get_sensitive() const;
+  
+  /** Changes the sensitivity of @a action_group 
+   * 
+   * Since: 2.4
+   * @param sensitive New sensitivity.
+   */
+  void set_sensitive(bool sensitive = true);
+  
+  /** Returns <tt>true</tt> if the group is visible.  The constituent actions
+   * can only be logically visible (see is_visible()) if
+   * they are visible (see get_visible()) and their group
+   * is visible.
+   * @return <tt>true</tt> if the group is visible.
+   * 
+   * Since: 2.4.
+   */
+  bool get_visible() const;
+  
+  /** Changes the visible of @a action_group .
+   * 
+   * Since: 2.4
+   * @param visible New visiblity.
+   */
+  void set_visible(bool visible = true);
+                                      
+  
+  /** Looks up an action in the action group by name.
+   * @param action_name The name of the action.
+   * @return The action, or <tt>0</tt> if no action by that name exists
+   * 
+   * Since: 2.4.
+   */
+  Glib::RefPtr<Action> get_action(const Glib::ustring& action_name);
+  
+  /** Looks up an action in the action group by name.
+   * @param action_name The name of the action.
+   * @return The action, or <tt>0</tt> if no action by that name exists
+   * 
+   * Since: 2.4.
+   */
+  Glib::RefPtr<const Action> get_action(const Glib::ustring& action_name) const;
+
+  
+  /** Lists the actions in the action group.
+   * @return An allocated list of the action objects in the action group
+   * 
+   * Since: 2.4.
+   */
+  Glib::ListHandle< Glib::RefPtr<Action> > get_actions();
+  
+  /** Lists the actions in the action group.
+   * @return An allocated list of the action objects in the action group
+   * 
+   * Since: 2.4.
+   */
+  Glib::ListHandle< Glib::RefPtr<const Action> > get_actions() const;
+    
+  void add(const Glib::RefPtr<Action>& action);
+  
+  //We want it to always try to use the stock accelerator,
+  //so we use gtk_action_group_add_action_with_accel(), instead of gtk_action_group_add_action(),
+  //passing null for the accelerator.
+
+  void add(const Glib::RefPtr<Action>& action, const AccelKey& accel_key);
+  
+  //We need to duplicate the gtk_action_group_add_action_with_accel() implementation, because we want to
+  //use AccelKey, not just the accelerator string format that is _one_ of the ways to create an AccelKey.
+   
+  //TODO: Could this whole class have an STL-style interface?
+  void add(const Glib::RefPtr<Action>& action, const Action::SlotActivate& slot);
+  void add(const Glib::RefPtr<Action>& action, const AccelKey& accel_key, const Action::SlotActivate& slot);
+  
+  /** Removes an action object from the action group.
+   * 
+   * Since: 2.4
+   * @param action An action.
+   */
+  void remove(const Glib::RefPtr<Action>& action);
+  
+   //TODO: We probably need to use this in our add_actions() implementation:
+  
+  /** Translates a string using the specified translate_func(). This
+   * is mainly intended for language bindings.
+   * @param string A string.
+   * @return The translation of @a string 
+   * 
+   * Since: 2.6.
+   */
+  Glib::ustring translate_string(const Glib::ustring& str) const;
+  
+
+  //These are just C convenience methods:
+  
+  //These are also just C convenience methods that are useless unless you are using the other convenience methods:
+  
+
+  Glib::SignalProxy2< void,const Glib::RefPtr<Action>&,Widget* > signal_connect_proxy();
+
+  
+  Glib::SignalProxy2< void,const Glib::RefPtr<Action>&,Widget* > signal_disconnect_proxy();
+             
+  
+  Glib::SignalProxy1< void,const Glib::RefPtr<Action>& > signal_pre_activate();
+ 
+  
+  Glib::SignalProxy1< void,const Glib::RefPtr<Action>& > signal_post_activate();
+ 
+
+public:
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+};
+
+} // namespace Gtk
+
+
+namespace Glib
+{
+  /** @relates Gtk::ActionGroup
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Glib::RefPtr<Gtk::ActionGroup> wrap(GtkActionGroup* object, bool take_copy = false);
+}
+
+
+#endif /* _GTKMM_ACTIONGROUP_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/adjustment.cc b/libs/gtkmm2/gtk/gtkmm/adjustment.cc
new file mode 100644
index 0000000000..10b2e8815f
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/adjustment.cc
@@ -0,0 +1,343 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/adjustment.h>
+#include <gtkmm/private/adjustment_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* 
+ *
+ * Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+#include <gtk/gtkadjustment.h>
+
+namespace Gtk
+{
+
+Adjustment::Adjustment(double value,
+      	               double lower, double upper,
+      	               double step_increment, double page_increment,
+      	               double page_size)
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Object(Glib::ConstructParams(adjustment_class_.init(), (char*) 0))
+{
+  gobj()->lower = lower;
+  gobj()->upper = upper;
+  gobj()->step_increment = step_increment;
+  gobj()->page_increment = page_increment;
+  gobj()->page_size = page_size;
+  changed();
+
+  set_value(value);
+}
+
+void Adjustment::set_lower(double lower)
+{
+  gobj()->lower = lower;
+  changed();
+}
+
+void Adjustment::set_upper(double upper)
+{
+  gobj()->upper = upper;
+  changed();
+}
+
+void Adjustment::set_step_increment(double incr)
+{
+  gobj()->step_increment = incr;
+  changed();
+}
+
+void Adjustment::set_page_increment(double incr)
+{
+  gobj()->page_increment = incr;
+  changed();
+}
+
+void Adjustment::set_page_size(double size)
+{
+  gobj()->page_size = size;
+  changed();
+}
+
+} // namespace Gtk
+
+
+namespace
+{
+
+const Glib::SignalProxyInfo Adjustment_signal_changed_info =
+{
+  "changed",
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
+};
+
+
+const Glib::SignalProxyInfo Adjustment_signal_value_changed_info =
+{
+  "value_changed",
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
+};
+
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Gtk::Adjustment* wrap(GtkAdjustment* object, bool take_copy)
+{
+  return dynamic_cast<Gtk::Adjustment *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& Adjustment_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &Adjustment_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_adjustment_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void Adjustment_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+  klass->changed = &changed_callback;
+  klass->value_changed = &value_changed_callback;
+}
+
+
+void Adjustment_Class::changed_callback(GtkAdjustment* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_changed();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->changed)
+      (*base->changed)(self);
+  }
+}
+
+void Adjustment_Class::value_changed_callback(GtkAdjustment* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_value_changed();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->value_changed)
+      (*base->value_changed)(self);
+  }
+}
+
+
+Glib::ObjectBase* Adjustment_Class::wrap_new(GObject* o)
+{
+  return manage(new Adjustment((GtkAdjustment*)(o)));
+
+}
+
+
+/* The implementation: */
+
+Adjustment::Adjustment(const Glib::ConstructParams& construct_params)
+:
+  Gtk::Object(construct_params)
+{
+  }
+
+Adjustment::Adjustment(GtkAdjustment* castitem)
+:
+  Gtk::Object((GtkObject*)(castitem))
+{
+  }
+
+Adjustment::~Adjustment()
+{
+  destroy_();
+}
+
+Adjustment::CppClassType Adjustment::adjustment_class_; // initialize static member
+
+GType Adjustment::get_type()
+{
+  return adjustment_class_.init().get_type();
+}
+
+GType Adjustment::get_base_type()
+{
+  return gtk_adjustment_get_type();
+}
+
+
+void Adjustment::changed()
+{
+  gtk_adjustment_changed(gobj());
+}
+
+void Adjustment::value_changed()
+{
+  gtk_adjustment_value_changed(gobj());
+}
+
+void Adjustment::clamp_page(double lower, double upper)
+{
+  gtk_adjustment_clamp_page(gobj(), lower, upper);
+}
+
+void Adjustment::set_value(double value)
+{
+  gtk_adjustment_set_value(gobj(), value);
+}
+
+double Adjustment::get_value() const
+{
+  return gtk_adjustment_get_value(const_cast<GtkAdjustment*>(gobj()));
+}
+
+double Adjustment::get_lower() const
+{
+  return gobj()->lower;
+}
+
+double Adjustment::get_upper() const
+{
+  return gobj()->upper;
+}
+
+double Adjustment::get_step_increment() const
+{
+  return gobj()->step_increment;
+}
+
+double Adjustment::get_page_increment() const
+{
+  return gobj()->page_increment;
+}
+
+double Adjustment::get_page_size() const
+{
+  return gobj()->page_size;
+}
+
+
+Glib::SignalProxy0< void > Adjustment::signal_changed()
+{
+  return Glib::SignalProxy0< void >(this, &Adjustment_signal_changed_info);
+}
+
+Glib::SignalProxy0< void > Adjustment::signal_value_changed()
+{
+  return Glib::SignalProxy0< void >(this, &Adjustment_signal_value_changed_info);
+}
+
+
+void Gtk::Adjustment::on_changed()
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->changed)
+    (*base->changed)(gobj());
+}
+
+void Gtk::Adjustment::on_value_changed()
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->value_changed)
+    (*base->value_changed)(gobj());
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/adjustment.h b/libs/gtkmm2/gtk/gtkmm/adjustment.h
new file mode 100644
index 0000000000..2c45297cb4
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/adjustment.h
@@ -0,0 +1,236 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_ADJUSTMENT_H
+#define _GTKMM_ADJUSTMENT_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* adjustment.h
+ * 
+ * Copyright (C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/object.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkAdjustment GtkAdjustment;
+typedef struct _GtkAdjustmentClass GtkAdjustmentClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class Adjustment_Class; } // namespace Gtk
+namespace Gtk
+{
+
+/** A class representing an adjustable bounded value.
+ *
+ * The Gtk::Adjustment object represents a value which has an associated
+ * lower and upper bound, together with step and page increments, and a page
+ * size.  It is used within several gtkmm widgets, including
+ * Gtk::SpinButton, Gtk::Viewport, and Gtk::Range (which is a base class for
+ * Gtk::HScrollbar, Gtk::VScrollbar, Gtk::HScale, and Gtk::VScale).
+ *
+ * The Gtk::Adjustment object does not update the value itself. Instead it
+ * is left up to the owner of the Gtk::Adjustment to control the value.
+ *
+ * The owner of the Gtk::Adjustment typically calls the value_changed() and
+ * changed() functions after changing the value and its bounds. This results
+ * in the emission of the "value_changed" or "changed" signal respectively. 
+ *
+ */
+
+class Adjustment : public Object
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Adjustment CppObjectType;
+  typedef Adjustment_Class CppClassType;
+  typedef GtkAdjustment BaseObjectType;
+  typedef GtkAdjustmentClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~Adjustment();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class Adjustment_Class;
+  static CppClassType adjustment_class_;
+
+  // noncopyable
+  Adjustment(const Adjustment&);
+  Adjustment& operator=(const Adjustment&);
+
+protected:
+  explicit Adjustment(const Glib::ConstructParams& construct_params);
+  explicit Adjustment(GtkAdjustment* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GtkAdjustment*       gobj()       { return reinterpret_cast<GtkAdjustment*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GtkAdjustment* gobj() const { return reinterpret_cast<GtkAdjustment*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+  virtual void on_changed();
+  virtual void on_value_changed();
+
+
+private:
+
+public:
+
+  friend class Range;
+  friend class HScrollbar;
+  friend class VScrollbar;
+
+  /** Constructor to create an Adjustment object.
+   * @param value The initial value
+   * @param lower The minimum value
+   * @param upper The maximum value
+   * @param step_increment The step increment
+   * @param page_increment The page increment
+   * @param page_size The page size
+   */
+  Adjustment(double value,
+      	     double lower,  double upper,
+      	     double step_increment = 1, double page_increment = 10,
+      	     double page_size = 0);
+  
+
+  /** Emits a "changed" signal from the Adjustment.  This is typically called by the owner of the Adjustment after it has changed any of the Adjustment fields other than the value.
+   */
+  void changed();
+  
+  /** Emits a "value_changed" signal from the Adjustment.  This is typically called by the owner of the Adjustment after it has changed the Adjustment value field.
+   */
+  void value_changed();
+
+  
+  /** Updates the Adjustment value to ensure that the range between the parameters @a lower  and @a upper  is in the current page (i.e.\ between @a value  and @a value  + @a page_size ).  If this range is larger than the page size, then only the start of it will be in the current page.  A "changed" signal will be emitted if the value is changed.
+   * @param upper The upper value.
+   * @param lower The lower value.
+   */
+  void clamp_page(double lower, double upper);
+
+  
+  /** Sets the current value of the Adjustment
+   * @param value The new value of the Adjustment.
+   */
+  void set_value(double value);
+  
+  /** Gets the current value of the adjustment. See
+   * set_value().
+   * @return The current value of the adjustment.
+   */
+  double get_value() const;
+
+  // Other internal fields accessors
+  /** Retrieve the @a lower member variable.
+   * @return The current value of @a lower.
+   */
+  double get_lower() const;
+
+  /** Retrieve the @a upper member variable.
+   * @return The current value of @a upper.
+   */
+  double get_upper() const;
+
+  /** Retrieve the @a step_increment variable.
+   * @return The current value of @a step_increment.
+   */
+  double get_step_increment() const;
+
+  /** Retrieve the @a page_increment variable.
+   * @return The current value of @a page_increment.
+   */
+  double get_page_increment() const;
+
+  /** Retrieve the @a page_size variable.
+   * @return The current value of @a page_size.
+   */
+  double get_page_size() const;
+
+  // TODO: This section needs changing. We must be able to set more at a time,
+  // emitting "changed" signal only once.
+  /** Sets the @a lower member variable
+   * @param lower The value to set the @a lower member variable to.
+   */
+  void set_lower(double lower);
+  
+  /** Sets the @a upper member variable
+   * @param upper The value to set the @a upper member variable to.
+   */
+  void set_upper(double upper);
+
+  /** Sets the @a step_increment member variable
+   * @param incr The value to set the @a step_incrememnt member variable to.
+   */
+  void set_step_increment(double incr);
+
+  /** Sets the @a page_increment member variable
+   * @param incr The value to set the @a page_increment member variable to.
+   */
+  void set_page_increment(double incr);
+
+  /** Sets the @a page_size member variable
+   * @param size The value to set the @ page_size member varialbe to.
+   */
+  void set_page_size(double size);
+
+  
+  Glib::SignalProxy0< void > signal_changed();
+
+  
+  Glib::SignalProxy0< void > signal_value_changed();
+
+
+};
+
+} /* namespace Gtk */
+
+
+namespace Glib
+{
+  /** @relates Gtk::Adjustment
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gtk::Adjustment* wrap(GtkAdjustment* object, bool take_copy = false);
+}
+#endif /* _GTKMM_ADJUSTMENT_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/alignment.cc b/libs/gtkmm2/gtk/gtkmm/alignment.cc
new file mode 100644
index 0000000000..56f5c58726
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/alignment.cc
@@ -0,0 +1,243 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/alignment.h>
+#include <gtkmm/private/alignment_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* 
+ *
+ * Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtk/gtkalignment.h>
+
+namespace Gtk
+{
+
+
+} //namespace Gtk
+
+
+namespace
+{
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Gtk::Alignment* wrap(GtkAlignment* object, bool take_copy)
+{
+  return dynamic_cast<Gtk::Alignment *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& Alignment_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &Alignment_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_alignment_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void Alignment_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+}
+
+
+Glib::ObjectBase* Alignment_Class::wrap_new(GObject* o)
+{
+  return manage(new Alignment((GtkAlignment*)(o)));
+
+}
+
+
+/* The implementation: */
+
+Alignment::Alignment(const Glib::ConstructParams& construct_params)
+:
+  Gtk::Bin(construct_params)
+{
+  }
+
+Alignment::Alignment(GtkAlignment* castitem)
+:
+  Gtk::Bin((GtkBin*)(castitem))
+{
+  }
+
+Alignment::~Alignment()
+{
+  destroy_();
+}
+
+Alignment::CppClassType Alignment::alignment_class_; // initialize static member
+
+GType Alignment::get_type()
+{
+  return alignment_class_.init().get_type();
+}
+
+GType Alignment::get_base_type()
+{
+  return gtk_alignment_get_type();
+}
+
+
+Alignment::Alignment(float xalign, float yalign, float xscale, float yscale)
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Bin(Glib::ConstructParams(alignment_class_.init(), "xalign", xalign, "yalign", yalign, "xscale", xscale, "yscale", yscale, (char*) 0))
+{
+  }
+
+Alignment::Alignment(AlignmentEnum xalign, AlignmentEnum yalign, float xscale, float yscale)
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Bin(Glib::ConstructParams(alignment_class_.init(), "xalign", _gtkmm_align_float_from_enum(xalign), "yalign", _gtkmm_align_float_from_enum(yalign), "xscale", xscale, "yscale", yscale, (char*) 0))
+{
+  }
+
+void Alignment::set(float xalign, float yalign, float xscale, float yscale)
+{
+  gtk_alignment_set(gobj(), xalign, yalign, xscale, yscale);
+}
+
+void Alignment::set(AlignmentEnum xalign, AlignmentEnum yalign, float xscale, float yscale)
+{
+  gtk_alignment_set(gobj(), _gtkmm_align_float_from_enum(xalign), _gtkmm_align_float_from_enum(yalign), xscale, yscale);
+}
+
+void Alignment::set_padding(guint padding_top, guint padding_bottom, guint padding_left, guint padding_right)
+{
+  gtk_alignment_set_padding(gobj(), padding_top, padding_bottom, padding_left, padding_right);
+}
+
+void Alignment::get_padding(guint& padding_top, guint& padding_bottom, guint& padding_left, guint& padding_right)
+{
+  gtk_alignment_get_padding(gobj(), &(padding_top), &(padding_bottom), &(padding_left), &(padding_right));
+}
+
+
+Glib::PropertyProxy<float> Alignment::property_xalign() 
+{
+  return Glib::PropertyProxy<float>(this, "xalign");
+}
+
+Glib::PropertyProxy_ReadOnly<float> Alignment::property_xalign() const
+{
+  return Glib::PropertyProxy_ReadOnly<float>(this, "xalign");
+}
+
+Glib::PropertyProxy<float> Alignment::property_yalign() 
+{
+  return Glib::PropertyProxy<float>(this, "yalign");
+}
+
+Glib::PropertyProxy_ReadOnly<float> Alignment::property_yalign() const
+{
+  return Glib::PropertyProxy_ReadOnly<float>(this, "yalign");
+}
+
+Glib::PropertyProxy<float> Alignment::property_xscale() 
+{
+  return Glib::PropertyProxy<float>(this, "xscale");
+}
+
+Glib::PropertyProxy_ReadOnly<float> Alignment::property_xscale() const
+{
+  return Glib::PropertyProxy_ReadOnly<float>(this, "xscale");
+}
+
+Glib::PropertyProxy<float> Alignment::property_yscale() 
+{
+  return Glib::PropertyProxy<float>(this, "yscale");
+}
+
+Glib::PropertyProxy_ReadOnly<float> Alignment::property_yscale() const
+{
+  return Glib::PropertyProxy_ReadOnly<float>(this, "yscale");
+}
+
+Glib::PropertyProxy<guint> Alignment::property_top_padding() 
+{
+  return Glib::PropertyProxy<guint>(this, "top-padding");
+}
+
+Glib::PropertyProxy_ReadOnly<guint> Alignment::property_top_padding() const
+{
+  return Glib::PropertyProxy_ReadOnly<guint>(this, "top-padding");
+}
+
+Glib::PropertyProxy<guint> Alignment::property_bottom_padding() 
+{
+  return Glib::PropertyProxy<guint>(this, "bottom-padding");
+}
+
+Glib::PropertyProxy_ReadOnly<guint> Alignment::property_bottom_padding() const
+{
+  return Glib::PropertyProxy_ReadOnly<guint>(this, "bottom-padding");
+}
+
+Glib::PropertyProxy<guint> Alignment::property_left_padding() 
+{
+  return Glib::PropertyProxy<guint>(this, "left-padding");
+}
+
+Glib::PropertyProxy_ReadOnly<guint> Alignment::property_left_padding() const
+{
+  return Glib::PropertyProxy_ReadOnly<guint>(this, "left-padding");
+}
+
+Glib::PropertyProxy<guint> Alignment::property_right_padding() 
+{
+  return Glib::PropertyProxy<guint>(this, "right-padding");
+}
+
+Glib::PropertyProxy_ReadOnly<guint> Alignment::property_right_padding() const
+{
+  return Glib::PropertyProxy_ReadOnly<guint>(this, "right-padding");
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/alignment.h b/libs/gtkmm2/gtk/gtkmm/alignment.h
new file mode 100644
index 0000000000..98130b9e2d
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/alignment.h
@@ -0,0 +1,318 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_ALIGNMENT_H
+#define _GTKMM_ALIGNMENT_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* alignment.h
+ * 
+ * Copyright (C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/bin.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkAlignment GtkAlignment;
+typedef struct _GtkAlignmentClass GtkAlignmentClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class Alignment_Class; } // namespace Gtk
+namespace Gtk
+{
+
+/** A widget which controls the alignment and size of its child.
+ *
+ * Normally, a widget is allocated at least as much size as it requests, and,
+ * most widgets expand to fill any extra allocated space, but sometimes
+ * this behavior is not desired. The alignment widget allows the
+ * programmer to specify how a widget should expand and position itself
+ * to fill the area it is allocated.
+ *
+ * It has four settings: xscale, yscale, xalign, and yalign:
+ * The scale settings specify how much the child widget should expand to fill the space allocated to the Gtk::Alignment. The values can range from 0 (meaning the child doesn't expand at all) to 1 (meaning the child expands to fill all of the available space).
+ * The align settings place the child widget within the available area. The values range from 0 (top or left) to 1 (bottom or right). Of course, if the scale settings are both set to 1, the alignment settings have no effect.
+ *
+ * @ingroup Widgets
+ * @ingroup Containers
+ */
+
+class Alignment : public Bin
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Alignment CppObjectType;
+  typedef Alignment_Class CppClassType;
+  typedef GtkAlignment BaseObjectType;
+  typedef GtkAlignmentClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~Alignment();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class Alignment_Class;
+  static CppClassType alignment_class_;
+
+  // noncopyable
+  Alignment(const Alignment&);
+  Alignment& operator=(const Alignment&);
+
+protected:
+  explicit Alignment(const Glib::ConstructParams& construct_params);
+  explicit Alignment(GtkAlignment* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GtkAlignment*       gobj()       { return reinterpret_cast<GtkAlignment*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GtkAlignment* gobj() const { return reinterpret_cast<GtkAlignment*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+private:
+
+public:
+
+  /** Constructor to create an Alignment object.
+   * @param xalign The initial horizontal alignment of the child.
+   * @param yalign The initial vertical alignment of the child.
+   * @param xscale The initial amount that the child expands horizontally to fill up unused space.
+   * @param yscale The initial amount that the child expands vertically to fill up unused space.
+   */
+  explicit Alignment(float xalign = 0.5, float yalign = 0.5, float xscale = 1.0, float yscale = 1.0);
+
+  /** Constructor to create an Alignment object.
+   * @param xalign A Gtk::AlignmentEnum describing the initial horizontal alignment of the child.
+   * @param yalign A Gtk::AlignmentEnum describing the initial vertical alignment of the child.
+   * @param xscale The initial amount that the child expands horizontally to fill up unused space.
+   * @param yscale The initial amount that the child expands vertically to fill up unused space.
+   */
+  explicit Alignment(AlignmentEnum xalign, AlignmentEnum yalign = Gtk::ALIGN_CENTER, float xscale = 1.0, float yscale = 1.0);
+
+  
+  /** Sets the Alignment values.
+   * @param xalign The horizontal alignment of the child of this Alignment, from 0 (left) to 1 (right).
+   * @param yalign The vertical alignment of the child of this Alignment, from 0 (top) to 1 (bottom).
+   * @param xscale The amount that the child expands horizontally to fill up unused space, from 0 to 1.  A value of 0 indicates that the child widget should never expand.  A value of 1 indicates that the child widget will expand to fill all the space allocated for the Alignment.
+   * @param yscale The amount that the child widget expands vertically to fill up unused space from 0 to 1.  The values are similar to @a xscale .
+   */
+  void set(float xalign = 0.5, float yalign = 0.5, float xscale = 1.0, float yscale=  1.0);
+  
+  /** Sets the Alignment values.
+   * @param xalign The horizontal alignment of the child of this Alignment, from 0 (left) to 1 (right).
+   * @param yalign The vertical alignment of the child of this Alignment, from 0 (top) to 1 (bottom).
+   * @param xscale The amount that the child expands horizontally to fill up unused space, from 0 to 1.  A value of 0 indicates that the child widget should never expand.  A value of 1 indicates that the child widget will expand to fill all the space allocated for the Alignment.
+   * @param yscale The amount that the child widget expands vertically to fill up unused space from 0 to 1.  The values are similar to @a xscale .
+   */
+  void set(AlignmentEnum xalign, AlignmentEnum yalign = Gtk::ALIGN_CENTER, float xscale = 1.0, float yscale=  1.0);
+
+  //New in GTK+ 2.4
+  
+  /** Sets the padding on the different sides of the widget.
+   * The padding adds blank space to the sides of the widget. For instance,
+   * this can be used to indent the child widget towards the right by adding
+   * padding on the left.
+   * 
+   * Since: 2.4
+   * @param padding_top The padding at the top of the widget.
+   * @param padding_bottom The padding at the bottom of the widget.
+   * @param padding_left The padding at the left of the widget.
+   * @param padding_right The padding at the right of the widget.
+   */
+  void set_padding(guint padding_top, guint padding_bottom, guint padding_left, guint padding_right);
+  
+  /** Gets the padding on the different sides of the widget.
+   * See set_padding().
+   * 
+   * Since: 2.4
+   * @param padding_top Location to store the padding for the top of the widget, or <tt>0</tt>.
+   * @param padding_bottom Location to store the padding for the bottom of the widget, or <tt>0</tt>.
+   * @param padding_left Location to store the padding for the left of the widget, or <tt>0</tt>.
+   * @param padding_right Location to store the padding for the right of the widget, or <tt>0</tt>.
+   */
+  void get_padding(guint& padding_top, guint& padding_bottom, guint& padding_left, guint& padding_right);
+              
+  /** Horizontal position of child in available space. 0.0 is left aligned
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<float> property_xalign() ;
+
+/** Horizontal position of child in available space. 0.0 is left aligned
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<float> property_xalign() const;
+
+  /** Vertical position of child in available space. 0.0 is top aligned
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<float> property_yalign() ;
+
+/** Vertical position of child in available space. 0.0 is top aligned
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<float> property_yalign() const;
+
+  /** If available horizontal space is bigger than needed for the child
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<float> property_xscale() ;
+
+/** If available horizontal space is bigger than needed for the child
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<float> property_xscale() const;
+
+  /** If available vertical space is bigger than needed for the child
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<float> property_yscale() ;
+
+/** If available vertical space is bigger than needed for the child
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<float> property_yscale() const;
+
+
+  //New in GTK+ 2.4
+  /** The padding to insert at the top of the widget.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<guint> property_top_padding() ;
+
+/** The padding to insert at the top of the widget.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<guint> property_top_padding() const;
+
+  /** The padding to insert at the bottom of the widget.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<guint> property_bottom_padding() ;
+
+/** The padding to insert at the bottom of the widget.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<guint> property_bottom_padding() const;
+
+  /** The padding to insert at the left of the widget.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<guint> property_left_padding() ;
+
+/** The padding to insert at the left of the widget.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<guint> property_left_padding() const;
+
+  /** The padding to insert at the right of the widget.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<guint> property_right_padding() ;
+
+/** The padding to insert at the right of the widget.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<guint> property_right_padding() const;
+
+
+};
+
+} /* namespace Gtk */
+
+
+namespace Glib
+{
+  /** @relates Gtk::Alignment
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gtk::Alignment* wrap(GtkAlignment* object, bool take_copy = false);
+}
+#endif /* _GTKMM_ALIGNMENT_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/arrow.cc b/libs/gtkmm2/gtk/gtkmm/arrow.cc
new file mode 100644
index 0000000000..681847cc02
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/arrow.cc
@@ -0,0 +1,177 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/arrow.h>
+#include <gtkmm/private/arrow_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* 
+ *
+ * Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+#include <gtk/gtkarrow.h>
+
+namespace Gtk
+{
+
+/*
+#define MIN_ARROW_SIZE  11
+
+Arrow::Arrow(ArrowType arrow_type, ShadowType shadow_type)
+  _CONSTRUCT()
+{
+
+  GtkArrow *arrow=gobj();
+
+  GTK_WIDGET (arrow)->requisition.width = MIN_ARROW_SIZE + GTK_MISC (arrow)->xpad * 2;
+  GTK_WIDGET (arrow)->requisition.height = MIN_ARROW_SIZE + GTK_MISC (arrow)->ypad * 2;
+
+  arrow->arrow_type = arrow_type;
+  arrow->shadow_type = shadow_type;
+}
+
+*/
+
+} /* namespace Gtk */
+
+
+namespace
+{
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Gtk::Arrow* wrap(GtkArrow* object, bool take_copy)
+{
+  return dynamic_cast<Gtk::Arrow *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& Arrow_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &Arrow_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_arrow_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void Arrow_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+}
+
+
+Glib::ObjectBase* Arrow_Class::wrap_new(GObject* o)
+{
+  return manage(new Arrow((GtkArrow*)(o)));
+
+}
+
+
+/* The implementation: */
+
+Arrow::Arrow(const Glib::ConstructParams& construct_params)
+:
+  Gtk::Misc(construct_params)
+{
+  }
+
+Arrow::Arrow(GtkArrow* castitem)
+:
+  Gtk::Misc((GtkMisc*)(castitem))
+{
+  }
+
+Arrow::~Arrow()
+{
+  destroy_();
+}
+
+Arrow::CppClassType Arrow::arrow_class_; // initialize static member
+
+GType Arrow::get_type()
+{
+  return arrow_class_.init().get_type();
+}
+
+GType Arrow::get_base_type()
+{
+  return gtk_arrow_get_type();
+}
+
+
+Arrow::Arrow(ArrowType arrow_type, ShadowType shadow_type)
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Misc(Glib::ConstructParams(arrow_class_.init(), "arrow_type", ((GtkArrowType)(arrow_type)), "shadow_type", ((GtkShadowType)(shadow_type)), (char*) 0))
+{
+  }
+
+void Arrow::set(ArrowType arrow_type, ShadowType shadow_type)
+{
+  gtk_arrow_set(gobj(), ((GtkArrowType)(arrow_type)), ((GtkShadowType)(shadow_type)));
+}
+
+
+Glib::PropertyProxy<ArrowType> Arrow::property_arrow_type() 
+{
+  return Glib::PropertyProxy<ArrowType>(this, "arrow-type");
+}
+
+Glib::PropertyProxy_ReadOnly<ArrowType> Arrow::property_arrow_type() const
+{
+  return Glib::PropertyProxy_ReadOnly<ArrowType>(this, "arrow-type");
+}
+
+Glib::PropertyProxy<ShadowType> Arrow::property_shadow_type() 
+{
+  return Glib::PropertyProxy<ShadowType>(this, "shadow-type");
+}
+
+Glib::PropertyProxy_ReadOnly<ShadowType> Arrow::property_shadow_type() const
+{
+  return Glib::PropertyProxy_ReadOnly<ShadowType>(this, "shadow-type");
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/arrow.h b/libs/gtkmm2/gtk/gtkmm/arrow.h
new file mode 100644
index 0000000000..f34a744d3e
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/arrow.h
@@ -0,0 +1,177 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_ARROW_H
+#define _GTKMM_ARROW_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* arrow.h
+ * 
+ * Copyright (C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/misc.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkArrow GtkArrow;
+typedef struct _GtkArrowClass GtkArrowClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class Arrow_Class; } // namespace Gtk
+namespace Gtk
+{
+
+/** Produces an arrow pointing in one of the four cardinal directions.
+ *
+ * This is intended for use where a directional arrow (in one of the four
+ * cardinal directions) is desired. As such, it has very limited
+ * functionality and basically only draws itself in a particular direction
+ * and with a particular shadow type.
+ *
+ * Gtk::Arrow will fill any space alloted to it, but since it is inherited
+ * from Gtk::Misc, it can be padded and/or aligned, to fill exactly the
+ * space the programmer desires.
+ *
+ * @ingroup Widgets
+ */
+
+class Arrow : public Misc {
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Arrow CppObjectType;
+  typedef Arrow_Class CppClassType;
+  typedef GtkArrow BaseObjectType;
+  typedef GtkArrowClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~Arrow();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class Arrow_Class;
+  static CppClassType arrow_class_;
+
+  // noncopyable
+  Arrow(const Arrow&);
+  Arrow& operator=(const Arrow&);
+
+protected:
+  explicit Arrow(const Glib::ConstructParams& construct_params);
+  explicit Arrow(GtkArrow* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GtkArrow*       gobj()       { return reinterpret_cast<GtkArrow*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GtkArrow* gobj() const { return reinterpret_cast<GtkArrow*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+private:
+
+public:
+
+
+  /** Creates an arrow.
+   *
+   * @param arrow_type A Gtk::ArrowType enum describing the arrow direction.
+   * @param shadow_type A Gtk::ShadowType enum describing the shadow type of
+   * the arrow.
+   */
+  explicit Arrow(ArrowType arrow_type, ShadowType shadow_type);
+  
+
+  // Changes the direction and shadow of an arrow.
+  
+  /** Sets the direction and shadow of this Arrow.
+   * @param arrow_type A Gtk::ArrowType enum describing what arrow type to set this Arrow to.
+   * @param shadow_type A Gtk::ShadowType enum describing what shadow type to set this Arrow to.
+   */
+  void set(ArrowType arrow_type, ShadowType shadow_type);
+
+  /** The direction the arrow should point.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<ArrowType> property_arrow_type() ;
+
+/** The direction the arrow should point.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<ArrowType> property_arrow_type() const;
+
+  /** Appearance of the shadow surrounding the arrow.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<ShadowType> property_shadow_type() ;
+
+/** Appearance of the shadow surrounding the arrow.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<ShadowType> property_shadow_type() const;
+
+
+};
+
+
+} /* namespace Gtk */
+
+
+namespace Glib
+{
+  /** @relates Gtk::Arrow
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gtk::Arrow* wrap(GtkArrow* object, bool take_copy = false);
+}
+#endif /* _GTKMM_ARROW_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/aspectframe.cc b/libs/gtkmm2/gtk/gtkmm/aspectframe.cc
new file mode 100644
index 0000000000..faf6a94286
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/aspectframe.cc
@@ -0,0 +1,187 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/aspectframe.h>
+#include <gtkmm/private/aspectframe_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* 
+ *
+ * Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtk/gtkaspectframe.h>
+
+
+namespace
+{
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Gtk::AspectFrame* wrap(GtkAspectFrame* object, bool take_copy)
+{
+  return dynamic_cast<Gtk::AspectFrame *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& AspectFrame_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &AspectFrame_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_aspect_frame_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void AspectFrame_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+}
+
+
+Glib::ObjectBase* AspectFrame_Class::wrap_new(GObject* o)
+{
+  return manage(new AspectFrame((GtkAspectFrame*)(o)));
+
+}
+
+
+/* The implementation: */
+
+AspectFrame::AspectFrame(const Glib::ConstructParams& construct_params)
+:
+  Gtk::Frame(construct_params)
+{
+  }
+
+AspectFrame::AspectFrame(GtkAspectFrame* castitem)
+:
+  Gtk::Frame((GtkFrame*)(castitem))
+{
+  }
+
+AspectFrame::~AspectFrame()
+{
+  destroy_();
+}
+
+AspectFrame::CppClassType AspectFrame::aspectframe_class_; // initialize static member
+
+GType AspectFrame::get_type()
+{
+  return aspectframe_class_.init().get_type();
+}
+
+GType AspectFrame::get_base_type()
+{
+  return gtk_aspect_frame_get_type();
+}
+
+
+AspectFrame::AspectFrame(const Glib::ustring& label, AlignmentEnum xalign, AlignmentEnum yalign, float ratio, bool obey_child)
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Frame(Glib::ConstructParams(aspectframe_class_.init(), "label", label.c_str(), "xalign", _gtkmm_align_float_from_enum(xalign), "yalign", _gtkmm_align_float_from_enum(yalign), "ratio", ratio, "obey_child", static_cast<int>(obey_child), (char*) 0))
+{
+  }
+
+AspectFrame::AspectFrame(const Glib::ustring& label, float xalign, float yalign, float ratio, bool obey_child)
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Frame(Glib::ConstructParams(aspectframe_class_.init(), "label", label.c_str(), "xalign", xalign, "yalign", yalign, "ratio", ratio, "obey_child", static_cast<int>(obey_child), (char*) 0))
+{
+  }
+
+void AspectFrame::set(float xalign, float yalign, float ratio, bool obey_child)
+{
+  gtk_aspect_frame_set(gobj(), xalign, yalign, ratio, static_cast<int>(obey_child));
+}
+
+void AspectFrame::set(AlignmentEnum xalign, AlignmentEnum yalign, float ratio, bool obey_child)
+{
+  gtk_aspect_frame_set(gobj(), _gtkmm_align_float_from_enum(xalign), _gtkmm_align_float_from_enum(yalign), ratio, static_cast<int>(obey_child));
+}
+
+
+Glib::PropertyProxy<float> AspectFrame::property_xalign() 
+{
+  return Glib::PropertyProxy<float>(this, "xalign");
+}
+
+Glib::PropertyProxy_ReadOnly<float> AspectFrame::property_xalign() const
+{
+  return Glib::PropertyProxy_ReadOnly<float>(this, "xalign");
+}
+
+Glib::PropertyProxy<float> AspectFrame::property_yalign() 
+{
+  return Glib::PropertyProxy<float>(this, "yalign");
+}
+
+Glib::PropertyProxy_ReadOnly<float> AspectFrame::property_yalign() const
+{
+  return Glib::PropertyProxy_ReadOnly<float>(this, "yalign");
+}
+
+Glib::PropertyProxy<float> AspectFrame::property_ratio() 
+{
+  return Glib::PropertyProxy<float>(this, "ratio");
+}
+
+Glib::PropertyProxy_ReadOnly<float> AspectFrame::property_ratio() const
+{
+  return Glib::PropertyProxy_ReadOnly<float>(this, "ratio");
+}
+
+Glib::PropertyProxy<bool> AspectFrame::property_obey_child() 
+{
+  return Glib::PropertyProxy<bool>(this, "obey-child");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> AspectFrame::property_obey_child() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "obey-child");
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/aspectframe.h b/libs/gtkmm2/gtk/gtkmm/aspectframe.h
new file mode 100644
index 0000000000..4687417211
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/aspectframe.h
@@ -0,0 +1,242 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_ASPECTFRAME_H
+#define _GTKMM_ASPECTFRAME_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* aspectframe.h
+ * 
+ * Copyright (C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/frame.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkAspectFrame GtkAspectFrame;
+typedef struct _GtkAspectFrameClass GtkAspectFrameClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class AspectFrame_Class; } // namespace Gtk
+namespace Gtk
+{
+
+/** A frame that constrains its child to a particular aspect ratio.
+ *
+ * The Gtk::AspectFrame is useful when you want pack a widget so that it can
+ * resize but always retains the same aspect ratio.  For instance, one might
+ * be drawing a small preview of a larger image. Because it derives from
+ * Gtk::Frame, it can draw a label and a frame around the child. The frame
+ * will be "shrink-wrapped" to the size of the child.
+ *
+ * @ingroup Widgets
+ * @ingroup Containers
+ */
+
+class AspectFrame : public Frame
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef AspectFrame CppObjectType;
+  typedef AspectFrame_Class CppClassType;
+  typedef GtkAspectFrame BaseObjectType;
+  typedef GtkAspectFrameClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~AspectFrame();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class AspectFrame_Class;
+  static CppClassType aspectframe_class_;
+
+  // noncopyable
+  AspectFrame(const AspectFrame&);
+  AspectFrame& operator=(const AspectFrame&);
+
+protected:
+  explicit AspectFrame(const Glib::ConstructParams& construct_params);
+  explicit AspectFrame(GtkAspectFrame* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GtkAspectFrame*       gobj()       { return reinterpret_cast<GtkAspectFrame*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GtkAspectFrame* gobj() const { return reinterpret_cast<GtkAspectFrame*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+private:
+
+
+public:
+
+  /** Constructor to create a new AspectFrame object.
+   * @param label Label text.
+   * @param xalign Horizontal alignment of the child within the allocation of this
+   * AspectFrame.  For possible values, see Gtk::AlignmentEnum.
+   * @param yalign Vertical alignment of the child within the allocation of this 
+   * AspectFrame. For possible values, see Gtk::AlignmentEnum.
+   * @param ratio The desired aspect ratio.
+   * @param obey_child If <tt>true</tt>, @a ratio  is ignored and the aspect ratio
+   * is taken from the requisition of the child.
+   */
+  explicit AspectFrame(const Glib::ustring& label = Glib::ustring(),
+    AlignmentEnum xalign = Gtk::ALIGN_CENTER, AlignmentEnum yalign = Gtk::ALIGN_CENTER,
+    float ratio = 1.0, bool obey_child = false);
+
+  /** Constructor to create a new AspectFrame object.
+   * @param label Label text.
+   * @param xalign Horizontal alignment of the child within the allocation of this 
+   * AspectFrame.  This ranges from 0.0 (left aligned) to 1.0 (right aligned).
+   * @param yalign Vertical alignment of the child within the allocation of this 
+   * AspectFrame. This ranges from 0.0 (top aligned) to 1.0 (bottom aligned).
+   * @param ratio The desired aspect ratio.
+   * @param obey_child If <tt>true</tt>, @a ratio  is ignored and the aspect ratio 
+   * is taken from the requisition of the child.
+   */
+  explicit AspectFrame(const Glib::ustring& label,
+    float xalign, float yalign,
+    float ratio = 1.0, bool obey_child = false);
+
+  //TODO: Is "obey_child = true" a good default?
+  /** Set the properties of this AspectFrame.
+   * @param xalign Horizontal alignment of the child within the allocation of this 
+   * AspectFrame.  This ranges from 0.0 (left aligned) to 1.0 (right aligned).
+   * @param yalign Vertical alignment of the child within the allocation of this 
+   * AspectFrame.  This ranges from 0.0 (top aligned) to 1.0 (bottom aligned).
+   * @param ratio The desired aspect ratio.
+   * @param obey_child If <tt>true</tt>, @a ratio  is ignored and the aspect ratio 
+   * is taken from the requisition of the child.
+   */
+  
+  void set(float xalign, float yalign, float ratio, bool obey_child = true);
+  /** Set the properties of this AspectFrame.
+   * @param xalign Horizontal alignment of the child within the allocation of this 
+   * AspectFrame.  For possible values, see Gtk::AlignmentEnum.
+   * @param yalign Vertical alignment of the child within the allocation of this 
+   * AspectFrame.  For possible values, see Gtk::AlignmentEnum.
+   * @param ratio The desired aspect ratio.
+   * @param obey_child If <tt>true</tt>, @a ratio  is ignored and the aspect ratio
+   * is taken from the requisition of the child.
+   */
+  
+  void set(AlignmentEnum xalign, AlignmentEnum yalign, float ratio, bool obey_child = true);
+
+  /** X alignment of the child.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<float> property_xalign() ;
+
+/** X alignment of the child.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<float> property_xalign() const;
+
+  /** Y alignment of the child.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<float> property_yalign() ;
+
+/** Y alignment of the child.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<float> property_yalign() const;
+
+  /** Aspect ratio if obey_child is FALSE.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<float> property_ratio() ;
+
+/** Aspect ratio if obey_child is FALSE.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<float> property_ratio() const;
+
+  /** Force aspect ratio to match that of the frame's child.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_obey_child() ;
+
+/** Force aspect ratio to match that of the frame's child.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_obey_child() const;
+
+
+};
+
+} /* namespace Gtk */
+
+
+namespace Glib
+{
+  /** @relates Gtk::AspectFrame
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gtk::AspectFrame* wrap(GtkAspectFrame* object, bool take_copy = false);
+}
+#endif /* _GTKMM_ASPECTFRAME_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/base.h b/libs/gtkmm2/gtk/gtkmm/base.h
new file mode 100644
index 0000000000..82bcdb2ab5
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/base.h
@@ -0,0 +1,53 @@
+// -*- c++ -*-
+#ifndef _GTKMM_BASE_H
+#define _GTKMM_BASE_H
+
+/* $Id$ */
+
+/* base.h
+ *
+ * Copyright (C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <glibmm/utility.h>
+#include <glibmm/ustring.h>
+
+namespace Gtk
+{
+  using Glib::unconst;
+
+}
+
+/* This aint pretty, but I don't know a better way to make
+   sure things work when the stl classes are defined in a namespace */
+
+// Gtk-- Base and other utility classes
+#define GTK_VERSION_GT(major,minor) ((GTK_MAJOR_VERSION>major)||(GTK_MAJOR_VERSION==major)&&(GTK_MINOR_VERSION>minor))
+#define GTK_VERSION_GE(major,minor) ((GTK_MAJOR_VERSION>major)||(GTK_MAJOR_VERSION==major)&&(GTK_MINOR_VERSION>=minor))
+#define GTK_VERSION_EQ(major,minor) ((GTK_MAJOR_VERSION==major)&&(GTK_MINOR_VERSION==minor))
+#define GTK_VERSION_NE(major,minor) ((GTK_MAJOR_VERSION!=major)||(GTK_MINOR_VERSION!=minor))
+#define GTK_VERSION_LE(major,minor) ((GTK_MAJOR_VERSION<major)||(GTK_MAJOR_VERSION==major)&&(GTK_MINOR_VERSION<=minor))
+#define GTK_VERSION_LT(major,minor) ((GTK_MAJOR_VERSION<major)||(GTK_MAJOR_VERSION==major)&&(GTK_MINOR_VERSION<minor))
+
+#define GTK_VERSION_GT_MICRO(major,minor,micro) \
+  ((GTK_MAJOR_VERSION>major)|| \
+  (GTK_MAJOR_VERSION==major)&&(GTK_MINOR_VERSION>minor)||\
+  (GTK_MAJOR_VERSION==major)&&(GTK_MINOR_VERSION==minor)&&(GTK_MICRO_VERSION>minor))
+
+
+#endif /* _GTKMM_BASE_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/bin.cc b/libs/gtkmm2/gtk/gtkmm/bin.cc
new file mode 100644
index 0000000000..2b58d2954c
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/bin.cc
@@ -0,0 +1,242 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/bin.h>
+#include <gtkmm/private/bin_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* 
+ *
+ * Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtk/gtkbin.h>
+#include <gtkmm/adjustment.h>
+#include <gtkmm/label.h>
+#include <gtkmm/box.h>
+#include <gtkmm/image.h>
+
+namespace Gtk
+{
+
+
+void 
+Bin::remove()
+{
+  if(gobj()->child)
+  {
+    Gtk::Widget* cppChild = Glib::wrap(gobj()->child);
+    
+    //If this is a managed widget,
+    //then do an extra ref so that it will
+    //not be destroyed when adding to another container
+    //This should leave it in much the same state as when it was instantiated,
+    //before being added to the first container.
+    if(cppChild->is_managed_())
+      cppChild->reference();
+     
+    gtk_container_remove(Container::gobj(), cppChild->gobj());
+  }
+}
+
+void 
+Bin::add_label(const Glib::ustring& str, bool mnemonic /* = false */,
+	             double x_align /* = 0.5 */, double y_align /* = 0.5 */)
+{
+  Label* label = manage(new Label(str, mnemonic, x_align, y_align));
+  add(*label);
+
+  //This might not always be appropriate:
+  //because maybe the mnemonic widget should be another child widget.
+  //if(mnemonic)
+    //label->set_mnemonic_widget(*this);
+
+  label->show();
+}
+
+void 
+Bin::add_label(const Glib::ustring& str, bool mnemonic,
+	       AlignmentEnum x_align, AlignmentEnum y_align /* = ALIGN_CENTER */)
+{
+  add_label(str, mnemonic,
+	    _gtkmm_align_float_from_enum(x_align),
+	    _gtkmm_align_float_from_enum(y_align));
+}
+
+void
+Bin::add_pixmap(const Glib::RefPtr<Gdk::Pixmap>& pixmap, const Glib::RefPtr<Gdk::Bitmap>& mask)
+{
+  Image* p = manage(new Image(pixmap, mask));
+  add(*p);
+  p->show();
+}
+
+void
+Bin::add_pixlabel (const Glib::RefPtr<Gdk::Pixmap>& pixmap,
+		   const Glib::RefPtr<Gdk::Bitmap>& mask,
+		   const Glib::ustring& str,
+		   double x_align /* = 0.5 */, double y_align /* = 0.5 */)
+{
+  //Create Pixmap and Label widgets:
+  Image* pmap = manage(new Image(pixmap, mask));
+  Label* label = manage(new Label(str));
+  label->set_alignment (x_align, y_align);
+
+  //Put them in a VBox:
+  Box* box = manage(new HBox(false,5));
+  box->pack_start(*pmap, PACK_SHRINK);
+  box->pack_start(*label);
+  box->show_all();
+
+  //And put that VBox in this:
+  add(*box);
+}
+
+void
+Bin::add_pixlabel(const Glib::ustring& pixfile,
+		  const Glib::ustring& str,
+		  double x_align /* = 0.5 */, double y_align /* = 0.5 */)
+{
+  //Create Pixmap and Label widgets:
+  Image* pmap = manage(new Image(pixfile));
+  Label* label = manage(new Label(str));
+  label->set_alignment (x_align, y_align);
+
+  //Put them in a VBox:
+  Box* vbox = manage(new HBox(false, 5));
+  vbox->pack_start(*pmap, PACK_SHRINK);
+  vbox->pack_start(*label);
+  vbox->show_all();
+
+  //And put that VBox in this:
+  add(*vbox);
+}
+
+
+} /* namespace Gtk */
+
+
+namespace
+{
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Gtk::Bin* wrap(GtkBin* object, bool take_copy)
+{
+  return dynamic_cast<Gtk::Bin *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& Bin_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &Bin_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_bin_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void Bin_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+}
+
+
+Glib::ObjectBase* Bin_Class::wrap_new(GObject* o)
+{
+  return manage(new Bin((GtkBin*)(o)));
+
+}
+
+
+/* The implementation: */
+
+Bin::Bin(const Glib::ConstructParams& construct_params)
+:
+  Gtk::Container(construct_params)
+{
+  }
+
+Bin::Bin(GtkBin* castitem)
+:
+  Gtk::Container((GtkContainer*)(castitem))
+{
+  }
+
+Bin::~Bin()
+{
+  destroy_();
+}
+
+Bin::CppClassType Bin::bin_class_; // initialize static member
+
+GType Bin::get_type()
+{
+  return bin_class_.init().get_type();
+}
+
+GType Bin::get_base_type()
+{
+  return gtk_bin_get_type();
+}
+
+
+Bin::Bin()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Container(Glib::ConstructParams(bin_class_.init()))
+{
+  }
+
+Widget* Bin::get_child()
+{
+  return Glib::wrap(gobj()->child);
+}
+
+const Widget* Bin::get_child() const
+{
+  return Glib::wrap(gobj()->child);
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/bin.h b/libs/gtkmm2/gtk/gtkmm/bin.h
new file mode 100644
index 0000000000..2100110f69
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/bin.h
@@ -0,0 +1,211 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_BIN_H
+#define _GTKMM_BIN_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* bin.h
+ * 
+ * Copyright (C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/container.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkBin GtkBin;
+typedef struct _GtkBinClass GtkBinClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class Bin_Class; } // namespace Gtk
+namespace Gtk
+{
+
+/** A container with just one child.
+ *
+ * This is an abstract base class from which all classes holding
+ * up to 1 widget inside of them derive.  It provides access to methods
+ * relevent to a single object, such as add_label, add_pixmap, etc.
+ *
+ * @ingroup Widgets
+ */
+
+class Bin : public Container
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Bin CppObjectType;
+  typedef Bin_Class CppClassType;
+  typedef GtkBin BaseObjectType;
+  typedef GtkBinClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~Bin();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class Bin_Class;
+  static CppClassType bin_class_;
+
+  // noncopyable
+  Bin(const Bin&);
+  Bin& operator=(const Bin&);
+
+protected:
+  explicit Bin(const Glib::ConstructParams& construct_params);
+  explicit Bin(GtkBin* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GtkBin*       gobj()       { return reinterpret_cast<GtkBin*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GtkBin* gobj() const { return reinterpret_cast<GtkBin*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+private:
+
+protected:
+  Bin();
+public:
+  
+
+  // get_child() is a convenience function to get a c++ wrapper of
+  // the contained widget. It may return NULL if such an item is not
+  // available.
+  Widget* get_child();
+  const Widget* get_child() const;
+
+  /** Remove the contained object
+   * Since this can only hold one object it is not necessary to
+   * specify which object to remove like other containers.
+   *
+   * When calling remove() on a Gtk::ScrolledWindow this might not remove the
+   * expected child directly, because Gtk::ScrolledWindow::add() sometimes creates a
+   * Gtk::ViewPort child and places the widget in that.
+   */
+  void remove();
+
+  //Convenience methods that don't correspond to GTK+ functions:
+
+  /** Add a Label object.
+   * This does not correspond to any GTK+ function and is provided purely for
+   * convenience.
+   * @param label The text for the label.
+   * @param mnemonic If <tt>true</tt>, characters preceded by an underscore 
+   * (_) will be underlined and used as a keyboard accelerator (shortcut).
+   * @param x_align The horizontal alignment of the text.  This ranges from 
+   * 0.0 (left aligned) to 1.0 (right aligned).
+   * @param y_align The vertical alignment of the text.  This ranges from 
+   * 0.0 (top aligned) to 1.0 (bottom aligned).
+   */
+  void add_label(const Glib::ustring& label, bool mnemonic = false,
+		 double x_align = 0.5, double y_align = 0.5);
+
+  /** Add a Label object.
+   * This does not correspond to any GTK+ function and is provided purely for
+   * convenience.
+   * @param label The label text.
+   * @param mnemonic If <tt>true</tt>, characters preceded by an underscore
+   * (_) will be underlined and used as a keyboard accelerator (shortcut).
+   * @param x_align The horizontal alignment of the text.  For possible 
+   * values, see Gtk::AlignmentEnum.
+   * @param y_align The vertical alignment of the text.  For possible 
+   * values, see Gtk::AlignmentEnum.
+   */
+  void add_label(const Glib::ustring& label, bool mnemonic,
+		 AlignmentEnum x_align, AlignmentEnum y_align = ALIGN_CENTER);
+
+  /** Add an Image object.
+   * This does not correspond to any GTK+ function and is provided purely for
+   * convenience.
+   * This will create, manage, add, and show a new Image to this Bin.
+   * @param pixmap A Glib::RefPtr to a Gdk::Pixmap.
+   * @param mask A Glib::RefPtr to a Gdk::Bitmap.
+   */
+  void add_pixmap(const Glib::RefPtr<Gdk::Pixmap>& pixmap,
+		  const Glib::RefPtr<Gdk::Bitmap>& mask);
+
+  /** Add Image and Label objects.
+   * This does not correspond to any GTK+ function and is provided purely for
+   * convenience.
+   * This will create, manage, add, and show a new Image and Label (within an 
+   * HBox) to this Bin.
+   * @param pixmap A Glib::RefPtr to a Gdk::Pixmap.
+   * @param mask A Glib::RefPtr to a Gdk::Bitmap.
+   * @param label The text for the label.
+   * @param x_align The horizontal alignment of the text in the label.
+   * @param y_align The vertical alignment of the text in the label.
+   */
+  void add_pixlabel(const Glib::RefPtr<Gdk::Pixmap>& pixmap,
+                    const Glib::RefPtr<Gdk::Bitmap>& mask,
+                    const Glib::ustring& label,
+		                double x_align = 0.5, double y_align = 0.5);
+
+  /** Add Image and Label objects.
+   * This does not correspond to any GTK+ function and is provided purely for
+   * convenience.
+   * This will create, manage, add, and show a new Image and Label (within an 
+   * HBox) to this Bin.
+   * @param pixfile The path to a file to be displayed.
+   * @param label The text for the label.
+   * @param x_align The horizontal alignment of the text in the label.
+   * @param y_align The vertical alignment of the text in the label.
+   */
+  void add_pixlabel(const Glib::ustring& pixfile,
+                    const Glib::ustring& label,
+		                double x_align = 0.5, double y_align = 0.5);
+
+
+};
+
+}  /* namespace Gtk */
+
+
+namespace Glib
+{
+  /** @relates Gtk::Bin
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gtk::Bin* wrap(GtkBin* object, bool take_copy = false);
+}
+#endif /* _GTKMM_BIN_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/box.cc b/libs/gtkmm2/gtk/gtkmm/box.cc
new file mode 100644
index 0000000000..a67411b47b
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/box.cc
@@ -0,0 +1,572 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/box.h>
+#include <gtkmm/private/box_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* 
+ *
+ * Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtk/gtkbox.h>
+#include <gtk/gtkvbox.h>
+#include <gtk/gtkhbox.h>
+#include <glibmm/wrap.h>
+
+namespace Gtk
+{
+
+namespace Box_Helpers
+{
+
+Widget* Child::get_widget() const
+{ 
+  return Glib::wrap(gobj()->widget);
+}
+
+void Child::set_options(PackOptions options, guint padding)
+{
+  const bool expand = (options == PACK_EXPAND_PADDING || options == PACK_EXPAND_WIDGET);
+  const bool fill   = (options == PACK_EXPAND_WIDGET);
+
+  set_options(expand, fill, padding);
+}
+
+void Child::set_options(bool expand, bool fill, guint padding)
+{
+  gobj()->expand  = expand;
+  gobj()->fill    = fill;
+  gobj()->padding = padding;
+}
+
+void Child::set_pack(PackType pack)
+{
+  gobj()->pack = pack;
+}
+
+
+/**************************************************************************/
+
+
+typedef Box_Helpers::BoxList::iterator box_iterator;
+
+box_iterator BoxList::insert(box_iterator position, const Element& e)
+{
+  iterator i;
+  bool expand = (e.options_ == PACK_EXPAND_PADDING) || (e.options_ == PACK_EXPAND_WIDGET);
+  bool fill = (e.options_ == PACK_EXPAND_WIDGET);
+
+  if (e.pack_ == PACK_START)
+    gtk_box_pack_start(gparent(), (e.widget_? e.widget_->gobj() : 0),
+                       (gboolean)expand, (gboolean)fill, e.padding_);
+  else
+    gtk_box_pack_end(gparent(), (e.widget_ ? e.widget_->gobj() : 0),
+                       (gboolean)expand, (gboolean)fill, e.padding_);
+
+  i = --end();
+
+  if (position!=end())
+    reorder(i, position);
+
+  return i;
+}
+
+// Non-standard
+void BoxList::reorder(box_iterator loc, box_iterator pos)
+{
+  int position = g_list_position(glist(), pos.node_);
+  gtk_box_reorder_child(gparent(), loc->gobj()->widget, position);
+}
+
+} /* namespace Box_Helpers */
+
+Box::BoxList& Box::children()
+{
+  children_proxy_ = BoxList(gobj());
+  return children_proxy_;
+}
+
+const Box::BoxList& Box::children() const
+{
+  children_proxy_ = BoxList(const_cast<GtkBox*>(gobj()));
+  return children_proxy_;
+}
+
+void Box::pack_start(Widget& child, PackOptions options, guint padding)
+{
+  bool expand = (options == PACK_EXPAND_PADDING) || (options == PACK_EXPAND_WIDGET);
+  bool fill = (options == PACK_EXPAND_WIDGET);
+
+  gtk_box_pack_start(gobj(), child.gobj(), (gboolean)expand, (gboolean)fill, padding);
+}
+
+void Box::pack_end(Widget& child, PackOptions options, guint padding)
+{
+  bool expand = (options == PACK_EXPAND_PADDING) || (options == PACK_EXPAND_WIDGET);
+  bool fill = (options == PACK_EXPAND_WIDGET);
+
+  gtk_box_pack_end(gobj(), child.gobj(), (gboolean)expand, (gboolean)fill, padding);
+}
+
+
+} /* namespace Gtk */
+
+
+namespace
+{
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Gtk::Box* wrap(GtkBox* object, bool take_copy)
+{
+  return dynamic_cast<Gtk::Box *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& Box_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &Box_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_box_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void Box_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+}
+
+
+Glib::ObjectBase* Box_Class::wrap_new(GObject* o)
+{
+  return manage(new Box((GtkBox*)(o)));
+
+}
+
+
+/* The implementation: */
+
+Box::Box(const Glib::ConstructParams& construct_params)
+:
+  Gtk::Container(construct_params)
+{
+  }
+
+Box::Box(GtkBox* castitem)
+:
+  Gtk::Container((GtkContainer*)(castitem))
+{
+  }
+
+Box::~Box()
+{
+  destroy_();
+}
+
+Box::CppClassType Box::box_class_; // initialize static member
+
+GType Box::get_type()
+{
+  return box_class_.init().get_type();
+}
+
+GType Box::get_base_type()
+{
+  return gtk_box_get_type();
+}
+
+
+namespace Box_Helpers
+{
+
+BoxList::iterator BoxList::find(const_reference w)
+{
+  iterator i = begin();
+  for(i = begin(); i != end() && (i->get_widget()->gobj() != w.get_widget()->gobj()); i++);
+  return i;
+}
+
+BoxList::iterator BoxList::find(Widget& w)
+{
+  iterator i;
+  for(i = begin(); i != end() && ((GtkWidget*)i->get_widget()->gobj() != w.gobj()); i++);
+  return i;
+}
+
+} /* namespace Box_Helpers */
+
+
+namespace Box_Helpers
+{
+
+void BoxList::remove(const_reference child)
+{
+  gtk_container_remove(GTK_CONTAINER(gparent_),
+                       (GtkWidget*)(child.get_widget()->gobj()));
+}
+
+void BoxList::remove(Widget& widget)
+{
+  gtk_container_remove(GTK_CONTAINER(gparent_), (GtkWidget*)(widget.gobj()));
+}
+
+BoxList::iterator BoxList::erase(iterator position)
+{
+  //Check that it is a valid iterator, to a real item:
+  if ( !position.node_|| (position == end()) )
+    return end();
+
+  //Get an iterator the the next item, to return:
+  iterator next = position;
+  next++;
+
+  //Use GTK+ C function to remove it, by providing the GtkWidget*:
+  gtk_container_remove( GTK_CONTAINER(gparent_), (GtkWidget*)(position->get_widget()->gobj()) );
+  return next;
+}
+
+} /* namespace Box_Helpers */
+
+
+namespace Box_Helpers
+{
+
+BoxList::BoxList()
+{}
+
+BoxList::BoxList(GtkBox* gparent)
+: type_base((GObject*)gparent)
+{}
+
+BoxList::BoxList(const BoxList& src)
+:
+  type_base(src)
+{}
+
+BoxList& BoxList::operator=(const BoxList& src)
+{
+  type_base::operator=(src);
+  return *this;
+}
+
+GList*& BoxList::glist() const
+{
+  return ((GtkBox*)gparent_)->children;
+}
+
+void BoxList::erase(iterator start, iterator stop)
+{
+  type_base::erase(start, stop);
+}
+
+GtkBox* BoxList::gparent()
+{
+  return (GtkBox*)type_base::gparent();
+}
+
+const GtkBox* BoxList::gparent() const
+{
+  return (GtkBox*)type_base::gparent();
+}
+
+BoxList::reference BoxList::operator[](size_type l) const
+{
+  return type_base::operator[](l);
+}
+
+} /* namespace Box_Helpers */
+
+Box::Box()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Container(Glib::ConstructParams(box_class_.init()))
+{
+  }
+
+void Box::pack_start(Widget& child, bool expand, bool fill, guint padding)
+{
+  gtk_box_pack_start(gobj(), (child).gobj(), static_cast<int>(expand), static_cast<int>(fill), padding);
+}
+
+void Box::pack_end(Widget& child, bool expand, bool fill, guint padding)
+{
+  gtk_box_pack_end(gobj(), (child).gobj(), static_cast<int>(expand), static_cast<int>(fill), padding);
+}
+
+void Box::set_homogeneous(bool homogeneous)
+{
+  gtk_box_set_homogeneous(gobj(), static_cast<int>(homogeneous));
+}
+
+bool Box::get_homogeneous() const
+{
+  return gtk_box_get_homogeneous(const_cast<GtkBox*>(gobj()));
+}
+
+void Box::set_spacing(int spacing)
+{
+  gtk_box_set_spacing(gobj(), spacing);
+}
+
+int Box::get_spacing() const
+{
+  return gtk_box_get_spacing(const_cast<GtkBox*>(gobj()));
+}
+
+void Box::reorder_child(Widget& child, int pos)
+{
+  gtk_box_reorder_child(gobj(), (child).gobj(), pos);
+}
+
+
+Glib::PropertyProxy<int> Box::property_spacing() 
+{
+  return Glib::PropertyProxy<int>(this, "spacing");
+}
+
+Glib::PropertyProxy_ReadOnly<int> Box::property_spacing() const
+{
+  return Glib::PropertyProxy_ReadOnly<int>(this, "spacing");
+}
+
+Glib::PropertyProxy<bool> Box::property_homogeneous() 
+{
+  return Glib::PropertyProxy<bool>(this, "homogeneous");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> Box::property_homogeneous() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "homogeneous");
+}
+
+
+} // namespace Gtk
+
+
+namespace Glib
+{
+
+Gtk::VBox* wrap(GtkVBox* object, bool take_copy)
+{
+  return dynamic_cast<Gtk::VBox *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& VBox_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &VBox_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_vbox_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void VBox_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+}
+
+
+Glib::ObjectBase* VBox_Class::wrap_new(GObject* o)
+{
+  return manage(new VBox((GtkVBox*)(o)));
+
+}
+
+
+/* The implementation: */
+
+VBox::VBox(const Glib::ConstructParams& construct_params)
+:
+  Gtk::Box(construct_params)
+{
+  }
+
+VBox::VBox(GtkVBox* castitem)
+:
+  Gtk::Box((GtkBox*)(castitem))
+{
+  }
+
+VBox::~VBox()
+{
+  destroy_();
+}
+
+VBox::CppClassType VBox::vbox_class_; // initialize static member
+
+GType VBox::get_type()
+{
+  return vbox_class_.init().get_type();
+}
+
+GType VBox::get_base_type()
+{
+  return gtk_vbox_get_type();
+}
+
+VBox::VBox(bool homogeneous, int spacing)
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Box(Glib::ConstructParams(vbox_class_.init(), "homogeneous", static_cast<int>(homogeneous), "spacing", spacing, (char*) 0))
+{
+  }
+
+
+} // namespace Gtk
+
+
+namespace Glib
+{
+
+Gtk::HBox* wrap(GtkHBox* object, bool take_copy)
+{
+  return dynamic_cast<Gtk::HBox *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& HBox_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &HBox_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_hbox_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void HBox_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+}
+
+
+Glib::ObjectBase* HBox_Class::wrap_new(GObject* o)
+{
+  return manage(new HBox((GtkHBox*)(o)));
+
+}
+
+
+/* The implementation: */
+
+HBox::HBox(const Glib::ConstructParams& construct_params)
+:
+  Gtk::Box(construct_params)
+{
+  }
+
+HBox::HBox(GtkHBox* castitem)
+:
+  Gtk::Box((GtkBox*)(castitem))
+{
+  }
+
+HBox::~HBox()
+{
+  destroy_();
+}
+
+HBox::CppClassType HBox::hbox_class_; // initialize static member
+
+GType HBox::get_type()
+{
+  return hbox_class_.init().get_type();
+}
+
+GType HBox::get_base_type()
+{
+  return gtk_hbox_get_type();
+}
+
+HBox::HBox(bool homogeneous, int spacing)
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Box(Glib::ConstructParams(hbox_class_.init(), "homogeneous", static_cast<int>(homogeneous), "spacing", spacing, (char*) 0))
+{
+  }
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/box.h b/libs/gtkmm2/gtk/gtkmm/box.h
new file mode 100644
index 0000000000..3955273760
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/box.h
@@ -0,0 +1,587 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_BOX_H
+#define _GTKMM_BOX_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* Copyright (C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+
+#include <gtkmm/container.h>
+#include <glibmm/helperlist.h>
+#include <gtk/gtkbox.h>  /* For _GtkBoxChild */
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkBox GtkBox;
+typedef struct _GtkBoxClass GtkBoxClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class Box_Class; } // namespace Gtk
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkVBox GtkVBox;
+typedef struct _GtkVBoxClass GtkVBoxClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class VBox_Class; } // namespace Gtk
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkHBox GtkHBox;
+typedef struct _GtkHBoxClass GtkHBoxClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class HBox_Class; } // namespace Gtk
+namespace Gtk
+{
+
+/** Packing options for adding child widgets to a Box with pack_start() and pack_end(). 
+ * @ingroup gtkmmEnums
+ */
+enum PackOptions
+{
+  PACK_SHRINK, /**< Space is contracted to the child widget size. */
+  PACK_EXPAND_PADDING, /**< Space is expanded, with extra space filled with padding. */
+  PACK_EXPAND_WIDGET /**< Space is expanded, with extra space filled by increasing the child widget size. */
+};
+
+class Box;
+
+namespace Box_Helpers
+{
+
+//This may not have any data or virtual functions. See below.
+class Child : protected _GtkBoxChild
+{
+private:
+  Child& operator=(const Child&); //Not implemented.
+  Child(const Child&); //Not implemented.
+
+public:
+  /// Provides access to the underlying C GObject.
+  inline _GtkBoxChild* gobj() { return this; }
+  /// Provides access to the underlying C GObject.
+  inline const _GtkBoxChild* gobj() const { return this; }
+
+  Widget* get_widget() const;
+
+  inline guint16 get_padding() const   { return (gobj()->padding); }
+  inline bool get_expand() const       { return (gobj()->expand); }
+  inline bool get_fill() const         { return (gobj()->fill); }
+  inline bool get_pack() const         { return (gobj()->pack); }
+
+  void set_options(PackOptions options, guint padding = 0);
+  void set_options(bool expand, bool fill, guint padding = 0);
+
+  void set_pack(PackType pack);
+
+protected:
+  inline GtkBox* parent()
+    { return (GtkBox*) (gobj()->widget->parent); }
+
+  void redraw();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  friend class Dummy_; // silence the compiler (Child has only private ctors)
+#endif
+};
+
+class Element
+{
+public:
+ Element(Widget& widget,
+          PackOptions options = PACK_EXPAND_WIDGET,
+          guint padding = 0,
+          PackType pack = PACK_START)
+      : widget_(&widget), options_(options),
+        padding_(padding), pack_(pack)
+    {}
+
+  Widget* widget_;
+  PackOptions options_;
+  guint padding_;
+  PackType pack_;
+};
+
+typedef Element StartElem;
+
+struct EndElem : public Element
+{
+  EndElem(Widget& widget,
+          PackOptions options = PACK_EXPAND_WIDGET,
+          guint padding = 0)
+      : Element (widget, options, padding, PACK_END)
+    {}
+};
+
+ 
+class BoxList : public Glib::HelperList< Child, const Element, Glib::List_Iterator< Child > >
+{
+public:
+  BoxList();
+  explicit BoxList(GtkBox* gparent);
+  BoxList(const BoxList& src);
+  virtual ~BoxList() {}
+
+  BoxList& operator=(const BoxList& src);
+
+  typedef Glib::HelperList< Child, const Element,  Glib::List_Iterator< Child > > type_base;
+
+  GtkBox* gparent();
+  const GtkBox* gparent() const;
+
+  virtual GList*& glist() const;      // front of list
+
+  virtual void erase(iterator start, iterator stop);
+  virtual iterator erase(iterator);  //Implented as custom or by LIST_CONTAINER_REMOVE
+  virtual void remove(const_reference); //Implented as custom or by LIST_CONTAINER_REMOVE
+
+  /// This is order n. (use at own risk)
+  reference operator[](size_type l) const;
+
+public:
+  iterator insert(iterator position, element_type& e); //custom-implemented.
+
+  template <class InputIterator>
+  inline void insert(iterator position, InputIterator first, InputIterator last)
+  {
+    for(;first != last; ++first)
+      position = insert(position, *first);
+  }
+
+ inline void push_front(element_type& e)
+    { insert(begin(), e); }
+  inline void push_back(element_type& e)
+    { insert(end(), e); }
+
+
+  //The standard iterator, instead of List_Cpp_Iterator,
+  //only works because Child is derived from _GtkBoxChild.
+  
+  
+  iterator find(const_reference c);
+  iterator find(Widget&);
+
+  
+virtual void remove(Widget& w); //Implented as custom or by LIST_CONTAINER_REMOVE
+
+        // Non-standard
+        void reorder(iterator loc,iterator pos);
+  };
+
+
+} /* namespace Box_Helpers */
+
+
+/** A base class for box containers
+ *
+ * Abstract base class for horizontal and vertical boxes, which organize a
+ * variable number of widgets into a rectangular area.  This is an abstract
+ * class and it defers choice of which way the widgets are packed to the screen
+ * to the derived classes.  It provides a common interface for inserting
+ * widgets to a box indepenently of how it is shown in the screen.
+ *
+ * Gtk::Box uses a notion of packing. Packing refers to adding widgets with
+ * reference to a particular position in a Gtk::Container. There are two
+ * reference positions: the start and the end of the box. For a VBox, the start
+ * is defined as the top of the box and the end is defined as the bottom.  For
+ * a HBox the start is defined as the left side and the end is defined as the
+ * right side.  Use repeated calls to pack_start() to pack widgets into a
+ * Gtk::Box from start to end. Use pack_end() to add widgets from end to start.
+ * You may intersperse these calls and add widgets from both ends of the same
+ * Gtk::Box.
+ *
+ * Because Gtk::Box is a Gtk::Container, you may also use Gtk::Container::add()
+ * to insert widgets, and they will be packed as if with pack_start(). Use
+ * Gtk::Container::remove() to remove widgets.
+ *
+ * Use set_homogeneous() to specify whether or not all children of the Gtk::Box
+ * occupy the same amount of space.  Use set_spacing() to determine the minimum
+ * space placed between all children in the Gtk::Box.  Use reorder_child() to
+ * move a child widget to a different place in the box.  Use
+ * set_child_packing() to reset the pack options and padding attributes of any
+ * Gtk::Box child. Use query_child_packing() to query these fields.
+ */
+
+class Box : public Container
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Box CppObjectType;
+  typedef Box_Class CppClassType;
+  typedef GtkBox BaseObjectType;
+  typedef GtkBoxClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~Box();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class Box_Class;
+  static CppClassType box_class_;
+
+  // noncopyable
+  Box(const Box&);
+  Box& operator=(const Box&);
+
+protected:
+  explicit Box(const Glib::ConstructParams& construct_params);
+  explicit Box(GtkBox* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GtkBox*       gobj()       { return reinterpret_cast<GtkBox*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GtkBox* gobj() const { return reinterpret_cast<GtkBox*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+private:
+
+  
+public:
+  typedef Box_Helpers::BoxList BoxList;
+
+protected:
+  Box();
+public:
+
+  
+  /** Left side insert a widget to a box.
+   * The expand argument to pack_start() or pack_end()
+   * controls whether the widgets are laid out in the box to fill in all
+   * the extra space in the box so the box is expanded to fill the area
+   * allocated to it (<tt>true</tt>). Or the box is shrunk to just fit the widgets
+   * (<tt>false</tt>).  Setting @a expand  to <tt>false</tt> will allow you to do right and left
+   * justifying of your widgets.  Otherwise, they will all expand to fit in
+   * the box, and the same effect could be achieved by using only one of
+   * pack_start() or pack_end() functions.
+   * 
+   * The @a fill  argument to the pack_start()/pack_end() functions control whether the
+   * extra space is allocated to the objects themselves (<tt>true</tt>), or as extra
+   * padding in the box around these objects (<tt>false</tt>). It only has an effect
+   * if the @a expand  argument is also <tt>true</tt>.
+   * 
+   * The difference between spacing (set when the box is created)
+   * and padding (set when elements are packed) is, that spacing is added between
+   * objects, and padding is added on either side of an object.
+   */
+  void pack_start(Widget& child, bool expand, bool fill, guint padding = 0);
+
+  /** Left side insert a widget to a box.
+   * @param child A Widget to be added to box.
+   * @param options Controls how the widget expands to fill space, and how the space around them is used.
+   * @param padding Padding that is added on either side of the widget. This is different to spacing set when the box is created (or with set_spacing()) - spacing is added between objects, and padding is added on either side of an object.
+   */
+  void pack_start(Widget& child, PackOptions options = PACK_EXPAND_WIDGET, guint padding = 0);
+
+  
+  void pack_end(Widget& child, bool expand, bool fill, guint padding = 0);
+
+  /** Right side insert a widget to a box.
+   * @param child A Widget to be added to box.
+   * @param options Controls how the widget expands to fill space, and how the space around them is used.
+   * @param padding Padding that is added on either side of the widget. This is different to spacing set when the box is created (or with set_spacing()) - spacing is added between objects, and padding is added on either side of an object.
+   */
+  void pack_end(Widget& child, PackOptions options = PACK_EXPAND_WIDGET, guint padding = 0);
+
+  
+  void set_homogeneous(bool homogeneous = true);
+  
+  /** Returns whether the box is homogeneous (all children are the
+   * same size). See set_homogeneous().
+   * @return <tt>true</tt> if the box is homogeneous.
+   */
+  bool get_homogeneous() const;
+
+  
+  void set_spacing(int spacing);
+  
+  /** Gets the value set by set_spacing().
+   * @return Spacing between children.
+   */
+  int get_spacing() const;
+
+  
+  void reorder_child(Widget& child, int pos);
+
+  /* Get the child widgets.
+   * @result An STL-style container of pointers to the box's child widgets.
+   */
+  BoxList& children();
+
+  /* Get the child widgets.
+   * @result An STL-style container of pointers to the box's child widgets.
+   */
+  const BoxList& children() const;
+
+  /** The amount of space between children.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<int> property_spacing() ;
+
+/** The amount of space between children.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<int> property_spacing() const;
+
+  /** Whether the children should all be the same size.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_homogeneous() ;
+
+/** Whether the children should all be the same size.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_homogeneous() const;
+
+
+protected:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  mutable BoxList children_proxy_;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+};
+
+
+/** Vertical Box for laying widgets in a vertical row.
+ *
+ * You should create these objects, but it is more confortable to pass
+ * around pointers of Gtk::Box. All the methods that do anything are in
+ * class Gtk::Box and this allows you to later change the direction of the
+ * box, when there's no dependencies to HBox and VBox classes.
+ *
+ * @ingroup Widgets
+ * @ingroup Containers
+ */
+
+class VBox : public Box
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef VBox CppObjectType;
+  typedef VBox_Class CppClassType;
+  typedef GtkVBox BaseObjectType;
+  typedef GtkVBoxClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~VBox();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class VBox_Class;
+  static CppClassType vbox_class_;
+
+  // noncopyable
+  VBox(const VBox&);
+  VBox& operator=(const VBox&);
+
+protected:
+  explicit VBox(const Glib::ConstructParams& construct_params);
+  explicit VBox(GtkVBox* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GtkVBox*       gobj()       { return reinterpret_cast<GtkVBox*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GtkVBox* gobj() const { return reinterpret_cast<GtkVBox*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+private:
+
+public:
+
+  /** Creates a new vertical box.
+   * @param homogeneous Whether each widget in the VBox should have the same
+   * height.  If set, a PACK_SHRINK argument to pack_start() or pack_end() is
+   * ignored.
+   * @param spacing Determines the space in pixels between child widgets.
+   */
+  explicit VBox(bool homogeneous = false, int spacing = 0);
+  
+
+};
+
+/** Horizontal Box for laying widgets in a horizontal row.
+ *
+ * You should create these objects, but it is more confortable to pass
+ * around pointers of Gtk::Box. All the methods that do anything are in
+ * class Gtk::Box and this allows you to later change the direction of the
+ * box, when there's no dependencies to HBox and VBox classes.
+ *
+ * Use the Gtk::Box packing interface to determine the arrangement, spacing,
+ * width, and alignment of Gtk::HBox children.
+ *
+ * All children are allocated the same height.
+ *
+ * @ingroup Widgets
+ * @ingroup Containers
+ */
+
+class HBox : public Box
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef HBox CppObjectType;
+  typedef HBox_Class CppClassType;
+  typedef GtkHBox BaseObjectType;
+  typedef GtkHBoxClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~HBox();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class HBox_Class;
+  static CppClassType hbox_class_;
+
+  // noncopyable
+  HBox(const HBox&);
+  HBox& operator=(const HBox&);
+
+protected:
+  explicit HBox(const Glib::ConstructParams& construct_params);
+  explicit HBox(GtkHBox* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GtkHBox*       gobj()       { return reinterpret_cast<GtkHBox*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GtkHBox* gobj() const { return reinterpret_cast<GtkHBox*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+private:
+
+public:
+
+  /** Creates a new horizontal box.
+   * @param homogeneous Whether each widget in the HBox should have the same
+   * width.  If set, a PACK_SHRINK argument to pack_start() or pack_end() is
+   * ignored.
+   * @param spacing Determines the space in pixels between child widgets.
+   */
+  explicit HBox(bool homogeneous = false, int spacing = 0);
+
+
+};
+
+} // namespace Gtk
+
+
+namespace Glib
+{
+  /** @relates Gtk::Box
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gtk::Box* wrap(GtkBox* object, bool take_copy = false);
+}
+namespace Glib
+{
+  /** @relates Gtk::VBox
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gtk::VBox* wrap(GtkVBox* object, bool take_copy = false);
+}
+namespace Glib
+{
+  /** @relates Gtk::HBox
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gtk::HBox* wrap(GtkHBox* object, bool take_copy = false);
+}
+#endif /* _GTKMM_BOX_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/button.cc b/libs/gtkmm2/gtk/gtkmm/button.cc
new file mode 100644
index 0000000000..01a3265d8c
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/button.cc
@@ -0,0 +1,682 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/button.h>
+#include <gtkmm/private/button_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* 
+ *
+ * Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtk/gtklabel.h>
+#include <gtk/gtkmisc.h>
+#include <gtk/gtkbutton.h>
+#include <gtkmm/stock.h>
+
+
+namespace Gtk
+{
+
+Button::Button(const Glib::ustring& label, bool mnemonic)
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Bin(Glib::ConstructParams(button_class_.init(), "label",label.c_str(),"use_underline",gboolean(mnemonic), (char*) 0))
+{}
+
+Button::Button(const StockID& stock_id)
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Bin(Glib::ConstructParams(button_class_.init(), "use_stock",1,"label",stock_id.get_c_str(), (char*) 0))
+{}
+
+} // namespace Gtk
+
+
+namespace
+{
+
+const Glib::SignalProxyInfo Button_signal_pressed_info =
+{
+  "pressed",
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
+};
+
+
+const Glib::SignalProxyInfo Button_signal_released_info =
+{
+  "released",
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
+};
+
+
+const Glib::SignalProxyInfo Button_signal_clicked_info =
+{
+  "clicked",
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
+};
+
+
+const Glib::SignalProxyInfo Button_signal_enter_info =
+{
+  "enter",
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
+};
+
+
+const Glib::SignalProxyInfo Button_signal_leave_info =
+{
+  "leave",
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
+};
+
+
+const Glib::SignalProxyInfo Button_signal_activate_info =
+{
+  "activate",
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
+};
+
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Gtk::Button* wrap(GtkButton* object, bool take_copy)
+{
+  return dynamic_cast<Gtk::Button *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& Button_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &Button_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_button_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void Button_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+  klass->pressed = &pressed_callback;
+  klass->released = &released_callback;
+  klass->clicked = &clicked_callback;
+  klass->enter = &enter_callback;
+  klass->leave = &leave_callback;
+  klass->activate = &activate_callback;
+}
+
+
+void Button_Class::pressed_callback(GtkButton* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_pressed();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->pressed)
+      (*base->pressed)(self);
+  }
+}
+
+void Button_Class::released_callback(GtkButton* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_released();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->released)
+      (*base->released)(self);
+  }
+}
+
+void Button_Class::clicked_callback(GtkButton* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_clicked();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->clicked)
+      (*base->clicked)(self);
+  }
+}
+
+void Button_Class::enter_callback(GtkButton* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_enter();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->enter)
+      (*base->enter)(self);
+  }
+}
+
+void Button_Class::leave_callback(GtkButton* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_leave();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->leave)
+      (*base->leave)(self);
+  }
+}
+
+void Button_Class::activate_callback(GtkButton* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_activate();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->activate)
+      (*base->activate)(self);
+  }
+}
+
+
+Glib::ObjectBase* Button_Class::wrap_new(GObject* o)
+{
+  return manage(new Button((GtkButton*)(o)));
+
+}
+
+
+/* The implementation: */
+
+Button::Button(const Glib::ConstructParams& construct_params)
+:
+  Gtk::Bin(construct_params)
+{
+  }
+
+Button::Button(GtkButton* castitem)
+:
+  Gtk::Bin((GtkBin*)(castitem))
+{
+  }
+
+Button::~Button()
+{
+  destroy_();
+}
+
+Button::CppClassType Button::button_class_; // initialize static member
+
+GType Button::get_type()
+{
+  return button_class_.init().get_type();
+}
+
+GType Button::get_base_type()
+{
+  return gtk_button_get_type();
+}
+
+
+Button::Button()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Bin(Glib::ConstructParams(button_class_.init()))
+{
+  }
+
+void Button::pressed()
+{
+  gtk_button_pressed(gobj());
+}
+
+void Button::released()
+{
+  gtk_button_released(gobj());
+}
+
+void Button::clicked()
+{
+  gtk_button_clicked(gobj());
+}
+
+void Button::enter()
+{
+  gtk_button_enter(gobj());
+}
+
+void Button::leave()
+{
+  gtk_button_leave(gobj());
+}
+
+void Button::set_relief(ReliefStyle newstyle)
+{
+  gtk_button_set_relief(gobj(), ((GtkReliefStyle)(newstyle)));
+}
+
+ReliefStyle Button::get_relief() const
+{
+  return ((ReliefStyle)(gtk_button_get_relief(const_cast<GtkButton*>(gobj()))));
+}
+
+void Button::set_label(const Glib::ustring& label)
+{
+  gtk_button_set_label(gobj(), label.c_str());
+}
+
+Glib::ustring Button::get_label() const
+{
+  return Glib::convert_const_gchar_ptr_to_ustring(gtk_button_get_label(const_cast<GtkButton*>(gobj())));
+}
+
+void Button::set_use_underline(bool use_underline)
+{
+  gtk_button_set_use_underline(gobj(), static_cast<int>(use_underline));
+}
+
+bool Button::get_use_underline() const
+{
+  return gtk_button_get_use_underline(const_cast<GtkButton*>(gobj()));
+}
+
+void Button::set_use_stock(bool use_stock)
+{
+  gtk_button_set_use_stock(gobj(), static_cast<int>(use_stock));
+}
+
+bool Button::get_use_stock() const
+{
+  return gtk_button_get_use_stock(const_cast<GtkButton*>(gobj()));
+}
+
+void Button::set_focus_on_click(bool focus_on_click)
+{
+  gtk_button_set_focus_on_click(gobj(), static_cast<int>(focus_on_click));
+}
+
+bool Button::get_focus_on_click() const
+{
+  return gtk_button_get_focus_on_click(const_cast<GtkButton*>(gobj()));
+}
+
+void Button::set_alignment(float xalign, float yalign)
+{
+  gtk_button_set_alignment(gobj(), xalign, yalign);
+}
+
+void Button::get_alignment(float& xalign, float& yalign)
+{
+  gtk_button_get_alignment(gobj(), &(xalign), &(yalign));
+}
+
+void Button::set_image(Widget& image)
+{
+  gtk_button_set_image(gobj(), (image).gobj());
+}
+
+Widget* Button::get_image()
+{
+  return Glib::wrap(gtk_button_get_image(gobj()));
+}
+
+const Widget* Button::get_image() const
+{
+  return Glib::wrap(gtk_button_get_image(const_cast<GtkButton*>(gobj())));
+}
+
+
+Glib::SignalProxy0< void > Button::signal_pressed()
+{
+  return Glib::SignalProxy0< void >(this, &Button_signal_pressed_info);
+}
+
+Glib::SignalProxy0< void > Button::signal_released()
+{
+  return Glib::SignalProxy0< void >(this, &Button_signal_released_info);
+}
+
+Glib::SignalProxy0< void > Button::signal_clicked()
+{
+  return Glib::SignalProxy0< void >(this, &Button_signal_clicked_info);
+}
+
+Glib::SignalProxy0< void > Button::signal_enter()
+{
+  return Glib::SignalProxy0< void >(this, &Button_signal_enter_info);
+}
+
+Glib::SignalProxy0< void > Button::signal_leave()
+{
+  return Glib::SignalProxy0< void >(this, &Button_signal_leave_info);
+}
+
+Glib::SignalProxy0< void > Button::signal_activate()
+{
+  return Glib::SignalProxy0< void >(this, &Button_signal_activate_info);
+}
+
+
+Glib::PropertyProxy<Glib::ustring> Button::property_label() 
+{
+  return Glib::PropertyProxy<Glib::ustring>(this, "label");
+}
+
+Glib::PropertyProxy_ReadOnly<Glib::ustring> Button::property_label() const
+{
+  return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "label");
+}
+
+Glib::PropertyProxy<ReliefStyle> Button::property_relief() 
+{
+  return Glib::PropertyProxy<ReliefStyle>(this, "relief");
+}
+
+Glib::PropertyProxy_ReadOnly<ReliefStyle> Button::property_relief() const
+{
+  return Glib::PropertyProxy_ReadOnly<ReliefStyle>(this, "relief");
+}
+
+Glib::PropertyProxy<bool> Button::property_use_underline() 
+{
+  return Glib::PropertyProxy<bool>(this, "use-underline");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> Button::property_use_underline() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "use-underline");
+}
+
+Glib::PropertyProxy<bool> Button::property_use_stock() 
+{
+  return Glib::PropertyProxy<bool>(this, "use-stock");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> Button::property_use_stock() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "use-stock");
+}
+
+Glib::PropertyProxy<bool> Button::property_focus_on_click() 
+{
+  return Glib::PropertyProxy<bool>(this, "focus-on-click");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> Button::property_focus_on_click() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "focus-on-click");
+}
+
+Glib::PropertyProxy<float> Button::property_xalign() 
+{
+  return Glib::PropertyProxy<float>(this, "xalign");
+}
+
+Glib::PropertyProxy_ReadOnly<float> Button::property_xalign() const
+{
+  return Glib::PropertyProxy_ReadOnly<float>(this, "xalign");
+}
+
+Glib::PropertyProxy<float> Button::property_yalign() 
+{
+  return Glib::PropertyProxy<float>(this, "yalign");
+}
+
+Glib::PropertyProxy_ReadOnly<float> Button::property_yalign() const
+{
+  return Glib::PropertyProxy_ReadOnly<float>(this, "yalign");
+}
+
+Glib::PropertyProxy<Gtk::Widget*> Button::property_image() 
+{
+  return Glib::PropertyProxy<Gtk::Widget*>(this, "image");
+}
+
+Glib::PropertyProxy_ReadOnly<Gtk::Widget*> Button::property_image() const
+{
+  return Glib::PropertyProxy_ReadOnly<Gtk::Widget*>(this, "image");
+}
+
+
+void Gtk::Button::on_pressed()
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->pressed)
+    (*base->pressed)(gobj());
+}
+
+void Gtk::Button::on_released()
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->released)
+    (*base->released)(gobj());
+}
+
+void Gtk::Button::on_clicked()
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->clicked)
+    (*base->clicked)(gobj());
+}
+
+void Gtk::Button::on_enter()
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->enter)
+    (*base->enter)(gobj());
+}
+
+void Gtk::Button::on_leave()
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->leave)
+    (*base->leave)(gobj());
+}
+
+void Gtk::Button::on_activate()
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->activate)
+    (*base->activate)(gobj());
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/button.h b/libs/gtkmm2/gtk/gtkmm/button.h
new file mode 100644
index 0000000000..1ba9920a0f
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/button.h
@@ -0,0 +1,432 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_BUTTON_H
+#define _GTKMM_BUTTON_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* box.h
+ * 
+ * Copyright (C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/bin.h>
+#include <gtkmm/stockid.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkButton GtkButton;
+typedef struct _GtkButtonClass GtkButtonClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class Button_Class; } // namespace Gtk
+namespace Gtk
+{
+
+namespace Stock { struct BuiltinStockID; }
+
+
+/** A widget that creates a signal when clicked on.
+ *
+ * This widget is generally used with a signal handler that is called when the button is pressed.
+ * It can hold any valid child widget.  The most commonly used child is the Gtk::Label.
+ *
+ * @ingroup Widgets
+ */
+
+class Button : public Bin
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Button CppObjectType;
+  typedef Button_Class CppClassType;
+  typedef GtkButton BaseObjectType;
+  typedef GtkButtonClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~Button();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class Button_Class;
+  static CppClassType button_class_;
+
+  // noncopyable
+  Button(const Button&);
+  Button& operator=(const Button&);
+
+protected:
+  explicit Button(const Glib::ConstructParams& construct_params);
+  explicit Button(GtkButton* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GtkButton*       gobj()       { return reinterpret_cast<GtkButton*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GtkButton* gobj() const { return reinterpret_cast<GtkButton*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+  virtual void on_pressed();
+  virtual void on_released();
+  virtual void on_clicked();
+  virtual void on_enter();
+  virtual void on_leave();
+  virtual void on_activate();
+
+
+private:
+
+public:
+
+  /** Create an empty button.
+   * With an empty button, you can Gtk::Button::add() a widget
+   * such as a Gtk::Pixmap or Gtk::Box.
+   *
+   * If you just wish to add a Gtk::Label,
+   * you may want to
+   * use the Gtk::Button(const Glib::ustring& label) ctor
+   * directly instead.
+   */
+  Button();
+  
+
+  /** Simple Push Button with label.
+   * Create a button with the given label inside. You won't be able
+   * to add a widget in this button since it already has a Gtk::Label
+   * in it
+   */
+  explicit Button(const Glib::ustring& label, bool mnemonic = false);
+  explicit Button(const StockID& stock_id);
+
+
+  void pressed();
+  
+  void released();
+  
+  void clicked();
+  
+  void enter();
+  
+  void leave();
+
+  
+  void set_relief(ReliefStyle newstyle);
+  
+  ReliefStyle get_relief() const;
+
+  
+  /** Sets the text of the label of the button to @a str . This text is
+   * also used to select the stock item if set_use_stock()
+   * is used.
+   * 
+   * This will also clear any previously set labels.
+   * @param label A string.
+   */
+  void set_label(const Glib::ustring& label);
+  
+  /** Fetches the text from the label of the button, as set by
+   * set_label(). If the label text has not 
+   * been set the return value will be <tt>0</tt>. This will be the 
+   * case if you create an empty button with new() to 
+   * use as a container.
+   * @return The text of the label widget. This string is owned
+   * by the widget and must not be modified or freed.
+   */
+  Glib::ustring get_label() const;
+  
+  /** If true, an underline in the text of the button label indicates
+   * the next character should be used for the mnemonic accelerator key.
+   * @param use_underline <tt>true</tt> if underlines in the text indicate mnemonics.
+   */
+  void set_use_underline(bool use_underline = true);
+  
+  /** Returns whether an embedded underline in the button label indicates a
+   * mnemonic. See set_use_underline().
+   * @return <tt>true</tt> if an embedded underline in the button label
+   * indicates the mnemonic accelerator keys.
+   */
+  bool get_use_underline() const;
+  
+  /** If true, the label set on the button is used as a
+   * stock id to select the stock item for the button.
+   * @param use_stock <tt>true</tt> if the button should use a stock item.
+   */
+  void set_use_stock(bool use_stock = true);
+  
+  /** Returns whether the button label is a stock item.
+   * @return <tt>true</tt> if the button label is used to
+   * select a stock item instead of being
+   * used directly as the label text.
+   */
+  bool get_use_stock() const;
+
+  
+  /** Sets whether the button will grab focus when it is clicked with the mouse.
+   * Making mouse clicks not grab focus is useful in places like toolbars where
+   * you don't want the keyboard focus removed from the main area of the
+   * application.
+   * 
+   * Since: 2.4
+   * @param focus_on_click Whether the button grabs focus when clicked with the mouse.
+   */
+  void set_focus_on_click(bool focus_on_click = true);
+  
+  /** Returns whether the button grabs focus when it is clicked with the mouse.
+   * See set_focus_on_click().
+   * @return <tt>true</tt> if the button grabs focus when it is clicked with
+   * the mouse.
+   * 
+   * Since: 2.4.
+   */
+  bool get_focus_on_click() const;
+
+  
+  /** Sets the alignment of the child. This property has no effect unless 
+   * the child is a Gtk::Misc or a Gtk::Aligment.
+   * 
+   * Since: 2.4
+   * @param xalign The horizontal position of the child, 0.0 is left aligned, 
+   * 1.0 is right aligned.
+   * @param yalign The vertical position of the child, 0.0 is top aligned, 
+   * 1.0 is bottom aligned.
+   */
+  void set_alignment(float xalign, float yalign);
+  
+  /** Gets the alignment of the child in the button.
+   * 
+   * Since: 2.4
+   * @param xalign Return location for horizontal alignment.
+   * @param yalign Return location for vertical alignment.
+   */
+  void get_alignment(float& xalign, float& yalign);
+
+  
+  /** Set the image of @a button  to the given widget. Note that
+   * it depends on the show-button-images setting whether the
+   * image will be displayed or not.
+   * 
+   * Since: 2.6
+   * @param image A widget to set as the image for the button.
+   */
+  void set_image(Widget& image);
+  
+  /** Gets the widget that is currenty set as the image of @a button .
+   * This may have been explicitly set by set_image()
+   * or constructed by new_from_stock().
+   * 
+   * Since: 2.6
+   */
+  Widget* get_image();
+  
+  /** Gets the widget that is currenty set as the image of @a button .
+   * This may have been explicitly set by set_image()
+   * or constructed by new_from_stock().
+   * 
+   * Since: 2.6
+   */
+  const Widget* get_image() const;
+   
+  
+  Glib::SignalProxy0< void > signal_pressed();
+
+  
+  Glib::SignalProxy0< void > signal_released();
+
+  
+  Glib::SignalProxy0< void > signal_clicked();
+
+  
+  Glib::SignalProxy0< void > signal_enter();
+
+  
+  Glib::SignalProxy0< void > signal_leave();
+
+  
+  Glib::SignalProxy0< void > signal_activate();
+
+
+  /** Text of the label widget inside the button
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Glib::ustring> property_label() ;
+
+/** Text of the label widget inside the button
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Glib::ustring> property_label() const;
+
+  /** The border relief style.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<ReliefStyle> property_relief() ;
+
+/** The border relief style.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<ReliefStyle> property_relief() const;
+
+  /** If set
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_use_underline() ;
+
+/** If set
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_use_underline() const;
+
+  /** If set
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_use_stock() ;
+
+/** If set
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_use_stock() const;
+
+  /** Whether the button grabs focus when it is clicked with the mouse.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_focus_on_click() ;
+
+/** Whether the button grabs focus when it is clicked with the mouse.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_focus_on_click() const;
+
+  /** Horizontal position of child in available space. 0.0 is left aligned
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<float> property_xalign() ;
+
+/** Horizontal position of child in available space. 0.0 is left aligned
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<float> property_xalign() const;
+
+  /** Vertical position of child in available space. 0.0 is top aligned
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<float> property_yalign() ;
+
+/** Vertical position of child in available space. 0.0 is top aligned
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<float> property_yalign() const;
+
+  /** Child widget to appear next to the button text.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Gtk::Widget*> property_image() ;
+
+/** Child widget to appear next to the button text.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Gtk::Widget*> property_image() const;
+
+
+};
+
+/*! A Gtk::Button example.
+ * Example 1: @link book/buttons/button/buttons.h @endlink
+ * Example 2: @link book/buttons/button/buttons.cc @endlink
+ * Example 3: @link book/buttons/button/main.cc @endlink
+ */
+
+} // namespace Gtk
+
+
+namespace Glib
+{
+  /** @relates Gtk::Button
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gtk::Button* wrap(GtkButton* object, bool take_copy = false);
+}
+#endif /* _GTKMM_BUTTON_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/buttonbox.cc b/libs/gtkmm2/gtk/gtkmm/buttonbox.cc
new file mode 100644
index 0000000000..7fe9bd53f6
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/buttonbox.cc
@@ -0,0 +1,389 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/buttonbox.h>
+#include <gtkmm/private/buttonbox_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* 
+ *
+ * Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtk/gtkhbbox.h>
+#include <gtk/gtkvbbox.h>
+
+namespace Gtk
+{
+
+VButtonBox::VButtonBox(ButtonBoxStyle layout, int spacing)
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  ButtonBox(Glib::ConstructParams(vbuttonbox_class_.init(), (char*) 0))
+{
+  set_layout(layout);
+  set_spacing(spacing);
+}
+
+HButtonBox::HButtonBox(ButtonBoxStyle layout, int spacing)
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  ButtonBox(Glib::ConstructParams(hbuttonbox_class_.init(), (char*) 0))
+{
+  set_layout(layout);
+  set_spacing(spacing);
+}
+
+} // namespace Gtk
+
+
+namespace
+{
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Gtk::ButtonBox* wrap(GtkButtonBox* object, bool take_copy)
+{
+  return dynamic_cast<Gtk::ButtonBox *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& ButtonBox_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &ButtonBox_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_button_box_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void ButtonBox_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+}
+
+
+Glib::ObjectBase* ButtonBox_Class::wrap_new(GObject* o)
+{
+  return manage(new ButtonBox((GtkButtonBox*)(o)));
+
+}
+
+
+/* The implementation: */
+
+ButtonBox::ButtonBox(const Glib::ConstructParams& construct_params)
+:
+  Gtk::Box(construct_params)
+{
+  }
+
+ButtonBox::ButtonBox(GtkButtonBox* castitem)
+:
+  Gtk::Box((GtkBox*)(castitem))
+{
+  }
+
+ButtonBox::~ButtonBox()
+{
+  destroy_();
+}
+
+ButtonBox::CppClassType ButtonBox::buttonbox_class_; // initialize static member
+
+GType ButtonBox::get_type()
+{
+  return buttonbox_class_.init().get_type();
+}
+
+GType ButtonBox::get_base_type()
+{
+  return gtk_button_box_get_type();
+}
+
+
+ButtonBoxStyle ButtonBox::get_layout() const
+{
+  return ((ButtonBoxStyle)(gtk_button_box_get_layout(const_cast<GtkButtonBox*>(gobj()))));
+}
+
+void ButtonBox::set_layout(ButtonBoxStyle layout_style)
+{
+  gtk_button_box_set_layout(gobj(), ((GtkButtonBoxStyle)(layout_style)));
+}
+
+void ButtonBox::set_child_secondary(Widget& child, bool is_secondary)
+{
+  gtk_button_box_set_child_secondary(gobj(), (child).gobj(), static_cast<int>(is_secondary));
+}
+
+bool ButtonBox::get_child_secondary(const Gtk::Widget& child) const
+{
+  return gtk_button_box_get_child_secondary(const_cast<GtkButtonBox*>(gobj()), const_cast<GtkWidget*>(child.gobj()));
+}
+
+int ButtonBox::get_child_min_width() const
+{
+  return gobj()->child_min_width;
+}
+
+void ButtonBox::set_child_min_width(const int& value)
+{
+  gobj()->child_min_width = value;
+}
+
+int ButtonBox::get_child_min_height() const
+{
+  return gobj()->child_min_height;
+}
+
+void ButtonBox::set_child_min_height(const int& value)
+{
+  gobj()->child_min_height = value;
+}
+
+int ButtonBox::get_child_ipadding_x() const
+{
+  return gobj()->child_ipad_x;
+}
+
+void ButtonBox::set_child_ipadding_x(const int& value)
+{
+  gobj()->child_ipad_x = value;
+}
+
+int ButtonBox::get_child_ipadding_y() const
+{
+  return gobj()->child_ipad_y;
+}
+
+void ButtonBox::set_child_ipadding_y(const int& value)
+{
+  gobj()->child_ipad_y = value;
+}
+
+
+Glib::PropertyProxy<ButtonBoxStyle> ButtonBox::property_layout_style() 
+{
+  return Glib::PropertyProxy<ButtonBoxStyle>(this, "layout-style");
+}
+
+Glib::PropertyProxy_ReadOnly<ButtonBoxStyle> ButtonBox::property_layout_style() const
+{
+  return Glib::PropertyProxy_ReadOnly<ButtonBoxStyle>(this, "layout-style");
+}
+
+
+} // namespace Gtk
+
+
+namespace Glib
+{
+
+Gtk::VButtonBox* wrap(GtkVButtonBox* object, bool take_copy)
+{
+  return dynamic_cast<Gtk::VButtonBox *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& VButtonBox_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &VButtonBox_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_vbutton_box_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void VButtonBox_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+}
+
+
+Glib::ObjectBase* VButtonBox_Class::wrap_new(GObject* o)
+{
+  return manage(new VButtonBox((GtkVButtonBox*)(o)));
+
+}
+
+
+/* The implementation: */
+
+VButtonBox::VButtonBox(const Glib::ConstructParams& construct_params)
+:
+  Gtk::ButtonBox(construct_params)
+{
+  }
+
+VButtonBox::VButtonBox(GtkVButtonBox* castitem)
+:
+  Gtk::ButtonBox((GtkButtonBox*)(castitem))
+{
+  }
+
+VButtonBox::~VButtonBox()
+{
+  destroy_();
+}
+
+VButtonBox::CppClassType VButtonBox::vbuttonbox_class_; // initialize static member
+
+GType VButtonBox::get_type()
+{
+  return vbuttonbox_class_.init().get_type();
+}
+
+GType VButtonBox::get_base_type()
+{
+  return gtk_vbutton_box_get_type();
+}
+
+
+} // namespace Gtk
+
+
+namespace Glib
+{
+
+Gtk::HButtonBox* wrap(GtkHButtonBox* object, bool take_copy)
+{
+  return dynamic_cast<Gtk::HButtonBox *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& HButtonBox_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &HButtonBox_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_hbutton_box_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void HButtonBox_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+}
+
+
+Glib::ObjectBase* HButtonBox_Class::wrap_new(GObject* o)
+{
+  return manage(new HButtonBox((GtkHButtonBox*)(o)));
+
+}
+
+
+/* The implementation: */
+
+HButtonBox::HButtonBox(const Glib::ConstructParams& construct_params)
+:
+  Gtk::ButtonBox(construct_params)
+{
+  }
+
+HButtonBox::HButtonBox(GtkHButtonBox* castitem)
+:
+  Gtk::ButtonBox((GtkButtonBox*)(castitem))
+{
+  }
+
+HButtonBox::~HButtonBox()
+{
+  destroy_();
+}
+
+HButtonBox::CppClassType HButtonBox::hbuttonbox_class_; // initialize static member
+
+GType HButtonBox::get_type()
+{
+  return hbuttonbox_class_.init().get_type();
+}
+
+GType HButtonBox::get_base_type()
+{
+  return gtk_hbutton_box_get_type();
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/buttonbox.h b/libs/gtkmm2/gtk/gtkmm/buttonbox.h
new file mode 100644
index 0000000000..6f39c6aed9
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/buttonbox.h
@@ -0,0 +1,361 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_BUTTONBOX_H
+#define _GTKMM_BUTTONBOX_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* buttonbox.h
+ * 
+ * Copyright (C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/box.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkButtonBox GtkButtonBox;
+typedef struct _GtkButtonBoxClass GtkButtonBoxClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class ButtonBox_Class; } // namespace Gtk
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkVButtonBox GtkVButtonBox;
+typedef struct _GtkVButtonBoxClass GtkVButtonBoxClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class VButtonBox_Class; } // namespace Gtk
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkHButtonBox GtkHButtonBox;
+typedef struct _GtkHButtonBoxClass GtkHButtonBoxClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class HButtonBox_Class; } // namespace Gtk
+namespace Gtk
+{
+
+// This is a #define in GTK+, and unrelated to the GtkButtonBoxStyle enum.
+/** @ingroup gtkmmEnums */
+enum { BUTTONBOX_DEFAULT = -1 };
+
+
+/** Base class for Gtk::HButtonBox and Gtk::VButtonBox
+ *
+ * A button box should be used to provide a consistent layout of buttons
+ * throughout your application.  There is one default layout and a default
+ * spacing value that are persistant across all ButtonBox widgets.
+ */
+
+class ButtonBox : public Box
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef ButtonBox CppObjectType;
+  typedef ButtonBox_Class CppClassType;
+  typedef GtkButtonBox BaseObjectType;
+  typedef GtkButtonBoxClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~ButtonBox();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class ButtonBox_Class;
+  static CppClassType buttonbox_class_;
+
+  // noncopyable
+  ButtonBox(const ButtonBox&);
+  ButtonBox& operator=(const ButtonBox&);
+
+protected:
+  explicit ButtonBox(const Glib::ConstructParams& construct_params);
+  explicit ButtonBox(GtkButtonBox* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GtkButtonBox*       gobj()       { return reinterpret_cast<GtkButtonBox*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GtkButtonBox* gobj() const { return reinterpret_cast<GtkButtonBox*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+private:
+
+  
+public:
+  
+  ButtonBoxStyle get_layout() const;
+  
+  void set_layout(ButtonBoxStyle layout_style);
+  
+  
+  /** Sets whether @a child  should appear in a secondary group of children.
+   * A typical use of a secondary child is the help button in a dialog.
+   * 
+   * This group appears after the other children if the style
+   * is Gtk::BUTTONBOX_START, Gtk::BUTTONBOX_SPREAD or
+   * Gtk::BUTTONBOX_EDGE, and before the the other children if the style
+   * is Gtk::BUTTONBOX_END. For horizontal button boxes, the definition
+   * of before/after depends on direction of the widget (see
+   * Gtk::Widget::set_direction()). If the style is Gtk::BUTTONBOX_START
+   * or Gtk::BUTTONBOX_END, then the secondary children are aligned at
+   * the other end of the button box from the main children. For the
+   * other styles, they appear immediately next to the main children.
+   * @param child A child of @a widget .
+   * @param is_secondary If <tt>true</tt>, the @a child  appears in a secondary group of the
+   * button box.
+   */
+  void set_child_secondary(Widget& child, bool is_secondary = true);
+  
+  /** Returns whether @a child  should appear in a secondary group of children.
+   * @param child A child of @a widget .
+   * @return Whether @a child  should appear in a secondary group of children.
+   * 
+   * Since: 2.4.
+   */
+  bool get_child_secondary(const Gtk::Widget& child) const;
+
+  int get_child_min_width() const;
+  void set_child_min_width(const int& value);
+
+  int get_child_min_height() const;
+  void set_child_min_height(const int& value);
+
+  int get_child_ipadding_x() const;
+  void set_child_ipadding_x(const int& value);
+
+  int get_child_ipadding_y() const;
+  void set_child_ipadding_y(const int& value);
+
+  /** How to layout the buttons in the box. Possible values are default
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<ButtonBoxStyle> property_layout_style() ;
+
+/** How to layout the buttons in the box. Possible values are default
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<ButtonBoxStyle> property_layout_style() const;
+
+
+};
+
+/** A container for arranging buttons vertically.
+ *
+ * A button box should be used to provide a consistent layout of buttons
+ * throughout your application. There is one default layout and a default spacing
+ * value that are persistant across all Gtk::VButtonBox widgets. 
+ *
+ * The layout/spacing can then be altered by the programmer, or if desired,
+ * by the user to alter the 'feel' of a program to a small degree. 
+ *
+ * @ingroup Widgets
+ * @ingroup Containers
+ */
+
+class VButtonBox : public ButtonBox
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef VButtonBox CppObjectType;
+  typedef VButtonBox_Class CppClassType;
+  typedef GtkVButtonBox BaseObjectType;
+  typedef GtkVButtonBoxClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~VButtonBox();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class VButtonBox_Class;
+  static CppClassType vbuttonbox_class_;
+
+  // noncopyable
+  VButtonBox(const VButtonBox&);
+  VButtonBox& operator=(const VButtonBox&);
+
+protected:
+  explicit VButtonBox(const Glib::ConstructParams& construct_params);
+  explicit VButtonBox(GtkVButtonBox* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GtkVButtonBox*       gobj()       { return reinterpret_cast<GtkVButtonBox*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GtkVButtonBox* gobj() const { return reinterpret_cast<GtkVButtonBox*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+private:
+
+public:
+  explicit VButtonBox(ButtonBoxStyle layout = BUTTONBOX_DEFAULT_STYLE, int spacing = BUTTONBOX_DEFAULT);
+
+
+};
+
+/** A container for arranging buttons horizontally.
+ *
+ * A button box should be used to provide a consistent layout of buttons
+ * throughout your application. There is one default layout and a default spacing
+ * value that are persistant across all Gtk::HButtonBox widgets. 
+ *
+ * The layout/spacing can then be altered by the programmer, or if desired,
+ * by the user to alter the 'feel' of a program to a small degree. 
+ *
+ * @ingroup Widgets
+ * @ingroup Containers
+ */
+
+class HButtonBox : public ButtonBox
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef HButtonBox CppObjectType;
+  typedef HButtonBox_Class CppClassType;
+  typedef GtkHButtonBox BaseObjectType;
+  typedef GtkHButtonBoxClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~HButtonBox();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class HButtonBox_Class;
+  static CppClassType hbuttonbox_class_;
+
+  // noncopyable
+  HButtonBox(const HButtonBox&);
+  HButtonBox& operator=(const HButtonBox&);
+
+protected:
+  explicit HButtonBox(const Glib::ConstructParams& construct_params);
+  explicit HButtonBox(GtkHButtonBox* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GtkHButtonBox*       gobj()       { return reinterpret_cast<GtkHButtonBox*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GtkHButtonBox* gobj() const { return reinterpret_cast<GtkHButtonBox*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+private:
+
+public:
+  explicit HButtonBox(ButtonBoxStyle layout = BUTTONBOX_DEFAULT_STYLE, int spacing = BUTTONBOX_DEFAULT);
+
+
+};
+
+} // namespace Gtk
+
+
+namespace Glib
+{
+  /** @relates Gtk::ButtonBox
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gtk::ButtonBox* wrap(GtkButtonBox* object, bool take_copy = false);
+}
+namespace Glib
+{
+  /** @relates Gtk::VButtonBox
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gtk::VButtonBox* wrap(GtkVButtonBox* object, bool take_copy = false);
+}
+namespace Glib
+{
+  /** @relates Gtk::HButtonBox
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gtk::HButtonBox* wrap(GtkHButtonBox* object, bool take_copy = false);
+}
+#endif /* _GTKMM_BUTTONBOX_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/calendar.cc b/libs/gtkmm2/gtk/gtkmm/calendar.cc
new file mode 100644
index 0000000000..66add813c7
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/calendar.cc
@@ -0,0 +1,605 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/calendar.h>
+#include <gtkmm/private/calendar_p.h>
+
+#include <gtk/gtktypebuiltins.h>
+// -*- c++ -*-
+/* $Id$ */
+
+/* 
+ *
+ * Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtk/gtkcalendar.h>
+
+namespace Gtk
+{
+
+}
+
+
+namespace
+{
+
+const Glib::SignalProxyInfo Calendar_signal_month_changed_info =
+{
+  "month_changed",
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
+};
+
+
+const Glib::SignalProxyInfo Calendar_signal_day_selected_info =
+{
+  "day_selected",
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
+};
+
+
+const Glib::SignalProxyInfo Calendar_signal_day_selected_double_click_info =
+{
+  "day_selected_double_click",
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
+};
+
+
+const Glib::SignalProxyInfo Calendar_signal_prev_month_info =
+{
+  "prev_month",
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
+};
+
+
+const Glib::SignalProxyInfo Calendar_signal_next_month_info =
+{
+  "next_month",
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
+};
+
+
+const Glib::SignalProxyInfo Calendar_signal_prev_year_info =
+{
+  "prev_year",
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
+};
+
+
+const Glib::SignalProxyInfo Calendar_signal_next_year_info =
+{
+  "next_year",
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
+};
+
+} // anonymous namespace
+
+// static
+GType Glib::Value<Gtk::CalendarDisplayOptions>::value_type()
+{
+  return gtk_calendar_display_options_get_type();
+}
+
+
+namespace Glib
+{
+
+Gtk::Calendar* wrap(GtkCalendar* object, bool take_copy)
+{
+  return dynamic_cast<Gtk::Calendar *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& Calendar_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &Calendar_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_calendar_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void Calendar_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+  klass->month_changed = &month_changed_callback;
+  klass->day_selected = &day_selected_callback;
+  klass->day_selected_double_click = &day_selected_double_click_callback;
+  klass->prev_month = &prev_month_callback;
+  klass->next_month = &next_month_callback;
+  klass->prev_year = &prev_year_callback;
+  klass->next_year = &next_year_callback;
+}
+
+
+void Calendar_Class::month_changed_callback(GtkCalendar* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_month_changed();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->month_changed)
+      (*base->month_changed)(self);
+  }
+}
+
+void Calendar_Class::day_selected_callback(GtkCalendar* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_day_selected();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->day_selected)
+      (*base->day_selected)(self);
+  }
+}
+
+void Calendar_Class::day_selected_double_click_callback(GtkCalendar* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_day_selected_double_click();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->day_selected_double_click)
+      (*base->day_selected_double_click)(self);
+  }
+}
+
+void Calendar_Class::prev_month_callback(GtkCalendar* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_prev_month();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->prev_month)
+      (*base->prev_month)(self);
+  }
+}
+
+void Calendar_Class::next_month_callback(GtkCalendar* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_next_month();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->next_month)
+      (*base->next_month)(self);
+  }
+}
+
+void Calendar_Class::prev_year_callback(GtkCalendar* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_prev_year();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->prev_year)
+      (*base->prev_year)(self);
+  }
+}
+
+void Calendar_Class::next_year_callback(GtkCalendar* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_next_year();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->next_year)
+      (*base->next_year)(self);
+  }
+}
+
+
+Glib::ObjectBase* Calendar_Class::wrap_new(GObject* o)
+{
+  return manage(new Calendar((GtkCalendar*)(o)));
+
+}
+
+
+/* The implementation: */
+
+Calendar::Calendar(const Glib::ConstructParams& construct_params)
+:
+  Gtk::Widget(construct_params)
+{
+  }
+
+Calendar::Calendar(GtkCalendar* castitem)
+:
+  Gtk::Widget((GtkWidget*)(castitem))
+{
+  }
+
+Calendar::~Calendar()
+{
+  destroy_();
+}
+
+Calendar::CppClassType Calendar::calendar_class_; // initialize static member
+
+GType Calendar::get_type()
+{
+  return calendar_class_.init().get_type();
+}
+
+GType Calendar::get_base_type()
+{
+  return gtk_calendar_get_type();
+}
+
+
+Calendar::Calendar()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Widget(Glib::ConstructParams(calendar_class_.init()))
+{
+  }
+
+int Calendar::select_month(guint month, guint year)
+{
+  return gtk_calendar_select_month(gobj(), month, year);
+}
+
+void Calendar::select_day(guint day)
+{
+  gtk_calendar_select_day(gobj(), day);
+}
+
+int Calendar::mark_day(guint day)
+{
+  return gtk_calendar_mark_day(gobj(), day);
+}
+
+int Calendar::unmark_day(guint day)
+{
+  return gtk_calendar_unmark_day(gobj(), day);
+}
+
+void Calendar::clear_marks()
+{
+  gtk_calendar_clear_marks(gobj());
+}
+
+void Calendar::display_options(CalendarDisplayOptions flags)
+{
+  gtk_calendar_display_options(gobj(), ((GtkCalendarDisplayOptions)(flags)));
+}
+
+void Calendar::set_display_options(CalendarDisplayOptions flags)
+{
+  gtk_calendar_set_display_options(gobj(), ((GtkCalendarDisplayOptions)(flags)));
+}
+
+CalendarDisplayOptions Calendar::get_display_options() const
+{
+  return ((CalendarDisplayOptions)(gtk_calendar_get_display_options(const_cast<GtkCalendar*>(gobj()))));
+}
+
+void Calendar::get_date(guint& year, guint& month, guint& day) const
+{
+  gtk_calendar_get_date(const_cast<GtkCalendar*>(gobj()), &(year), &(month), &(day));
+}
+
+void Calendar::freeze()
+{
+  gtk_calendar_freeze(gobj());
+}
+
+void Calendar::thaw()
+{
+  gtk_calendar_thaw(gobj());
+}
+
+
+Glib::SignalProxy0< void > Calendar::signal_month_changed()
+{
+  return Glib::SignalProxy0< void >(this, &Calendar_signal_month_changed_info);
+}
+
+Glib::SignalProxy0< void > Calendar::signal_day_selected()
+{
+  return Glib::SignalProxy0< void >(this, &Calendar_signal_day_selected_info);
+}
+
+Glib::SignalProxy0< void > Calendar::signal_day_selected_double_click()
+{
+  return Glib::SignalProxy0< void >(this, &Calendar_signal_day_selected_double_click_info);
+}
+
+Glib::SignalProxy0< void > Calendar::signal_prev_month()
+{
+  return Glib::SignalProxy0< void >(this, &Calendar_signal_prev_month_info);
+}
+
+Glib::SignalProxy0< void > Calendar::signal_next_month()
+{
+  return Glib::SignalProxy0< void >(this, &Calendar_signal_next_month_info);
+}
+
+Glib::SignalProxy0< void > Calendar::signal_prev_year()
+{
+  return Glib::SignalProxy0< void >(this, &Calendar_signal_prev_year_info);
+}
+
+Glib::SignalProxy0< void > Calendar::signal_next_year()
+{
+  return Glib::SignalProxy0< void >(this, &Calendar_signal_next_year_info);
+}
+
+
+void Gtk::Calendar::on_month_changed()
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->month_changed)
+    (*base->month_changed)(gobj());
+}
+
+void Gtk::Calendar::on_day_selected()
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->day_selected)
+    (*base->day_selected)(gobj());
+}
+
+void Gtk::Calendar::on_day_selected_double_click()
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->day_selected_double_click)
+    (*base->day_selected_double_click)(gobj());
+}
+
+void Gtk::Calendar::on_prev_month()
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->prev_month)
+    (*base->prev_month)(gobj());
+}
+
+void Gtk::Calendar::on_next_month()
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->next_month)
+    (*base->next_month)(gobj());
+}
+
+void Gtk::Calendar::on_prev_year()
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->prev_year)
+    (*base->prev_year)(gobj());
+}
+
+void Gtk::Calendar::on_next_year()
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->next_year)
+    (*base->next_year)(gobj());
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/calendar.h b/libs/gtkmm2/gtk/gtkmm/calendar.h
new file mode 100644
index 0000000000..a026c941e6
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/calendar.h
@@ -0,0 +1,273 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_CALENDAR_H
+#define _GTKMM_CALENDAR_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* calendar.h
+ * 
+ * Copyright (C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/widget.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkCalendar GtkCalendar;
+typedef struct _GtkCalendarClass GtkCalendarClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class Calendar_Class; } // namespace Gtk
+namespace Gtk
+{
+
+
+/** @addtogroup gtkmmEnums Enums and Flags */
+
+/**
+ * @ingroup gtkmmEnums
+ * @par Bitwise operators:
+ * <tt>%CalendarDisplayOptions operator|(CalendarDisplayOptions, CalendarDisplayOptions)</tt><br>
+ * <tt>%CalendarDisplayOptions operator&(CalendarDisplayOptions, CalendarDisplayOptions)</tt><br>
+ * <tt>%CalendarDisplayOptions operator^(CalendarDisplayOptions, CalendarDisplayOptions)</tt><br>
+ * <tt>%CalendarDisplayOptions operator~(CalendarDisplayOptions)</tt><br>
+ * <tt>%CalendarDisplayOptions& operator|=(CalendarDisplayOptions&, CalendarDisplayOptions)</tt><br>
+ * <tt>%CalendarDisplayOptions& operator&=(CalendarDisplayOptions&, CalendarDisplayOptions)</tt><br>
+ * <tt>%CalendarDisplayOptions& operator^=(CalendarDisplayOptions&, CalendarDisplayOptions)</tt><br>
+ */
+enum CalendarDisplayOptions
+{
+  CALENDAR_SHOW_HEADING = 1 << 0,
+  CALENDAR_SHOW_DAY_NAMES = 1 << 1,
+  CALENDAR_NO_MONTH_CHANGE = 1 << 2,
+  CALENDAR_SHOW_WEEK_NUMBERS = 1 << 3,
+  CALENDAR_WEEK_START_MONDAY = 1 << 4
+};
+
+/** @ingroup gtkmmEnums */
+inline CalendarDisplayOptions operator|(CalendarDisplayOptions lhs, CalendarDisplayOptions rhs)
+  { return static_cast<CalendarDisplayOptions>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs)); }
+
+/** @ingroup gtkmmEnums */
+inline CalendarDisplayOptions operator&(CalendarDisplayOptions lhs, CalendarDisplayOptions rhs)
+  { return static_cast<CalendarDisplayOptions>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs)); }
+
+/** @ingroup gtkmmEnums */
+inline CalendarDisplayOptions operator^(CalendarDisplayOptions lhs, CalendarDisplayOptions rhs)
+  { return static_cast<CalendarDisplayOptions>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs)); }
+
+/** @ingroup gtkmmEnums */
+inline CalendarDisplayOptions operator~(CalendarDisplayOptions flags)
+  { return static_cast<CalendarDisplayOptions>(~static_cast<unsigned>(flags)); }
+
+/** @ingroup gtkmmEnums */
+inline CalendarDisplayOptions& operator|=(CalendarDisplayOptions& lhs, CalendarDisplayOptions rhs)
+  { return (lhs = static_cast<CalendarDisplayOptions>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs))); }
+
+/** @ingroup gtkmmEnums */
+inline CalendarDisplayOptions& operator&=(CalendarDisplayOptions& lhs, CalendarDisplayOptions rhs)
+  { return (lhs = static_cast<CalendarDisplayOptions>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs))); }
+
+/** @ingroup gtkmmEnums */
+inline CalendarDisplayOptions& operator^=(CalendarDisplayOptions& lhs, CalendarDisplayOptions rhs)
+  { return (lhs = static_cast<CalendarDisplayOptions>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs))); }
+
+} // namespace Gtk
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Gtk::CalendarDisplayOptions> : public Glib::Value_Flags<Gtk::CalendarDisplayOptions>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{
+
+
+/** Display a calendar and/or allow the user to select a date.
+ *
+ * This is a widget that displays a calendar, one month at a time.
+ *
+ * The month and year currently displayed can be altered with
+ * select_month().  The exact day can be selected from the displayed month
+ * using select_day().
+ *
+ * The way in which the calendar itself is displayed can be altered using
+ * set_display_options().
+ *
+ * The selected date can be retrieved from a GtkCalendar using get_date().
+ *
+ * If performing many 'mark' operations, the calendar can be frozen to
+ * prevent flicker, using freeze(), and 'thawed' again using thaw().
+ *
+ * @ingroup Widgets
+ */
+
+class Calendar : public Widget
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Calendar CppObjectType;
+  typedef Calendar_Class CppClassType;
+  typedef GtkCalendar BaseObjectType;
+  typedef GtkCalendarClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~Calendar();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class Calendar_Class;
+  static CppClassType calendar_class_;
+
+  // noncopyable
+  Calendar(const Calendar&);
+  Calendar& operator=(const Calendar&);
+
+protected:
+  explicit Calendar(const Glib::ConstructParams& construct_params);
+  explicit Calendar(GtkCalendar* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GtkCalendar*       gobj()       { return reinterpret_cast<GtkCalendar*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GtkCalendar* gobj() const { return reinterpret_cast<GtkCalendar*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+  virtual void on_month_changed();
+  virtual void on_day_selected();
+  virtual void on_day_selected_double_click();
+  virtual void on_prev_month();
+  virtual void on_next_month();
+  virtual void on_prev_year();
+  virtual void on_next_year();
+
+
+private:
+
+public:
+  Calendar();
+  
+  
+  int select_month(guint month, guint year);
+  
+  void select_day(guint day);
+  
+  int mark_day(guint day);
+  
+  int unmark_day(guint day);
+  
+  void clear_marks();
+
+  #ifndef GTKMM_DISABLE_DEPRECATED
+  
+  void display_options(CalendarDisplayOptions flags);
+  #endif //GTKMM_DISABLE_DEPRECATED
+  
+  
+  /** Sets display options (whether to display the heading and the month  
+   * headings).
+   * 
+   * Since: 2.4
+   * @param flags The display options to set.
+   */
+  void set_display_options(CalendarDisplayOptions flags);
+  
+  /** Returns the current display options of @a calendar .
+   * @return The display options.
+   * 
+   * Since: 2.4.
+   */
+  CalendarDisplayOptions get_display_options() const;
+
+  
+  void get_date(guint& year, guint& month, guint& day) const;
+  
+  void freeze();
+  
+  void thaw();
+
+  
+  Glib::SignalProxy0< void > signal_month_changed();
+
+  
+  Glib::SignalProxy0< void > signal_day_selected();
+
+  
+  Glib::SignalProxy0< void > signal_day_selected_double_click();
+
+  
+  Glib::SignalProxy0< void > signal_prev_month();
+
+  
+  Glib::SignalProxy0< void > signal_next_month();
+
+  
+  Glib::SignalProxy0< void > signal_prev_year();
+
+  
+  Glib::SignalProxy0< void > signal_next_year();
+
+
+};
+
+} /* namespace Gtk */
+
+
+namespace Glib
+{
+  /** @relates Gtk::Calendar
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gtk::Calendar* wrap(GtkCalendar* object, bool take_copy = false);
+}
+#endif /* _GTKMM_CALENDAR_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/celleditable.cc b/libs/gtkmm2/gtk/gtkmm/celleditable.cc
new file mode 100644
index 0000000000..2f0d2a5b1b
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/celleditable.cc
@@ -0,0 +1,307 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/celleditable.h>
+#include <gtkmm/private/celleditable_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtk/gtkcelleditable.h>
+
+
+namespace
+{
+
+const Glib::SignalProxyInfo CellEditable_signal_editing_done_info =
+{
+  "editing_done",
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
+};
+
+
+const Glib::SignalProxyInfo CellEditable_signal_remove_widget_info =
+{
+  "remove_widget",
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
+};
+
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Glib::RefPtr<Gtk::CellEditable> wrap(GtkCellEditable* object, bool take_copy)
+{
+  return Glib::RefPtr<Gtk::CellEditable>( dynamic_cast<Gtk::CellEditable*> (Glib::wrap_auto ((GObject*)(object), take_copy)) );
+  //We use dynamic_cast<> in case of multiple inheritance.
+}
+
+} // namespace Glib
+
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Interface_Class& CellEditable_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Interface_Class has to know the interface init function
+    // in order to add interfaces to implementing types.
+    class_init_func_ = &CellEditable_Class::iface_init_function;
+
+    // We can not derive from another interface, and it is not necessary anyway.
+    gtype_ = gtk_cell_editable_get_type();
+  }
+
+  return *this;
+}
+
+void CellEditable_Class::iface_init_function(void* g_iface, void*)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_iface);
+
+  //This is just to avoid an "unused variable" warning when there are no vfuncs or signal handlers to connect.
+  //This is a temporary fix until I find out why I can not seem to derive a GtkFileChooser interface. murrayc
+  g_assert(klass != 0); 
+
+  klass->start_editing = &start_editing_vfunc_callback;
+  klass->editing_done = &editing_done_callback;
+  klass->remove_widget = &remove_widget_callback;
+}
+
+void CellEditable_Class::start_editing_vfunc_callback(GtkCellEditable* self, GdkEvent* event)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->start_editing_vfunc(event);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->start_editing)
+      (*base->start_editing)(self, event);
+  }
+}
+
+
+void CellEditable_Class::editing_done_callback(GtkCellEditable* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_editing_done();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->editing_done)
+      (*base->editing_done)(self);
+  }
+}
+
+void CellEditable_Class::remove_widget_callback(GtkCellEditable* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_remove_widget();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->remove_widget)
+      (*base->remove_widget)(self);
+  }
+}
+
+
+Glib::ObjectBase* CellEditable_Class::wrap_new(GObject* object)
+{
+  return new CellEditable((GtkCellEditable*)(object));
+}
+
+
+/* The implementation: */
+
+CellEditable::CellEditable()
+:
+  Glib::Interface(celleditable_class_.init())
+{}
+
+CellEditable::CellEditable(GtkCellEditable* castitem)
+:
+  Glib::Interface((GObject*)(castitem))
+{}
+
+CellEditable::~CellEditable()
+{}
+
+// static
+void CellEditable::add_interface(GType gtype_implementer)
+{
+  celleditable_class_.init().add_interface(gtype_implementer);
+}
+
+CellEditable::CppClassType CellEditable::celleditable_class_; // initialize static member
+
+GType CellEditable::get_type()
+{
+  return celleditable_class_.init().get_type();
+}
+
+GType CellEditable::get_base_type()
+{
+  return gtk_cell_editable_get_type();
+}
+
+
+void CellEditable::start_editing(GdkEvent* event)
+{
+  gtk_cell_editable_start_editing(gobj(), event);
+}
+
+void CellEditable::editing_done()
+{
+  gtk_cell_editable_editing_done(gobj());
+}
+
+void CellEditable::remove_widget()
+{
+  gtk_cell_editable_remove_widget(gobj());
+}
+
+
+Glib::SignalProxy0< void > CellEditable::signal_editing_done()
+{
+  return Glib::SignalProxy0< void >(this, &CellEditable_signal_editing_done_info);
+}
+
+Glib::SignalProxy0< void > CellEditable::signal_remove_widget()
+{
+  return Glib::SignalProxy0< void >(this, &CellEditable_signal_remove_widget_info);
+}
+
+
+void Gtk::CellEditable::on_editing_done()
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->editing_done)
+    (*base->editing_done)(gobj());
+}
+
+void Gtk::CellEditable::on_remove_widget()
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->remove_widget)
+    (*base->remove_widget)(gobj());
+}
+
+
+void Gtk::CellEditable::start_editing_vfunc(GdkEvent* event) 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->start_editing)
+    (*base->start_editing)(gobj(),event);
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/celleditable.h b/libs/gtkmm2/gtk/gtkmm/celleditable.h
new file mode 100644
index 0000000000..8d2bfdd6c5
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/celleditable.h
@@ -0,0 +1,158 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_CELLEDITABLE_H
+#define _GTKMM_CELLEDITABLE_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* Copyright (C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <glibmm/interface.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+extern "C"
+{
+typedef struct _GtkCellEditableIface GtkCellEditableIface;
+typedef union _GdkEvent GdkEvent;
+}
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkCellEditable GtkCellEditable;
+typedef struct _GtkCellEditableClass GtkCellEditableClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class CellEditable_Class; } // namespace Gtk
+namespace Gtk
+{
+
+/** Interface for widgets which are used for editing cells.
+ * The CellEditable interface must be implemented for widgets to be usable when editing the contents of a TreeView cell. 
+ */
+
+class CellEditable : public Glib::Interface
+{
+  
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+public:
+  typedef CellEditable CppObjectType;
+  typedef CellEditable_Class CppClassType;
+  typedef GtkCellEditable BaseObjectType;
+  typedef GtkCellEditableIface BaseClassType;
+
+private:
+  friend class CellEditable_Class;
+  static CppClassType celleditable_class_;
+
+  // noncopyable
+  CellEditable(const CellEditable&);
+  CellEditable& operator=(const CellEditable&);
+
+protected:
+  CellEditable(); // you must derive from this class
+  explicit CellEditable(GtkCellEditable* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+  virtual ~CellEditable();
+
+  static void add_interface(GType gtype_implementer);
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GObject.
+  GtkCellEditable*       gobj()       { return reinterpret_cast<GtkCellEditable*>(gobject_); }
+
+  ///Provides access to the underlying C GObject.  
+  const GtkCellEditable* gobj() const { return reinterpret_cast<GtkCellEditable*>(gobject_); }
+
+private:
+
+
+public:
+  
+  /** Begins editing on a @a cell_editable .  @a event  is the Gdk::Event that began the
+   * editing process.  It may be <tt>0</tt>, in the instance that editing was initiated
+   * through programatic means.
+   * @param event A Gdk::Event, or <tt>0</tt>.
+   */
+  void start_editing(GdkEvent* event);
+  
+  /** Emits the "editing_done" signal.  This signal is a sign for the cell renderer
+   * to update its value from the cell.
+   */
+  void editing_done();
+  
+  /** Emits the "remove_widget" signal.  This signal is meant to indicate that the
+   * cell is finished editing, and the widget may now be destroyed.
+   */
+  void remove_widget();
+
+  
+  Glib::SignalProxy0< void > signal_editing_done();
+
+  
+  Glib::SignalProxy0< void > signal_remove_widget();
+
+
+protected:
+    virtual void start_editing_vfunc(GdkEvent* event);
+
+
+public:
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+  virtual void on_editing_done();
+  virtual void on_remove_widget();
+
+
+};
+
+} // namespace Gtk
+
+
+namespace Glib
+{
+  /** @relates Gtk::CellEditable
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Glib::RefPtr<Gtk::CellEditable> wrap(GtkCellEditable* object, bool take_copy = false);
+
+} // namespace Glib
+
+#endif /* _GTKMM_CELLEDITABLE_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/celllayout.cc b/libs/gtkmm2/gtk/gtkmm/celllayout.cc
new file mode 100644
index 0000000000..474dea3e5b
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/celllayout.cc
@@ -0,0 +1,519 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/celllayout.h>
+#include <gtkmm/private/celllayout_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* Copyright 2003 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtk/gtkcelllayout.h>
+
+
+namespace //anonymous
+{
+
+// This Signal Proxy allows the C++ coder to specify
+// a sigc::slot instead of a static function.
+class SignalProxy_CellData
+{
+public:
+  typedef Gtk::CellLayout::SlotCellData SlotType;
+
+  SignalProxy_CellData(const SlotType& slot)
+  : slot_(slot) {}
+
+  ~SignalProxy_CellData();
+
+  static void gtk_callback(GtkCellLayout* cell_layout, GtkCellRenderer* cell, GtkTreeModel* tree_model, GtkTreeIter* iter, gpointer data);
+  static void gtk_callback_destroy(void* data);
+
+private:
+  SlotType slot_;
+};
+
+SignalProxy_CellData::~SignalProxy_CellData()
+{}
+
+void SignalProxy_CellData::gtk_callback(GtkCellLayout* /* cell_layout */, GtkCellRenderer* /* cell */, GtkTreeModel* tree_model, GtkTreeIter* iter, gpointer data)
+{
+  SignalProxy_CellData *const self = static_cast<SignalProxy_CellData*>(data);
+
+  try
+  {
+    //We ignore the cell, because that was given as an argument to the connecting method, so the caller should know which one it is already.
+    //And we ignore the tree_model because that can be obtained from the iter or from the CellLayout itself.
+    (self->slot_)(Gtk::TreeModel::const_iterator(tree_model, iter));
+  }
+  catch(...)
+  {
+    Glib::exception_handlers_invoke();
+  }
+
+}
+
+void SignalProxy_CellData::gtk_callback_destroy(void* data)
+{
+  delete static_cast<SignalProxy_CellData*>(data);
+}
+
+} // anonymous namespace
+
+
+namespace Gtk
+{
+
+void CellLayout::add_attribute(const Glib::PropertyProxy_Base& property, const TreeModelColumnBase& column)
+{
+  gtk_cell_layout_add_attribute(gobj(),
+      (GtkCellRenderer*) property.get_object()->gobj(), property.get_name(), column.index());
+}
+
+void CellLayout::set_cell_data_func(CellRenderer& cell, const SlotCellData& slot)
+{
+  // Create a signal proxy.  A pointer to this will be passed
+  // through the callback's data parameter.  It will be deleted
+  // when SignalProxy_CellData::gtk_callback_destroy() is called.
+  SignalProxy_CellData *const pSignalProxy = new SignalProxy_CellData(slot);
+
+  gtk_cell_layout_set_cell_data_func(gobj(), cell.gobj(),
+      &SignalProxy_CellData::gtk_callback, pSignalProxy,
+      &SignalProxy_CellData::gtk_callback_destroy);
+}
+  
+
+} //namespace Gtk
+
+
+namespace
+{
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Glib::RefPtr<Gtk::CellLayout> wrap(GtkCellLayout* object, bool take_copy)
+{
+  return Glib::RefPtr<Gtk::CellLayout>( dynamic_cast<Gtk::CellLayout*> (Glib::wrap_auto ((GObject*)(object), take_copy)) );
+  //We use dynamic_cast<> in case of multiple inheritance.
+}
+
+} // namespace Glib
+
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Interface_Class& CellLayout_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Interface_Class has to know the interface init function
+    // in order to add interfaces to implementing types.
+    class_init_func_ = &CellLayout_Class::iface_init_function;
+
+    // We can not derive from another interface, and it is not necessary anyway.
+    gtype_ = gtk_cell_layout_get_type();
+  }
+
+  return *this;
+}
+
+void CellLayout_Class::iface_init_function(void* g_iface, void*)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_iface);
+
+  //This is just to avoid an "unused variable" warning when there are no vfuncs or signal handlers to connect.
+  //This is a temporary fix until I find out why I can not seem to derive a GtkFileChooser interface. murrayc
+  g_assert(klass != 0); 
+
+  klass->pack_start = &pack_start_vfunc_callback;
+  klass->pack_end = &pack_end_vfunc_callback;
+  klass->clear = &clear_vfunc_callback;
+  klass->add_attribute = &add_attribute_vfunc_callback;
+  klass->clear_attributes = &clear_attributes_vfunc_callback;
+  klass->reorder = &reorder_vfunc_callback;
+}
+
+void CellLayout_Class::pack_start_vfunc_callback(GtkCellLayout* self, GtkCellRenderer* cell, gboolean expand)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->pack_start_vfunc(Glib::wrap(cell)
+, expand
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->pack_start)
+      (*base->pack_start)(self, cell, expand);
+  }
+}
+
+void CellLayout_Class::pack_end_vfunc_callback(GtkCellLayout* self, GtkCellRenderer* cell, gboolean expand)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->pack_end_vfunc(Glib::wrap(cell)
+, expand
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->pack_end)
+      (*base->pack_end)(self, cell, expand);
+  }
+}
+
+void CellLayout_Class::clear_vfunc_callback(GtkCellLayout* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->clear_vfunc();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->clear)
+      (*base->clear)(self);
+  }
+}
+
+void CellLayout_Class::add_attribute_vfunc_callback(GtkCellLayout* self, GtkCellRenderer* cell, const gchar* attribute, gint column)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->add_attribute_vfunc(Glib::wrap(cell)
+, Glib::convert_const_gchar_ptr_to_ustring(attribute)
+, column
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->add_attribute)
+      (*base->add_attribute)(self, cell, attribute, column);
+  }
+}
+
+void CellLayout_Class::clear_attributes_vfunc_callback(GtkCellLayout* self, GtkCellRenderer* cell)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->clear_attributes_vfunc(Glib::wrap(cell)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->clear_attributes)
+      (*base->clear_attributes)(self, cell);
+  }
+}
+
+void CellLayout_Class::reorder_vfunc_callback(GtkCellLayout* self, GtkCellRenderer* cell, gint position)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->reorder_vfunc(Glib::wrap(cell)
+, position
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->reorder)
+      (*base->reorder)(self, cell, position);
+  }
+}
+
+
+Glib::ObjectBase* CellLayout_Class::wrap_new(GObject* object)
+{
+  return new CellLayout((GtkCellLayout*)(object));
+}
+
+
+/* The implementation: */
+
+CellLayout::CellLayout()
+:
+  Glib::Interface(celllayout_class_.init())
+{}
+
+CellLayout::CellLayout(GtkCellLayout* castitem)
+:
+  Glib::Interface((GObject*)(castitem))
+{}
+
+CellLayout::~CellLayout()
+{}
+
+// static
+void CellLayout::add_interface(GType gtype_implementer)
+{
+  celllayout_class_.init().add_interface(gtype_implementer);
+}
+
+CellLayout::CppClassType CellLayout::celllayout_class_; // initialize static member
+
+GType CellLayout::get_type()
+{
+  return celllayout_class_.init().get_type();
+}
+
+GType CellLayout::get_base_type()
+{
+  return gtk_cell_layout_get_type();
+}
+
+
+void CellLayout::pack_start(CellRenderer& cell, bool expand)
+{
+  gtk_cell_layout_pack_start(gobj(), (cell).gobj(), static_cast<int>(expand));
+}
+
+void CellLayout::pack_end(CellRenderer& cell, bool expand)
+{
+  gtk_cell_layout_pack_end(gobj(), (cell).gobj(), static_cast<int>(expand));
+}
+
+void CellLayout::clear()
+{
+  gtk_cell_layout_clear(gobj());
+}
+
+void CellLayout::add_attribute(CellRenderer& cell, const Glib::ustring& attribute, int column)
+{
+  gtk_cell_layout_add_attribute(gobj(), (cell).gobj(), attribute.c_str(), column);
+}
+
+void CellLayout::clear_attributes(CellRenderer& cell)
+{
+  gtk_cell_layout_clear_attributes(gobj(), (cell).gobj());
+}
+
+void CellLayout::reorder(CellRenderer& cell, int position)
+{
+  gtk_cell_layout_reorder(gobj(), (cell).gobj(), position);
+}
+
+
+void Gtk::CellLayout::pack_start_vfunc(CellRenderer* cell, bool expand) 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->pack_start)
+    (*base->pack_start)(gobj(),(GtkCellRenderer*)Glib::unwrap(cell),static_cast<int>(expand));
+}
+
+void Gtk::CellLayout::pack_end_vfunc(CellRenderer* cell, bool expand) 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->pack_end)
+    (*base->pack_end)(gobj(),(GtkCellRenderer*)Glib::unwrap(cell),static_cast<int>(expand));
+}
+
+void Gtk::CellLayout::clear_vfunc() 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->clear)
+    (*base->clear)(gobj());
+}
+
+void Gtk::CellLayout::add_attribute_vfunc(CellRenderer* cell, const Glib::ustring& attribute, int column) 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->add_attribute)
+    (*base->add_attribute)(gobj(),(GtkCellRenderer*)Glib::unwrap(cell),attribute.c_str(),column);
+}
+
+void Gtk::CellLayout::clear_attributes_vfunc(CellRenderer* cell) 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->clear_attributes)
+    (*base->clear_attributes)(gobj(),(GtkCellRenderer*)Glib::unwrap(cell));
+}
+
+void Gtk::CellLayout::reorder_vfunc(CellRenderer* cell, int position) 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->reorder)
+    (*base->reorder)(gobj(),(GtkCellRenderer*)Glib::unwrap(cell),position);
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/celllayout.h b/libs/gtkmm2/gtk/gtkmm/celllayout.h
new file mode 100644
index 0000000000..1fc7c8f6eb
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/celllayout.h
@@ -0,0 +1,226 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_CELLLAYOUT_H
+#define _GTKMM_CELLLAYOUT_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* Copyright (C) 2003 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <glibmm/interface.h>
+#include <gtkmm/cellrenderer.h>
+#include <gtkmm/cellrenderer_generation.h>
+#include <gtkmm/treemodel.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+extern "C"
+{
+typedef struct _GtkCellLayoutIface GtkCellLayoutIface;
+}
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkCellLayout GtkCellLayout;
+typedef struct _GtkCellLayoutClass GtkCellLayoutClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class CellLayout_Class; } // namespace Gtk
+namespace Gtk
+{
+
+/** An interface for packing cells.
+ * CellLayout is an interface to be implemented by all objects which want to provide a TreeView::Column-like API 
+ * for packing cells, setting attributes and data funcs.
+ */
+
+class CellLayout : public Glib::Interface
+{
+  
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+public:
+  typedef CellLayout CppObjectType;
+  typedef CellLayout_Class CppClassType;
+  typedef GtkCellLayout BaseObjectType;
+  typedef GtkCellLayoutIface BaseClassType;
+
+private:
+  friend class CellLayout_Class;
+  static CppClassType celllayout_class_;
+
+  // noncopyable
+  CellLayout(const CellLayout&);
+  CellLayout& operator=(const CellLayout&);
+
+protected:
+  CellLayout(); // you must derive from this class
+  explicit CellLayout(GtkCellLayout* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+  virtual ~CellLayout();
+
+  static void add_interface(GType gtype_implementer);
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GObject.
+  GtkCellLayout*       gobj()       { return reinterpret_cast<GtkCellLayout*>(gobject_); }
+
+  ///Provides access to the underlying C GObject.  
+  const GtkCellLayout* gobj() const { return reinterpret_cast<GtkCellLayout*>(gobject_); }
+
+private:
+
+
+public:
+
+  template <class ColumnType> inline
+  void pack_start(const TreeModelColumn<ColumnType>& model_column, bool expand = true);
+  
+
+  /** Packs the @a cell  into the beginning of @a cell_layout . If @a expand  is <tt>false</tt>,
+   * then the @a cell  is allocated no more space than it needs. Any unused space
+   * is divided evenly between cells for which @a expand  is <tt>true</tt>.
+   * 
+   * Since: 2.4
+   * @param cell A Gtk::CellRenderer.
+   * @param expand <tt>true</tt> if @a cell  is to be given extra space allocated to @a cell_layout .
+   */
+  void pack_start(CellRenderer& cell, bool expand = true);
+  
+  /** Adds the @a cell  to the end of @a cell_layout . If @a expand  is <tt>false</tt>, then the
+   *  @a cell  is allocated no more space than it needs. Any unused space is
+   * divided evenly between cells for which @a expand  is <tt>true</tt>.
+   * 
+   * Since: 2.4
+   * @param cell A Gtk::CellRenderer.
+   * @param expand <tt>true</tt> if @a cell  is to be given extra space allocated to @a cell_layout .
+   */
+  void pack_end(CellRenderer& cell, bool expand = true);
+  
+  /** Unsets all the mappings on all renderers on @a cell_layout  and
+   * removes all renderers from @a cell_layout .
+   * 
+   * Since: 2.4
+   */
+  void clear();
+  
+   //I think this is just a convenience method, equivalent to clear() and multiple add_attribute()s. murrayc.
+
+  
+  /** Adds an attribute mapping to the list in @a cell_layout . The @a column  is the
+   * column of the model to get a value from, and the @a attribute  is the
+   * parameter on @a cell  to be set from the value. So for example if column 2
+   * of the model contains strings, you could have the "text" attribute of a
+   * Gtk::CellRendererText get its values from column 2.
+   * 
+   * Since: 2.4
+   * @param cell A Gtk::CellRenderer.
+   * @param attribute An attribute on the renderer.
+   * @param column The column position on the model to get the attribute from.
+   */
+  void add_attribute(CellRenderer& cell, const Glib::ustring& attribute, int column);
+  void add_attribute(const Glib::PropertyProxy_Base& property, const TreeModelColumnBase& column);
+
+  //For instance, void on_cell_data(const TreeModel::const_iterator& iter)                                        
+  typedef sigc::slot<void, const TreeModel::const_iterator&> SlotCellData;
+
+  void set_cell_data_func(CellRenderer& cell, const SlotCellData& slot);
+  
+                                                                                  
+  /** Clears all existing attributes previously set with
+   * set_attributes().
+   * 
+   * Since: 2.4
+   * @param cell A Gtk::CellRenderer to clear the attribute mapping on.
+   */
+  void clear_attributes(CellRenderer& cell);
+
+  
+  /** Re-inserts @a cell  at @a position . Note that @a cell  has already to be packed
+   * into @a cell_layout  for this to function properly.
+   * 
+   * Since: 2.4
+   * @param cell A Gtk::CellRenderer to reorder.
+   * @param position New position to insert @a cell  at.
+   */
+  void reorder(CellRenderer& cell, int position);
+
+protected:
+    virtual void pack_start_vfunc(CellRenderer* cell, bool expand);
+    virtual void pack_end_vfunc(CellRenderer* cell, bool expand);
+    virtual void clear_vfunc();
+    virtual void add_attribute_vfunc(CellRenderer* cell, const Glib::ustring& attribute, int column);
+//TODO:  _WRAP_VFUNC(void set_cell_data_func(CellRenderer* cell, GtkCellLayoutDataFunc func, gpointer func_data, GDestroyNotify destroy), set_cell_data_func)
+    virtual void clear_attributes_vfunc(CellRenderer* cell);
+    virtual void reorder_vfunc(CellRenderer* cell, int position);
+                                 
+
+public:
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+};
+
+template<class T_ModelColumnType>
+void CellLayout::pack_start(const TreeModelColumn<T_ModelColumnType>& column, bool expand)
+{
+  //Generate appropriate Renderer for the column:
+  CellRenderer* pCellRenderer = manage( CellRenderer_Generation::generate_cellrenderer<T_ModelColumnType>() );
+
+  //Use the renderer:
+  pack_start(*pCellRenderer, expand);
+
+  //Make the renderer render the column:
+  add_attribute(pCellRenderer->_property_renderable(), column);
+}
+
+} // namespace Gtk
+
+
+namespace Glib
+{
+  /** @relates Gtk::CellLayout
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Glib::RefPtr<Gtk::CellLayout> wrap(GtkCellLayout* object, bool take_copy = false);
+
+} // namespace Glib
+
+#endif /* _GTKMM_CELLLAYOUT_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/cellrenderer.cc b/libs/gtkmm2/gtk/gtkmm/cellrenderer.cc
new file mode 100644
index 0000000000..8cec8dc46f
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/cellrenderer.cc
@@ -0,0 +1,638 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/cellrenderer.h>
+#include <gtkmm/private/cellrenderer_p.h>
+
+#include <gtk/gtktypebuiltins.h>
+// -*- c++ -*-
+/* $Id$ */
+
+/* Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtk/gtkcellrenderer.h>
+
+namespace Gtk
+{
+
+void CellRenderer::get_size(Widget& widget, int& x_offset, int& y_offset, int& width, int& height) const
+{
+  gtk_cell_renderer_get_size(const_cast<GtkCellRenderer*>(gobj()), widget.gobj(), 0, &x_offset, &y_offset, &width, &height);
+}
+
+Glib::PropertyProxy_Base CellRenderer::_property_renderable()
+{
+  g_assert_not_reached();
+  return Glib::PropertyProxy<int>(0, 0); // shut up warnings
+}
+
+} // namespace Gtk
+
+
+namespace
+{
+
+const Glib::SignalProxyInfo CellRenderer_signal_editing_canceled_info =
+{
+  "editing_canceled",
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
+};
+
+
+void CellRenderer_signal_editing_started_callback(GtkCellRenderer* self, GtkCellEditable* p0,const gchar* p1,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,CellEditable*,const Glib::ustring& > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(dynamic_cast<CellEditable*>(Glib::wrap_auto((GObject*)(p0), false))
+, Glib::convert_const_gchar_ptr_to_ustring(p1)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+}
+
+const Glib::SignalProxyInfo CellRenderer_signal_editing_started_info =
+{
+  "editing_started",
+  (GCallback) &CellRenderer_signal_editing_started_callback,
+  (GCallback) &CellRenderer_signal_editing_started_callback
+};
+
+} // anonymous namespace
+
+// static
+GType Glib::Value<Gtk::CellRendererState>::value_type()
+{
+  return gtk_cell_renderer_state_get_type();
+}
+
+// static
+GType Glib::Value<Gtk::CellRendererMode>::value_type()
+{
+  return gtk_cell_renderer_mode_get_type();
+}
+
+
+namespace Glib
+{
+
+Gtk::CellRenderer* wrap(GtkCellRenderer* object, bool take_copy)
+{
+  return dynamic_cast<Gtk::CellRenderer *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& CellRenderer_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &CellRenderer_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_cell_renderer_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void CellRenderer_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+  klass->get_size = &get_size_vfunc_callback;
+  klass->render = &render_vfunc_callback;
+  klass->activate = &activate_vfunc_callback;
+  klass->start_editing = &start_editing_vfunc_callback;
+  klass->editing_canceled = &editing_canceled_callback;
+}
+
+void CellRenderer_Class::get_size_vfunc_callback(GtkCellRenderer* self, GtkWidget* widget, GdkRectangle* cell_area, gint* x_offset, gint* y_offset, gint* width, gint* height)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->get_size_vfunc(*Glib::wrap(widget)
+, &Glib::wrap(cell_area)
+, x_offset
+, y_offset
+, width
+, height
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->get_size)
+      (*base->get_size)(self, widget, cell_area, x_offset, y_offset, width, height);
+  }
+}
+
+void CellRenderer_Class::render_vfunc_callback(GtkCellRenderer* self, GdkDrawable* window, GtkWidget* widget, GdkRectangle* background_area, GdkRectangle* cell_area, GdkRectangle* expose_area, GtkCellRendererState flags)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->render_vfunc(Glib::wrap(window, true)
+, *Glib::wrap(widget)
+, Glib::wrap(background_area)
+, Glib::wrap(cell_area)
+, Glib::wrap(expose_area)
+, ((CellRendererState)(flags))
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->render)
+      (*base->render)(self, window, widget, background_area, cell_area, expose_area, flags);
+  }
+}
+
+gboolean CellRenderer_Class::activate_vfunc_callback(GtkCellRenderer* self, GdkEvent* event, GtkWidget* widget, const gchar* path, GdkRectangle* background_area, GdkRectangle* cell_area, GtkCellRendererState flags)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return static_cast<int>(obj->activate_vfunc(event, *Glib::wrap(widget)
+, Glib::convert_const_gchar_ptr_to_ustring(path)
+, Glib::wrap(background_area)
+, Glib::wrap(cell_area)
+, ((CellRendererState)(flags))
+));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->activate)
+      return (*base->activate)(self, event, widget, path, background_area, cell_area, flags);
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+GtkCellEditable* CellRenderer_Class::start_editing_vfunc_callback(GtkCellRenderer* self, GdkEvent* event, GtkWidget* widget, const gchar* path, GdkRectangle* background_area, GdkRectangle* cell_area, GtkCellRendererState flags)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(false) //obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return Glib::unwrap(obj->start_editing_vfunc(event, *Glib::wrap(widget)
+, Glib::convert_const_gchar_ptr_to_ustring(path)
+, Glib::wrap(background_area)
+, Glib::wrap(cell_area)
+, ((CellRendererState)(flags))
+));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->start_editing)
+      return (*base->start_editing)(self, event, widget, path, background_area, cell_area, flags);
+  }
+
+  typedef GtkCellEditable* RType;
+  return RType();
+}
+
+
+void CellRenderer_Class::editing_canceled_callback(GtkCellRenderer* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_editing_canceled();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->editing_canceled)
+      (*base->editing_canceled)(self);
+  }
+}
+
+
+Glib::ObjectBase* CellRenderer_Class::wrap_new(GObject* o)
+{
+  return manage(new CellRenderer((GtkCellRenderer*)(o)));
+
+}
+
+
+/* The implementation: */
+
+CellRenderer::CellRenderer(const Glib::ConstructParams& construct_params)
+:
+  Gtk::Object(construct_params)
+{
+  }
+
+CellRenderer::CellRenderer(GtkCellRenderer* castitem)
+:
+  Gtk::Object((GtkObject*)(castitem))
+{
+  }
+
+CellRenderer::~CellRenderer()
+{
+  destroy_();
+}
+
+CellRenderer::CppClassType CellRenderer::cellrenderer_class_; // initialize static member
+
+GType CellRenderer::get_type()
+{
+  return cellrenderer_class_.init().get_type();
+}
+
+GType CellRenderer::get_base_type()
+{
+  return gtk_cell_renderer_get_type();
+}
+
+
+void CellRenderer::get_size(Widget& widget, const Gdk::Rectangle& cell_area, int& x_offset, int& y_offset, int& width, int& height) const
+{
+  gtk_cell_renderer_get_size(const_cast<GtkCellRenderer*>(gobj()), (widget).gobj(), const_cast<GdkRectangle*>(cell_area.gobj()), &x_offset, &y_offset, &width, &height);
+}
+
+void CellRenderer::render(const Glib::RefPtr<Gdk::Window>& window, Widget& widget, const Gdk::Rectangle& background_area, const Gdk::Rectangle& cell_area, const Gdk::Rectangle& expose_area, CellRendererState flags)
+{
+  gtk_cell_renderer_render(gobj(), Glib::unwrap(window), (widget).gobj(), const_cast<GdkRectangle*>(background_area.gobj()), const_cast<GdkRectangle*>(cell_area.gobj()), const_cast<GdkRectangle*>(expose_area.gobj()), ((GtkCellRendererState)(flags)));
+}
+
+bool CellRenderer::activate(GdkEvent* event, Widget& widget, const Glib::ustring& path, const Gdk::Rectangle& background_area, const Gdk::Rectangle& cell_area, CellRendererState flags)
+{
+  return gtk_cell_renderer_activate(gobj(), event, (widget).gobj(), path.c_str(), const_cast<GdkRectangle*>(background_area.gobj()), const_cast<GdkRectangle*>(cell_area.gobj()), ((GtkCellRendererState)(flags)));
+}
+
+CellEditable* CellRenderer::start_editing(GdkEvent* event, Widget& widget, const Glib::ustring& path, const Gdk::Rectangle& background_area, const Gdk::Rectangle& cell_area, CellRendererState flags)
+{
+  return dynamic_cast<CellEditable*>(Glib::wrap_auto((GObject*)(gtk_cell_renderer_start_editing(gobj(), event, (widget).gobj(), path.c_str(), const_cast<GdkRectangle*>(background_area.gobj()), const_cast<GdkRectangle*>(cell_area.gobj()), ((GtkCellRendererState)(flags)))), false));
+}
+
+void CellRenderer::set_fixed_size(int width, int height)
+{
+  gtk_cell_renderer_set_fixed_size(gobj(), width, height);
+}
+
+void CellRenderer::get_fixed_size(int& width, int& height) const
+{
+  gtk_cell_renderer_get_fixed_size(const_cast<GtkCellRenderer*>(gobj()), &width, &height);
+}
+
+void CellRenderer::editing_canceled()
+{
+  gtk_cell_renderer_editing_canceled(gobj());
+}
+
+void CellRenderer::stop_editing(bool canceled)
+{
+  gtk_cell_renderer_stop_editing(gobj(), static_cast<int>(canceled));
+}
+
+CellRenderer::CellRenderer()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Object(Glib::ConstructParams(cellrenderer_class_.init()))
+{
+  }
+
+
+Glib::SignalProxy0< void > CellRenderer::signal_editing_canceled()
+{
+  return Glib::SignalProxy0< void >(this, &CellRenderer_signal_editing_canceled_info);
+}
+
+Glib::SignalProxy2< void,CellEditable*,const Glib::ustring& > CellRenderer::signal_editing_started()
+{
+  return Glib::SignalProxy2< void,CellEditable*,const Glib::ustring& >(this, &CellRenderer_signal_editing_started_info);
+}
+
+
+Glib::PropertyProxy<CellRendererMode> CellRenderer::property_mode() 
+{
+  return Glib::PropertyProxy<CellRendererMode>(this, "mode");
+}
+
+Glib::PropertyProxy_ReadOnly<CellRendererMode> CellRenderer::property_mode() const
+{
+  return Glib::PropertyProxy_ReadOnly<CellRendererMode>(this, "mode");
+}
+
+Glib::PropertyProxy<bool> CellRenderer::property_visible() 
+{
+  return Glib::PropertyProxy<bool>(this, "visible");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> CellRenderer::property_visible() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "visible");
+}
+
+Glib::PropertyProxy<float> CellRenderer::property_xalign() 
+{
+  return Glib::PropertyProxy<float>(this, "xalign");
+}
+
+Glib::PropertyProxy_ReadOnly<float> CellRenderer::property_xalign() const
+{
+  return Glib::PropertyProxy_ReadOnly<float>(this, "xalign");
+}
+
+Glib::PropertyProxy<float> CellRenderer::property_yalign() 
+{
+  return Glib::PropertyProxy<float>(this, "yalign");
+}
+
+Glib::PropertyProxy_ReadOnly<float> CellRenderer::property_yalign() const
+{
+  return Glib::PropertyProxy_ReadOnly<float>(this, "yalign");
+}
+
+Glib::PropertyProxy<unsigned int> CellRenderer::property_xpad() 
+{
+  return Glib::PropertyProxy<unsigned int>(this, "xpad");
+}
+
+Glib::PropertyProxy_ReadOnly<unsigned int> CellRenderer::property_xpad() const
+{
+  return Glib::PropertyProxy_ReadOnly<unsigned int>(this, "xpad");
+}
+
+Glib::PropertyProxy<unsigned int> CellRenderer::property_ypad() 
+{
+  return Glib::PropertyProxy<unsigned int>(this, "ypad");
+}
+
+Glib::PropertyProxy_ReadOnly<unsigned int> CellRenderer::property_ypad() const
+{
+  return Glib::PropertyProxy_ReadOnly<unsigned int>(this, "ypad");
+}
+
+Glib::PropertyProxy<int> CellRenderer::property_width() 
+{
+  return Glib::PropertyProxy<int>(this, "width");
+}
+
+Glib::PropertyProxy_ReadOnly<int> CellRenderer::property_width() const
+{
+  return Glib::PropertyProxy_ReadOnly<int>(this, "width");
+}
+
+Glib::PropertyProxy<int> CellRenderer::property_height() 
+{
+  return Glib::PropertyProxy<int>(this, "height");
+}
+
+Glib::PropertyProxy_ReadOnly<int> CellRenderer::property_height() const
+{
+  return Glib::PropertyProxy_ReadOnly<int>(this, "height");
+}
+
+Glib::PropertyProxy<bool> CellRenderer::property_is_expander() 
+{
+  return Glib::PropertyProxy<bool>(this, "is-expander");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> CellRenderer::property_is_expander() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "is-expander");
+}
+
+Glib::PropertyProxy<bool> CellRenderer::property_is_expanded() 
+{
+  return Glib::PropertyProxy<bool>(this, "is-expanded");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> CellRenderer::property_is_expanded() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "is-expanded");
+}
+
+Glib::PropertyProxy_WriteOnly<Glib::ustring> CellRenderer::property_cell_background() 
+{
+  return Glib::PropertyProxy_WriteOnly<Glib::ustring>(this, "cell-background");
+}
+
+Glib::PropertyProxy_ReadOnly<Glib::ustring> CellRenderer::property_cell_background() const
+{
+  return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "cell-background");
+}
+
+Glib::PropertyProxy<Gdk::Color> CellRenderer::property_cell_background_gdk() 
+{
+  return Glib::PropertyProxy<Gdk::Color>(this, "cell-background-gdk");
+}
+
+Glib::PropertyProxy_ReadOnly<Gdk::Color> CellRenderer::property_cell_background_gdk() const
+{
+  return Glib::PropertyProxy_ReadOnly<Gdk::Color>(this, "cell-background-gdk");
+}
+
+Glib::PropertyProxy<bool> CellRenderer::property_cell_background_set() 
+{
+  return Glib::PropertyProxy<bool>(this, "cell-background-set");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> CellRenderer::property_cell_background_set() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "cell-background-set");
+}
+
+
+void Gtk::CellRenderer::on_editing_canceled()
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->editing_canceled)
+    (*base->editing_canceled)(gobj());
+}
+
+
+void Gtk::CellRenderer::get_size_vfunc(Widget& widget, const Gdk::Rectangle* cell_area, int* x_offset, int* y_offset, int* width, int* height) const
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->get_size)
+    (*base->get_size)(const_cast<GtkCellRenderer*>(gobj()),(widget).gobj(),Glib::unwrap(const_cast<Gdk::Rectangle*>(cell_area)),x_offset,y_offset,width,height);
+}
+
+void Gtk::CellRenderer::render_vfunc(const Glib::RefPtr<Gdk::Drawable>& window, Widget& widget, const Gdk::Rectangle& background_area, const Gdk::Rectangle& cell_area, const Gdk::Rectangle& expose_area, CellRendererState flags) 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->render)
+    (*base->render)(gobj(),Glib::unwrap(window),(widget).gobj(),const_cast<GdkRectangle*>(background_area.gobj()),const_cast<GdkRectangle*>(cell_area.gobj()),const_cast<GdkRectangle*>(expose_area.gobj()),((GtkCellRendererState)(flags)));
+}
+
+bool Gtk::CellRenderer::activate_vfunc(GdkEvent* event, Widget& widget, const Glib::ustring& path, const Gdk::Rectangle& background_area, const Gdk::Rectangle& cell_area, CellRendererState flags) 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->activate)
+    return (*base->activate)(gobj(),event,(widget).gobj(),path.c_str(),const_cast<GdkRectangle*>(background_area.gobj()),const_cast<GdkRectangle*>(cell_area.gobj()),((GtkCellRendererState)(flags)));
+
+  typedef bool RType;
+  return RType();
+}
+
+CellEditable* Gtk::CellRenderer::start_editing_vfunc(GdkEvent* event, Widget& widget, const Glib::ustring& path, const Gdk::Rectangle& background_area, const Gdk::Rectangle& cell_area, CellRendererState flags) 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->start_editing)
+    return dynamic_cast<CellEditable*>(Glib::wrap_auto((GObject*)((*base->start_editing)(gobj(),event,(widget).gobj(),path.c_str(),const_cast<GdkRectangle*>(background_area.gobj()),const_cast<GdkRectangle*>(cell_area.gobj()),((GtkCellRendererState)(flags)))), false));
+
+  typedef CellEditable* RType;
+  return RType();
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/cellrenderer.h b/libs/gtkmm2/gtk/gtkmm/cellrenderer.h
new file mode 100644
index 0000000000..7c382c44c5
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/cellrenderer.h
@@ -0,0 +1,610 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_CELLRENDERER_H
+#define _GTKMM_CELLRENDERER_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* Copyright (C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/object.h>
+#include <gtkmm/widget.h>
+#include <gtkmm/celleditable.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkCellRenderer GtkCellRenderer;
+typedef struct _GtkCellRendererClass GtkCellRendererClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class CellRenderer_Class; } // namespace Gtk
+namespace Gtk
+{
+
+
+/** @addtogroup gtkmmEnums Enums and Flags */
+
+/**
+ * @ingroup gtkmmEnums
+ * @par Bitwise operators:
+ * <tt>%CellRendererState operator|(CellRendererState, CellRendererState)</tt><br>
+ * <tt>%CellRendererState operator&(CellRendererState, CellRendererState)</tt><br>
+ * <tt>%CellRendererState operator^(CellRendererState, CellRendererState)</tt><br>
+ * <tt>%CellRendererState operator~(CellRendererState)</tt><br>
+ * <tt>%CellRendererState& operator|=(CellRendererState&, CellRendererState)</tt><br>
+ * <tt>%CellRendererState& operator&=(CellRendererState&, CellRendererState)</tt><br>
+ * <tt>%CellRendererState& operator^=(CellRendererState&, CellRendererState)</tt><br>
+ */
+enum CellRendererState
+{
+  CELL_RENDERER_SELECTED = 1 << 0,
+  CELL_RENDERER_PRELIT = 1 << 1,
+  CELL_RENDERER_INSENSITIVE = 1 << 2,
+  CELL_RENDERER_SORTED = 1 << 3,
+  CELL_RENDERER_FOCUSED = 1 << 4
+};
+
+/** @ingroup gtkmmEnums */
+inline CellRendererState operator|(CellRendererState lhs, CellRendererState rhs)
+  { return static_cast<CellRendererState>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs)); }
+
+/** @ingroup gtkmmEnums */
+inline CellRendererState operator&(CellRendererState lhs, CellRendererState rhs)
+  { return static_cast<CellRendererState>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs)); }
+
+/** @ingroup gtkmmEnums */
+inline CellRendererState operator^(CellRendererState lhs, CellRendererState rhs)
+  { return static_cast<CellRendererState>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs)); }
+
+/** @ingroup gtkmmEnums */
+inline CellRendererState operator~(CellRendererState flags)
+  { return static_cast<CellRendererState>(~static_cast<unsigned>(flags)); }
+
+/** @ingroup gtkmmEnums */
+inline CellRendererState& operator|=(CellRendererState& lhs, CellRendererState rhs)
+  { return (lhs = static_cast<CellRendererState>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs))); }
+
+/** @ingroup gtkmmEnums */
+inline CellRendererState& operator&=(CellRendererState& lhs, CellRendererState rhs)
+  { return (lhs = static_cast<CellRendererState>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs))); }
+
+/** @ingroup gtkmmEnums */
+inline CellRendererState& operator^=(CellRendererState& lhs, CellRendererState rhs)
+  { return (lhs = static_cast<CellRendererState>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs))); }
+
+} // namespace Gtk
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Gtk::CellRendererState> : public Glib::Value_Flags<Gtk::CellRendererState>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{
+
+/**
+ * @ingroup gtkmmEnums
+ */
+enum CellRendererMode
+{
+  CELL_RENDERER_MODE_INERT,
+  CELL_RENDERER_MODE_ACTIVATABLE,
+  CELL_RENDERER_MODE_EDITABLE
+};
+
+} // namespace Gtk
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Gtk::CellRendererMode> : public Glib::Value_Enum<Gtk::CellRendererMode>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{
+
+
+/** CellRenderers are used by Gtk::TreeView columns to render the Gtk::TreeModel column data appropriately.
+ * They display, and allow editing of, the values of their properties.
+ * In most cases, Gtk::TreeView::append_column() will automatically choose the appropriate renderer for the mode column's data type,
+ * so you will rarely need to worry about these classes.
+ *
+ * @ingroup TreeView
+ */
+
+class CellRenderer : public Gtk::Object
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef CellRenderer CppObjectType;
+  typedef CellRenderer_Class CppClassType;
+  typedef GtkCellRenderer BaseObjectType;
+  typedef GtkCellRendererClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~CellRenderer();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class CellRenderer_Class;
+  static CppClassType cellrenderer_class_;
+
+  // noncopyable
+  CellRenderer(const CellRenderer&);
+  CellRenderer& operator=(const CellRenderer&);
+
+protected:
+  explicit CellRenderer(const Glib::ConstructParams& construct_params);
+  explicit CellRenderer(GtkCellRenderer* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GtkCellRenderer*       gobj()       { return reinterpret_cast<GtkCellRenderer*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GtkCellRenderer* gobj() const { return reinterpret_cast<GtkCellRenderer*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+  virtual void on_editing_canceled();
+
+
+private:
+
+public:
+
+  
+  /** Obtains the width and height needed to render the cell. Used by view widgets
+   * to determine the appropriate size for the cell_area passed to
+   * render().  Fills in the x and y
+   * offsets of the cell relative to this location.  Please note that the
+   * values set in @a width  and @a height , as well as those in @a x_offset  and @a y_offset 
+   * are inclusive of the xpad and ypad properties.
+   * @param widget The widget the renderer is rendering to.
+   * @param cell_area The area a cell will be allocated.
+   * @param x_offset Location to return x offset of cell relative to @a cell_area .
+   * @param y_offset Location to return y offset of cell relative to @a cell_area .
+   * @param width Location to return width needed to render a cell.
+   * @param height Location to return height needed to render a cell.
+   */
+  void get_size(
+                  Widget& widget,
+                  const Gdk::Rectangle& cell_area,
+                  int& x_offset, int& y_offset,
+                  int& width,    int& height) const;
+
+  /** Obtains the width and height needed to render the cell. Used by view widgets
+   * to determine the appropriate size for the cell_area passed to
+   * render().  Fills in the x and y
+   * offsets of the cell relative to this location.  Please note that the
+   * values set in @a width  and @a height , as well as those in @a x_offset  and @a y_offset
+   * are inclusive of the xpad and ypad properties.
+   * @param widget The widget the renderer is rendering to.
+   * @param x_offset Location to return x offset of cell relative to @a cell_area.
+   * @param y_offset Location to return y offset of cell relative to @a cell_area.
+   * @param width Location to return width needed to render a cell.
+   * @param height Location to return height needed to render a cell.
+   */
+  void get_size(Widget& widget, int& x_offset, int& y_offset, int& width, int& height) const;
+
+  
+  /** Invokes the virtual render function of the Gtk::CellRenderer. The three
+   * passed-in rectangles are areas of @a window . Most renderers will draw within
+   *  @a cell_area ; the xalign, yalign, xpad, and ypad fields of the Gtk::CellRenderer
+   * should be honored with respect to @a cell_area . @a background_area  includes the
+   * blank space around the cell, and also the area containing the tree expander;
+   * so the @a background_area  rectangles for all cells tile to cover the entire
+   *  @a window .  @a expose_area  is a clip rectangle.
+   * @param window A Gdk::Drawable to draw to.
+   * @param widget The widget owning @a window .
+   * @param background_area Entire cell area (including tree expanders and maybe padding on the sides).
+   * @param cell_area Area normally rendered by a cell renderer.
+   * @param expose_area Area that actually needs updating.
+   * @param flags Flags that affect rendering.
+   */
+  void render(
+                  const Glib::RefPtr<Gdk::Window>& window,
+                  Widget& widget,
+                  const Gdk::Rectangle& background_area,
+                  const Gdk::Rectangle& cell_area,
+                  const Gdk::Rectangle& expose_area,
+                  CellRendererState flags);
+
+  
+  /** Passes an activate event to the cell renderer for possible processing.  Some
+   * cell renderers may use events; for example, Gtk::CellRendererToggle toggles
+   * when it gets a mouse click.
+   * @param event A Gdk::Event.
+   * @param widget Widget that received the event.
+   * @param path Widget-dependent string representation of the event location; e.g. for Gtk::TreeView, a string representation of Gtk::TreePath.
+   * @param background_area Background area as passed to @a gtk_cell_renderer_render .
+   * @param cell_area Cell area as passed to @a gtk_cell_renderer_render .
+   * @param flags Render flags.
+   * @return <tt>true</tt> if the event was consumed/handled.
+   */
+  bool activate(
+                  GdkEvent* event,
+                  Widget& widget,
+                  const Glib::ustring& path,
+                  const Gdk::Rectangle& background_area,
+                  const Gdk::Rectangle& cell_area,
+                  CellRendererState flags);
+
+  
+  /** Passes an activate event to the cell renderer for possible processing.
+   * @param event A Gdk::Event.
+   * @param widget Widget that received the event.
+   * @param path Widget-dependent string representation of the event location; e.g. for Gtk::TreeView, a string representation of Gtk::TreePath.
+   * @param background_area Background area as passed to @a gtk_cell_renderer_render .
+   * @param cell_area Cell area as passed to @a gtk_cell_renderer_render .
+   * @param flags Render flags.
+   * @return A new Gtk::CellEditable, or <tt>0</tt>.
+   */
+  CellEditable* start_editing(
+                  GdkEvent* event, Widget& widget,
+                  const Glib::ustring& path,
+                  const Gdk::Rectangle& background_area,
+                  const Gdk::Rectangle& cell_area,
+                  CellRendererState flags = CellRendererState(0));
+
+  
+  /** Sets the renderer size to be explicit, independent of the properties set.
+   * @param width The width of the cell renderer, or -1.
+   * @param height The height of the cell renderer, or -1.
+   */
+  void set_fixed_size(int width, int height);
+  
+  /** Fills in @a width  and @a height  with the appropriate size of @a cell .
+   * @param width Location to fill in with the fixed width of the widget.
+   * @param height Location to fill in with the fixed height of the widget.
+   */
+  void get_fixed_size(int& width, int& height) const;
+
+  //TODO: Mark as @deprecated: See stop_editing().
+  
+  /** Causes the cell renderer to emit the "editing-canceled" signal.  This
+   * function is for use only by implementations of cell renderers that need to
+   * notify the client program that an editing process was canceled and the
+   * changes were not committed.
+   * 
+   * Since: 2.4
+   * Deprecated: Use stop_editing() instead
+   */
+  void editing_canceled();
+
+  
+  /** Informs the cell renderer that the editing is stopped.
+   * If @a canceled  is <tt>true</tt>, the cell renderer will emit the "editing-canceled" 
+   * signal. This function should be called by cell renderer implementations 
+   * in response to the "editing-done" signal of Gtk::CellEditable.
+   * 
+   * Since: 2.6
+   * @param canceled <tt>true</tt> if the editing has been canceled.
+   */
+  void stop_editing(bool canceled = false);
+
+  /** Returns the property that this CellRenderer renders.
+   * For instance, property_text for CellRendererText, and property_active for CellRendererToggle
+   * Needs to be overridden in derived classes.
+   */
+  virtual Glib::PropertyProxy_Base _property_renderable();
+
+  
+  Glib::SignalProxy0< void > signal_editing_canceled();
+
+  
+  //We use no_default_handler for this, because we can not add a new vfunc to 2.5 without breaking ABI.
+  //TODO: Remove no_default_handler when we do an ABI-break-with-parallel-install.
+  
+
+  Glib::SignalProxy2< void,CellEditable*,const Glib::ustring& > signal_editing_started();
+
+
+  /** Editable mode of the CellRenderer.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<CellRendererMode> property_mode() ;
+
+/** Editable mode of the CellRenderer.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<CellRendererMode> property_mode() const;
+
+  /** Display the cell.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_visible() ;
+
+/** Display the cell.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_visible() const;
+
+  /** The x-align.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<float> property_xalign() ;
+
+/** The x-align.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<float> property_xalign() const;
+
+  /** The y-align.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<float> property_yalign() ;
+
+/** The y-align.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<float> property_yalign() const;
+
+  /** The xpad.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<unsigned int> property_xpad() ;
+
+/** The xpad.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<unsigned int> property_xpad() const;
+
+  /** The ypad.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<unsigned int> property_ypad() ;
+
+/** The ypad.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<unsigned int> property_ypad() const;
+
+  /** The fixed width.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<int> property_width() ;
+
+/** The fixed width.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<int> property_width() const;
+
+  /** The fixed height.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<int> property_height() ;
+
+/** The fixed height.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<int> property_height() const;
+
+  /** Row has children.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_is_expander() ;
+
+/** Row has children.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_is_expander() const;
+
+  /** Row is an expander row
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_is_expanded() ;
+
+/** Row is an expander row
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_is_expanded() const;
+
+  /** Cell background color as a string.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_WriteOnly<Glib::ustring> property_cell_background() ;
+
+/** Cell background color as a string.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Glib::ustring> property_cell_background() const;
+
+  /** Cell background color as a GdkColor.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Gdk::Color> property_cell_background_gdk() ;
+
+/** Cell background color as a GdkColor.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Gdk::Color> property_cell_background_gdk() const;
+ 
+  /** Whether this tag affects the cell background color.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_cell_background_set() ;
+
+/** Whether this tag affects the cell background color.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_cell_background_set() const;
+
+
+protected:
+  CellRenderer();
+
+  /** Override this in derived CellRenderers.
+   *
+   * Obtains the width and height needed to render the cell. Used by view widgets
+   * to determine the appropriate size for the cell_area passed to
+   * render().  If @a cell_area is not 0, fills in the x and y
+   * offsets (if set) of the cell relative to this location.  Please note that the
+   * values set in @a width and @a height, as well as those in @a x_offset and @a y_offset
+   * are inclusive of the xpad and ypad properties.
+   *
+   * @param widget The widget the renderer is rendering to.
+   * @param cell_area The area a cell will be allocated, or 0.
+   * @param x_offset x offset of cell relative to @a cell_area.
+   * @param y_offset y offset of cell relative to @a cell_area.
+   * @param width Width needed to render a cell.
+   * @param height Height needed to render a cell.
+   **/
+    virtual void get_size_vfunc(Widget& widget, const Gdk::Rectangle* cell_area, int* x_offset, int* y_offset, int* width, int* height) const;
+                  
+
+    virtual void render_vfunc(const Glib::RefPtr<Gdk::Drawable>& window, Widget& widget, const Gdk::Rectangle& background_area, const Gdk::Rectangle& cell_area, const Gdk::Rectangle& expose_area, CellRendererState flags);
+
+    virtual bool activate_vfunc(GdkEvent* event, Widget& widget, const Glib::ustring& path, const Gdk::Rectangle& background_area, const Gdk::Rectangle& cell_area, CellRendererState flags);
+
+    virtual CellEditable* start_editing_vfunc(GdkEvent* event, Widget& widget, const Glib::ustring& path, const Gdk::Rectangle& background_area, const Gdk::Rectangle& cell_area, CellRendererState flags);
+
+
+};
+
+} // namespace Gtk
+
+
+namespace Glib
+{
+  /** @relates Gtk::CellRenderer
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gtk::CellRenderer* wrap(GtkCellRenderer* object, bool take_copy = false);
+}
+#endif /* _GTKMM_CELLRENDERER_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/cellrenderer_generation.cc b/libs/gtkmm2/gtk/gtkmm/cellrenderer_generation.cc
new file mode 100644
index 0000000000..fc5a69c6bd
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/cellrenderer_generation.cc
@@ -0,0 +1,52 @@
+/* $Id$ */
+
+/* Copyright(C) 2003 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/cellrenderer_generation.h>
+
+
+//template specializations:
+
+namespace Gtk
+{
+
+namespace CellRenderer_Generation
+{
+
+template<>
+CellRenderer* generate_cellrenderer< Glib::RefPtr<Gdk::Pixbuf> >(bool /*editable*/)
+{
+  //Ignore editable because there is no way for the user to edit a Pixbuf.
+  return new CellRendererPixbuf();
+}
+
+template<>
+CellRenderer* generate_cellrenderer<bool>(bool editable)
+{
+  CellRendererToggle* pCellRenderer = new CellRendererToggle();
+
+  //GTK+'s "activatable" really means "editable":
+  pCellRenderer->property_activatable() = editable;
+
+  return pCellRenderer;
+}
+
+} //CellRenderer_Generation
+
+
+} //namespace Gtk
diff --git a/libs/gtkmm2/gtk/gtkmm/cellrenderer_generation.h b/libs/gtkmm2/gtk/gtkmm/cellrenderer_generation.h
new file mode 100644
index 0000000000..309fba4b07
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/cellrenderer_generation.h
@@ -0,0 +1,62 @@
+#ifndef _GTKMM_CELLRENDERER_GENERATION_H
+#define _GTKMM_CELLRENDERER_GENERATION_H
+/* $Id$ */
+
+/* cellrenderer_generation.h
+ *
+ * Copyright(C) 2003 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/cellrenderertext.h>
+#include <gtkmm/cellrendererpixbuf.h>
+#include <gtkmm/cellrenderertoggle.h>
+
+namespace Gtk
+{
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace CellRenderer_Generation
+{
+
+template<class T_ModelColumnType> //e.g. bool or Glib::ustring.
+CellRenderer* generate_cellrenderer(bool editable = false)
+{
+  CellRendererText* pCellRenderer = new CellRendererText(); //the default - template specializations will use other renderers.
+  //CellRendererText can render both strings and numerical values.
+
+  pCellRenderer->property_editable() = editable;
+  return pCellRenderer;
+}
+
+#if !defined(__GNUC__) || __GNUC__ > 2
+// gcc 2.95.x fails in TreeView::append_column_editable if the
+// following specializations are declared in the header.
+template<>
+CellRenderer* generate_cellrenderer<bool>(bool editable);
+
+template<>
+CellRenderer* generate_cellrenderer< Glib::RefPtr<Gdk::Pixbuf> >(bool editable);
+
+#endif
+
+} //CellRenderer_Generation
+#endif //DOXYGEN_SHOULD_SKIP_THIS
+
+} // namespace Gtk
+
+
+#endif /* _GTKMM_CELLRENDERER_GENERATION_H */
diff --git a/libs/gtkmm2/gtk/gtkmm/cellrenderercombo.cc b/libs/gtkmm2/gtk/gtkmm/cellrenderercombo.cc
new file mode 100644
index 0000000000..7570da7fa1
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/cellrenderercombo.cc
@@ -0,0 +1,170 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/cellrenderercombo.h>
+#include <gtkmm/private/cellrenderercombo_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* 
+ *
+ * Copyright 2004 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+ 
+#include <gtk/gtkcellrenderercombo.h>
+
+namespace Gtk
+{
+
+Glib::PropertyProxy_Base CellRendererCombo::_property_renderable()
+{
+  return CellRendererText::_property_renderable();
+}
+
+} //namespace Gtk
+
+
+namespace
+{
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Gtk::CellRendererCombo* wrap(GtkCellRendererCombo* object, bool take_copy)
+{
+  return dynamic_cast<Gtk::CellRendererCombo *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& CellRendererCombo_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &CellRendererCombo_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_cell_renderer_combo_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void CellRendererCombo_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+}
+
+
+Glib::ObjectBase* CellRendererCombo_Class::wrap_new(GObject* o)
+{
+  return manage(new CellRendererCombo((GtkCellRendererCombo*)(o)));
+
+}
+
+
+/* The implementation: */
+
+CellRendererCombo::CellRendererCombo(const Glib::ConstructParams& construct_params)
+:
+  Gtk::CellRendererText(construct_params)
+{
+  }
+
+CellRendererCombo::CellRendererCombo(GtkCellRendererCombo* castitem)
+:
+  Gtk::CellRendererText((GtkCellRendererText*)(castitem))
+{
+  }
+
+CellRendererCombo::~CellRendererCombo()
+{
+  destroy_();
+}
+
+CellRendererCombo::CppClassType CellRendererCombo::cellrenderercombo_class_; // initialize static member
+
+GType CellRendererCombo::get_type()
+{
+  return cellrenderercombo_class_.init().get_type();
+}
+
+GType CellRendererCombo::get_base_type()
+{
+  return gtk_cell_renderer_combo_get_type();
+}
+
+
+CellRendererCombo::CellRendererCombo()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::CellRendererText(Glib::ConstructParams(cellrenderercombo_class_.init()))
+{
+  }
+
+
+Glib::PropertyProxy< Glib::RefPtr<Gtk::TreeModel> > CellRendererCombo::property_model() 
+{
+  return Glib::PropertyProxy< Glib::RefPtr<Gtk::TreeModel> >(this, "model");
+}
+
+Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gtk::TreeModel> > CellRendererCombo::property_model() const
+{
+  return Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gtk::TreeModel> >(this, "model");
+}
+
+Glib::PropertyProxy<int> CellRendererCombo::property_text_column() 
+{
+  return Glib::PropertyProxy<int>(this, "text-column");
+}
+
+Glib::PropertyProxy_ReadOnly<int> CellRendererCombo::property_text_column() const
+{
+  return Glib::PropertyProxy_ReadOnly<int>(this, "text-column");
+}
+
+Glib::PropertyProxy<bool> CellRendererCombo::property_has_entry() 
+{
+  return Glib::PropertyProxy<bool>(this, "has-entry");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> CellRendererCombo::property_has_entry() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "has-entry");
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/cellrenderercombo.h b/libs/gtkmm2/gtk/gtkmm/cellrenderercombo.h
new file mode 100644
index 0000000000..7e158bd106
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/cellrenderercombo.h
@@ -0,0 +1,180 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_CELLRENDERERCOMBO_H
+#define _GTKMM_CELLRENDERERCOMBO_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* cellrenderercombo.h
+ * 
+ * Copyright (C) 2004 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/cellrenderertext.h>
+#include <gtkmm/treemodel.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkCellRendererCombo GtkCellRendererCombo;
+typedef struct _GtkCellRendererComboClass GtkCellRendererComboClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class CellRendererCombo_Class; } // namespace Gtk
+namespace Gtk
+{
+
+/**  Renders a combobox in a cell.
+ * CellRendererCombo renders text in a cell like CellRendererText, from which it is derived. But while 
+ * CellRendererText offers a simple entry to edit the text, CellRendererCombo offers a ComboBox or 
+ * ComboBoxEntry widget to edit the text. The values to display in the combo box are taken from the 
+ * tree model specified in the model property.
+ *
+ * The combo cell renderer takes care of adding a text cell renderer to the combo box and sets it to 
+ * display the column specified by its text_column property. Further cell renderers can be added in a 
+ * handler for the editing_started signal. 
+ *
+ * @ingroup TreeView
+ */
+
+class CellRendererCombo : public CellRendererText
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef CellRendererCombo CppObjectType;
+  typedef CellRendererCombo_Class CppClassType;
+  typedef GtkCellRendererCombo BaseObjectType;
+  typedef GtkCellRendererComboClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~CellRendererCombo();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class CellRendererCombo_Class;
+  static CppClassType cellrenderercombo_class_;
+
+  // noncopyable
+  CellRendererCombo(const CellRendererCombo&);
+  CellRendererCombo& operator=(const CellRendererCombo&);
+
+protected:
+  explicit CellRendererCombo(const Glib::ConstructParams& construct_params);
+  explicit CellRendererCombo(GtkCellRendererCombo* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GtkCellRendererCombo*       gobj()       { return reinterpret_cast<GtkCellRendererCombo*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GtkCellRendererCombo* gobj() const { return reinterpret_cast<GtkCellRendererCombo*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+private:
+
+public:
+
+  CellRendererCombo();
+
+  /** The model containing the possible values for the combo box.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy< Glib::RefPtr<Gtk::TreeModel> > property_model() ;
+
+/** The model containing the possible values for the combo box.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gtk::TreeModel> > property_model() const;
+
+  /** A column in the data source model to get the strings from.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<int> property_text_column() ;
+
+/** A column in the data source model to get the strings from.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<int> property_text_column() const;
+
+  /** If FALSE
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_has_entry() ;
+
+/** If FALSE
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_has_entry() const;
+
+
+  virtual Glib::PropertyProxy_Base _property_renderable(); //override
+
+
+};
+
+} /* namespace Gtk */
+
+
+namespace Glib
+{
+  /** @relates Gtk::CellRendererCombo
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gtk::CellRendererCombo* wrap(GtkCellRendererCombo* object, bool take_copy = false);
+}
+#endif /* _GTKMM_CELLRENDERERCOMBO_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/cellrendererpixbuf.cc b/libs/gtkmm2/gtk/gtkmm/cellrendererpixbuf.cc
new file mode 100644
index 0000000000..bbf363d011
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/cellrendererpixbuf.cc
@@ -0,0 +1,199 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/cellrendererpixbuf.h>
+#include <gtkmm/private/cellrendererpixbuf_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* 
+ *
+ * Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+#include <gtk/gtkcellrendererpixbuf.h>
+
+namespace Gtk
+{
+
+Glib::PropertyProxy_Base CellRendererPixbuf::_property_renderable()
+{
+  return property_pixbuf();
+}
+
+} //namespace Gtk
+
+
+namespace
+{
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Gtk::CellRendererPixbuf* wrap(GtkCellRendererPixbuf* object, bool take_copy)
+{
+  return dynamic_cast<Gtk::CellRendererPixbuf *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& CellRendererPixbuf_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &CellRendererPixbuf_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_cell_renderer_pixbuf_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void CellRendererPixbuf_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+}
+
+
+Glib::ObjectBase* CellRendererPixbuf_Class::wrap_new(GObject* o)
+{
+  return manage(new CellRendererPixbuf((GtkCellRendererPixbuf*)(o)));
+
+}
+
+
+/* The implementation: */
+
+CellRendererPixbuf::CellRendererPixbuf(const Glib::ConstructParams& construct_params)
+:
+  Gtk::CellRenderer(construct_params)
+{
+  }
+
+CellRendererPixbuf::CellRendererPixbuf(GtkCellRendererPixbuf* castitem)
+:
+  Gtk::CellRenderer((GtkCellRenderer*)(castitem))
+{
+  }
+
+CellRendererPixbuf::~CellRendererPixbuf()
+{
+  destroy_();
+}
+
+CellRendererPixbuf::CppClassType CellRendererPixbuf::cellrendererpixbuf_class_; // initialize static member
+
+GType CellRendererPixbuf::get_type()
+{
+  return cellrendererpixbuf_class_.init().get_type();
+}
+
+GType CellRendererPixbuf::get_base_type()
+{
+  return gtk_cell_renderer_pixbuf_get_type();
+}
+
+
+CellRendererPixbuf::CellRendererPixbuf()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::CellRenderer(Glib::ConstructParams(cellrendererpixbuf_class_.init()))
+{
+  }
+
+
+Glib::PropertyProxy< Glib::RefPtr<Gdk::Pixbuf> > CellRendererPixbuf::property_pixbuf() 
+{
+  return Glib::PropertyProxy< Glib::RefPtr<Gdk::Pixbuf> >(this, "pixbuf");
+}
+
+Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::Pixbuf> > CellRendererPixbuf::property_pixbuf() const
+{
+  return Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::Pixbuf> >(this, "pixbuf");
+}
+
+Glib::PropertyProxy< Glib::RefPtr<Gdk::Pixbuf> > CellRendererPixbuf::property_pixbuf_expander_open() 
+{
+  return Glib::PropertyProxy< Glib::RefPtr<Gdk::Pixbuf> >(this, "pixbuf-expander-open");
+}
+
+Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::Pixbuf> > CellRendererPixbuf::property_pixbuf_expander_open() const
+{
+  return Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::Pixbuf> >(this, "pixbuf-expander-open");
+}
+
+Glib::PropertyProxy< Glib::RefPtr<Gdk::Pixbuf> > CellRendererPixbuf::property_pixbuf_expander_closed() 
+{
+  return Glib::PropertyProxy< Glib::RefPtr<Gdk::Pixbuf> >(this, "pixbuf-expander-closed");
+}
+
+Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::Pixbuf> > CellRendererPixbuf::property_pixbuf_expander_closed() const
+{
+  return Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::Pixbuf> >(this, "pixbuf-expander-closed");
+}
+
+Glib::PropertyProxy<Glib::ustring> CellRendererPixbuf::property_stock_id() 
+{
+  return Glib::PropertyProxy<Glib::ustring>(this, "stock-id");
+}
+
+Glib::PropertyProxy_ReadOnly<Glib::ustring> CellRendererPixbuf::property_stock_id() const
+{
+  return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "stock-id");
+}
+
+Glib::PropertyProxy<guint> CellRendererPixbuf::property_stock_size() 
+{
+  return Glib::PropertyProxy<guint>(this, "stock-size");
+}
+
+Glib::PropertyProxy_ReadOnly<guint> CellRendererPixbuf::property_stock_size() const
+{
+  return Glib::PropertyProxy_ReadOnly<guint>(this, "stock-size");
+}
+
+Glib::PropertyProxy<Glib::ustring> CellRendererPixbuf::property_stock_detail() 
+{
+  return Glib::PropertyProxy<Glib::ustring>(this, "stock-detail");
+}
+
+Glib::PropertyProxy_ReadOnly<Glib::ustring> CellRendererPixbuf::property_stock_detail() const
+{
+  return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "stock-detail");
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/cellrendererpixbuf.h b/libs/gtkmm2/gtk/gtkmm/cellrendererpixbuf.h
new file mode 100644
index 0000000000..8380c76492
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/cellrendererpixbuf.h
@@ -0,0 +1,226 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_CELLRENDERERPIXBUF_H
+#define _GTKMM_CELLRENDERERPIXBUF_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* cellrenderertext.h
+ * 
+ * Copyright (C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/cellrenderer.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkCellRendererPixbuf GtkCellRendererPixbuf;
+typedef struct _GtkCellRendererPixbufClass GtkCellRendererPixbufClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class CellRendererPixbuf_Class; } // namespace Gtk
+namespace Gtk
+{
+
+/** Renders a pixbuf in a cell.
+ * A CellRendererPixbuf can be used to render an image in a cell. It allows you to render either a 
+ * given Pixbuf (set via the pixbuf property) or a stock icon (set via the stock_id property).
+ *
+ * To support the tree view, CellRendererPixbuf also supports rendering two alternative pixbufs, when 
+ * the is_expanded property is true. If the is_expanded property is true and the pixbuf_expander_open 
+ * property is set to a pixbuf, it renders that pixbuf. If the is_expanded property is false and the *
+ * pixbuf_expander_closed property is set to a pixbuf, it renders that one.
+ *
+ * @ingroup TreeView
+ */
+
+class CellRendererPixbuf : public CellRenderer
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef CellRendererPixbuf CppObjectType;
+  typedef CellRendererPixbuf_Class CppClassType;
+  typedef GtkCellRendererPixbuf BaseObjectType;
+  typedef GtkCellRendererPixbufClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~CellRendererPixbuf();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class CellRendererPixbuf_Class;
+  static CppClassType cellrendererpixbuf_class_;
+
+  // noncopyable
+  CellRendererPixbuf(const CellRendererPixbuf&);
+  CellRendererPixbuf& operator=(const CellRendererPixbuf&);
+
+protected:
+  explicit CellRendererPixbuf(const Glib::ConstructParams& construct_params);
+  explicit CellRendererPixbuf(GtkCellRendererPixbuf* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GtkCellRendererPixbuf*       gobj()       { return reinterpret_cast<GtkCellRendererPixbuf*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GtkCellRendererPixbuf* gobj() const { return reinterpret_cast<GtkCellRendererPixbuf*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+private:
+
+public:
+
+  CellRendererPixbuf();
+  
+  /** The pixbuf to render.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy< Glib::RefPtr<Gdk::Pixbuf> > property_pixbuf() ;
+
+/** The pixbuf to render.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::Pixbuf> > property_pixbuf() const;
+
+  /** Pixbuf for open expander.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy< Glib::RefPtr<Gdk::Pixbuf> > property_pixbuf_expander_open() ;
+
+/** Pixbuf for open expander.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::Pixbuf> > property_pixbuf_expander_open() const;
+
+  /** Pixbuf for closed expander.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy< Glib::RefPtr<Gdk::Pixbuf> > property_pixbuf_expander_closed() ;
+
+/** Pixbuf for closed expander.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::Pixbuf> > property_pixbuf_expander_closed() const;
+
+  /** The stock ID of the stock icon to render.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Glib::ustring> property_stock_id() ;
+
+/** The stock ID of the stock icon to render.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Glib::ustring> property_stock_id() const;
+
+  /** The GtkIconSize value that specifies the size of the rendered icon.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<guint> property_stock_size() ;
+
+/** The GtkIconSize value that specifies the size of the rendered icon.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<guint> property_stock_size() const;
+
+  /** Render detail to pass to the theme engine.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Glib::ustring> property_stock_detail() ;
+
+/** Render detail to pass to the theme engine.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Glib::ustring> property_stock_detail() const;
+
+
+  virtual Glib::PropertyProxy_Base _property_renderable(); //override
+
+
+};
+
+} /* namespace Gtk */
+
+
+namespace Glib
+{
+  /** @relates Gtk::CellRendererPixbuf
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gtk::CellRendererPixbuf* wrap(GtkCellRendererPixbuf* object, bool take_copy = false);
+}
+#endif /* _GTKMM_CELLRENDERERPIXBUF_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/cellrendererprogress.cc b/libs/gtkmm2/gtk/gtkmm/cellrendererprogress.cc
new file mode 100644
index 0000000000..e3f3b0ed4f
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/cellrendererprogress.cc
@@ -0,0 +1,161 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/cellrendererprogress.h>
+#include <gtkmm/private/cellrendererprogress_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* 
+ *
+ * Copyright 2004 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+ 
+#include <gtk/gtkcellrendererprogress.h>
+
+namespace Gtk
+{
+
+Glib::PropertyProxy_Base CellRendererProgress::_property_renderable()
+{
+  return _property_renderable();
+}
+
+
+} // namespace Gtk
+
+
+namespace
+{
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Gtk::CellRendererProgress* wrap(GtkCellRendererProgress* object, bool take_copy)
+{
+  return dynamic_cast<Gtk::CellRendererProgress *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& CellRendererProgress_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &CellRendererProgress_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_cell_renderer_progress_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void CellRendererProgress_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+}
+
+
+Glib::ObjectBase* CellRendererProgress_Class::wrap_new(GObject* o)
+{
+  return manage(new CellRendererProgress((GtkCellRendererProgress*)(o)));
+
+}
+
+
+/* The implementation: */
+
+CellRendererProgress::CellRendererProgress(const Glib::ConstructParams& construct_params)
+:
+  Gtk::CellRenderer(construct_params)
+{
+  }
+
+CellRendererProgress::CellRendererProgress(GtkCellRendererProgress* castitem)
+:
+  Gtk::CellRenderer((GtkCellRenderer*)(castitem))
+{
+  }
+
+CellRendererProgress::~CellRendererProgress()
+{
+  destroy_();
+}
+
+CellRendererProgress::CppClassType CellRendererProgress::cellrendererprogress_class_; // initialize static member
+
+GType CellRendererProgress::get_type()
+{
+  return cellrendererprogress_class_.init().get_type();
+}
+
+GType CellRendererProgress::get_base_type()
+{
+  return gtk_cell_renderer_progress_get_type();
+}
+
+
+CellRendererProgress::CellRendererProgress()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::CellRenderer(Glib::ConstructParams(cellrendererprogress_class_.init()))
+{
+  }
+
+
+Glib::PropertyProxy<int> CellRendererProgress::property_value() 
+{
+  return Glib::PropertyProxy<int>(this, "value");
+}
+
+Glib::PropertyProxy_ReadOnly<int> CellRendererProgress::property_value() const
+{
+  return Glib::PropertyProxy_ReadOnly<int>(this, "value");
+}
+
+Glib::PropertyProxy<Glib::ustring> CellRendererProgress::property_text() 
+{
+  return Glib::PropertyProxy<Glib::ustring>(this, "text");
+}
+
+Glib::PropertyProxy_ReadOnly<Glib::ustring> CellRendererProgress::property_text() const
+{
+  return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "text");
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/cellrendererprogress.h b/libs/gtkmm2/gtk/gtkmm/cellrendererprogress.h
new file mode 100644
index 0000000000..7ad6132715
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/cellrendererprogress.h
@@ -0,0 +1,152 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_CELLRENDERERPROGRESS_H
+#define _GTKMM_CELLRENDERERPROGRESS_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* Copyright (C) 2004 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/cellrenderer.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkCellRendererProgress GtkCellRendererProgress;
+typedef struct _GtkCellRendererProgressClass GtkCellRendererProgressClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class CellRendererProgress_Class; } // namespace Gtk
+namespace Gtk
+{
+
+/** Renders numbers as progress bars.
+ *
+ * @ingroup TreeView
+ */
+
+class CellRendererProgress : public CellRenderer
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef CellRendererProgress CppObjectType;
+  typedef CellRendererProgress_Class CppClassType;
+  typedef GtkCellRendererProgress BaseObjectType;
+  typedef GtkCellRendererProgressClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~CellRendererProgress();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class CellRendererProgress_Class;
+  static CppClassType cellrendererprogress_class_;
+
+  // noncopyable
+  CellRendererProgress(const CellRendererProgress&);
+  CellRendererProgress& operator=(const CellRendererProgress&);
+
+protected:
+  explicit CellRendererProgress(const Glib::ConstructParams& construct_params);
+  explicit CellRendererProgress(GtkCellRendererProgress* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GtkCellRendererProgress*       gobj()       { return reinterpret_cast<GtkCellRendererProgress*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GtkCellRendererProgress* gobj() const { return reinterpret_cast<GtkCellRendererProgress*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+private:
+
+public:
+  CellRendererProgress();
+
+  /** Value of the progress bar.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<int> property_value() ;
+
+/** Value of the progress bar.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<int> property_value() const;
+
+  /** Text on the progress bar.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Glib::ustring> property_text() ;
+
+/** Text on the progress bar.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Glib::ustring> property_text() const;
+
+  
+  virtual Glib::PropertyProxy_Base _property_renderable(); //override
+
+
+};
+
+} // namespace Gtk
+
+
+namespace Glib
+{
+  /** @relates Gtk::CellRendererProgress
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gtk::CellRendererProgress* wrap(GtkCellRendererProgress* object, bool take_copy = false);
+}
+#endif /* _GTKMM_CELLRENDERERPROGRESS_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/cellrenderertext.cc b/libs/gtkmm2/gtk/gtkmm/cellrenderertext.cc
new file mode 100644
index 0000000000..3ffd88a287
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/cellrenderertext.cc
@@ -0,0 +1,624 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/cellrenderertext.h>
+#include <gtkmm/private/cellrenderertext_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* 
+ *
+ * Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+#include <gtk/gtkcellrenderertext.h>
+
+namespace Gtk
+{
+
+Glib::PropertyProxy_Base CellRendererText::_property_renderable()
+{
+  return property_text();
+}
+
+void CellRendererText::edited(const Glib::ustring& path, const Glib::ustring& new_text)
+{
+  g_signal_emit_by_name(gobj(), "edited", path.c_str(), new_text.c_str());
+}
+
+} // namespace Gtk
+
+
+namespace
+{
+
+void CellRendererText_signal_edited_callback(GtkCellRendererText* self, const gchar* p0,const gchar* p1,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,const Glib::ustring&,const Glib::ustring& > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(Glib::convert_const_gchar_ptr_to_ustring(p0)
+, Glib::convert_const_gchar_ptr_to_ustring(p1)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+}
+
+const Glib::SignalProxyInfo CellRendererText_signal_edited_info =
+{
+  "edited",
+  (GCallback) &CellRendererText_signal_edited_callback,
+  (GCallback) &CellRendererText_signal_edited_callback
+};
+
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Gtk::CellRendererText* wrap(GtkCellRendererText* object, bool take_copy)
+{
+  return dynamic_cast<Gtk::CellRendererText *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& CellRendererText_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &CellRendererText_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_cell_renderer_text_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void CellRendererText_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+  klass->edited = &edited_callback;
+}
+
+
+void CellRendererText_Class::edited_callback(GtkCellRendererText* self, const gchar* p0, const gchar* p1)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_edited(Glib::convert_const_gchar_ptr_to_ustring(p0)
+, Glib::convert_const_gchar_ptr_to_ustring(p1)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->edited)
+      (*base->edited)(self, p0, p1);
+  }
+}
+
+
+Glib::ObjectBase* CellRendererText_Class::wrap_new(GObject* o)
+{
+  return manage(new CellRendererText((GtkCellRendererText*)(o)));
+
+}
+
+
+/* The implementation: */
+
+CellRendererText::CellRendererText(const Glib::ConstructParams& construct_params)
+:
+  Gtk::CellRenderer(construct_params)
+{
+  }
+
+CellRendererText::CellRendererText(GtkCellRendererText* castitem)
+:
+  Gtk::CellRenderer((GtkCellRenderer*)(castitem))
+{
+  }
+
+CellRendererText::~CellRendererText()
+{
+  destroy_();
+}
+
+CellRendererText::CppClassType CellRendererText::cellrenderertext_class_; // initialize static member
+
+GType CellRendererText::get_type()
+{
+  return cellrenderertext_class_.init().get_type();
+}
+
+GType CellRendererText::get_base_type()
+{
+  return gtk_cell_renderer_text_get_type();
+}
+
+
+CellRendererText::CellRendererText()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::CellRenderer(Glib::ConstructParams(cellrenderertext_class_.init()))
+{
+  }
+
+void CellRendererText::set_fixed_height_from_font(int number_of_rows)
+{
+  gtk_cell_renderer_text_set_fixed_height_from_font(gobj(), number_of_rows);
+}
+
+
+Glib::SignalProxy2< void,const Glib::ustring&,const Glib::ustring& > CellRendererText::signal_edited()
+{
+  return Glib::SignalProxy2< void,const Glib::ustring&,const Glib::ustring& >(this, &CellRendererText_signal_edited_info);
+}
+
+
+Glib::PropertyProxy<Glib::ustring> CellRendererText::property_text() 
+{
+  return Glib::PropertyProxy<Glib::ustring>(this, "text");
+}
+
+Glib::PropertyProxy_ReadOnly<Glib::ustring> CellRendererText::property_text() const
+{
+  return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "text");
+}
+
+Glib::PropertyProxy_WriteOnly<Glib::ustring> CellRendererText::property_markup() 
+{
+  return Glib::PropertyProxy_WriteOnly<Glib::ustring>(this, "markup");
+}
+
+Glib::PropertyProxy_ReadOnly<Glib::ustring> CellRendererText::property_markup() const
+{
+  return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "markup");
+}
+
+Glib::PropertyProxy<Pango::AttrList> CellRendererText::property_attributes() 
+{
+  return Glib::PropertyProxy<Pango::AttrList>(this, "attributes");
+}
+
+Glib::PropertyProxy_ReadOnly<Pango::AttrList> CellRendererText::property_attributes() const
+{
+  return Glib::PropertyProxy_ReadOnly<Pango::AttrList>(this, "attributes");
+}
+
+Glib::PropertyProxy_WriteOnly<Glib::ustring> CellRendererText::property_background() 
+{
+  return Glib::PropertyProxy_WriteOnly<Glib::ustring>(this, "background");
+}
+
+Glib::PropertyProxy_ReadOnly<Glib::ustring> CellRendererText::property_background() const
+{
+  return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "background");
+}
+
+Glib::PropertyProxy_WriteOnly<Glib::ustring> CellRendererText::property_foreground() 
+{
+  return Glib::PropertyProxy_WriteOnly<Glib::ustring>(this, "foreground");
+}
+
+Glib::PropertyProxy_ReadOnly<Glib::ustring> CellRendererText::property_foreground() const
+{
+  return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "foreground");
+}
+
+Glib::PropertyProxy<Gdk::Color> CellRendererText::property_background_gdk() 
+{
+  return Glib::PropertyProxy<Gdk::Color>(this, "background-gdk");
+}
+
+Glib::PropertyProxy_ReadOnly<Gdk::Color> CellRendererText::property_background_gdk() const
+{
+  return Glib::PropertyProxy_ReadOnly<Gdk::Color>(this, "background-gdk");
+}
+
+Glib::PropertyProxy<Gdk::Color> CellRendererText::property_foreground_gdk() 
+{
+  return Glib::PropertyProxy<Gdk::Color>(this, "foreground-gdk");
+}
+
+Glib::PropertyProxy_ReadOnly<Gdk::Color> CellRendererText::property_foreground_gdk() const
+{
+  return Glib::PropertyProxy_ReadOnly<Gdk::Color>(this, "foreground-gdk");
+}
+
+Glib::PropertyProxy<Glib::ustring> CellRendererText::property_font() 
+{
+  return Glib::PropertyProxy<Glib::ustring>(this, "font");
+}
+
+Glib::PropertyProxy_ReadOnly<Glib::ustring> CellRendererText::property_font() const
+{
+  return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "font");
+}
+
+Glib::PropertyProxy<Pango::FontDescription> CellRendererText::property_font_desc() 
+{
+  return Glib::PropertyProxy<Pango::FontDescription>(this, "font-desc");
+}
+
+Glib::PropertyProxy_ReadOnly<Pango::FontDescription> CellRendererText::property_font_desc() const
+{
+  return Glib::PropertyProxy_ReadOnly<Pango::FontDescription>(this, "font-desc");
+}
+
+Glib::PropertyProxy<Glib::ustring> CellRendererText::property_family() 
+{
+  return Glib::PropertyProxy<Glib::ustring>(this, "family");
+}
+
+Glib::PropertyProxy_ReadOnly<Glib::ustring> CellRendererText::property_family() const
+{
+  return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "family");
+}
+
+Glib::PropertyProxy<Pango::Style> CellRendererText::property_style() 
+{
+  return Glib::PropertyProxy<Pango::Style>(this, "style");
+}
+
+Glib::PropertyProxy_ReadOnly<Pango::Style> CellRendererText::property_style() const
+{
+  return Glib::PropertyProxy_ReadOnly<Pango::Style>(this, "style");
+}
+
+Glib::PropertyProxy<Pango::Variant> CellRendererText::property_variant() 
+{
+  return Glib::PropertyProxy<Pango::Variant>(this, "variant");
+}
+
+Glib::PropertyProxy_ReadOnly<Pango::Variant> CellRendererText::property_variant() const
+{
+  return Glib::PropertyProxy_ReadOnly<Pango::Variant>(this, "variant");
+}
+
+Glib::PropertyProxy<int> CellRendererText::property_weight() 
+{
+  return Glib::PropertyProxy<int>(this, "weight");
+}
+
+Glib::PropertyProxy_ReadOnly<int> CellRendererText::property_weight() const
+{
+  return Glib::PropertyProxy_ReadOnly<int>(this, "weight");
+}
+
+Glib::PropertyProxy<Pango::Stretch> CellRendererText::property_stretch() 
+{
+  return Glib::PropertyProxy<Pango::Stretch>(this, "stretch");
+}
+
+Glib::PropertyProxy_ReadOnly<Pango::Stretch> CellRendererText::property_stretch() const
+{
+  return Glib::PropertyProxy_ReadOnly<Pango::Stretch>(this, "stretch");
+}
+
+Glib::PropertyProxy<int> CellRendererText::property_size() 
+{
+  return Glib::PropertyProxy<int>(this, "size");
+}
+
+Glib::PropertyProxy_ReadOnly<int> CellRendererText::property_size() const
+{
+  return Glib::PropertyProxy_ReadOnly<int>(this, "size");
+}
+
+Glib::PropertyProxy<double> CellRendererText::property_size_points() 
+{
+  return Glib::PropertyProxy<double>(this, "size-points");
+}
+
+Glib::PropertyProxy_ReadOnly<double> CellRendererText::property_size_points() const
+{
+  return Glib::PropertyProxy_ReadOnly<double>(this, "size-points");
+}
+
+Glib::PropertyProxy<double> CellRendererText::property_scale() 
+{
+  return Glib::PropertyProxy<double>(this, "scale");
+}
+
+Glib::PropertyProxy_ReadOnly<double> CellRendererText::property_scale() const
+{
+  return Glib::PropertyProxy_ReadOnly<double>(this, "scale");
+}
+
+Glib::PropertyProxy<bool> CellRendererText::property_editable() 
+{
+  return Glib::PropertyProxy<bool>(this, "editable");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> CellRendererText::property_editable() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "editable");
+}
+
+Glib::PropertyProxy<bool> CellRendererText::property_strikethrough() 
+{
+  return Glib::PropertyProxy<bool>(this, "strikethrough");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> CellRendererText::property_strikethrough() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "strikethrough");
+}
+
+Glib::PropertyProxy<Pango::Underline> CellRendererText::property_underline() 
+{
+  return Glib::PropertyProxy<Pango::Underline>(this, "underline");
+}
+
+Glib::PropertyProxy_ReadOnly<Pango::Underline> CellRendererText::property_underline() const
+{
+  return Glib::PropertyProxy_ReadOnly<Pango::Underline>(this, "underline");
+}
+
+Glib::PropertyProxy<int> CellRendererText::property_rise() 
+{
+  return Glib::PropertyProxy<int>(this, "rise");
+}
+
+Glib::PropertyProxy_ReadOnly<int> CellRendererText::property_rise() const
+{
+  return Glib::PropertyProxy_ReadOnly<int>(this, "rise");
+}
+
+Glib::PropertyProxy<Glib::ustring> CellRendererText::property_language() 
+{
+  return Glib::PropertyProxy<Glib::ustring>(this, "language");
+}
+
+Glib::PropertyProxy_ReadOnly<Glib::ustring> CellRendererText::property_language() const
+{
+  return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "language");
+}
+
+Glib::PropertyProxy<bool> CellRendererText::property_ellipsize() 
+{
+  return Glib::PropertyProxy<bool>(this, "ellipsize");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> CellRendererText::property_ellipsize() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "ellipsize");
+}
+
+Glib::PropertyProxy<bool> CellRendererText::property_background_set() 
+{
+  return Glib::PropertyProxy<bool>(this, "background-set");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> CellRendererText::property_background_set() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "background-set");
+}
+
+Glib::PropertyProxy<bool> CellRendererText::property_foreground_set() 
+{
+  return Glib::PropertyProxy<bool>(this, "foreground-set");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> CellRendererText::property_foreground_set() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "foreground-set");
+}
+
+Glib::PropertyProxy<bool> CellRendererText::property_family_set() 
+{
+  return Glib::PropertyProxy<bool>(this, "family-set");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> CellRendererText::property_family_set() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "family-set");
+}
+
+Glib::PropertyProxy<bool> CellRendererText::property_style_set() 
+{
+  return Glib::PropertyProxy<bool>(this, "style-set");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> CellRendererText::property_style_set() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "style-set");
+}
+
+Glib::PropertyProxy<bool> CellRendererText::property_variant_set() 
+{
+  return Glib::PropertyProxy<bool>(this, "variant-set");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> CellRendererText::property_variant_set() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "variant-set");
+}
+
+Glib::PropertyProxy<bool> CellRendererText::property_weight_set() 
+{
+  return Glib::PropertyProxy<bool>(this, "weight-set");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> CellRendererText::property_weight_set() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "weight-set");
+}
+
+Glib::PropertyProxy<bool> CellRendererText::property_stretch_set() 
+{
+  return Glib::PropertyProxy<bool>(this, "stretch-set");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> CellRendererText::property_stretch_set() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "stretch-set");
+}
+
+Glib::PropertyProxy<bool> CellRendererText::property_size_set() 
+{
+  return Glib::PropertyProxy<bool>(this, "size-set");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> CellRendererText::property_size_set() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "size-set");
+}
+
+Glib::PropertyProxy<bool> CellRendererText::property_scale_set() 
+{
+  return Glib::PropertyProxy<bool>(this, "scale-set");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> CellRendererText::property_scale_set() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "scale-set");
+}
+
+Glib::PropertyProxy<bool> CellRendererText::property_editable_set() 
+{
+  return Glib::PropertyProxy<bool>(this, "editable-set");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> CellRendererText::property_editable_set() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "editable-set");
+}
+
+Glib::PropertyProxy<bool> CellRendererText::property_strikethrough_set() 
+{
+  return Glib::PropertyProxy<bool>(this, "strikethrough-set");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> CellRendererText::property_strikethrough_set() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "strikethrough-set");
+}
+
+Glib::PropertyProxy<bool> CellRendererText::property_underline_set() 
+{
+  return Glib::PropertyProxy<bool>(this, "underline-set");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> CellRendererText::property_underline_set() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "underline-set");
+}
+
+Glib::PropertyProxy<bool> CellRendererText::property_rise_set() 
+{
+  return Glib::PropertyProxy<bool>(this, "rise-set");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> CellRendererText::property_rise_set() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "rise-set");
+}
+
+Glib::PropertyProxy<bool> CellRendererText::property_language_set() 
+{
+  return Glib::PropertyProxy<bool>(this, "language-set");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> CellRendererText::property_language_set() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "language-set");
+}
+
+Glib::PropertyProxy<bool> CellRendererText::property_ellipsize_set() 
+{
+  return Glib::PropertyProxy<bool>(this, "ellipsize-set");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> CellRendererText::property_ellipsize_set() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "ellipsize-set");
+}
+
+Glib::PropertyProxy<bool> CellRendererText::property_single_paragraph_mode() 
+{
+  return Glib::PropertyProxy<bool>(this, "single-paragraph-mode");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> CellRendererText::property_single_paragraph_mode() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "single-paragraph-mode");
+}
+
+
+void Gtk::CellRendererText::on_edited(const Glib::ustring& path, const Glib::ustring& new_text)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->edited)
+    (*base->edited)(gobj(),path.c_str(),new_text.c_str());
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/cellrenderertext.h b/libs/gtkmm2/gtk/gtkmm/cellrenderertext.h
new file mode 100644
index 0000000000..9135cdf83a
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/cellrenderertext.h
@@ -0,0 +1,769 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_CELLRENDERERTEXT_H
+#define _GTKMM_CELLRENDERERTEXT_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* Copyright (C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/cellrenderer.h>
+#include <pangomm/attrlist.h>
+#include <pangomm/fontdescription.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkCellRendererText GtkCellRendererText;
+typedef struct _GtkCellRendererTextClass GtkCellRendererTextClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class CellRendererText_Class; } // namespace Gtk
+namespace Gtk
+{
+
+/** Renders text in a cell.
+ *
+ * @ingroup TreeView
+ */
+
+class CellRendererText : public CellRenderer
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef CellRendererText CppObjectType;
+  typedef CellRendererText_Class CppClassType;
+  typedef GtkCellRendererText BaseObjectType;
+  typedef GtkCellRendererTextClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~CellRendererText();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class CellRendererText_Class;
+  static CppClassType cellrenderertext_class_;
+
+  // noncopyable
+  CellRendererText(const CellRendererText&);
+  CellRendererText& operator=(const CellRendererText&);
+
+protected:
+  explicit CellRendererText(const Glib::ConstructParams& construct_params);
+  explicit CellRendererText(GtkCellRendererText* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GtkCellRendererText*       gobj()       { return reinterpret_cast<GtkCellRendererText*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GtkCellRendererText* gobj() const { return reinterpret_cast<GtkCellRendererText*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+  virtual void on_edited(const Glib::ustring& path, const Glib::ustring& new_text);
+
+
+private:
+
+public:
+  CellRendererText();
+
+  
+  /** Sets the height of a renderer to explicitly be determined by the "font" and
+   * "y_pad" property set on it.  Further changes in these properties do not
+   * affect the height, so they must be accompanied by a subsequent call to this
+   * function.  Using this function is unflexible, and should really only be used
+   * if calculating the size of a cell is too slow (ie, a massive number of cells
+   * displayed).  If @a number_of_rows  is -1, then the fixed height is unset, and
+   * the height is determined by the properties again.
+   * @param number_of_rows Number of rows of text each cell renderer is allocated, or -1.
+   */
+  void set_fixed_height_from_font(int number_of_rows);
+
+  
+  Glib::SignalProxy2< void,const Glib::ustring&,const Glib::ustring& > signal_edited();
+
+
+  /** Text to render.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Glib::ustring> property_text() ;
+
+/** Text to render.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Glib::ustring> property_text() const;
+
+  /** Marked up text to render.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_WriteOnly<Glib::ustring> property_markup() ;
+
+/** Marked up text to render.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Glib::ustring> property_markup() const;
+
+  /** A list of style attributes to apply to the text of the renderer.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Pango::AttrList> property_attributes() ;
+
+/** A list of style attributes to apply to the text of the renderer.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Pango::AttrList> property_attributes() const;
+
+  /** Background color as a string.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_WriteOnly<Glib::ustring> property_background() ;
+
+/** Background color as a string.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Glib::ustring> property_background() const;
+
+  /** Foreground color as a string.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_WriteOnly<Glib::ustring> property_foreground() ;
+
+/** Foreground color as a string.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Glib::ustring> property_foreground() const;
+
+  /** Background color as a GdkColor.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Gdk::Color> property_background_gdk() ;
+
+/** Background color as a GdkColor.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Gdk::Color> property_background_gdk() const;
+
+  /** Foreground color as a GdkColor.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Gdk::Color> property_foreground_gdk() ;
+
+/** Foreground color as a GdkColor.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Gdk::Color> property_foreground_gdk() const;
+
+  /** Font description as a string.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Glib::ustring> property_font() ;
+
+/** Font description as a string.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Glib::ustring> property_font() const;
+
+  /** Font description as a PangoFontDescription struct.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Pango::FontDescription> property_font_desc() ;
+
+/** Font description as a PangoFontDescription struct.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Pango::FontDescription> property_font_desc() const;
+
+  /** Name of the font family
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Glib::ustring> property_family() ;
+
+/** Name of the font family
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Glib::ustring> property_family() const;
+
+  /** Font style.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Pango::Style> property_style() ;
+
+/** Font style.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Pango::Style> property_style() const;
+
+  /** Font variant.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Pango::Variant> property_variant() ;
+
+/** Font variant.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Pango::Variant> property_variant() const;
+
+  /** Font weight.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<int> property_weight() ;
+
+/** Font weight.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<int> property_weight() const;
+
+  /** Font stretch.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Pango::Stretch> property_stretch() ;
+
+/** Font stretch.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Pango::Stretch> property_stretch() const;
+
+  /** Font size.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<int> property_size() ;
+
+/** Font size.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<int> property_size() const;
+
+  /** Font size in points.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<double> property_size_points() ;
+
+/** Font size in points.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<double> property_size_points() const;
+
+  /** Font scaling factor.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<double> property_scale() ;
+
+/** Font scaling factor.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<double> property_scale() const;
+
+  /** Whether the text can be modified by the user.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_editable() ;
+
+/** Whether the text can be modified by the user.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_editable() const;
+
+  /** Whether to strike through the text.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_strikethrough() ;
+
+/** Whether to strike through the text.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_strikethrough() const;
+
+  /** Style of underline for this text.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Pango::Underline> property_underline() ;
+
+/** Style of underline for this text.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Pango::Underline> property_underline() const;
+
+  /** Offset of text above the baseline (below the baseline if rise is negative).
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<int> property_rise() ;
+
+/** Offset of text above the baseline (below the baseline if rise is negative).
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<int> property_rise() const;
+
+  /** The language this text is in
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Glib::ustring> property_language() ;
+
+/** The language this text is in
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Glib::ustring> property_language() const;
+
+  /** The preferred place to ellipsize the string
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_ellipsize() ;
+
+/** The preferred place to ellipsize the string
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_ellipsize() const;
+
+  /** Whether this tag affects the background color.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_background_set() ;
+
+/** Whether this tag affects the background color.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_background_set() const;
+
+  /** Whether this tag affects the foreground color.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_foreground_set() ;
+
+/** Whether this tag affects the foreground color.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_foreground_set() const;
+
+  /** Whether this tag affects the font family.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_family_set() ;
+
+/** Whether this tag affects the font family.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_family_set() const;
+
+  /** Whether this tag affects the font style.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_style_set() ;
+
+/** Whether this tag affects the font style.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_style_set() const;
+
+  /** Whether this tag affects the font variant.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_variant_set() ;
+
+/** Whether this tag affects the font variant.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_variant_set() const;
+
+  /** Whether this tag affects the font weight.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_weight_set() ;
+
+/** Whether this tag affects the font weight.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_weight_set() const;
+
+  /** Whether this tag affects the font stretch.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_stretch_set() ;
+
+/** Whether this tag affects the font stretch.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_stretch_set() const;
+
+  /** Whether this tag affects the font size.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_size_set() ;
+
+/** Whether this tag affects the font size.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_size_set() const;
+
+  /** Whether this tag scales the font size by a factor.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_scale_set() ;
+
+/** Whether this tag scales the font size by a factor.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_scale_set() const;
+
+  /** Whether this tag affects text editability.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_editable_set() ;
+
+/** Whether this tag affects text editability.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_editable_set() const;
+
+  /** Whether this tag affects strikethrough.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_strikethrough_set() ;
+
+/** Whether this tag affects strikethrough.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_strikethrough_set() const;
+
+  /** Whether this tag affects underlining.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_underline_set() ;
+
+/** Whether this tag affects underlining.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_underline_set() const;
+
+  /** Whether this tag affects the rise.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_rise_set() ;
+
+/** Whether this tag affects the rise.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_rise_set() const;
+
+  /** Whether this tag affects the language the text is rendered as.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_language_set() ;
+
+/** Whether this tag affects the language the text is rendered as.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_language_set() const;
+
+  /** Whether this tag affects the ellipsize mode.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_ellipsize_set() ;
+
+/** Whether this tag affects the ellipsize mode.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_ellipsize_set() const;
+
+  /** Whether or not to keep all text in a single paragraph.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_single_paragraph_mode() ;
+
+/** Whether or not to keep all text in a single paragraph.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_single_paragraph_mode() const;
+
+  
+  virtual Glib::PropertyProxy_Base _property_renderable(); //override
+
+protected:
+  /** Emits the "edited" signal.
+   * This is useful when implementing custom CellRenderers.
+   */
+  void edited(const Glib::ustring& path, const Glib::ustring& new_text);
+
+
+};
+
+} // namespace Gtk
+
+
+namespace Glib
+{
+  /** @relates Gtk::CellRendererText
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gtk::CellRendererText* wrap(GtkCellRendererText* object, bool take_copy = false);
+}
+#endif /* _GTKMM_CELLRENDERERTEXT_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/cellrenderertoggle.cc b/libs/gtkmm2/gtk/gtkmm/cellrenderertoggle.cc
new file mode 100644
index 0000000000..023c5382dd
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/cellrenderertoggle.cc
@@ -0,0 +1,273 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/cellrenderertoggle.h>
+#include <gtkmm/private/cellrenderertoggle_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* 
+ *
+ * Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtk/gtkcellrenderertoggle.h>
+
+namespace Gtk
+{
+
+Glib::PropertyProxy_Base CellRendererToggle::_property_renderable()
+{
+  return property_active();
+}
+
+} //namespace Gtk
+
+
+namespace
+{
+
+void CellRendererToggle_signal_toggled_callback(GtkCellRendererToggle* self, const gchar* p0,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,const Glib::ustring& > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(Glib::convert_const_gchar_ptr_to_ustring(p0)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+}
+
+const Glib::SignalProxyInfo CellRendererToggle_signal_toggled_info =
+{
+  "toggled",
+  (GCallback) &CellRendererToggle_signal_toggled_callback,
+  (GCallback) &CellRendererToggle_signal_toggled_callback
+};
+
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Gtk::CellRendererToggle* wrap(GtkCellRendererToggle* object, bool take_copy)
+{
+  return dynamic_cast<Gtk::CellRendererToggle *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& CellRendererToggle_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &CellRendererToggle_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_cell_renderer_toggle_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void CellRendererToggle_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+  klass->toggled = &toggled_callback;
+}
+
+
+void CellRendererToggle_Class::toggled_callback(GtkCellRendererToggle* self, const gchar* p0)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_toggled(Glib::convert_const_gchar_ptr_to_ustring(p0)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->toggled)
+      (*base->toggled)(self, p0);
+  }
+}
+
+
+Glib::ObjectBase* CellRendererToggle_Class::wrap_new(GObject* o)
+{
+  return manage(new CellRendererToggle((GtkCellRendererToggle*)(o)));
+
+}
+
+
+/* The implementation: */
+
+CellRendererToggle::CellRendererToggle(const Glib::ConstructParams& construct_params)
+:
+  Gtk::CellRenderer(construct_params)
+{
+  }
+
+CellRendererToggle::CellRendererToggle(GtkCellRendererToggle* castitem)
+:
+  Gtk::CellRenderer((GtkCellRenderer*)(castitem))
+{
+  }
+
+CellRendererToggle::~CellRendererToggle()
+{
+  destroy_();
+}
+
+CellRendererToggle::CppClassType CellRendererToggle::cellrenderertoggle_class_; // initialize static member
+
+GType CellRendererToggle::get_type()
+{
+  return cellrenderertoggle_class_.init().get_type();
+}
+
+GType CellRendererToggle::get_base_type()
+{
+  return gtk_cell_renderer_toggle_get_type();
+}
+
+
+CellRendererToggle::CellRendererToggle()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::CellRenderer(Glib::ConstructParams(cellrenderertoggle_class_.init()))
+{
+  }
+
+bool CellRendererToggle::get_radio() const
+{
+  return gtk_cell_renderer_toggle_get_radio(const_cast<GtkCellRendererToggle*>(gobj()));
+}
+
+void CellRendererToggle::set_radio(bool radio)
+{
+  gtk_cell_renderer_toggle_set_radio(gobj(), static_cast<int>(radio));
+}
+
+bool CellRendererToggle::get_active() const
+{
+  return gtk_cell_renderer_toggle_get_active(const_cast<GtkCellRendererToggle*>(gobj()));
+}
+
+void CellRendererToggle::set_active(bool setting)
+{
+  gtk_cell_renderer_toggle_set_active(gobj(), static_cast<int>(setting));
+}
+
+
+Glib::SignalProxy1< void,const Glib::ustring& > CellRendererToggle::signal_toggled()
+{
+  return Glib::SignalProxy1< void,const Glib::ustring& >(this, &CellRendererToggle_signal_toggled_info);
+}
+
+
+Glib::PropertyProxy<bool> CellRendererToggle::property_activatable() 
+{
+  return Glib::PropertyProxy<bool>(this, "activatable");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> CellRendererToggle::property_activatable() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "activatable");
+}
+
+Glib::PropertyProxy<bool> CellRendererToggle::property_active() 
+{
+  return Glib::PropertyProxy<bool>(this, "active");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> CellRendererToggle::property_active() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "active");
+}
+
+Glib::PropertyProxy<bool> CellRendererToggle::property_radio() 
+{
+  return Glib::PropertyProxy<bool>(this, "radio");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> CellRendererToggle::property_radio() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "radio");
+}
+
+
+void Gtk::CellRendererToggle::on_toggled(const Glib::ustring& path)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->toggled)
+    (*base->toggled)(gobj(),path.c_str());
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/cellrenderertoggle.h b/libs/gtkmm2/gtk/gtkmm/cellrenderertoggle.h
new file mode 100644
index 0000000000..293f4e7750
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/cellrenderertoggle.h
@@ -0,0 +1,206 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_CELLRENDERERTOGGLE_H
+#define _GTKMM_CELLRENDERERTOGGLE_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* cellrenderertoggle.h
+ * 
+ * Copyright (C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/cellrenderer.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkCellRendererToggle GtkCellRendererToggle;
+typedef struct _GtkCellRendererToggleClass GtkCellRendererToggleClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class CellRendererToggle_Class; } // namespace Gtk
+namespace Gtk
+{
+
+/** Renders a toggle button in a cell.
+ * The button is drawn as a radio- or checkbutton, depending on the radio property. When activated, it 
+ * emits the toggled signal.
+ *
+ * @ingroup TreeView
+ */
+
+class CellRendererToggle : public CellRenderer
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef CellRendererToggle CppObjectType;
+  typedef CellRendererToggle_Class CppClassType;
+  typedef GtkCellRendererToggle BaseObjectType;
+  typedef GtkCellRendererToggleClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~CellRendererToggle();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class CellRendererToggle_Class;
+  static CppClassType cellrenderertoggle_class_;
+
+  // noncopyable
+  CellRendererToggle(const CellRendererToggle&);
+  CellRendererToggle& operator=(const CellRendererToggle&);
+
+protected:
+  explicit CellRendererToggle(const Glib::ConstructParams& construct_params);
+  explicit CellRendererToggle(GtkCellRendererToggle* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GtkCellRendererToggle*       gobj()       { return reinterpret_cast<GtkCellRendererToggle*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GtkCellRendererToggle* gobj() const { return reinterpret_cast<GtkCellRendererToggle*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+  virtual void on_toggled(const Glib::ustring& path);
+
+
+private:
+
+public:
+
+  CellRendererToggle();
+  
+
+  /** Returns wether we're rendering radio toggles rather than checkboxes.
+   * @return <tt>true</tt> if we're rendering radio toggles rather than checkboxes.
+   */
+  bool get_radio() const;
+  
+  /** If @a radio  is <tt>true</tt>, the cell renderer renders a radio toggle
+   * (i.e.\ a toggle in a group of mutually-exclusive toggles).
+   * If <tt>false</tt>, it renders a check toggle (a standalone boolean option).
+   * This can be set globally for the cell renderer, or changed just
+   * before rendering each cell in the model (for Gtk::TreeView, you set
+   * up a per-row setting using Gtk::TreeViewColumn to associate model
+   * columns with cell renderer properties).
+   * @param radio <tt>true</tt> to make the toggle look like a radio button.
+   */
+  void set_radio(bool radio = true);
+  
+  /** Returns whether the cell renderer is active. See
+   * set_active().
+   * @return <tt>true</tt> if the cell renderer is active.
+   */
+  bool get_active() const;
+  
+  /** Activates or deactivates a cell renderer.
+   * @param setting The value to set.
+   */
+  void set_active(bool setting = true);
+
+
+  Glib::SignalProxy1< void,const Glib::ustring& > signal_toggled();
+
+
+  /** The toggle button can be activated.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_activatable() ;
+
+/** The toggle button can be activated.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_activatable() const;
+
+  /** The toggle state of the button.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_active() ;
+
+/** The toggle state of the button.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_active() const;
+
+  /** Draw the toggle button as a radio button.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_radio() ;
+
+/** Draw the toggle button as a radio button.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_radio() const;
+
+
+  virtual Glib::PropertyProxy_Base _property_renderable(); //override
+
+
+};
+
+} /* namespace Gtk */
+
+
+namespace Glib
+{
+  /** @relates Gtk::CellRendererToggle
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gtk::CellRendererToggle* wrap(GtkCellRendererToggle* object, bool take_copy = false);
+}
+#endif /* _GTKMM_CELLRENDERERTOGGLE_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/cellview.cc b/libs/gtkmm2/gtk/gtkmm/cellview.cc
new file mode 100644
index 0000000000..5b57ccf3a0
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/cellview.cc
@@ -0,0 +1,199 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/cellview.h>
+#include <gtkmm/private/cellview_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* 
+ *
+ * Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/cellrenderertext.h>
+#include <gtkmm/cellrendererpixbuf.h>
+#include <gtk/gtkcellview.h>
+
+namespace Gtk
+{
+
+CellView::CellView(const Glib::ustring& text, bool use_markup)
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Widget(Glib::ConstructParams(cellview_class_.init(), (char*) 0))
+{
+  Gtk::CellRendererText* cell = Gtk::manage(new Gtk::CellRendererText());
+  
+  if(use_markup)
+    cell->property_markup() = text;
+  else
+    cell->property_text() = text;
+  
+  pack_start(*cell);
+}
+
+CellView::CellView(const Glib::RefPtr<Gdk::Pixbuf>& pixbuf)
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Widget(Glib::ConstructParams(cellview_class_.init(), (char*) 0))
+{
+  Gtk::CellRendererPixbuf* cell = Gtk::manage(new Gtk::CellRendererPixbuf());
+  cell->property_pixbuf() = pixbuf;
+  
+  pack_start(*cell);
+}
+
+
+} //namespace Gtk
+
+
+namespace
+{
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Gtk::CellView* wrap(GtkCellView* object, bool take_copy)
+{
+  return dynamic_cast<Gtk::CellView *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& CellView_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &CellView_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_cell_view_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  CellLayout::add_interface(get_type());
+  }
+
+  return *this;
+}
+
+void CellView_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+}
+
+
+Glib::ObjectBase* CellView_Class::wrap_new(GObject* o)
+{
+  return manage(new CellView((GtkCellView*)(o)));
+
+}
+
+
+/* The implementation: */
+
+CellView::CellView(const Glib::ConstructParams& construct_params)
+:
+  Gtk::Widget(construct_params)
+{
+  }
+
+CellView::CellView(GtkCellView* castitem)
+:
+  Gtk::Widget((GtkWidget*)(castitem))
+{
+  }
+
+CellView::~CellView()
+{
+  destroy_();
+}
+
+CellView::CppClassType CellView::cellview_class_; // initialize static member
+
+GType CellView::get_type()
+{
+  return cellview_class_.init().get_type();
+}
+
+GType CellView::get_base_type()
+{
+  return gtk_cell_view_get_type();
+}
+
+
+CellView::CellView()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Widget(Glib::ConstructParams(cellview_class_.init()))
+{
+  }
+
+void CellView::set_model(const Glib::RefPtr<TreeModel>& model)
+{
+  gtk_cell_view_set_model(gobj(), Glib::unwrap(model));
+}
+
+void CellView::set_displayed_row(const TreeModel::Path& path)
+{
+  gtk_cell_view_set_displayed_row(gobj(), const_cast<GtkTreePath*>((path).gobj()));
+}
+
+TreeModel::Path CellView::get_displayed_row() const
+{
+  return Gtk::TreePath(gtk_cell_view_get_displayed_row(const_cast<GtkCellView*>(gobj())), false);
+}
+
+bool CellView::get_size_of_row(const TreeModel::Path& path, Requisition& requisition) const
+{
+  return gtk_cell_view_get_size_of_row(const_cast<GtkCellView*>(gobj()), const_cast<GtkTreePath*>((path).gobj()), (GtkRequisition*)(&requisition));
+}
+
+void CellView::set_background_color(const Gdk::Color& color)
+{
+  gtk_cell_view_set_background_color(gobj(), (color).gobj());
+}
+
+Glib::ListHandle<CellRenderer*> CellView::get_cell_renderers()
+{
+  return Glib::ListHandle<CellRenderer*>(gtk_cell_view_get_cell_renderers(gobj()), Glib::OWNERSHIP_SHALLOW);
+}
+
+Glib::ListHandle<const CellRenderer*> CellView::get_cell_renderers() const
+{
+  return Glib::ListHandle<const CellRenderer*>(gtk_cell_view_get_cell_renderers(const_cast<GtkCellView*>(gobj())), Glib::OWNERSHIP_SHALLOW);
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/cellview.h b/libs/gtkmm2/gtk/gtkmm/cellview.h
new file mode 100644
index 0000000000..6e798c5f56
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/cellview.h
@@ -0,0 +1,210 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_CELLVIEW_H
+#define _GTKMM_CELLVIEW_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* cellview.h
+ * 
+ * Copyright (C) 2004 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+
+#include <gtkmm/widget.h>
+#include <gtkmm/celllayout.h>
+#include <gtkmm/treemodel.h>
+#include <gtkmm/treepath.h>
+#include <gtkmm/cellrenderer.h>
+#include <gdkmm/pixbuf.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkCellView GtkCellView;
+typedef struct _GtkCellViewClass GtkCellViewClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class CellView_Class; } // namespace Gtk
+namespace Gtk
+{
+
+/** A widget displaying a single row of a TreeModel.
+ * A CellView displays a single row of a TreeModel, using cell renderers just like TreeView. CellView doesn't support some of the more 
+ * complex features of GtkTreeView, like cell editing and drag and drop.
+ *
+ * @ingroup Widgets
+ */
+
+class CellView :
+  public Widget,
+  public CellLayout
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef CellView CppObjectType;
+  typedef CellView_Class CppClassType;
+  typedef GtkCellView BaseObjectType;
+  typedef GtkCellViewClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~CellView();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class CellView_Class;
+  static CppClassType cellview_class_;
+
+  // noncopyable
+  CellView(const CellView&);
+  CellView& operator=(const CellView&);
+
+protected:
+  explicit CellView(const Glib::ConstructParams& construct_params);
+  explicit CellView(GtkCellView* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GtkCellView*       gobj()       { return reinterpret_cast<GtkCellView*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GtkCellView* gobj() const { return reinterpret_cast<GtkCellView*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+private:
+
+  
+public:
+  CellView();
+  
+  /** Creates a new CellView widget, adds a CellRendererText to it, and makes it show the text. 
+   * Optionally, the text can be marked up with the Pango text markup language.
+   *
+   * @param text The text to display in the cell view
+   * @param markup Whether the @a text uses Pango text markup language.
+   */
+  explicit CellView(const Glib::ustring& text, bool use_markup = false);
+  
+  
+  /** Creates a new CellView widget, adds a CellRendererPixbuf to it, and makes it show the pixbuf.
+   *
+   * @param pixbuf The image to display in the cell view
+   * @param markup Whether the @a text uses Pango text markup language.
+   */
+  explicit CellView(const Glib::RefPtr<Gdk::Pixbuf>& pixbuf);
+  
+
+  //_WRAP_METHOD(void set_value(CellRenderer& renderer, const Glib::ustring& property, const Glib::ValueBase& value), gtk_cell_view_set_value)
+  
+
+  /** Sets the model for @a cell_view .  If @a cell_view  already has a model
+   * set, it will remove it before setting the new model.  If @a model  is 
+   * <tt>0</tt>, then it will unset the old model.
+   * 
+   * Since: 2.6
+   * @param model A Gtk::TreeModel.
+   */
+  void set_model(const Glib::RefPtr<TreeModel>& model);
+  
+  /** Sets the row of the model that is currently displayed
+   * by the Gtk::CellView. If the path is unset, then the
+   * contents of the cellview "stick" at their last value;
+   * this is not normally a desired result, but may be
+   * a needed intermediate state if say, the model for
+   * the Gtk::CellView becomes temporarily empty.
+   * 
+   * Since: 2.6
+   * @param path A Gtk::TreePath or <tt>0</tt> to unset.
+   */
+  void set_displayed_row(const TreeModel::Path& path);
+  
+  TreeModel::Path get_displayed_row() const;
+  
+  /** Sets @a requisition  to the size needed by @a cell_view  to display 
+   * the model row pointed to by @a path .
+   * @param path A Gtk::TreePath.
+   * @param requisition Return location for the size.
+   * @return <tt>true</tt>
+   * 
+   * Since: 2.6.
+   */
+  bool get_size_of_row(const TreeModel::Path& path, Requisition& requisition) const;
+
+  
+  /** Sets the background color of @a view .
+   * 
+   * Since: 2.6
+   * @param color The new background color.
+   */
+  void set_background_color(const Gdk::Color& color);
+
+  
+  /** Returns the cell renderers which have been added to @a cell_view .
+   * @return A list of cell renderers. The list, but not the
+   * renderers has been newly allocated and should be freed with
+   * Glib::list_free() when no longer needed.
+   * 
+   * Since: 2.6.
+   */
+  Glib::ListHandle<CellRenderer*> get_cell_renderers();
+  
+  /** Returns the cell renderers which have been added to @a cell_view .
+   * @return A list of cell renderers. The list, but not the
+   * renderers has been newly allocated and should be freed with
+   * Glib::list_free() when no longer needed.
+   * 
+   * Since: 2.6.
+   */
+  Glib::ListHandle<const CellRenderer*> get_cell_renderers() const;
+
+
+};
+
+} // namespace Gtk
+
+
+namespace Glib
+{
+  /** @relates Gtk::CellView
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gtk::CellView* wrap(GtkCellView* object, bool take_copy = false);
+}
+#endif /* _GTKMM_CELLVIEW_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/checkbutton.cc b/libs/gtkmm2/gtk/gtkmm/checkbutton.cc
new file mode 100644
index 0000000000..110d0c5edc
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/checkbutton.cc
@@ -0,0 +1,186 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/checkbutton.h>
+#include <gtkmm/private/checkbutton_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* 
+ *
+ * Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtk/gtkcheckbutton.h>
+
+namespace Gtk
+{
+
+CheckButton::CheckButton(const Glib::ustring& label, bool mnemonic)
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::ToggleButton(Glib::ConstructParams(checkbutton_class_.init(), "label",label.c_str(),"use_underline",gboolean(mnemonic), (char*) 0))
+{}
+
+} // namespace Gtk
+
+
+namespace
+{
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Gtk::CheckButton* wrap(GtkCheckButton* object, bool take_copy)
+{
+  return dynamic_cast<Gtk::CheckButton *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& CheckButton_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &CheckButton_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_check_button_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void CheckButton_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+  klass->draw_indicator = &draw_indicator_vfunc_callback;
+}
+
+void CheckButton_Class::draw_indicator_vfunc_callback(GtkCheckButton* self, GdkRectangle* area)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->draw_indicator_vfunc(area);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->draw_indicator)
+      (*base->draw_indicator)(self, area);
+  }
+}
+
+
+Glib::ObjectBase* CheckButton_Class::wrap_new(GObject* o)
+{
+  return manage(new CheckButton((GtkCheckButton*)(o)));
+
+}
+
+
+/* The implementation: */
+
+CheckButton::CheckButton(const Glib::ConstructParams& construct_params)
+:
+  Gtk::ToggleButton(construct_params)
+{
+  }
+
+CheckButton::CheckButton(GtkCheckButton* castitem)
+:
+  Gtk::ToggleButton((GtkToggleButton*)(castitem))
+{
+  }
+
+CheckButton::~CheckButton()
+{
+  destroy_();
+}
+
+CheckButton::CppClassType CheckButton::checkbutton_class_; // initialize static member
+
+GType CheckButton::get_type()
+{
+  return checkbutton_class_.init().get_type();
+}
+
+GType CheckButton::get_base_type()
+{
+  return gtk_check_button_get_type();
+}
+
+
+CheckButton::CheckButton()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::ToggleButton(Glib::ConstructParams(checkbutton_class_.init()))
+{
+  }
+
+
+void Gtk::CheckButton::draw_indicator_vfunc(GdkRectangle* area) 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->draw_indicator)
+    (*base->draw_indicator)(gobj(),area);
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/checkbutton.h b/libs/gtkmm2/gtk/gtkmm/checkbutton.h
new file mode 100644
index 0000000000..bff262d400
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/checkbutton.h
@@ -0,0 +1,151 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_CHECKBUTTON_H
+#define _GTKMM_CHECKBUTTON_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* checkbutton.h
+ * 
+ * Copyright (C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/togglebutton.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkCheckButton GtkCheckButton;
+typedef struct _GtkCheckButtonClass GtkCheckButtonClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class CheckButton_Class; } // namespace Gtk
+namespace Gtk
+{
+
+/** Create widgets with a discrete toggle button.
+ *
+ * A Gtk::CheckButton places a discrete Gtk::ToggleButton next to a widget,
+ * (usually a Gtk::Label).  See Gtk::ToggleButton widgets for more
+ * information about toggle/check buttons.  The important signal,
+ * signal_toggled() is also inherited from Gtk::ToggleButton.
+ *
+ * @ingroup Widgets
+ */
+
+class CheckButton : public ToggleButton
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef CheckButton CppObjectType;
+  typedef CheckButton_Class CppClassType;
+  typedef GtkCheckButton BaseObjectType;
+  typedef GtkCheckButtonClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~CheckButton();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class CheckButton_Class;
+  static CppClassType checkbutton_class_;
+
+  // noncopyable
+  CheckButton(const CheckButton&);
+  CheckButton& operator=(const CheckButton&);
+
+protected:
+  explicit CheckButton(const Glib::ConstructParams& construct_params);
+  explicit CheckButton(GtkCheckButton* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GtkCheckButton*       gobj()       { return reinterpret_cast<GtkCheckButton*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GtkCheckButton* gobj() const { return reinterpret_cast<GtkCheckButton*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+private:
+
+public:
+
+  /** Create an empty check button.
+   * With an empty button, you can Gtk::Button::add() a widget such as a
+   * Gtk::Pixmap or Gtk::Box.
+   *
+   * If you just wish to add a Gtk::Label, you may want to use the
+   * Gtk::CheckButton(const Glib::ustring &label) constructor directly
+   * instead.
+   */
+  CheckButton();
+
+  /** Create a check button with a label.
+   * You won't be able to add a widget to this button since it already
+   * contains a Gtk::Label
+   */
+  explicit CheckButton(const Glib::ustring& label, bool mnemonic = false);
+  
+
+protected:
+  /** Emited on button redraw to update indicator.
+   * Triggered when the button is redrawn (e.g.after being toggled)
+   * Overload this signal if you want to implement your own check button
+   * look. Otherwise, you most likely don't care about it.
+   * The GdkRectangle specifies the area of the widget which will get
+   * redrawn.
+   */
+    virtual void draw_indicator_vfunc(GdkRectangle* area);
+  
+
+};
+
+
+} /* namespace Gtk */
+
+
+namespace Glib
+{
+  /** @relates Gtk::CheckButton
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gtk::CheckButton* wrap(GtkCheckButton* object, bool take_copy = false);
+}
+#endif /* _GTKMM_CHECKBUTTON_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/checkmenuitem.cc b/libs/gtkmm2/gtk/gtkmm/checkmenuitem.cc
new file mode 100644
index 0000000000..2a1a6b4ac2
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/checkmenuitem.cc
@@ -0,0 +1,317 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/checkmenuitem.h>
+#include <gtkmm/private/checkmenuitem_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* 
+ *
+ * Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtk/gtkcheckmenuitem.h>
+#include <gtkmm/misc.h>
+#include <gtkmm/label.h>
+
+namespace Gtk
+{
+
+CheckMenuItem::CheckMenuItem(const Glib::ustring& label, bool mnemonic)
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::MenuItem(Glib::ConstructParams(checkmenuitem_class_.init(), (char*) 0))
+{
+  add_accel_label(label, mnemonic); /* Left-aligned label */
+}
+
+} // namespace Gtk
+
+
+namespace
+{
+
+const Glib::SignalProxyInfo CheckMenuItem_signal_toggled_info =
+{
+  "toggled",
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
+};
+
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Gtk::CheckMenuItem* wrap(GtkCheckMenuItem* object, bool take_copy)
+{
+  return dynamic_cast<Gtk::CheckMenuItem *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& CheckMenuItem_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &CheckMenuItem_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_check_menu_item_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void CheckMenuItem_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+  klass->draw_indicator = &draw_indicator_vfunc_callback;
+  klass->toggled = &toggled_callback;
+}
+
+void CheckMenuItem_Class::draw_indicator_vfunc_callback(GtkCheckMenuItem* self, GdkRectangle* area)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->draw_indicator_vfunc(area);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->draw_indicator)
+      (*base->draw_indicator)(self, area);
+  }
+}
+
+
+void CheckMenuItem_Class::toggled_callback(GtkCheckMenuItem* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_toggled();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->toggled)
+      (*base->toggled)(self);
+  }
+}
+
+
+Glib::ObjectBase* CheckMenuItem_Class::wrap_new(GObject* o)
+{
+  return manage(new CheckMenuItem((GtkCheckMenuItem*)(o)));
+
+}
+
+
+/* The implementation: */
+
+CheckMenuItem::CheckMenuItem(const Glib::ConstructParams& construct_params)
+:
+  Gtk::MenuItem(construct_params)
+{
+  }
+
+CheckMenuItem::CheckMenuItem(GtkCheckMenuItem* castitem)
+:
+  Gtk::MenuItem((GtkMenuItem*)(castitem))
+{
+  }
+
+CheckMenuItem::~CheckMenuItem()
+{
+  destroy_();
+}
+
+CheckMenuItem::CppClassType CheckMenuItem::checkmenuitem_class_; // initialize static member
+
+GType CheckMenuItem::get_type()
+{
+  return checkmenuitem_class_.init().get_type();
+}
+
+GType CheckMenuItem::get_base_type()
+{
+  return gtk_check_menu_item_get_type();
+}
+
+
+CheckMenuItem::CheckMenuItem()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::MenuItem(Glib::ConstructParams(checkmenuitem_class_.init()))
+{
+  }
+
+void CheckMenuItem::set_active(bool state)
+{
+  gtk_check_menu_item_set_active(gobj(), static_cast<int>(state));
+}
+
+bool CheckMenuItem::get_active() const
+{
+  return gtk_check_menu_item_get_active(const_cast<GtkCheckMenuItem*>(gobj()));
+}
+
+void CheckMenuItem::toggled()
+{
+  gtk_check_menu_item_toggled(gobj());
+}
+
+void CheckMenuItem::set_inconsistent(bool setting)
+{
+  gtk_check_menu_item_set_inconsistent(gobj(), static_cast<int>(setting));
+}
+
+bool CheckMenuItem::get_inconsistent() const
+{
+  return gtk_check_menu_item_get_inconsistent(const_cast<GtkCheckMenuItem*>(gobj()));
+}
+
+void CheckMenuItem::set_draw_as_radio(bool draw_as_radio)
+{
+  gtk_check_menu_item_set_draw_as_radio(gobj(), static_cast<int>(draw_as_radio));
+}
+
+bool CheckMenuItem::get_draw_as_radio() const
+{
+  return gtk_check_menu_item_get_draw_as_radio(const_cast<GtkCheckMenuItem*>(gobj()));
+}
+
+
+Glib::SignalProxy0< void > CheckMenuItem::signal_toggled()
+{
+  return Glib::SignalProxy0< void >(this, &CheckMenuItem_signal_toggled_info);
+}
+
+
+Glib::PropertyProxy<bool> CheckMenuItem::property_active() 
+{
+  return Glib::PropertyProxy<bool>(this, "active");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> CheckMenuItem::property_active() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "active");
+}
+
+Glib::PropertyProxy<bool> CheckMenuItem::property_inconsistent() 
+{
+  return Glib::PropertyProxy<bool>(this, "inconsistent");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> CheckMenuItem::property_inconsistent() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "inconsistent");
+}
+
+Glib::PropertyProxy<bool> CheckMenuItem::property_draw_as_radio() 
+{
+  return Glib::PropertyProxy<bool>(this, "draw-as-radio");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> CheckMenuItem::property_draw_as_radio() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "draw-as-radio");
+}
+
+
+void Gtk::CheckMenuItem::on_toggled()
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->toggled)
+    (*base->toggled)(gobj());
+}
+
+
+void Gtk::CheckMenuItem::draw_indicator_vfunc(GdkRectangle* area) 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->draw_indicator)
+    (*base->draw_indicator)(gobj(),area);
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/checkmenuitem.h b/libs/gtkmm2/gtk/gtkmm/checkmenuitem.h
new file mode 100644
index 0000000000..faa95d431f
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/checkmenuitem.h
@@ -0,0 +1,237 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_CHECKMENUITEM_H
+#define _GTKMM_CHECKMENUITEM_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* checkmenuitem.h
+ * 
+ * Copyright (C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/menuitem.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkCheckMenuItem GtkCheckMenuItem;
+typedef struct _GtkCheckMenuItemClass GtkCheckMenuItemClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class CheckMenuItem_Class; } // namespace Gtk
+namespace Gtk
+{
+
+/** A menu item that maintains the state of a boolean value in addition to a Gtk::MenuItem's usual role in activating application code.
+ * A check box indicating the state of the boolean value is displayed at the left side of the Gtk::MenuItem.
+ * Activating the Gtk::MenuItem toggles the value.
+ * @ingroup Widgets
+ * @ingroup Menus
+ */
+
+class CheckMenuItem : public MenuItem
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef CheckMenuItem CppObjectType;
+  typedef CheckMenuItem_Class CppClassType;
+  typedef GtkCheckMenuItem BaseObjectType;
+  typedef GtkCheckMenuItemClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~CheckMenuItem();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class CheckMenuItem_Class;
+  static CppClassType checkmenuitem_class_;
+
+  // noncopyable
+  CheckMenuItem(const CheckMenuItem&);
+  CheckMenuItem& operator=(const CheckMenuItem&);
+
+protected:
+  explicit CheckMenuItem(const Glib::ConstructParams& construct_params);
+  explicit CheckMenuItem(GtkCheckMenuItem* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GtkCheckMenuItem*       gobj()       { return reinterpret_cast<GtkCheckMenuItem*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GtkCheckMenuItem* gobj() const { return reinterpret_cast<GtkCheckMenuItem*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+  virtual void on_toggled();
+
+
+private:
+
+  
+public:
+
+  CheckMenuItem();
+  explicit CheckMenuItem(const Glib::ustring& label, bool mnemonic = false);
+  
+
+  void set_active(bool state = true);
+  
+  /** Returns whether the check menu item is active. See
+   * set_active().
+   * @return <tt>true</tt> if the menu item is checked.
+   */
+  bool get_active() const;
+
+  
+  void toggled();
+
+  
+  /** If the user has selected a range of elements (such as some text or
+   * spreadsheet cells) that are affected by a boolean setting, and the
+   * current values in that range are inconsistent, you may want to
+   * display the check in an "in between" state. This function turns on
+   * "in between" display.  Normally you would turn off the inconsistent
+   * state again if the user explicitly selects a setting. This has to be
+   * done manually, set_inconsistent() only affects
+   * visual appearance, it doesn't affect the semantics of the widget.
+   * @param setting <tt>true</tt> to display an "inconsistent" third state check.
+   */
+  void set_inconsistent(bool setting = true);
+  
+  /** Retrieves the value set by set_inconsistent().
+   * @return <tt>true</tt> if inconsistent.
+   */
+  bool get_inconsistent() const;
+
+  
+  /** Sets whether @a check_menu_item  is drawn like a Gtk::RadioMenuItem
+   * 
+   * Since: 2.4
+   * @param draw_as_radio Whether @a check_menu_item  is drawn like a Gtk::RadioMenuItem.
+   */
+  void set_draw_as_radio(bool draw_as_radio = true);
+  
+  /** Returns whether @a check_menu_item  looks like a Gtk::RadioMenuItem
+   * @return Whether @a check_menu_item  looks like a Gtk::RadioMenuItem
+   * 
+   * Since: 2.4.
+   */
+  bool get_draw_as_radio() const;
+  
+  /** Triggered when the item changes state
+   * (Note : changing the item's state with set_active() will also trigger
+   * this signal)
+   */
+  
+
+  Glib::SignalProxy0< void > signal_toggled();
+
+
+  /** Whether the menu item is checked.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_active() ;
+
+/** Whether the menu item is checked.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_active() const;
+
+  /** Whether to display an inconsistent state.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_inconsistent() ;
+
+/** Whether to display an inconsistent state.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_inconsistent() const;
+
+  /** Whether the menu item looks like a radio menu item.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_draw_as_radio() ;
+
+/** Whether the menu item looks like a radio menu item.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_draw_as_radio() const;
+
+
+protected:
+  /** Triggered when the item is redrawn (e.g.after being toggled)
+   * Overload this signal if you want to implement your own check item
+   * look. Otherwise, you most likely don't care about it.
+   * The GdkRectangle specifies the area of the widget which will get
+   * redrawn.
+   */
+    virtual void draw_indicator_vfunc(GdkRectangle* area);
+
+
+};
+
+} /* namespace Gtk */
+
+
+namespace Glib
+{
+  /** @relates Gtk::CheckMenuItem
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gtk::CheckMenuItem* wrap(GtkCheckMenuItem* object, bool take_copy = false);
+}
+#endif /* _GTKMM_CHECKMENUITEM_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/clipboard.cc b/libs/gtkmm2/gtk/gtkmm/clipboard.cc
new file mode 100644
index 0000000000..e543bb8eee
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/clipboard.cc
@@ -0,0 +1,584 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/clipboard.h>
+#include <gtkmm/private/clipboard_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* 
+ *
+ * Copyright 2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/selectiondata_private.h>
+#include <glibmm/utility.h> //For ScopedPtr<>.
+#include <gtk/gtkclipboard.h>
+
+namespace
+{
+
+// SignalProxy_GetClear:
+// This Signal Proxy allows the C++ coder to specify a sigc::slot instead of a static function.
+class SignalProxy_GetClear
+{
+public:
+  SignalProxy_GetClear(const Gtk::Clipboard::SlotGet& slot_get,
+                       const Gtk::Clipboard::SlotClear& slot_clear);
+  ~SignalProxy_GetClear();
+
+  static void gtk_callback_get(GtkClipboard* clipboard, GtkSelectionData* selection_data,
+                               unsigned int info, void* data);
+  static void gtk_callback_clear(GtkClipboard* clipboard, void* data);
+
+protected:
+  Gtk::Clipboard::SlotGet   slot_get_;
+  Gtk::Clipboard::SlotClear slot_clear_;
+};
+
+SignalProxy_GetClear::SignalProxy_GetClear(const Gtk::Clipboard::SlotGet& slot_get,
+                                           const Gtk::Clipboard::SlotClear& slot_clear)
+:
+  slot_get_   (slot_get),
+  slot_clear_ (slot_clear)
+{}
+
+SignalProxy_GetClear::~SignalProxy_GetClear()
+{}
+
+void SignalProxy_GetClear::gtk_callback_get(GtkClipboard*, GtkSelectionData* selection_data,
+                                            unsigned int info, void* data)
+{
+  SignalProxy_GetClear *const self = static_cast<SignalProxy_GetClear*>(data);
+
+  try
+  {
+    Gtk::SelectionData_WithoutOwnership cppSelectionData(selection_data);
+    (self->slot_get_)(cppSelectionData, info);
+  }
+  catch(...)
+  {
+    Glib::exception_handlers_invoke();
+  }
+}
+
+void SignalProxy_GetClear::gtk_callback_clear(GtkClipboard*, void* data)
+{
+  SignalProxy_GetClear *const self = static_cast<SignalProxy_GetClear*>(data);
+
+  try
+  {
+    (self->slot_clear_)();
+  }
+  catch(...)
+  {
+    Glib::exception_handlers_invoke();
+  }
+
+  delete self; // After this callback has been called, none of the 2 callbacks will be called again.
+
+  //This might leak the last SignalProxy_GetClear(), but only the last one,
+  //because clear() is called when set() is called again.
+}
+
+
+// SignalProxy_Received:
+// This Signal Proxy allows the C++ coder to specify a sigc::slot instead of a static function.
+class SignalProxy_Received
+{
+public:
+  typedef Gtk::Clipboard::SlotReceived SlotType;
+
+  SignalProxy_Received(const SlotType& slot);
+  ~SignalProxy_Received();
+
+  static void gtk_callback(GtkClipboard* clipboard, GtkSelectionData* selection_data, gpointer data);
+
+protected:
+  SlotType slot_;
+};
+
+SignalProxy_Received::SignalProxy_Received(const SlotType& slot)
+:
+  slot_ (slot)
+{}
+
+SignalProxy_Received::~SignalProxy_Received()
+{}
+
+void SignalProxy_Received::gtk_callback(GtkClipboard*, GtkSelectionData* selection_data, void* data)
+{
+  SignalProxy_Received *const self = static_cast<SignalProxy_Received*>(data);
+
+  try
+  {
+    Gtk::SelectionData cppSelectionData(selection_data, true /*take_copy=true*/);
+    (self->slot_)(cppSelectionData);
+  }
+  catch(...)
+  {
+    Glib::exception_handlers_invoke();
+  }
+
+  delete self;
+}
+
+
+// SignalProxy_TargetsReceived:
+// This Signal Proxy allows the C++ coder to specify a sigc::slot instead of a static function.
+class SignalProxy_TargetsReceived
+{
+public:
+  typedef Gtk::Clipboard::SlotTargetsReceived SlotType;
+
+  SignalProxy_TargetsReceived(const SlotType& slot);
+  ~SignalProxy_TargetsReceived();
+
+  static void gtk_callback(GtkClipboard* clipboard, GdkAtom* atoms, gint n_atoms, gpointer data);
+
+protected:
+  SlotType slot_;
+};
+
+SignalProxy_TargetsReceived::SignalProxy_TargetsReceived(const SlotType& slot)
+:
+  slot_ (slot)
+{}
+
+SignalProxy_TargetsReceived::~SignalProxy_TargetsReceived()
+{}
+
+//This is not public API:
+typedef std::list<Glib::ustring> listStrings;
+static listStrings util_convert_atoms_to_strings(GdkAtom* targets, int n_targets)
+{
+  listStrings listTargets;
+
+  //Add the targets to the C++ container:
+  for(int i = 0; i < n_targets; i++)
+  {
+    //Convert the atom to a string:
+    Glib::ustring target = gdk_atom_name(targets[i]);
+    listTargets.push_back(target);
+  }
+
+  return listTargets;
+}
+
+void SignalProxy_TargetsReceived::gtk_callback(GtkClipboard*, GdkAtom* atoms, gint n_atoms, gpointer data)
+{
+  SignalProxy_TargetsReceived *const self = static_cast<SignalProxy_TargetsReceived*>(data);
+
+  try
+  {
+    listStrings listTargets = util_convert_atoms_to_strings(atoms, n_atoms);
+    (self->slot_)(listTargets);
+    //I guess that GTK+ does a g_free of the GdkAtoms* array itself, so we do not need to. murrayc.
+  }
+  catch(...)
+  {
+    Glib::exception_handlers_invoke();
+  }
+
+  delete self; // the callback is only used once
+}
+
+
+// SignalProxy_TextReceived:
+// This Signal Proxy allows the C++ coder to specify a sigc::slot instead of a static function.
+class SignalProxy_TextReceived
+{
+public:
+  typedef Gtk::Clipboard::SlotTextReceived SlotType;
+
+  SignalProxy_TextReceived(const SlotType& slot);
+  ~SignalProxy_TextReceived();
+
+  static void gtk_callback(GtkClipboard* clipboard, const char* text, void* data);
+
+protected:
+  SlotType slot_;
+};
+
+SignalProxy_TextReceived::SignalProxy_TextReceived(const SlotType& slot)
+:
+  slot_ (slot)
+{}
+
+SignalProxy_TextReceived::~SignalProxy_TextReceived()
+{}
+
+void SignalProxy_TextReceived::gtk_callback(GtkClipboard*, const char* text, void* data)
+{
+  SignalProxy_TextReceived *const self = static_cast<SignalProxy_TextReceived*>(data);
+
+  try
+  {
+    (self->slot_)((text) ? Glib::ustring(text) : Glib::ustring());
+  }
+  catch(...)
+  {
+    Glib::exception_handlers_invoke();
+  }
+
+  delete self; // the callback is only used once
+}
+
+
+// SignalProxy_ImageReceived:
+// This Signal Proxy allows the C++ coder to specify a sigc::slot instead of a static function.
+class SignalProxy_ImageReceived
+{
+public:
+  typedef Gtk::Clipboard::SlotImageReceived SlotType;
+
+  SignalProxy_ImageReceived(const SlotType& slot);
+  ~SignalProxy_ImageReceived();
+
+  static void gtk_callback(GtkClipboard* clipboard, GdkPixbuf* image, void* data);
+
+protected:
+  SlotType slot_;
+};
+
+SignalProxy_ImageReceived::SignalProxy_ImageReceived(const SlotType& slot)
+:
+  slot_ (slot)
+{}
+
+SignalProxy_ImageReceived::~SignalProxy_ImageReceived()
+{}
+
+void SignalProxy_ImageReceived::gtk_callback(GtkClipboard*, GdkPixbuf* image, void* data)
+{
+  SignalProxy_ImageReceived *const self = static_cast<SignalProxy_ImageReceived*>(data);
+
+  try
+  {
+    (self->slot_)(Glib::wrap(image, true /* take_ref */));
+  }
+  catch(...)
+  {
+    Glib::exception_handlers_invoke();
+  }
+
+  delete self; // the callback is only used once
+}
+
+} // anonymous namespace
+
+
+namespace Gtk
+{
+
+bool Clipboard::set(const ArrayHandle_TargetEntry& targets,
+                    const SlotGet& slot_get, const SlotClear& slot_clear)
+{
+  // Create a signal proxy. A pointer to this will be passed through the callback's data parameter.
+  SignalProxy_GetClear *const pSignalProxy = new SignalProxy_GetClear(slot_get, slot_clear);
+
+  return gtk_clipboard_set_with_data(
+      gobj(), targets.data(), targets.size(),
+      &SignalProxy_GetClear::gtk_callback_get,
+      &SignalProxy_GetClear::gtk_callback_clear,
+      pSignalProxy);
+}
+
+void Clipboard::set_text(const Glib::ustring& text)
+{
+  gtk_clipboard_set_text(gobj(), text.c_str(), text.bytes());
+}
+
+
+void Clipboard::request_contents(const Glib::ustring& target, const SlotReceived& slot)
+{
+  // Create a signal proxy. A pointer to this will be passed through the callback's data parameter.
+  SignalProxy_Received *const pSignalProxy = new SignalProxy_Received(slot);
+
+  gtk_clipboard_request_contents(gobj(), gdk_atom_intern(target.c_str(), FALSE),
+      &SignalProxy_Received::gtk_callback, pSignalProxy);
+}
+
+void Clipboard::request_text(const SlotTextReceived& slot)
+{
+  // Create a signal proxy. A pointer to this will be passed through the callback's data parameter.
+  SignalProxy_TextReceived *const pSignalProxy = new SignalProxy_TextReceived(slot);
+
+  gtk_clipboard_request_text(gobj(),
+      &SignalProxy_TextReceived::gtk_callback, pSignalProxy);
+}
+
+void Clipboard::request_image(const SlotImageReceived& slot)
+{
+  // Create a signal proxy. A pointer to this will be passed through the callback's data parameter.
+  SignalProxy_ImageReceived *const pSignalProxy = new SignalProxy_ImageReceived(slot);
+
+  gtk_clipboard_request_image(gobj(),
+      &SignalProxy_ImageReceived::gtk_callback, pSignalProxy);
+}
+
+void Clipboard::request_targets(const SlotTargetsReceived& slot)
+{
+  // Create a signal proxy. A pointer to this will be passed through the callback's data parameter.
+  SignalProxy_TargetsReceived *const pSignalProxy = new SignalProxy_TargetsReceived(slot);
+
+  gtk_clipboard_request_targets(gobj(), &SignalProxy_TargetsReceived::gtk_callback, pSignalProxy);
+}
+
+SelectionData Clipboard::wait_for_contents(const Glib::ustring& target) const
+{
+  //gtk_clipboard_wait_for_contents returns a newly-allocated GtkSelectionData, or NULL.
+  GtkSelectionData* cData = gtk_clipboard_wait_for_contents( const_cast<GtkClipboard*>(gobj()), gdk_atom_intern(target.c_str(), FALSE) );
+  return SelectionData(cData, false /* take_copy */);
+}
+
+Glib::StringArrayHandle Clipboard::wait_for_targets() const
+{
+  std::list<Glib::ustring> listTargets;
+
+  //Get a newly-allocated array of atoms:
+  GdkAtom* targets = 0;
+  gint n_targets = 0;
+  gboolean test = gtk_clipboard_wait_for_targets( const_cast<GtkClipboard*>(gobj()), &targets, &n_targets );
+  if(!test)
+    n_targets = 0; //otherwise it will be -1.
+
+  //Add the targets to the C++ container:
+  for(int i = 0; i < n_targets; i++)
+  {
+    //Convert the atom to a string:
+    gchar* const atom_name = gdk_atom_name(targets[i]);
+
+    Glib::ustring target;
+    if(atom_name)
+      target = Glib::ScopedPtr<char>(atom_name).get(); //This frees the gchar*.
+
+    listTargets.push_back(target);
+  }
+
+  return listTargets;
+}
+
+void Clipboard::set_can_store(const ArrayHandle_TargetEntry& targets)
+{
+  gtk_clipboard_set_can_store( gobj(), targets.data(), targets.size() );
+}
+
+void Clipboard::set_can_store()
+{
+  gtk_clipboard_set_can_store( gobj(), 0, 0 /* See C docs */ );
+}
+    
+} //namespace Gtk
+
+
+namespace
+{
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Glib::RefPtr<Gtk::Clipboard> wrap(GtkClipboard* object, bool take_copy)
+{
+  return Glib::RefPtr<Gtk::Clipboard>( dynamic_cast<Gtk::Clipboard*> (Glib::wrap_auto ((GObject*)(object), take_copy)) );
+  //We use dynamic_cast<> in case of multiple inheritance.
+}
+
+} /* namespace Glib */
+
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& Clipboard_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &Clipboard_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_clipboard_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void Clipboard_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+}
+
+
+Glib::ObjectBase* Clipboard_Class::wrap_new(GObject* object)
+{
+  return new Clipboard((GtkClipboard*)object);
+}
+
+
+/* The implementation: */
+
+GtkClipboard* Clipboard::gobj_copy()
+{
+  reference();
+  return gobj();
+}
+
+Clipboard::Clipboard(const Glib::ConstructParams& construct_params)
+:
+  Glib::Object(construct_params)
+{}
+
+Clipboard::Clipboard(GtkClipboard* castitem)
+:
+  Glib::Object((GObject*)(castitem))
+{}
+
+Clipboard::~Clipboard()
+{}
+
+
+Clipboard::CppClassType Clipboard::clipboard_class_; // initialize static member
+
+GType Clipboard::get_type()
+{
+  return clipboard_class_.init().get_type();
+}
+
+GType Clipboard::get_base_type()
+{
+  return gtk_clipboard_get_type();
+}
+
+
+Glib::RefPtr<Clipboard> Clipboard::get(GdkAtom selection)
+{
+
+  Glib::RefPtr<Clipboard> retvalue = Glib::wrap(gtk_clipboard_get(selection));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::RefPtr<Clipboard> Clipboard::get_for_display(const Glib::RefPtr<Gdk::Display>& display, GdkAtom selection)
+{
+
+  Glib::RefPtr<Clipboard> retvalue = Glib::wrap(gtk_clipboard_get_for_display(Glib::unwrap(display), selection));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::RefPtr<Gdk::Display> Clipboard::get_display()
+{
+
+  Glib::RefPtr<Gdk::Display> retvalue = Glib::wrap(gtk_clipboard_get_display(gobj()));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::RefPtr<const Gdk::Display> Clipboard::get_display() const
+{
+
+  Glib::RefPtr<const Gdk::Display> retvalue = Glib::wrap(gtk_clipboard_get_display(const_cast<GtkClipboard*>(gobj())));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::RefPtr<Glib::Object> Clipboard::get_owner()
+{
+
+  Glib::RefPtr<Glib::Object> retvalue = Glib::wrap(gtk_clipboard_get_owner(gobj()));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::RefPtr<const Glib::Object> Clipboard::get_owner() const
+{
+
+  Glib::RefPtr<const Glib::Object> retvalue = Glib::wrap(gtk_clipboard_get_owner(const_cast<GtkClipboard*>(gobj())));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+void Clipboard::clear()
+{
+  gtk_clipboard_clear(gobj());
+}
+
+void Clipboard::set_image(const Glib::RefPtr<Gdk::Pixbuf>& pixbuf)
+{
+  gtk_clipboard_set_image(gobj(), Glib::unwrap(pixbuf));
+}
+
+Glib::ustring Clipboard::wait_for_text() const
+{
+  return Glib::convert_return_gchar_ptr_to_ustring(gtk_clipboard_wait_for_text(const_cast<GtkClipboard*>(gobj())));
+}
+
+Glib::RefPtr<Gdk::Pixbuf> Clipboard::wait_for_image() const
+{
+  return Glib::wrap(gtk_clipboard_wait_for_image(const_cast<GtkClipboard*>(gobj())));
+}
+
+bool Clipboard::wait_is_text_available() const
+{
+  return gtk_clipboard_wait_is_text_available(const_cast<GtkClipboard*>(gobj()));
+}
+
+bool Clipboard::wait_is_image_available() const
+{
+  return gtk_clipboard_wait_is_image_available(const_cast<GtkClipboard*>(gobj()));
+}
+
+bool Clipboard::wait_is_target_available(const Glib::ustring& target)
+{
+  return gtk_clipboard_wait_is_target_available(gobj(), Gdk::AtomString::to_c_type(target));
+}
+
+void Clipboard::store()
+{
+  gtk_clipboard_store(gobj());
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/clipboard.h b/libs/gtkmm2/gtk/gtkmm/clipboard.h
new file mode 100644
index 0000000000..193eae10cc
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/clipboard.h
@@ -0,0 +1,489 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_CLIPBOARD_H
+#define _GTKMM_CLIPBOARD_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* clipboard.h
+ * 
+ * Copyright (C) 2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gdkmm/display.h> 
+#include <gdkmm/pixbuf.h>
+#include <gtkmm/targetentry.h>
+#include <gtkmm/selectiondata.h>
+#include <glibmm/object.h>
+#include <glibmm/containers.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkClipboard GtkClipboard;
+typedef struct _GtkClipboardClass GtkClipboardClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class Clipboard_Class; } // namespace Gtk
+namespace Gtk
+{
+
+/** The Clipboard object represents a clipboard of data shared between different processes or between 
+ * different widgets in the same process. Each clipboard is identified by a name encoded as a GdkAtom. *
+ * (Conversion to and from strings can be done with gdk_atom_intern() and gdk_atom_name().) The default 
+ * clipboard corresponds to the "CLIPBOARD" atom; another commonly used clipboard is the "PRIMARY" clipboard, 
+ * which, in X, traditionally contains the currently selected text.
+ *
+ * To support having a number of different formats on the clipboard at the same time, the clipboard mechanism 
+ * allows providing callbacks instead of the actual data. When you set the contents of the clipboard, you can 
+ * either supply the data directly (via functions like set_text()), or you can supply a callback 
+ * to be called at a later time when the data is needed (via set().) Providing a callback also avoids having to 
+ * make copies of the data when it is not needed.
+ *
+ * Requesting the data from the clipboard is essentially asynchronous. If the contents of the clipboard are 
+ * provided within the same process, then a direct function call will be made to retrieve the data, but if they 
+ * are provided by another process, then the data needs to be retrieved from the other process, which may take 
+ * some time. To avoid blocking the user interface, the call to request the selection, request_contents() takes 
+ * a callback that will be called when the contents are received (or when the request fails.) If you don't want 
+ * to deal with providing a separate callback, you can also use wait_for_contents(). This runs the 
+ * GLib main loop recursively waiting for the contents. This can simplify the code flow, but you still have to 
+ * be aware that other callbacks in your program can be called while this recursive mainloop is running.
+ *
+ * Along with the functions to get the clipboard contents as an arbitrary data chunk, there are also functions 
+ * to retrieve it as text, request_text() and wait_for_text(). These functions take 
+ * care of determining which formats are advertised by the clipboard provider, asking for the clipboard in the 
+ * best available format and converting the results into the UTF-8 encoding.
+ */
+
+class Clipboard : public Glib::Object
+{
+   
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+public:
+  typedef Clipboard CppObjectType;
+  typedef Clipboard_Class CppClassType;
+  typedef GtkClipboard BaseObjectType;
+  typedef GtkClipboardClass BaseClassType;
+
+private:  friend class Clipboard_Class;
+  static CppClassType clipboard_class_;
+
+private:
+  // noncopyable
+  Clipboard(const Clipboard&);
+  Clipboard& operator=(const Clipboard&);
+
+protected:
+  explicit Clipboard(const Glib::ConstructParams& construct_params);
+  explicit Clipboard(GtkClipboard* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+  virtual ~Clipboard();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GObject.
+  GtkClipboard*       gobj()       { return reinterpret_cast<GtkClipboard*>(gobject_); }
+
+  ///Provides access to the underlying C GObject.
+  const GtkClipboard* gobj() const { return reinterpret_cast<GtkClipboard*>(gobject_); }
+
+  ///Provides access to the underlying C instance. The caller is responsible for unrefing it. Use when directly setting fields in structs.
+  GtkClipboard* gobj_copy();
+
+private:
+
+public:
+
+  
+  /** Returns the clipboard object for the given selection.
+   * See gtk_clipboard_get_for_display() for complete details.
+   * @param selection A Gdk::Atom which identifies the clipboard
+   * to use.
+   * @return The appropriate clipboard object. If no
+   * clipboard already exists, a new one will
+   * be created. Once a clipboard object has
+   * been created, it is persistent and, since
+   * it is owned by GTK+, must not be freed or
+   * unrefd.
+   */
+  static Glib::RefPtr<Clipboard> get(GdkAtom selection = GDK_SELECTION_CLIPBOARD);
+  
+  /** Returns the clipboard object for the given selection.
+   * Cut/copy/paste menu items and keyboard shortcuts should use
+   * the default clipboard, returned by passing Gdk::SELECTION_CLIPBOARD for @a selection .
+   * (Gdk::NONE is supported as a synonym for GDK_SELECTION_CLIPBOARD
+   * for backwards compatibility reasons.)
+   * The currently-selected object or text should be provided on the clipboard
+   * identified by Gdk::SELECTION_PRIMARY. Cut/copy/paste menu items
+   * conceptually copy the contents of the Gdk::SELECTION_PRIMARY clipboard
+   * to the default clipboard, i.e. they copy the selection to what the
+   * user sees as the clipboard.
+   * 
+   * (Passing Gdk::NONE is the same as using <tt>gdk_atom_intern
+   * ("CLIPBOARD", <tt>false</tt>)</tt>. See 
+   * http://www.freedesktop.org/standards/clipboards-spec/clipboards.txt
+   * for a detailed discussion of the "CLIPBOARD" vs. "PRIMARY"
+   * selections under the X window system. On Win32 the
+   * Gdk::SELECTION_PRIMARY clipboard is essentially ignored.)
+   * 
+   * It's possible to have arbitrary named clipboards; if you do invent
+   * new clipboards, you should prefix the selection name with an
+   * underscore (because the ICCCM requires that nonstandard atoms are
+   * underscore-prefixed), and namespace it as well. For example,
+   * if your application called "Foo" has a special-purpose
+   * clipboard, you might call it "_FOO_SPECIAL_CLIPBOARD".
+   * @param display The display for which the clipboard is to be retrieved or created.
+   * @param selection A Gdk::Atom which identifies the clipboard
+   * to use.
+   * @return The appropriate clipboard object. If no
+   * clipboard already exists, a new one will
+   * be created. Once a clipboard object has
+   * been created, it is persistent and, since
+   * it is owned by GTK+, must not be freed or
+   * unrefd.
+   * 
+   * Since: 2.2.
+   */
+  static Glib::RefPtr<Clipboard> get_for_display(const Glib::RefPtr<Gdk::Display>& display, GdkAtom selection = GDK_SELECTION_CLIPBOARD);
+
+  
+  /** Gets the Gdk::Display associated with @a clipboard 
+   * @return The Gdk::Display associated with @a clipboard 
+   * 
+   * Since: 2.2.
+   */
+  Glib::RefPtr<Gdk::Display> get_display();
+  
+  /** Gets the Gdk::Display associated with @a clipboard 
+   * @return The Gdk::Display associated with @a clipboard 
+   * 
+   * Since: 2.2.
+   */
+  Glib::RefPtr<const Gdk::Display> get_display() const;
+
+  /// For instance: void on_get(Gtk::SelectionData& selection_data, guint info);
+  typedef sigc::slot<void, SelectionData&, guint> SlotGet;
+
+  /// For instance: void on_clear();
+  typedef sigc::slot<void> SlotClear;
+
+ /** Virtually sets the contents of the specified clipboard by providing
+  * a list of supported formats for the clipboard data and a function
+  * to call to get the actual data when it is requested.
+  *
+  * @param targets Information about the available forms for the clipboard data.
+  * @param slot_get method to call to get the actual clipboard data.
+  * @param slot_clear When the clipboard contents are set again, this method will
+  *              be called, and slot_get will not be subsequently called.
+  *
+  * @return true if setting the clipboard data succeeded. If setting
+  *               the clipboard data failed then the provided callback methods
+  *               will be ignored.
+  */
+  bool set(const ArrayHandle_TargetEntry& targets, const SlotGet& slot_get, const SlotClear& slot_clear);
+  
+  
+  /** If the clipboard contents callbacks were set with 
+   * gtk_clipboard_set_with_owner(), and the gtk_clipboard_set_with_data() or 
+   * gtk_clipboard_clear() has not subsequently called, returns the owner set 
+   * by gtk_clipboard_set_with_owner().
+   * @return The owner of the clipboard, if any; otherwise <tt>0</tt>.
+   */
+  Glib::RefPtr<Glib::Object> get_owner();
+  
+  /** If the clipboard contents callbacks were set with 
+   * gtk_clipboard_set_with_owner(), and the gtk_clipboard_set_with_data() or 
+   * gtk_clipboard_clear() has not subsequently called, returns the owner set 
+   * by gtk_clipboard_set_with_owner().
+   * @return The owner of the clipboard, if any; otherwise <tt>0</tt>.
+   */
+  Glib::RefPtr<const Glib::Object> get_owner() const;
+
+  /**
+   * Clears the contents of the clipboard. Generally this should only
+   * be called between the time you call set()
+   * and when the slot_clear you supplied is called. Otherwise, the
+   * clipboard may be owned by someone else.
+   */
+  
+  /** Clears the contents of the clipboard. Generally this should only
+   * be called between the time you call gtk_clipboard_set_with_owner()
+   * or gtk_clipboard_set_with_data(),
+   * and when the @a clear_func  you supplied is called. Otherwise, the
+   * clipboard may be owned by someone else.
+   */
+  void clear();
+
+  /**
+   * Sets the contents of the clipboard to the given UTF-8 string. GTK+ will
+   * make a copy of the text and take responsibility for responding
+   * for requests for the text, and for converting the text into
+   * the requested format.
+   *
+   * @param text  A UTF-8 string.
+   *
+   */
+  void set_text(const Glib::ustring& text);
+  
+  
+  /** Sets the contents of the clipboard to the given Gdk::Pixbuf. 
+   * GTK+ will take responsibility for responding for requests 
+   * for the image, and for converting the image into the 
+   * requested format.
+   * 
+   * Since: 2.6
+   * @param pixbuf A Gdk::Pixbuf.
+   */
+  void set_image(const Glib::RefPtr<Gdk::Pixbuf>& pixbuf);
+
+  /// For instance: void on_received(const SelectionData& selection_data);
+  typedef sigc::slot<void, const SelectionData&> SlotReceived;
+
+  /** Requests the contents of clipboard as the given target.
+   * When the results of the result are later received the supplied callback
+   * will be called.
+   *
+   * @param target The form into which the clipboard
+   *             owner should convert the selection.
+   * @param slot  A function to call when the results are received
+   *             (or the retrieval fails). If the retrieval fails
+   *             the length field of selection_data will be
+   *             negative.
+   **/
+  void request_contents(const Glib::ustring& target, const SlotReceived& slot);
+  
+  
+  /// For instance: void on_text_received(const Glib::ustring& text);
+  typedef sigc::slot<void, const Glib::ustring&> SlotTextReceived;
+
+  /** Requests the contents of the clipboard as text. When the text is
+   * later received, it will be converted to UTF-8 if necessary, and
+   * slot will be called.
+   *
+   * The text parameter to slot will contain the resulting text if
+   * the request succeeded, or will be empty if it failed. This could happen for
+   * various reasons, in particular if the clipboard was empty or if the
+   * contents of the clipboard could not be converted into text form.
+   *
+   * @param slot:  a function to call when the text is received,
+   *             or the retrieval fails. (It will always be called
+   *             one way or the other.)
+   */
+  void request_text(const SlotTextReceived& slot);
+  
+  
+  /// For instance: void on_image_received(const Glib::RefPtr<Gdk::Pixbuf>& text);
+  typedef sigc::slot<void, const Glib::RefPtr<Gdk::Pixbuf>&> SlotImageReceived;
+  
+  /** Requests the contents of the clipboard as image. When the image is
+   * later received, it will be converted to a Gdk::Pixbuf. 
+   * This function waits for
+   * the data to be received using the main loop, so events,
+   * timeouts, etc, may be dispatched during the wait.
+   *
+   * The pixbuf parameter to slot will contain the resulting pixbuf if
+   * the request succeeded, or will be empty if it failed. This could happen for
+   * various reasons, in particular if the clipboard was empty or if the
+   * contents of the clipboard could not be converted into image form.
+   *
+   * @param slot:  a function to call when the text is received,
+   *             or the retrieval fails. (It will always be called
+   *             one way or the other.)
+   */
+  void request_image(const SlotImageReceived& slot);
+  
+
+  /// For instance: void on_targetsreceived(const Glib::StringArrayHandle& targets);
+  typedef sigc::slot<void, const Glib::StringArrayHandle&> SlotTargetsReceived;
+
+  /** Requests the contents of the clipboard as list of supported targets.
+   * When the list is later received, callback will be called.
+   *
+   * The targets parameter to slot will contain the resulting targets if
+   * the request succeeded.
+   *
+   * @param slot a function to call when the targets are received,
+   *             or the retrieval fails. (It will always be called
+   *             one way or the other.) Remember that Glib::StringArrayHandle
+   *             is an intermediate type, so you should convert it to a
+   *             standard C++ container.
+   *
+   * Since: 2.4
+   */
+  void request_targets(const SlotTargetsReceived& slot);
+  
+               
+  /**
+   * Requests the contents of the clipboard using the given target.
+   * This function waits for the data to be received using the main
+   * loop, so events, timeouts, etc, may be dispatched during the wait.
+   *
+   * @param target The form into which the clipboard owner should convert the selection.
+   *
+   * @return A SelectionData object, which will be invalid if retrieving the given target failed. 
+   */
+  SelectionData wait_for_contents(const Glib::ustring& target) const;
+  
+
+  /** Requests the contents of the clipboard as text and converts
+   * the result to UTF-8 if necessary. This function waits for
+   * the data to be received using the main loop, so events,
+   * timeouts, etc, may be dispatched during the wait.
+   * @return A UTF-8 string, which is empty if retrieving
+   * the selection data failed. (This could happen
+   * for various reasons, in particular if the
+   * clipboard was empty or if the contents of the
+   * clipboard could not be converted into text form.).
+   */
+  Glib::ustring wait_for_text() const;
+  
+  //Maybe the result should be const, but constness is not so clear-cut here. murrayc
+  
+  /** Requests the contents of the clipboard as image and converts
+   * the result to a Gdk::Pixbuf. This function waits for
+   * the data to be received using the main loop, so events,
+   * timeouts, etc, may be dispatched during the wait.
+   * @return A newly-allocated Gdk::Pixbuf object which must
+   * be disposed with Glib::object_unref(), or <tt>0</tt> if 
+   * retrieving the selection data failed. (This 
+   * could happen for various reasons, in particular 
+   * if the clipboard was empty or if the contents of 
+   * the clipboard could not be converted into an image.)
+   * 
+   * Since: 2.6.
+   */
+  Glib::RefPtr<Gdk::Pixbuf> wait_for_image() const;
+  
+  
+  /** Test to see if there is text available to be pasted
+   * This is done by requesting the TARGETS atom and checking
+   * if it contains any of the supported text targets. This function 
+   * waits for the data to be received using the main loop, so events, 
+   * timeouts, etc, may be dispatched during the wait.
+   * 
+   * This function is a little faster than calling
+   * gtk_clipboard_wait_for_text() since it doesn't need to retrieve
+   * the actual text.
+   * @return <tt>true</tt> is there is text available, <tt>false</tt> otherwise.
+   */
+  bool wait_is_text_available() const;
+  
+  /** Test to see if there is an image available to be pasted
+   * This is done by requesting the TARGETS atom and checking
+   * if it contains any of the supported image targets. This function 
+   * waits for the data to be received using the main loop, so events, 
+   * timeouts, etc, may be dispatched during the wait.
+   * 
+   * This function is a little faster than calling
+   * gtk_clipboard_wait_for_image() since it doesn't need to retrieve
+   * the actual image data.
+   * @return <tt>true</tt> is there is an image available, <tt>false</tt> otherwise.
+   * 
+   * Since: 2.6.
+   */
+  bool wait_is_image_available() const;  
+  
+  /** Checks if a clipboard supports pasting data of a given type. This
+   * function can be used to determine if a "Paste" menu item should be
+   * insensitive or not.
+   * 
+   * If you want to see if there's text available on the clipboard, use
+   * gtk_clipboard_wait_is_text_available() instead.
+   * @param target A Gdk::Atom indicating which target to look for.
+   * @return <tt>true</tt> if the target is available, <tt>false</tt> otherwise.
+   * 
+   * Since: 2.6.
+   */
+  bool wait_is_target_available(const Glib::ustring& target);
+
+  /** Returns a list of targets that are present on the clipboard.
+   * This function waits for the data to be received using the main
+   * loop, so events, timeouts, etc, may be dispatched during the wait.
+   *
+   * @result targets: The targets.
+   *
+   * Since: 2.4
+   */
+  Glib::StringArrayHandle wait_for_targets() const;
+  
+
+  /** Hints that the clipboard data should be stored somewhere when the application exits or when store() 
+   * is called.
+   * 
+   * This value is reset when the clipboard owner changes. Where the clipboard data is stored is platform 
+   * dependent, see Gdk::Display::store_clipboard() for more information.
+   *
+   * @param targets Array containing information about which forms should be stored.
+   */
+  void set_can_store(const ArrayHandle_TargetEntry& targets);
+  
+  /** Hints that all forms of clipboard data should be stored somewhere when the application exits or when store() 
+   * is called.
+   * 
+   * This value is reset when the clipboard owner changes. Where the clipboard data is stored is platform 
+   * dependent, see Gdk::Display::store_clipboard() for more information.
+   */
+  void set_can_store();
+  
+
+  /** Stores the current clipboard data somewhere so that it will stay
+   * around after the application has quit.
+   * 
+   * Since: 2.6
+   */
+  void store();
+           
+
+public:
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+};
+
+} /* namespace Gtk */
+
+
+namespace Glib
+{
+  /** @relates Gtk::Clipboard
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Glib::RefPtr<Gtk::Clipboard> wrap(GtkClipboard* object, bool take_copy = false);
+}
+
+
+#endif /* _GTKMM_CLIPBOARD_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/colorbutton.cc b/libs/gtkmm2/gtk/gtkmm/colorbutton.cc
new file mode 100644
index 0000000000..15b2f5ddd1
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/colorbutton.cc
@@ -0,0 +1,287 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/colorbutton.h>
+#include <gtkmm/private/colorbutton_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/*
+ *
+ * Copyright 2003 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtk/gtkcolorbutton.h>
+#include <gdkmm/color.h>
+
+namespace Gtk
+{
+
+Gdk::Color ColorButton::get_color() const
+{
+  Gdk::Color color;
+  gtk_color_button_get_color(const_cast<GtkColorButton*>(gobj()), color.gobj());
+  return color;
+}
+
+  
+} // namespace Gtk
+
+
+namespace
+{
+
+const Glib::SignalProxyInfo ColorButton_signal_color_set_info =
+{
+  "color-set",
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
+};
+
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Gtk::ColorButton* wrap(GtkColorButton* object, bool take_copy)
+{
+  return dynamic_cast<Gtk::ColorButton *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& ColorButton_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &ColorButton_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_color_button_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void ColorButton_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+  klass->color_set = &color_set_callback;
+}
+
+
+void ColorButton_Class::color_set_callback(GtkColorButton* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_color_set();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->color_set)
+      (*base->color_set)(self);
+  }
+}
+
+
+Glib::ObjectBase* ColorButton_Class::wrap_new(GObject* o)
+{
+  return manage(new ColorButton((GtkColorButton*)(o)));
+
+}
+
+
+/* The implementation: */
+
+ColorButton::ColorButton(const Glib::ConstructParams& construct_params)
+:
+  Gtk::Button(construct_params)
+{
+  }
+
+ColorButton::ColorButton(GtkColorButton* castitem)
+:
+  Gtk::Button((GtkButton*)(castitem))
+{
+  }
+
+ColorButton::~ColorButton()
+{
+  destroy_();
+}
+
+ColorButton::CppClassType ColorButton::colorbutton_class_; // initialize static member
+
+GType ColorButton::get_type()
+{
+  return colorbutton_class_.init().get_type();
+}
+
+GType ColorButton::get_base_type()
+{
+  return gtk_color_button_get_type();
+}
+
+
+ColorButton::ColorButton()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Button(Glib::ConstructParams(colorbutton_class_.init()))
+{
+  }
+
+ColorButton::ColorButton(const Gdk::Color& color)
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Button(Glib::ConstructParams(colorbutton_class_.init(), "color", (color).gobj(), (char*) 0))
+{
+  }
+
+void ColorButton::set_color(const Gdk::Color& color)
+{
+  gtk_color_button_set_color(gobj(), (color).gobj());
+}
+
+void ColorButton::set_alpha(guint16 alpha)
+{
+  gtk_color_button_set_alpha(gobj(), alpha);
+}
+
+guint16 ColorButton::get_alpha() const
+{
+  return gtk_color_button_get_alpha(const_cast<GtkColorButton*>(gobj()));
+}
+
+void ColorButton::set_use_alpha(bool use_alpha)
+{
+  gtk_color_button_set_use_alpha(gobj(), static_cast<int>(use_alpha));
+}
+
+bool ColorButton::get_use_alpha() const
+{
+  return gtk_color_button_get_use_alpha(const_cast<GtkColorButton*>(gobj()));
+}
+
+void ColorButton::set_title(const Glib::ustring& title)
+{
+  gtk_color_button_set_title(gobj(), title.c_str());
+}
+
+Glib::ustring ColorButton::get_title() const
+{
+  return Glib::convert_const_gchar_ptr_to_ustring(gtk_color_button_get_title(const_cast<GtkColorButton*>(gobj())));
+}
+
+
+Glib::SignalProxy0< void > ColorButton::signal_color_set()
+{
+  return Glib::SignalProxy0< void >(this, &ColorButton_signal_color_set_info);
+}
+
+
+Glib::PropertyProxy<bool> ColorButton::property_use_alpha() 
+{
+  return Glib::PropertyProxy<bool>(this, "use-alpha");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> ColorButton::property_use_alpha() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "use-alpha");
+}
+
+Glib::PropertyProxy<Glib::ustring> ColorButton::property_title() 
+{
+  return Glib::PropertyProxy<Glib::ustring>(this, "title");
+}
+
+Glib::PropertyProxy_ReadOnly<Glib::ustring> ColorButton::property_title() const
+{
+  return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "title");
+}
+
+Glib::PropertyProxy<Gdk::Color> ColorButton::property_color() 
+{
+  return Glib::PropertyProxy<Gdk::Color>(this, "color");
+}
+
+Glib::PropertyProxy_ReadOnly<Gdk::Color> ColorButton::property_color() const
+{
+  return Glib::PropertyProxy_ReadOnly<Gdk::Color>(this, "color");
+}
+
+Glib::PropertyProxy<guint16> ColorButton::property_alpha() 
+{
+  return Glib::PropertyProxy<guint16>(this, "alpha");
+}
+
+Glib::PropertyProxy_ReadOnly<guint16> ColorButton::property_alpha() const
+{
+  return Glib::PropertyProxy_ReadOnly<guint16>(this, "alpha");
+}
+
+
+void Gtk::ColorButton::on_color_set()
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->color_set)
+    (*base->color_set)(gobj());
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/colorbutton.h b/libs/gtkmm2/gtk/gtkmm/colorbutton.h
new file mode 100644
index 0000000000..aea0bc1d16
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/colorbutton.h
@@ -0,0 +1,277 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_COLORBUTTON_H
+#define _GTKMM_COLORBUTTON_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* colorbutton.h
+ *
+ * Copyright (C) 2003 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/button.h>
+#include <gdkmm/color.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkColorButton GtkColorButton;
+typedef struct _GtkColorButtonClass GtkColorButtonClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class ColorButton_Class; } // namespace Gtk
+namespace Gtk
+{
+
+/** A button to launch a color selection dialog.
+ *
+ * The GtkColorButton is a button which displays the currently selected color an allows to
+ * open a color selection dialog to change the color. It is suitable widget for selecting a
+ * color in a preference dialog.
+ *
+ * @ingroup Widgets
+ */
+
+class ColorButton : public Button
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef ColorButton CppObjectType;
+  typedef ColorButton_Class CppClassType;
+  typedef GtkColorButton BaseObjectType;
+  typedef GtkColorButtonClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~ColorButton();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class ColorButton_Class;
+  static CppClassType colorbutton_class_;
+
+  // noncopyable
+  ColorButton(const ColorButton&);
+  ColorButton& operator=(const ColorButton&);
+
+protected:
+  explicit ColorButton(const Glib::ConstructParams& construct_params);
+  explicit ColorButton(GtkColorButton* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GtkColorButton*       gobj()       { return reinterpret_cast<GtkColorButton*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GtkColorButton* gobj() const { return reinterpret_cast<GtkColorButton*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+  virtual void on_color_set();
+
+
+private:
+
+public:
+
+  /** Creates a new color button.
+   * 
+   * This creates a widget in the form of a small button containing a swatch representing
+   * the current selected color. When the button is clicked, a color-selection dialog will
+   * open, allowing the user to select a color. The swatch will be updated to reflect the
+   * new color when the user finishes.
+   *
+   * Since: 2.4
+   */
+  ColorButton();
+  
+  
+  /** Creates a new color button with a predefined color.
+   * 
+   * Same as Gtk::ColorButton::ColorButton(). Additionally takes a Gdk::Color and
+   * initializes the button with this color. Equivalent to calling set_color(@a color)
+   * after the default constructor.
+   *
+   * @param color A Gdk::Color to set the current color with.
+   *
+   * Since: 2.4
+   */
+  explicit ColorButton(const Gdk::Color& color);
+
+  
+  /** Sets the current color to be @a color .
+   * 
+   * Since: 2.4
+   * @param color A Gdk::Color to set the current color with.
+   */
+  void set_color(const Gdk::Color& color);
+  
+  /** Sets the current opacity to be @a alpha . 
+   * 
+   * Since: 2.4
+   * @param alpha An integer between 0 and 65535.
+   */
+  void set_alpha(guint16 alpha);
+  
+  /** Returns a copy of the the current color.
+   * 
+   * Changes to the return value will have no effect on the Gtk::ColorButton.
+   *
+   * @return A Gdk::Color representing the current internal color of the Gtk::ColorButton.
+   *
+   * Since: 2.4
+   */
+  Gdk::Color get_color() const;
+  
+  
+  /** Returns the current alpha value.
+   * @return An integer between 0 and 65535.
+   * 
+   * Since: 2.4.
+   */
+  guint16 get_alpha() const;
+  
+  /** Sets whether or not the color button should use the alpha channel.
+   * 
+   * Since: 2.4
+   * @param use_alpha <tt>true</tt> if color button should use alpha channel, <tt>false</tt> if not.
+   */
+  void set_use_alpha(bool use_alpha = true);
+  
+  /** Does the color selection dialog use the alpha channel?
+   * @return <tt>true</tt> if the color sample uses alpha channel, <tt>false</tt> if not.
+   * 
+   * Since: 2.4.
+   */
+  bool get_use_alpha() const;
+  
+  /** Sets the title for the color selection dialog.
+   * 
+   * Since: 2.4
+   * @param title String containing new window title.
+   */
+  void set_title(const Glib::ustring& title);
+  
+  /** Gets the title of the color selection dialog.
+   * @return An internal string, do not free the return value
+   * 
+   * Since: 2.4.
+   */
+  Glib::ustring get_title() const;
+
+  /** Whether or not to give the color an alpha value.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_use_alpha() ;
+
+/** Whether or not to give the color an alpha value.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_use_alpha() const;
+
+  /** The title of the color selection dialog.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Glib::ustring> property_title() ;
+
+/** The title of the color selection dialog.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Glib::ustring> property_title() const;
+
+  /** The selected color.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Gdk::Color> property_color() ;
+
+/** The selected color.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Gdk::Color> property_color() const;
+
+  /** The selected opacity value (0 fully transparent, 65535 fully opaque).
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<guint16> property_alpha() ;
+
+/** The selected opacity value (0 fully transparent, 65535 fully opaque).
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<guint16> property_alpha() const;
+
+
+  Glib::SignalProxy0< void > signal_color_set();
+                    
+
+};
+
+
+} // namespace Gtk
+
+
+namespace Glib
+{
+  /** @relates Gtk::ColorButton
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gtk::ColorButton* wrap(GtkColorButton* object, bool take_copy = false);
+}
+#endif /* _GTKMM_COLORBUTTON_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/colorselection.cc b/libs/gtkmm2/gtk/gtkmm/colorselection.cc
new file mode 100644
index 0000000000..54525905bf
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/colorselection.cc
@@ -0,0 +1,538 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/colorselection.h>
+#include <gtkmm/private/colorselection_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtk/gtkcolorsel.h>
+#include <gtk/gtkcolorseldialog.h>
+
+
+namespace
+{
+
+Gtk::ColorSelection::SlotChangePaletteHook* global_change_palette_hook = 0;
+
+void global_change_palette_hook_callback(GdkScreen* screen, const GdkColor* colors, int n_colors)
+{
+  g_return_if_fail(global_change_palette_hook != 0);
+
+  try
+  {
+    (*global_change_palette_hook)(
+        Glib::wrap(screen, true),
+        Gdk::ArrayHandle_Color(colors, n_colors, Glib::OWNERSHIP_NONE));
+  }
+  catch(...)
+  {
+    Glib::exception_handlers_invoke();
+  }
+}
+
+void old_change_palette_hook_callback(const Glib::RefPtr<Gdk::Screen>& screen,
+                                      const Gdk::ArrayHandle_Color&    colors,
+                                      GtkColorSelectionChangePaletteWithScreenFunc func)
+{
+  g_return_if_fail(func != 0);
+
+  (*func)(Glib::unwrap(screen), colors.data(), colors.size());
+}
+
+} // anonymous namespace
+
+
+namespace Gtk
+{
+
+Gdk::Color ColorSelection::get_current_color() const
+{
+  Gdk::Color color; //GdkColor Just a simple struct.
+  gtk_color_selection_get_current_color(const_cast<GtkColorSelection*>(gobj()), color.gobj());
+  return color;
+}
+
+Gdk::Color ColorSelection::get_previous_color() const
+{
+  Gdk::Color color; //GdkColor Just a simple struct.
+  gtk_color_selection_get_previous_color(const_cast<GtkColorSelection*>(gobj()), color.gobj());
+  return color;
+}
+
+// static
+Gdk::ArrayHandle_Color ColorSelection::palette_from_string(const Glib::ustring& str)
+{
+  GdkColor* colors = 0;
+  int     n_colors = 0;
+
+  gtk_color_selection_palette_from_string(str.c_str(), &colors, &n_colors);
+
+  return Gdk::ArrayHandle_Color(colors, n_colors, Glib::OWNERSHIP_SHALLOW);
+}
+
+// static
+Glib::ustring ColorSelection::palette_to_string(const Gdk::ArrayHandle_Color& colors)
+{
+  if(char *const str = gtk_color_selection_palette_to_string(colors.data(), colors.size()))
+    return Glib::ustring(Glib::ScopedPtr<char>(str).get());
+  else
+    return Glib::ustring();
+}
+
+// static
+ColorSelection::SlotChangePaletteHook
+ColorSelection::set_change_palette_hook(const ColorSelection::SlotChangePaletteHook& slot)
+{
+  GtkColorSelectionChangePaletteWithScreenFunc new_func = 0;
+  SlotChangePaletteHook* new_slot = 0;
+  SlotChangePaletteHook  old_slot;
+
+  if(slot)
+  {
+    new_func = &global_change_palette_hook_callback;
+    new_slot = new SlotChangePaletteHook(slot);
+  }
+
+  const GtkColorSelectionChangePaletteWithScreenFunc old_func =
+      gtk_color_selection_set_change_palette_with_screen_hook(new_func);
+
+  if(old_func)
+  {
+    try
+    {
+      if(old_func != &global_change_palette_hook_callback)
+        old_slot = sigc::bind<-1>(sigc::ptr_fun(&old_change_palette_hook_callback), old_func);
+      else if(global_change_palette_hook)
+        old_slot = *global_change_palette_hook;
+    }
+    catch(...)
+    {
+      gtk_color_selection_set_change_palette_with_screen_hook(old_func);
+      delete new_slot;
+      throw;
+    }
+  }
+
+  delete global_change_palette_hook;
+  global_change_palette_hook = new_slot;
+
+  return old_slot;
+}
+
+} // namespace Gtk
+
+
+namespace
+{
+
+const Glib::SignalProxyInfo ColorSelection_signal_color_changed_info =
+{
+  "color_changed",
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
+};
+
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Gtk::ColorSelection* wrap(GtkColorSelection* object, bool take_copy)
+{
+  return dynamic_cast<Gtk::ColorSelection *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& ColorSelection_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &ColorSelection_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_color_selection_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void ColorSelection_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+  klass->color_changed = &color_changed_callback;
+}
+
+
+void ColorSelection_Class::color_changed_callback(GtkColorSelection* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_color_changed();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->color_changed)
+      (*base->color_changed)(self);
+  }
+}
+
+
+Glib::ObjectBase* ColorSelection_Class::wrap_new(GObject* o)
+{
+  return manage(new ColorSelection((GtkColorSelection*)(o)));
+
+}
+
+
+/* The implementation: */
+
+ColorSelection::ColorSelection(const Glib::ConstructParams& construct_params)
+:
+  Gtk::VBox(construct_params)
+{
+  }
+
+ColorSelection::ColorSelection(GtkColorSelection* castitem)
+:
+  Gtk::VBox((GtkVBox*)(castitem))
+{
+  }
+
+ColorSelection::~ColorSelection()
+{
+  destroy_();
+}
+
+ColorSelection::CppClassType ColorSelection::colorselection_class_; // initialize static member
+
+GType ColorSelection::get_type()
+{
+  return colorselection_class_.init().get_type();
+}
+
+GType ColorSelection::get_base_type()
+{
+  return gtk_color_selection_get_type();
+}
+
+
+ColorSelection::ColorSelection()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::VBox(Glib::ConstructParams(colorselection_class_.init()))
+{
+  }
+
+bool ColorSelection::get_has_opacity_control() const
+{
+  return gtk_color_selection_get_has_opacity_control(const_cast<GtkColorSelection*>(gobj()));
+}
+
+void ColorSelection::set_has_opacity_control(bool has_opacity)
+{
+  gtk_color_selection_set_has_opacity_control(gobj(), static_cast<int>(has_opacity));
+}
+
+bool ColorSelection::get_has_palette() const
+{
+  return gtk_color_selection_get_has_palette(const_cast<GtkColorSelection*>(gobj()));
+}
+
+void ColorSelection::set_has_palette(bool has_palette)
+{
+  gtk_color_selection_set_has_palette(gobj(), static_cast<int>(has_palette));
+}
+
+void ColorSelection::set_current_color(const Gdk::Color& color)
+{
+  gtk_color_selection_set_current_color(gobj(), (color).gobj());
+}
+
+void ColorSelection::set_current_alpha(guint16 alpha)
+{
+  gtk_color_selection_set_current_alpha(gobj(), alpha);
+}
+
+guint16 ColorSelection::get_current_alpha() const
+{
+  return gtk_color_selection_get_current_alpha(const_cast<GtkColorSelection*>(gobj()));
+}
+
+void ColorSelection::set_previous_color(const Gdk::Color& color)
+{
+  gtk_color_selection_set_previous_color(gobj(), (color).gobj());
+}
+
+void ColorSelection::set_previous_alpha(guint16 alpha)
+{
+  gtk_color_selection_set_previous_alpha(gobj(), alpha);
+}
+
+guint16 ColorSelection::get_previous_alpha() const
+{
+  return gtk_color_selection_get_previous_alpha(const_cast<GtkColorSelection*>(gobj()));
+}
+
+bool ColorSelection::is_adjusting() const
+{
+  return gtk_color_selection_is_adjusting(const_cast<GtkColorSelection*>(gobj()));
+}
+
+
+Glib::SignalProxy0< void > ColorSelection::signal_color_changed()
+{
+  return Glib::SignalProxy0< void >(this, &ColorSelection_signal_color_changed_info);
+}
+
+
+Glib::PropertyProxy<bool> ColorSelection::property_has_palette() 
+{
+  return Glib::PropertyProxy<bool>(this, "has-palette");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> ColorSelection::property_has_palette() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "has-palette");
+}
+
+Glib::PropertyProxy<bool> ColorSelection::property_has_opacity_control() 
+{
+  return Glib::PropertyProxy<bool>(this, "has-opacity-control");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> ColorSelection::property_has_opacity_control() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "has-opacity-control");
+}
+
+Glib::PropertyProxy<Gdk::Color> ColorSelection::property_current_color() 
+{
+  return Glib::PropertyProxy<Gdk::Color>(this, "current-color");
+}
+
+Glib::PropertyProxy_ReadOnly<Gdk::Color> ColorSelection::property_current_color() const
+{
+  return Glib::PropertyProxy_ReadOnly<Gdk::Color>(this, "current-color");
+}
+
+Glib::PropertyProxy<guint> ColorSelection::property_current_alpha() 
+{
+  return Glib::PropertyProxy<guint>(this, "current-alpha");
+}
+
+Glib::PropertyProxy_ReadOnly<guint> ColorSelection::property_current_alpha() const
+{
+  return Glib::PropertyProxy_ReadOnly<guint>(this, "current-alpha");
+}
+
+
+void Gtk::ColorSelection::on_color_changed()
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->color_changed)
+    (*base->color_changed)(gobj());
+}
+
+
+} // namespace Gtk
+
+
+namespace Glib
+{
+
+Gtk::ColorSelectionDialog* wrap(GtkColorSelectionDialog* object, bool take_copy)
+{
+  return dynamic_cast<Gtk::ColorSelectionDialog *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& ColorSelectionDialog_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &ColorSelectionDialog_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_color_selection_dialog_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void ColorSelectionDialog_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+}
+
+
+Glib::ObjectBase* ColorSelectionDialog_Class::wrap_new(GObject* o)
+{
+  return new ColorSelectionDialog((GtkColorSelectionDialog*)(o)); //top-level windows can not be manage()ed.
+
+}
+
+
+/* The implementation: */
+
+ColorSelectionDialog::ColorSelectionDialog(const Glib::ConstructParams& construct_params)
+:
+  Gtk::Dialog(construct_params)
+{
+  }
+
+ColorSelectionDialog::ColorSelectionDialog(GtkColorSelectionDialog* castitem)
+:
+  Gtk::Dialog((GtkDialog*)(castitem))
+{
+  }
+
+ColorSelectionDialog::~ColorSelectionDialog()
+{
+  destroy_();
+}
+
+ColorSelectionDialog::CppClassType ColorSelectionDialog::colorselectiondialog_class_; // initialize static member
+
+GType ColorSelectionDialog::get_type()
+{
+  return colorselectiondialog_class_.init().get_type();
+}
+
+GType ColorSelectionDialog::get_base_type()
+{
+  return gtk_color_selection_dialog_get_type();
+}
+
+ColorSelectionDialog::ColorSelectionDialog()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Dialog(Glib::ConstructParams(colorselectiondialog_class_.init()))
+{
+  }
+
+ColorSelectionDialog::ColorSelectionDialog(const Glib::ustring& title)
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Dialog(Glib::ConstructParams(colorselectiondialog_class_.init(), "title", title.c_str(), (char*) 0))
+{
+  }
+
+ColorSelection* ColorSelectionDialog::get_colorsel()
+{
+  return Glib::wrap((GtkColorSelection*)(gobj()->colorsel));
+}
+
+const ColorSelection* ColorSelectionDialog::get_colorsel() const
+{
+  return Glib::wrap((GtkColorSelection*)(gobj()->colorsel));
+}
+
+Button* ColorSelectionDialog::get_ok_button()
+{
+  return Glib::wrap((GtkButton*)(gobj()->ok_button));
+}
+
+const Button* ColorSelectionDialog::get_ok_button() const
+{
+  return Glib::wrap((GtkButton*)(gobj()->ok_button));
+}
+
+Button* ColorSelectionDialog::get_cancel_button()
+{
+  return Glib::wrap((GtkButton*)(gobj()->cancel_button));
+}
+
+const Button* ColorSelectionDialog::get_cancel_button() const
+{
+  return Glib::wrap((GtkButton*)(gobj()->cancel_button));
+}
+
+Button* ColorSelectionDialog::get_help_button()
+{
+  return Glib::wrap((GtkButton*)(gobj()->help_button));
+}
+
+const Button* ColorSelectionDialog::get_help_button() const
+{
+  return Glib::wrap((GtkButton*)(gobj()->help_button));
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/colorselection.h b/libs/gtkmm2/gtk/gtkmm/colorselection.h
new file mode 100644
index 0000000000..0d77feb43e
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/colorselection.h
@@ -0,0 +1,362 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_COLORSELECTION_H
+#define _GTKMM_COLORSELECTION_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* Copyright (C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+
+#include <gtkmm/box.h>
+#include <gtkmm/dialog.h>
+#include <gtkmm/button.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkColorSelection GtkColorSelection;
+typedef struct _GtkColorSelectionClass GtkColorSelectionClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class ColorSelection_Class; } // namespace Gtk
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkColorSelectionDialog GtkColorSelectionDialog;
+typedef struct _GtkColorSelectionDialogClass GtkColorSelectionDialogClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class ColorSelectionDialog_Class; } // namespace Gtk
+namespace Gtk
+{
+
+/** A widget used to select a color.
+ *
+ * This widget is used to select a color. It
+ * consists of a color wheel and number of sliders and entry boxes for color
+ * parameters such as hue, saturation, value, red, green, blue, and opacity.
+ *
+ * It is found on the standard color selection dialog box
+ * Gtk::ColorSelectionDialog. 
+ *
+ * @ingroup Widgets
+ */
+
+class ColorSelection : public VBox
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef ColorSelection CppObjectType;
+  typedef ColorSelection_Class CppClassType;
+  typedef GtkColorSelection BaseObjectType;
+  typedef GtkColorSelectionClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~ColorSelection();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class ColorSelection_Class;
+  static CppClassType colorselection_class_;
+
+  // noncopyable
+  ColorSelection(const ColorSelection&);
+  ColorSelection& operator=(const ColorSelection&);
+
+protected:
+  explicit ColorSelection(const Glib::ConstructParams& construct_params);
+  explicit ColorSelection(GtkColorSelection* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GtkColorSelection*       gobj()       { return reinterpret_cast<GtkColorSelection*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GtkColorSelection* gobj() const { return reinterpret_cast<GtkColorSelection*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+  virtual void on_color_changed();
+
+
+private:
+
+  
+public:
+  ColorSelection();
+
+  
+  /** Determines whether the colorsel has an opacity control.
+   * @return <tt>true</tt> if the @a colorsel  has an opacity control.  <tt>false</tt> if it does't.
+   */
+  bool get_has_opacity_control() const;
+  
+  /** Sets the @a colorsel  to use or not use opacity.
+   * @param has_opacity <tt>true</tt> if @a colorsel  can set the opacity, <tt>false</tt> otherwise.
+   */
+  void set_has_opacity_control(bool has_opacity = true);
+  
+  /** Determines whether the color selector has a color palette.
+   * @return <tt>true</tt> if the selector has a palette.  <tt>false</tt> if it hasn't.
+   */
+  bool get_has_palette() const;
+  
+  /** Shows and hides the palette based upon the value of @a has_palette .
+   * @param has_palette <tt>true</tt> if palette is to be visible, <tt>false</tt> otherwise.
+   */
+  void set_has_palette(bool has_palette = true);
+  
+  /** Sets the current color to be @a color .  The first time this is called, it will
+   * also set the original color to be @a color  too.
+   * @param color A Gdk::Color to set the current color with.
+   */
+  void set_current_color(const Gdk::Color& color);
+  
+  /** Sets the current opacity to be @a alpha .  The first time this is called, it will
+   * also set the original opacity to be @a alpha  too.
+   * @param alpha An integer between 0 and 65535.
+   */
+  void set_current_alpha(guint16 alpha);
+  Gdk::Color get_current_color() const;
+  
+  /** Returns the current alpha value.
+   * @return An integer between 0 and 65535.
+   */
+  guint16 get_current_alpha() const;
+  
+  /** Sets the 'previous' color to be @a color .  This function should be called with
+   * some hesitations, as it might seem confusing to have that color change.
+   * Calling set_current_color() will also set this color the first
+   * time it is called.
+   * @param color A Gdk::Color to set the previous color with.
+   */
+  void set_previous_color(const Gdk::Color& color);
+  
+  /** Sets the 'previous' alpha to be @a alpha .  This function should be called with
+   * some hesitations, as it might seem confusing to have that alpha change.
+   * @param alpha An integer between 0 and 65535.
+   */
+  void set_previous_alpha(guint16 alpha);
+  Gdk::Color get_previous_color() const;
+  
+  /** Returns the previous alpha value.
+   * @return An integer between 0 and 65535.
+   */
+  guint16 get_previous_alpha() const;
+
+  
+  /** Gets the current state of the @a colorsel .
+   * @return <tt>true</tt> if the user is currently dragging a color around, and <tt>false</tt>
+   * if the selection has stopped.
+   */
+  bool is_adjusting() const;
+
+  static Gdk::ArrayHandle_Color palette_from_string(const Glib::ustring& str);
+  static Glib::ustring palette_to_string(const Gdk::ArrayHandle_Color& colors);
+
+  typedef sigc::slot<void, const Glib::RefPtr<Gdk::Screen>&,
+                            const Gdk::ArrayHandle_Color&> SlotChangePaletteHook;
+
+  static SlotChangePaletteHook set_change_palette_hook(const SlotChangePaletteHook& slot);
+
+  
+  Glib::SignalProxy0< void > signal_color_changed();
+
+
+  /** Whether a palette should be used.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_has_palette() ;
+
+/** Whether a palette should be used.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_has_palette() const;
+
+  /** Whether the color selector should allow setting opacity.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_has_opacity_control() ;
+
+/** Whether the color selector should allow setting opacity.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_has_opacity_control() const;
+
+  /** The current color.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Gdk::Color> property_current_color() ;
+
+/** The current color.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Gdk::Color> property_current_color() const;
+
+  /** The current opacity value (0 fully transparent, 65535 fully opaque).
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<guint> property_current_alpha() ;
+
+/** The current opacity value (0 fully transparent, 65535 fully opaque).
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<guint> property_current_alpha() const;
+
+
+};
+
+/** This dialog allows the user to select a color.
+ * @ingroup Dialogs
+ */
+
+class ColorSelectionDialog : public Dialog
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef ColorSelectionDialog CppObjectType;
+  typedef ColorSelectionDialog_Class CppClassType;
+  typedef GtkColorSelectionDialog BaseObjectType;
+  typedef GtkColorSelectionDialogClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~ColorSelectionDialog();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class ColorSelectionDialog_Class;
+  static CppClassType colorselectiondialog_class_;
+
+  // noncopyable
+  ColorSelectionDialog(const ColorSelectionDialog&);
+  ColorSelectionDialog& operator=(const ColorSelectionDialog&);
+
+protected:
+  explicit ColorSelectionDialog(const Glib::ConstructParams& construct_params);
+  explicit ColorSelectionDialog(GtkColorSelectionDialog* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GtkColorSelectionDialog*       gobj()       { return reinterpret_cast<GtkColorSelectionDialog*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GtkColorSelectionDialog* gobj() const { return reinterpret_cast<GtkColorSelectionDialog*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+private:
+
+  
+public:
+
+  ColorSelectionDialog();
+  explicit ColorSelectionDialog(const Glib::ustring& title);
+
+  ColorSelection* get_colorsel();
+  const ColorSelection* get_colorsel() const;
+  Button* get_ok_button();
+  const Button* get_ok_button() const;
+  Button* get_cancel_button();
+  const Button* get_cancel_button() const;
+  Button* get_help_button();
+  const Button* get_help_button() const;
+
+
+};
+
+} // namespace Gtk
+
+
+namespace Glib
+{
+  /** @relates Gtk::ColorSelection
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gtk::ColorSelection* wrap(GtkColorSelection* object, bool take_copy = false);
+}
+namespace Glib
+{
+  /** @relates Gtk::ColorSelectionDialog
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gtk::ColorSelectionDialog* wrap(GtkColorSelectionDialog* object, bool take_copy = false);
+}
+#endif /* _GTKMM_COLORSELECTION_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/combo.cc b/libs/gtkmm2/gtk/gtkmm/combo.cc
new file mode 100644
index 0000000000..453c7ec39e
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/combo.cc
@@ -0,0 +1,993 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/combo.h>
+#include <gtkmm/private/combo_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* 
+ *
+ * Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+//These were deprecated between 1.2 and 2.0:
+#include <gtk/gtklistitem.h>
+#include <gtk/gtklist.h>
+
+#include <gtk/gtkcombo.h>
+#include <gtk/gtklabel.h>
+#include <gtkmm/entry.h>
+#include <gtkmm/button.h>
+#include <gtkmm/scrolledwindow.h>
+#include <gtkmm/window.h>
+#include <gtkmm/item.h>
+
+namespace Gtk
+{
+
+namespace ComboDropDown_Helpers
+{
+
+ComboDropDownList::iterator ComboDropDownList::insert(ComboDropDownList::iterator position, const Element& item)
+{
+  int pos = -1;
+
+  if(position.node_)
+    pos = g_list_position(glist(), position.node_);
+
+  // gtk+ inserts the GList node allocated by g_list_append into the list as is!
+  gtk_list_insert_items((GtkList*)gparent(), g_list_append(0, const_cast<GtkWidget*>(item.Widget::gobj())), pos);
+
+  return --position;
+}
+
+void ComboDropDownList::remove(const_reference child)
+{
+  GList child_list;
+  child_list.data = (gpointer)child.gobj();
+  child_list.next = child_list.prev = 0;
+  gtk_list_remove_items(GTK_LIST(gparent_), &child_list);
+}
+
+ComboDropDownList::iterator ComboDropDownList::erase(iterator position)
+{
+  //Check that it is a valid iterator, to a real item:
+  if ( !position.node_|| (position == end()) )
+    return end();
+
+  //Get an iterator the the next item, to return:
+  iterator next = position;
+  next++;
+
+  //Use GTK+ C function to remove it, by providing the GtkWidget*:
+  GList child_list;
+  child_list.data = (gpointer)position->gobj();
+  child_list.next = child_list.prev = 0;
+  gtk_list_remove_items(GTK_LIST(gparent_), &child_list);
+
+  return next;
+}
+
+} // namespace ComboList_Helpers
+
+ComboDropDown::ComboDropDownList& ComboDropDown::children()
+{
+  children_proxy_ = ComboDropDownList(gobj());
+  return children_proxy_;
+}
+
+const ComboDropDown::ComboDropDownList& ComboDropDown::children() const
+{
+  children_proxy_ = ComboDropDownList(const_cast<GtkList*>(gobj()));
+  return children_proxy_;
+}
+
+} // namespace Gtk
+
+
+namespace Gtk
+{
+
+void Combo::remove_item_string(Gtk::Item& item)
+{
+  gtk_combo_set_item_string(gobj(), item.gobj(), 0);
+}
+
+Glib::ListHandle<Glib::ustring> Combo::get_popdown_strings() const
+{
+  GList* popdown_strings = 0;
+
+  GList *const list_children =
+      gtk_container_get_children(reinterpret_cast<GtkContainer*>(gobj()->list));
+
+  for(const GList* node = list_children; node != 0; node = node->next)
+  {
+    GtkLabel *const label = reinterpret_cast<GtkLabel*>(
+        gtk_bin_get_child(static_cast<GtkBin*>(node->data)));
+
+    popdown_strings = g_list_prepend(
+        popdown_strings, const_cast<char*>(gtk_label_get_text(label)));
+  }
+
+  g_list_free(list_children);
+  popdown_strings = g_list_reverse(popdown_strings);
+
+  return Glib::ListHandle<Glib::ustring>(popdown_strings, Glib::OWNERSHIP_SHALLOW);
+}
+
+} // namespace Gtk
+
+
+namespace
+{
+
+void ComboDropDownItem_signal_scroll_horizontal_callback(GtkListItem* self, GtkScrollType p0,gfloat p1,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,ScrollType,float > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(((ScrollType)(p0))
+, p1
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+}
+
+const Glib::SignalProxyInfo ComboDropDownItem_signal_scroll_horizontal_info =
+{
+  "scroll-horizontal",
+  (GCallback) &ComboDropDownItem_signal_scroll_horizontal_callback,
+  (GCallback) &ComboDropDownItem_signal_scroll_horizontal_callback
+};
+
+
+void ComboDropDownItem_signal_scroll_vertical_callback(GtkListItem* self, GtkScrollType p0,gfloat p1,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,ScrollType,float > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(((ScrollType)(p0))
+, p1
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+}
+
+const Glib::SignalProxyInfo ComboDropDownItem_signal_scroll_vertical_info =
+{
+  "scroll-vertical",
+  (GCallback) &ComboDropDownItem_signal_scroll_vertical_callback,
+  (GCallback) &ComboDropDownItem_signal_scroll_vertical_callback
+};
+
+
+void ComboDropDown_signal_select_child_callback(GtkList* self, GtkWidget* p0,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,Widget& > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(*Glib::wrap(p0)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+}
+
+const Glib::SignalProxyInfo ComboDropDown_signal_select_child_info =
+{
+  "select_child",
+  (GCallback) &ComboDropDown_signal_select_child_callback,
+  (GCallback) &ComboDropDown_signal_select_child_callback
+};
+
+
+const Glib::SignalProxyInfo ComboDropDown_signal_selection_changed_info =
+{
+  "selection_changed",
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
+};
+
+
+void ComboDropDown_signal_unselect_child_callback(GtkList* self, GtkWidget* p0,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,Widget& > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(*Glib::wrap(p0)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+}
+
+const Glib::SignalProxyInfo ComboDropDown_signal_unselect_child_info =
+{
+  "unselect_child",
+  (GCallback) &ComboDropDown_signal_unselect_child_callback,
+  (GCallback) &ComboDropDown_signal_unselect_child_callback
+};
+
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Gtk::ComboDropDownItem* wrap(GtkListItem* object, bool take_copy)
+{
+  return dynamic_cast<Gtk::ComboDropDownItem *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& ComboDropDownItem_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &ComboDropDownItem_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_list_item_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void ComboDropDownItem_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+  klass->scroll_horizontal = &scroll_horizontal_callback;
+  klass->scroll_vertical = &scroll_vertical_callback;
+}
+
+
+void ComboDropDownItem_Class::scroll_horizontal_callback(GtkListItem* self, GtkScrollType p0, gfloat p1)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_scroll_horizontal(((ScrollType)(p0))
+, p1
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->scroll_horizontal)
+      (*base->scroll_horizontal)(self, p0, p1);
+  }
+}
+
+void ComboDropDownItem_Class::scroll_vertical_callback(GtkListItem* self, GtkScrollType p0, gfloat p1)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_scroll_vertical(((ScrollType)(p0))
+, p1
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->scroll_vertical)
+      (*base->scroll_vertical)(self, p0, p1);
+  }
+}
+
+
+Glib::ObjectBase* ComboDropDownItem_Class::wrap_new(GObject* o)
+{
+  return manage(new ComboDropDownItem((GtkListItem*)(o)));
+
+}
+
+
+/* The implementation: */
+
+ComboDropDownItem::ComboDropDownItem(const Glib::ConstructParams& construct_params)
+:
+  Gtk::Item(construct_params)
+{
+  }
+
+ComboDropDownItem::ComboDropDownItem(GtkListItem* castitem)
+:
+  Gtk::Item((GtkItem*)(castitem))
+{
+  }
+
+ComboDropDownItem::~ComboDropDownItem()
+{
+  destroy_();
+}
+
+ComboDropDownItem::CppClassType ComboDropDownItem::combodropdownitem_class_; // initialize static member
+
+GType ComboDropDownItem::get_type()
+{
+  return combodropdownitem_class_.init().get_type();
+}
+
+GType ComboDropDownItem::get_base_type()
+{
+  return gtk_list_item_get_type();
+}
+
+
+ComboDropDownItem::ComboDropDownItem()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Item(Glib::ConstructParams(combodropdownitem_class_.init()))
+{
+  }
+
+
+Glib::SignalProxy2< void,ScrollType,float > ComboDropDownItem::signal_scroll_horizontal()
+{
+  return Glib::SignalProxy2< void,ScrollType,float >(this, &ComboDropDownItem_signal_scroll_horizontal_info);
+}
+
+Glib::SignalProxy2< void,ScrollType,float > ComboDropDownItem::signal_scroll_vertical()
+{
+  return Glib::SignalProxy2< void,ScrollType,float >(this, &ComboDropDownItem_signal_scroll_vertical_info);
+}
+
+
+void Gtk::ComboDropDownItem::on_scroll_horizontal(ScrollType scroll_type, float position)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->scroll_horizontal)
+    (*base->scroll_horizontal)(gobj(),((GtkScrollType)(scroll_type)),position);
+}
+
+void Gtk::ComboDropDownItem::on_scroll_vertical(ScrollType scroll_type, float position)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->scroll_vertical)
+    (*base->scroll_vertical)(gobj(),((GtkScrollType)(scroll_type)),position);
+}
+
+
+} // namespace Gtk
+
+
+namespace Glib
+{
+
+Gtk::ComboDropDown* wrap(GtkList* object, bool take_copy)
+{
+  return dynamic_cast<Gtk::ComboDropDown *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& ComboDropDown_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &ComboDropDown_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_list_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void ComboDropDown_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+  klass->select_child = &select_child_callback;
+  klass->selection_changed = &selection_changed_callback;
+  klass->unselect_child = &unselect_child_callback;
+}
+
+
+void ComboDropDown_Class::select_child_callback(GtkList* self, GtkWidget* p0)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_select_child(*Glib::wrap(p0)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->select_child)
+      (*base->select_child)(self, p0);
+  }
+}
+
+void ComboDropDown_Class::selection_changed_callback(GtkList* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_selection_changed();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->selection_changed)
+      (*base->selection_changed)(self);
+  }
+}
+
+void ComboDropDown_Class::unselect_child_callback(GtkList* self, GtkWidget* p0)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_unselect_child(*Glib::wrap(p0)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->unselect_child)
+      (*base->unselect_child)(self, p0);
+  }
+}
+
+
+Glib::ObjectBase* ComboDropDown_Class::wrap_new(GObject* o)
+{
+  return manage(new ComboDropDown((GtkList*)(o)));
+
+}
+
+
+/* The implementation: */
+
+ComboDropDown::ComboDropDown(const Glib::ConstructParams& construct_params)
+:
+  Gtk::Container(construct_params)
+{
+  }
+
+ComboDropDown::ComboDropDown(GtkList* castitem)
+:
+  Gtk::Container((GtkContainer*)(castitem))
+{
+  }
+
+ComboDropDown::~ComboDropDown()
+{
+  destroy_();
+}
+
+ComboDropDown::CppClassType ComboDropDown::combodropdown_class_; // initialize static member
+
+GType ComboDropDown::get_type()
+{
+  return combodropdown_class_.init().get_type();
+}
+
+GType ComboDropDown::get_base_type()
+{
+  return gtk_list_get_type();
+}
+
+
+namespace ComboDropDown_Helpers
+{
+
+ComboDropDownList::iterator ComboDropDownList::find(const_reference w)
+{
+  iterator i = begin();
+  for(i = begin(); i != end() && (i->gobj() != w.gobj()); i++);
+  return i;
+}
+
+ComboDropDownList::iterator ComboDropDownList::find(Widget& w)
+{
+  iterator i;
+  for(i = begin(); i != end() && ((GtkWidget*)i->gobj() != w.gobj()); i++);
+  return i;
+}
+
+} /* namespace ComboDropDown_Helpers */
+
+
+namespace ComboDropDown_Helpers
+{
+
+ComboDropDownList::ComboDropDownList()
+{}
+
+ComboDropDownList::ComboDropDownList(GtkList* gparent)
+: type_base((GObject*)gparent)
+{}
+
+ComboDropDownList::ComboDropDownList(const ComboDropDownList& src)
+:
+  type_base(src)
+{}
+
+ComboDropDownList& ComboDropDownList::operator=(const ComboDropDownList& src)
+{
+  type_base::operator=(src);
+  return *this;
+}
+
+GList*& ComboDropDownList::glist() const
+{
+  return ((GtkList*)gparent_)->children;
+}
+
+void ComboDropDownList::erase(iterator start, iterator stop)
+{
+  type_base::erase(start, stop);
+}
+
+GtkList* ComboDropDownList::gparent()
+{
+  return (GtkList*)type_base::gparent();
+}
+
+const GtkList* ComboDropDownList::gparent() const
+{
+  return (GtkList*)type_base::gparent();
+}
+
+ComboDropDownList::reference ComboDropDownList::operator[](size_type l) const
+{
+  return type_base::operator[](l);
+}
+
+} /* namespace ComboDropDown_Helpers */
+
+ComboDropDown::ComboDropDown()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Container(Glib::ConstructParams(combodropdown_class_.init()))
+{
+  }
+
+void ComboDropDown::scroll_horizontal(ScrollType scroll_type, float position)
+{
+  gtk_list_scroll_horizontal(gobj(), ((GtkScrollType)(scroll_type)), position);
+}
+
+void ComboDropDown::scroll_vertical(ScrollType scroll_type, float position)
+{
+  gtk_list_scroll_vertical(gobj(), ((GtkScrollType)(scroll_type)), position);
+}
+
+
+Glib::SignalProxy1< void,Widget& > ComboDropDown::signal_select_child()
+{
+  return Glib::SignalProxy1< void,Widget& >(this, &ComboDropDown_signal_select_child_info);
+}
+
+Glib::SignalProxy0< void > ComboDropDown::signal_selection_changed()
+{
+  return Glib::SignalProxy0< void >(this, &ComboDropDown_signal_selection_changed_info);
+}
+
+Glib::SignalProxy1< void,Widget& > ComboDropDown::signal_unselect_child()
+{
+  return Glib::SignalProxy1< void,Widget& >(this, &ComboDropDown_signal_unselect_child_info);
+}
+
+
+void Gtk::ComboDropDown::on_select_child(Widget& item)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->select_child)
+    (*base->select_child)(gobj(),(item).gobj());
+}
+
+void Gtk::ComboDropDown::on_selection_changed()
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->selection_changed)
+    (*base->selection_changed)(gobj());
+}
+
+void Gtk::ComboDropDown::on_unselect_child(Widget& item)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->unselect_child)
+    (*base->unselect_child)(gobj(),(item).gobj());
+}
+
+
+} // namespace Gtk
+
+
+namespace Glib
+{
+
+Gtk::Combo* wrap(GtkCombo* object, bool take_copy)
+{
+  return dynamic_cast<Gtk::Combo *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& Combo_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &Combo_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_combo_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void Combo_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+}
+
+
+Glib::ObjectBase* Combo_Class::wrap_new(GObject* o)
+{
+  return manage(new Combo((GtkCombo*)(o)));
+
+}
+
+
+/* The implementation: */
+
+Combo::Combo(const Glib::ConstructParams& construct_params)
+:
+  Gtk::HBox(construct_params)
+{
+  }
+
+Combo::Combo(GtkCombo* castitem)
+:
+  Gtk::HBox((GtkHBox*)(castitem))
+{
+  }
+
+Combo::~Combo()
+{
+  destroy_();
+}
+
+Combo::CppClassType Combo::combo_class_; // initialize static member
+
+GType Combo::get_type()
+{
+  return combo_class_.init().get_type();
+}
+
+GType Combo::get_base_type()
+{
+  return gtk_combo_get_type();
+}
+
+Combo::Combo()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::HBox(Glib::ConstructParams(combo_class_.init()))
+{
+  }
+
+void Combo::set_value_in_list(bool value, bool empty)
+{
+  gtk_combo_set_value_in_list(gobj(), static_cast<int>(value), static_cast<int>(empty));
+}
+
+void Combo::set_use_arrows(bool arrows_on)
+{
+  gtk_combo_set_use_arrows(gobj(), static_cast<int>(arrows_on));
+}
+
+void Combo::set_use_arrows_always(bool arrows_always)
+{
+  gtk_combo_set_use_arrows_always(gobj(), static_cast<int>(arrows_always));
+}
+
+void Combo::set_case_sensitive(bool val)
+{
+  gtk_combo_set_case_sensitive(gobj(), static_cast<int>(val));
+}
+
+void Combo::set_item_string(Gtk::Item& item, const Glib::ustring& item_value)
+{
+  gtk_combo_set_item_string(gobj(), (item).gobj(), item_value.c_str());
+}
+
+void Combo::set_popdown_strings(const Glib::ListHandle<Glib::ustring>& strings)
+{
+  gtk_combo_set_popdown_strings(gobj(), strings.data());
+}
+
+void Combo::disable_activate()
+{
+  gtk_combo_disable_activate(gobj());
+}
+
+Entry* Combo::get_entry()
+{
+  return Glib::wrap((GtkEntry*)(gobj()->entry));
+}
+
+const Entry* Combo::get_entry() const
+{
+  return Glib::wrap((GtkEntry*)(gobj()->entry));
+}
+
+ComboDropDown* Combo::get_list()
+{
+  return Glib::wrap((GtkList*)(gobj()->list));
+}
+
+const ComboDropDown* Combo::get_list() const
+{
+  return Glib::wrap((GtkList*)(gobj()->list));
+}
+
+
+Glib::PropertyProxy<bool> Combo::property_enable_arrow_keys() 
+{
+  return Glib::PropertyProxy<bool>(this, "enable-arrow-keys");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> Combo::property_enable_arrow_keys() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "enable-arrow-keys");
+}
+
+Glib::PropertyProxy<bool> Combo::property_enable_arrows_always() 
+{
+  return Glib::PropertyProxy<bool>(this, "enable-arrows-always");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> Combo::property_enable_arrows_always() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "enable-arrows-always");
+}
+
+Glib::PropertyProxy<bool> Combo::property_case_sensitive() 
+{
+  return Glib::PropertyProxy<bool>(this, "case-sensitive");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> Combo::property_case_sensitive() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "case-sensitive");
+}
+
+Glib::PropertyProxy<bool> Combo::property_allow_empty() 
+{
+  return Glib::PropertyProxy<bool>(this, "allow-empty");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> Combo::property_allow_empty() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "allow-empty");
+}
+
+Glib::PropertyProxy<bool> Combo::property_value_in_list() 
+{
+  return Glib::PropertyProxy<bool>(this, "value-in-list");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> Combo::property_value_in_list() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "value-in-list");
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/combo.h b/libs/gtkmm2/gtk/gtkmm/combo.h
new file mode 100644
index 0000000000..d0c973204d
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/combo.h
@@ -0,0 +1,545 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_COMBO_H
+#define _GTKMM_COMBO_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* combo.h
+ * 
+ * Copyright (C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <glibmm/listhandle.h>
+#include <glibmm/helperlist.h>
+#include <gtkmm/box.h>
+#include <gtkmm/button.h>
+#include <gtkmm/entry.h>
+#include <gtkmm/item.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkListItem GtkListItem;
+typedef struct _GtkListItemClass GtkListItemClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class ComboDropDownItem_Class; } // namespace Gtk
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkList GtkList;
+typedef struct _GtkListClass GtkListClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class ComboDropDown_Class; } // namespace Gtk
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkCombo GtkCombo;
+typedef struct _GtkComboClass GtkComboClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class Combo_Class; } // namespace Gtk
+namespace Gtk
+{
+
+
+/** An item in a ComboDropDownList.
+ * 
+ * Items in a ComboDropDownList inherit Item. Two signals are added.
+ *
+ * @deprecated Use the ComboBox widget instead. 
+ */
+
+class ComboDropDownItem : public Gtk::Item
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef ComboDropDownItem CppObjectType;
+  typedef ComboDropDownItem_Class CppClassType;
+  typedef GtkListItem BaseObjectType;
+  typedef GtkListItemClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~ComboDropDownItem();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class ComboDropDownItem_Class;
+  static CppClassType combodropdownitem_class_;
+
+  // noncopyable
+  ComboDropDownItem(const ComboDropDownItem&);
+  ComboDropDownItem& operator=(const ComboDropDownItem&);
+
+protected:
+  explicit ComboDropDownItem(const Glib::ConstructParams& construct_params);
+  explicit ComboDropDownItem(GtkListItem* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GtkListItem*       gobj()       { return reinterpret_cast<GtkListItem*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GtkListItem* gobj() const { return reinterpret_cast<GtkListItem*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+  virtual void on_scroll_horizontal(ScrollType scroll_type, float position);
+  virtual void on_scroll_vertical(ScrollType scroll_type, float position);
+
+
+private:
+
+  
+public:
+  ComboDropDownItem();
+
+  
+  Glib::SignalProxy2< void,ScrollType,float > signal_scroll_horizontal();
+
+  
+  Glib::SignalProxy2< void,ScrollType,float > signal_scroll_vertical();
+
+
+};
+
+
+namespace ComboDropDown_Helpers
+{
+
+typedef Gtk::ComboDropDownItem Element;
+
+ 
+class ComboDropDownList : public Glib::HelperList< ComboDropDownItem, const Element, Glib::List_Cpp_Iterator<GtkListItem,ComboDropDownItem> >
+{
+public:
+  ComboDropDownList();
+  explicit ComboDropDownList(GtkList* gparent);
+  ComboDropDownList(const ComboDropDownList& src);
+  virtual ~ComboDropDownList() {}
+
+  ComboDropDownList& operator=(const ComboDropDownList& src);
+
+  typedef Glib::HelperList< ComboDropDownItem, const Element,  Glib::List_Cpp_Iterator<GtkListItem,ComboDropDownItem> > type_base;
+
+  GtkList* gparent();
+  const GtkList* gparent() const;
+
+  virtual GList*& glist() const;      // front of list
+
+  virtual void erase(iterator start, iterator stop);
+  virtual iterator erase(iterator);  //Implented as custom or by LIST_CONTAINER_REMOVE
+  virtual void remove(const_reference); //Implented as custom or by LIST_CONTAINER_REMOVE
+
+  /// This is order n. (use at own risk)
+  reference operator[](size_type l) const;
+
+public:
+  iterator insert(iterator position, element_type& e); //custom-implemented.
+
+  template <class InputIterator>
+  inline void insert(iterator position, InputIterator first, InputIterator last)
+  {
+    for(;first != last; ++first)
+      position = insert(position, *first);
+  }
+
+ inline void push_front(element_type& e)
+    { insert(begin(), e); }
+  inline void push_back(element_type& e)
+    { insert(end(), e); }
+
+
+  iterator find(const_reference c);
+  iterator find(Widget&);
+
+  };
+
+
+} /* namespace ComboDropDown_Helpers */
+
+
+class Combo;
+
+/** The dropdown list of a Combo.
+ * 
+ * A combo is a compound widget which crosses a text entry area and a pull
+ * down list. The dropdown list is implemented with the deprecated GtkList
+ * widget on the gtk+ side. ComboDropDown is a thin wrapper around GtkList
+ * containing just the functionality necessary for a Combo's list. To add
+ * and remove items use the STL-style interface that is accessible through
+ * ComboDropDown::children().
+ *
+ * @deprecated Use the ComboBox widget instead.
+ */
+
+class ComboDropDown : public Gtk::Container
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef ComboDropDown CppObjectType;
+  typedef ComboDropDown_Class CppClassType;
+  typedef GtkList BaseObjectType;
+  typedef GtkListClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~ComboDropDown();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class ComboDropDown_Class;
+  static CppClassType combodropdown_class_;
+
+  // noncopyable
+  ComboDropDown(const ComboDropDown&);
+  ComboDropDown& operator=(const ComboDropDown&);
+
+protected:
+  explicit ComboDropDown(const Glib::ConstructParams& construct_params);
+  explicit ComboDropDown(GtkList* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GtkList*       gobj()       { return reinterpret_cast<GtkList*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GtkList* gobj() const { return reinterpret_cast<GtkList*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+  virtual void on_select_child(Widget& item);
+  virtual void on_selection_changed();
+  virtual void on_unselect_child(Widget& item);
+
+
+private:
+
+  
+public:
+  typedef ComboDropDown_Helpers::ComboDropDownList ComboDropDownList;
+
+protected:
+  ComboDropDown();
+  friend class Combo;
+public:
+
+  
+  void scroll_horizontal(ScrollType scroll_type, float position);
+  
+  void scroll_vertical(ScrollType scroll_type, float position);
+
+  ComboDropDownList& children();
+  const ComboDropDownList& children() const;
+
+  
+  Glib::SignalProxy1< void,Widget& > signal_select_child();
+
+  
+  Glib::SignalProxy0< void > signal_selection_changed();
+
+  
+  Glib::SignalProxy1< void,Widget& > signal_unselect_child();
+
+
+protected:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  mutable ComboDropDownList children_proxy_;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+};
+
+
+class ScrolledWindow;
+class Window;
+
+/** A text entry field with a dropdown list.
+ * 
+ * A combo is a compound widget which crosses a text entry area and a pull
+ * down list.  It may allow text entry or it may just allow list
+ * values depending on the settings.
+ *
+ * Access members allow altering of the widget components.
+ *
+ * @deprecated Use the ComboBox widget instead.
+ */
+
+class Combo : public HBox
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Combo CppObjectType;
+  typedef Combo_Class CppClassType;
+  typedef GtkCombo BaseObjectType;
+  typedef GtkComboClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~Combo();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class Combo_Class;
+  static CppClassType combo_class_;
+
+  // noncopyable
+  Combo(const Combo&);
+  Combo& operator=(const Combo&);
+
+protected:
+  explicit Combo(const Glib::ConstructParams& construct_params);
+  explicit Combo(GtkCombo* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GtkCombo*       gobj()       { return reinterpret_cast<GtkCombo*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GtkCombo* gobj() const { return reinterpret_cast<GtkCombo*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+private:
+
+public:
+
+  Combo();
+  
+
+  /** Allow direct text entry
+   * Whether the text in the entry must be or not be in the list.
+   *
+   * @param value Set to true if the value must be in list.
+   * @param empty Set to true if the text area is allowed to be empty.
+   */
+  
+  void set_value_in_list(bool value = true, bool empty = false);
+
+  /** Set arrows keys to change value
+   * Up and down will scroll through the list items.
+   * Useful when there is a small list of value that the
+   * list must have.
+   *
+   * @param arrows_on true indicates the arrow keys scroll.
+   */
+  
+  void set_use_arrows(bool arrows_on = true);
+
+  /** Set arrows keys to change if value not in list
+   * Up and down will scroll through the list items but only
+   * change the current value if the text does not match a list item..
+   * Useful when there is a small list of value that the
+   * list must have.
+   *
+   * @param arrows_always true indicates the value will change.
+   */
+  
+  void set_use_arrows_always(bool arrows_always = true);
+
+  /** Sets list case sensitive
+   * Determines if the list items and text comparisons for
+   * set_use_arrows_always() should be case sensitive.
+   */
+  
+  void set_case_sensitive(bool val = true);
+
+  /** Set the current entry Glib::ustring
+   * Call this function on an item if it isn't a label or you
+   * want it to have a different value to be displayed in the entry
+   */
+  
+  void set_item_string(Gtk::Item& item, const Glib::ustring& item_value);
+   void remove_item_string(Gtk::Item& item);
+
+  /// Insert a list of items.
+  
+  void set_popdown_strings(const Glib::ListHandle<Glib::ustring>& strings);
+
+  Glib::ListHandle<Glib::ustring> get_popdown_strings() const;
+
+  
+  void disable_activate();
+
+  Entry* get_entry();
+  const Entry* get_entry() const;
+  ComboDropDown* get_list();
+  const ComboDropDown* get_list() const;
+
+  /** Whether the arrow keys move through the list of items.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_enable_arrow_keys() ;
+
+/** Whether the arrow keys move through the list of items.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_enable_arrow_keys() const;
+
+  /** Obsolete property
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_enable_arrows_always() ;
+
+/** Obsolete property
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_enable_arrows_always() const;
+
+  /** Whether list item matching is case sensitive.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_case_sensitive() ;
+
+/** Whether list item matching is case sensitive.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_case_sensitive() const;
+
+  /** Whether an empty value may be entered in this field.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_allow_empty() ;
+
+/** Whether an empty value may be entered in this field.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_allow_empty() const;
+
+  /** Whether entered values must already be present in the list.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_value_in_list() ;
+
+/** Whether entered values must already be present in the list.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_value_in_list() const;
+
+
+};
+
+
+} /* namespace Gtk */
+
+
+namespace Glib
+{
+  /** @relates Gtk::ComboDropDownItem
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gtk::ComboDropDownItem* wrap(GtkListItem* object, bool take_copy = false);
+}
+namespace Glib
+{
+  /** @relates Gtk::ComboDropDown
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gtk::ComboDropDown* wrap(GtkList* object, bool take_copy = false);
+}
+namespace Glib
+{
+  /** @relates Gtk::Combo
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gtk::Combo* wrap(GtkCombo* object, bool take_copy = false);
+}
+#endif /* _GTKMM_COMBO_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/combobox.cc b/libs/gtkmm2/gtk/gtkmm/combobox.cc
new file mode 100644
index 0000000000..d16c27d274
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/combobox.cc
@@ -0,0 +1,452 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/combobox.h>
+#include <gtkmm/private/combobox_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* 
+ *
+ * Copyright 2003 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+ 
+#include <gtkmm/liststore.h>
+#include <gtkmm/cellrenderertext.h>
+#include <gtkmm/treeview_private.h> //For SignalProxy_RowSeparator.
+#include <gtk/gtkcombobox.h>
+#include <gtk/gtkcelllayout.h>
+
+namespace Gtk
+{
+
+void ComboBox::unset_active()
+{
+  gtk_combo_box_set_active(gobj(), -1 /* see GTK+ docs */);
+}
+
+TreeModel::iterator ComboBox::get_active()
+{
+  Gtk::TreeModel::iterator iter;
+
+  Glib::RefPtr<Gtk::TreeModel> model = get_model();
+  if(model)
+  {
+    gtk_combo_box_get_active_iter(gobj(), iter.gobj());
+
+    //It must be given the model, because the C++ wrapper has extra information.
+    iter.set_model_gobject(model->gobj());
+  }
+  
+  return iter;
+}
+
+TreeModel::const_iterator ComboBox::get_active() const
+{
+  Gtk::TreeModel::iterator iter;
+
+  Glib::RefPtr<const Gtk::TreeModel> model = get_model();
+  if(model)
+  {
+    gtk_combo_box_get_active_iter(const_cast<GtkComboBox*>(gobj()), iter.gobj());
+
+    //It must be given the model, because the C++ wrapper has extra information.
+    iter.set_model_gobject(const_cast<GtkTreeModel*>(model->gobj()));
+  }
+
+  return iter;
+}
+
+
+void ComboBox::set_row_separator_func(const SlotRowSeparator& slot)
+{
+  //Create a signal proxy. A pointer to this will be passed through the callback's data parameter.
+  //It will be deleted when SignalProxy_RowSeparator::gtk_callback_destroy() is called.
+  TreeView_Private::SignalProxy_RowSeparator *const pSignalProxy = new TreeView_Private::SignalProxy_RowSeparator(slot);
+
+  gtk_combo_box_set_row_separator_func(gobj(),
+      &TreeView_Private::SignalProxy_RowSeparator::gtk_callback, pSignalProxy,
+      &TreeView_Private::SignalProxy_RowSeparator::gtk_callback_destroy);
+}
+
+void ComboBox::unset_row_separator_func()
+{
+  gtk_combo_box_set_row_separator_func(gobj(), 0, 0, 0 /* See C docs. */);
+}
+
+} // namespace Gtk
+
+
+namespace
+{
+
+const Glib::SignalProxyInfo ComboBox_signal_changed_info =
+{
+  "changed",
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
+};
+
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Gtk::ComboBox* wrap(GtkComboBox* object, bool take_copy)
+{
+  return dynamic_cast<Gtk::ComboBox *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& ComboBox_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &ComboBox_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_combo_box_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  CellLayout::add_interface(get_type());
+  }
+
+  return *this;
+}
+
+void ComboBox_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+  klass->changed = &changed_callback;
+}
+
+
+void ComboBox_Class::changed_callback(GtkComboBox* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_changed();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->changed)
+      (*base->changed)(self);
+  }
+}
+
+
+Glib::ObjectBase* ComboBox_Class::wrap_new(GObject* o)
+{
+  return manage(new ComboBox((GtkComboBox*)(o)));
+
+}
+
+
+/* The implementation: */
+
+ComboBox::ComboBox(const Glib::ConstructParams& construct_params)
+:
+  Gtk::Bin(construct_params)
+{
+  }
+
+ComboBox::ComboBox(GtkComboBox* castitem)
+:
+  Gtk::Bin((GtkBin*)(castitem))
+{
+  }
+
+ComboBox::~ComboBox()
+{
+  destroy_();
+}
+
+ComboBox::CppClassType ComboBox::combobox_class_; // initialize static member
+
+GType ComboBox::get_type()
+{
+  return combobox_class_.init().get_type();
+}
+
+GType ComboBox::get_base_type()
+{
+  return gtk_combo_box_get_type();
+}
+
+
+ComboBox::ComboBox()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Bin(Glib::ConstructParams(combobox_class_.init()))
+{
+  }
+
+ComboBox::ComboBox(const Glib::RefPtr<TreeModel>& model)
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Bin(Glib::ConstructParams(combobox_class_.init(), "model", Glib::unwrap(model), (char*) 0))
+{
+  }
+
+void ComboBox::set_wrap_width(int width)
+{
+  gtk_combo_box_set_wrap_width(gobj(), width);
+}
+
+int ComboBox::get_wrap_width() const
+{
+  return gtk_combo_box_get_wrap_width(const_cast<GtkComboBox*>(gobj()));
+}
+
+void ComboBox::set_row_span_column(int row_span)
+{
+  gtk_combo_box_set_row_span_column(gobj(), row_span);
+}
+
+int ComboBox::get_row_span_column() const
+{
+  return gtk_combo_box_get_row_span_column(const_cast<GtkComboBox*>(gobj()));
+}
+
+void ComboBox::set_column_span_column(int column_span)
+{
+  gtk_combo_box_set_column_span_column(gobj(), column_span);
+}
+
+int ComboBox::get_column_span_column() const
+{
+  return gtk_combo_box_get_column_span_column(const_cast<GtkComboBox*>(gobj()));
+}
+
+bool ComboBox::get_add_tearoffs() const
+{
+  return gtk_combo_box_get_add_tearoffs(const_cast<GtkComboBox*>(gobj()));
+}
+
+void ComboBox::set_add_tearoffs(bool add_tearoffs)
+{
+  gtk_combo_box_set_add_tearoffs(gobj(), static_cast<int>(add_tearoffs));
+}
+
+bool ComboBox::get_focus_on_click() const
+{
+  return gtk_combo_box_get_focus_on_click(const_cast<GtkComboBox*>(gobj()));
+}
+
+void ComboBox::set_focus_on_click(bool focus_on_click)
+{
+  gtk_combo_box_set_focus_on_click(gobj(), static_cast<int>(focus_on_click));
+}
+
+int ComboBox::get_active_row_number() const
+{
+  return gtk_combo_box_get_active(const_cast<GtkComboBox*>(gobj()));
+}
+
+void ComboBox::set_active(int index)
+{
+  gtk_combo_box_set_active(gobj(), index);
+}
+
+void ComboBox::set_active(const TreeModel::iterator& iter)
+{
+  gtk_combo_box_set_active_iter(gobj(), const_cast<GtkTreeIter*>((iter).gobj()));
+}
+
+Glib::RefPtr<TreeModel> ComboBox::get_model()
+{
+
+  Glib::RefPtr<TreeModel> retvalue = Glib::wrap(gtk_combo_box_get_model(gobj()));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::RefPtr<const TreeModel> ComboBox::get_model() const
+{
+
+  Glib::RefPtr<const TreeModel> retvalue = Glib::wrap(gtk_combo_box_get_model(const_cast<GtkComboBox*>(gobj())));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+void ComboBox::set_model(const Glib::RefPtr<TreeModel>& model)
+{
+  gtk_combo_box_set_model(gobj(), Glib::unwrap(model));
+}
+
+void ComboBox::popup()
+{
+  gtk_combo_box_popup(gobj());
+}
+
+void ComboBox::popdown()
+{
+  gtk_combo_box_popdown(gobj());
+}
+
+Glib::RefPtr<Atk::Object> ComboBox::get_popup_accessible()
+{
+  return Glib::wrap(gtk_combo_box_get_popup_accessible(gobj()));
+}
+
+Glib::RefPtr<const Atk::Object> ComboBox::get_popup_accessible() const
+{
+  return Glib::wrap(gtk_combo_box_get_popup_accessible(const_cast<GtkComboBox*>(gobj())));
+}
+
+
+Glib::SignalProxy0< void > ComboBox::signal_changed()
+{
+  return Glib::SignalProxy0< void >(this, &ComboBox_signal_changed_info);
+}
+
+
+Glib::PropertyProxy< Glib::RefPtr<TreeModel> > ComboBox::property_model() 
+{
+  return Glib::PropertyProxy< Glib::RefPtr<TreeModel> >(this, "model");
+}
+
+Glib::PropertyProxy_ReadOnly< Glib::RefPtr<TreeModel> > ComboBox::property_model() const
+{
+  return Glib::PropertyProxy_ReadOnly< Glib::RefPtr<TreeModel> >(this, "model");
+}
+
+Glib::PropertyProxy<int> ComboBox::property_wrap_width() 
+{
+  return Glib::PropertyProxy<int>(this, "wrap-width");
+}
+
+Glib::PropertyProxy_ReadOnly<int> ComboBox::property_wrap_width() const
+{
+  return Glib::PropertyProxy_ReadOnly<int>(this, "wrap-width");
+}
+
+Glib::PropertyProxy<int> ComboBox::property_row_span_column() 
+{
+  return Glib::PropertyProxy<int>(this, "row-span-column");
+}
+
+Glib::PropertyProxy_ReadOnly<int> ComboBox::property_row_span_column() const
+{
+  return Glib::PropertyProxy_ReadOnly<int>(this, "row-span-column");
+}
+
+Glib::PropertyProxy<int> ComboBox::property_column_span_column() 
+{
+  return Glib::PropertyProxy<int>(this, "column-span-column");
+}
+
+Glib::PropertyProxy_ReadOnly<int> ComboBox::property_column_span_column() const
+{
+  return Glib::PropertyProxy_ReadOnly<int>(this, "column-span-column");
+}
+
+Glib::PropertyProxy<int> ComboBox::property_active() 
+{
+  return Glib::PropertyProxy<int>(this, "active");
+}
+
+Glib::PropertyProxy_ReadOnly<int> ComboBox::property_active() const
+{
+  return Glib::PropertyProxy_ReadOnly<int>(this, "active");
+}
+
+Glib::PropertyProxy<bool> ComboBox::property_add_tearoffs() 
+{
+  return Glib::PropertyProxy<bool>(this, "add-tearoffs");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> ComboBox::property_add_tearoffs() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "add-tearoffs");
+}
+
+Glib::PropertyProxy<bool> ComboBox::property_has_frame() 
+{
+  return Glib::PropertyProxy<bool>(this, "has-frame");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> ComboBox::property_has_frame() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "has-frame");
+}
+
+Glib::PropertyProxy<bool> ComboBox::property_focus_on_click() 
+{
+  return Glib::PropertyProxy<bool>(this, "focus-on-click");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> ComboBox::property_focus_on_click() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "focus-on-click");
+}
+
+
+void Gtk::ComboBox::on_changed()
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->changed)
+    (*base->changed)(gobj());
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/combobox.h b/libs/gtkmm2/gtk/gtkmm/combobox.h
new file mode 100644
index 0000000000..c143e59bc2
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/combobox.h
@@ -0,0 +1,492 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_COMBOBOX_H
+#define _GTKMM_COMBOBOX_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* combobox.h
+ * 
+ * Copyright (C) 2003 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/bin.h>
+#include <gtkmm/celllayout.h>
+#include <gtkmm/treemodel.h>
+#include <gtkmm/cellrenderer.h>
+#include <gtkmm/treeview.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkComboBox GtkComboBox;
+typedef struct _GtkComboBoxClass GtkComboBoxClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class ComboBox_Class; } // namespace Gtk
+namespace Gtk
+{
+
+/** A widget used to choose from a list of items.
+ *
+ * A ComboBox is a widget that allows the user to choose from a list of valid choices. The ComboBox displays the 
+ * selected choice. When activated, the ComboBox displays a popup which allows the user to make a new choice. The 
+ * style in which the selected value is displayed, and the style of the popup is determined by the current theme. 
+ * It may be similar to a OptionMenu, or similar to a Windows-style combo box.
+ *
+ * The ComboBox uses the model-view pattern; the list of valid choices is specified in the form of a tree model, 
+ * and the display of the choices can be adapted to the data in the model by using cell renderers, as you would in 
+ * a tree view. This is possible since ComboBox implements the CellLayout interface. The tree model holding the 
+ * valid choices is not restricted to a flat list, it can be a real tree, and the popup will reflect the tree 
+ * structure.
+ *
+ * See also ComboBoxText, which is specialised for a single text column.
+ *
+ * @ingroup Widgets
+ */
+
+class ComboBox
+: public Bin,
+  public CellLayout
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef ComboBox CppObjectType;
+  typedef ComboBox_Class CppClassType;
+  typedef GtkComboBox BaseObjectType;
+  typedef GtkComboBoxClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~ComboBox();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class ComboBox_Class;
+  static CppClassType combobox_class_;
+
+  // noncopyable
+  ComboBox(const ComboBox&);
+  ComboBox& operator=(const ComboBox&);
+
+protected:
+  explicit ComboBox(const Glib::ConstructParams& construct_params);
+  explicit ComboBox(GtkComboBox* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GtkComboBox*       gobj()       { return reinterpret_cast<GtkComboBox*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GtkComboBox* gobj() const { return reinterpret_cast<GtkComboBox*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+  virtual void on_changed();
+
+
+private:
+
+  
+public:
+  ComboBox();
+  
+  /** Creates a new ComboBox with the model initialized to @a model.
+   */
+  explicit ComboBox(const Glib::RefPtr<TreeModel>& model);
+   //See ComboBoxText for an equivalent of gtk_combo_box_new_text().
+
+
+  /** Sets the wrap width of @a combo_box  to be @a width . The wrap width is basically
+   * the preferred number of columns when you want the popup to be layed out
+   * in a table.
+   * 
+   * Since: 2.4
+   * @param width Preferred number of columns.
+   */
+  void set_wrap_width(int width);
+  
+  /** Returns the wrap width which is used to determine the number
+   * of columns for the popup menu. If the wrap width is larger than
+   * 1, the combo box is in table mode.
+   * @return The wrap width.
+   * 
+   * Since: 2.6.
+   */
+  int get_wrap_width() const;
+
+  
+  /** Sets the column with row span information for @a combo_box  to be @a row_span .
+   * The row span column contains integers which indicate how many rows
+   * an item should span.
+   * 
+   * Since: 2.4
+   * @param row_span A column in the model passed during construction.
+   */
+  void set_row_span_column(int row_span);
+  
+  /** Returns the column with row span information for @a combo_box .
+   * @return The row span column.
+   * 
+   * Since: 2.6.
+   */
+  int get_row_span_column() const;
+
+  
+  /** Sets the column with column span information for @a combo_box  to be
+   *  @a column_span . The column span column contains integers which indicate
+   * how many columns an item should span.
+   * 
+   * Since: 2.4
+   * @param column_span A column in the model passed during construction.
+   */
+  void set_column_span_column(int column_span);
+  
+  /** Returns the column with column span information for @a combo_box .
+   * @return The column span column.
+   * 
+   * Since: 2.6.
+   */
+  int get_column_span_column() const;
+
+  
+  /** Gets the current value of the :add-tearoffs property.
+   * @return The current value of the :add-tearoffs property.
+   */
+  bool get_add_tearoffs() const;
+  
+  /** Sets whether the popup menu should have a tearoff 
+   * menu item.
+   * 
+   * Since: 2.6
+   * @param add_tearoffs <tt>true</tt> to add tearoff menu items.
+   */
+  void set_add_tearoffs(bool add_tearoffs = true);
+
+  
+  /** Returns whether the combo box grabs focus when it is clicked 
+   * with the mouse. See set_focus_on_click().
+   * @return <tt>true</tt> if the combo box grabs focus when it is 
+   * clicked with the mouse.
+   * 
+   * Since: 2.6.
+   */
+  bool get_focus_on_click() const;
+  
+  /** Sets whether the combo box will grab focus when it is clicked with 
+   * the mouse. Making mouse clicks not grab focus is useful in places 
+   * like toolbars where you don't want the keyboard focus removed from 
+   * the main area of the application.
+   * 
+   * Since: 2.6
+   * @param focus_on_click Whether the combo box grabs focus when clicked 
+   * with the mouse.
+   */
+  void set_focus_on_click(bool focus_on_click = true);
+
+/* get/set active item */
+  
+  /** Returns the index of the currently active item, or -1 if there's no
+   * active item. If the model is a non-flat treemodel, and the active item 
+   * is not an immediate child of the root of the tree, this function returns 
+   * <tt>gtk_tree_path_get_indices (path)[0]</tt>, where 
+   * <tt>path</tt> is the Gtk::TreePath of the active item.
+   * @return An integer which is the index of the currently active item, or
+   * -1 if there's no active item.
+   * 
+   * Since: 2.4.
+   */
+  int get_active_row_number() const;
+
+  /** Gets an iterator that points to the current active item, if it exists.
+   * @result The iterator.
+   */
+  TreeModel::iterator get_active();
+  
+  /** Gets an iterator that points to the current active item, if it exists.
+   * @result The iterator.
+   */
+  TreeModel::const_iterator get_active() const;
+  
+    
+  /** Sets the active item of @a combo_box  to be the item at @a index .
+   * 
+   * Since: 2.4
+   * @param index An index in the model passed during construction, or -1 to have
+   * no active item.
+   */
+  void set_active(int index);
+  
+  /** Sets the current active item to be the one referenced by @a iter . 
+   *  @a iter  must correspond to a path of depth one.
+   * 
+   * Since: 2.4
+   * @param iter The Gtk::TreeIter.
+   */
+  void set_active(const TreeModel::iterator& iter);
+  
+  /** Causes no item to be active. See also set_active().
+   */
+  void unset_active();
+
+  
+  /** Returns the Gtk::TreeModel which is acting as data source for @a combo_box .
+   * @return A Gtk::TreeModel which was passed during construction.
+   * 
+   * Since: 2.4.
+   */
+  Glib::RefPtr<TreeModel> get_model();
+  
+  /** Returns the Gtk::TreeModel which is acting as data source for @a combo_box .
+   * @return A Gtk::TreeModel which was passed during construction.
+   * 
+   * Since: 2.4.
+   */
+  Glib::RefPtr<const TreeModel> get_model() const;
+  
+  /** Sets the model used by @a combo_box  to be @a model . Will unset a previously set 
+   * model (if applicable). If model is <tt>0</tt>, then it will unset the model.
+   * 
+   * Note that this function does not clear the cell renderers, you have to 
+   * call gtk_combo_box_cell_layout_clear() yourself if you need to set up 
+   * different cell renderers for the new model.
+   * 
+   * Since: 2.4
+   * @param model A Gtk::TreeModel.
+   */
+  void set_model(const Glib::RefPtr<TreeModel>& model);
+
+  typedef TreeView::SlotRowSeparator SlotRowSeparator;  
+  
+  /** Sets the row separator function, which is used to determine whether a row should be drawn as a separator. 
+   * See also unset_row_separator_func().
+   * 
+   * @param slot The callback.
+   */
+  void set_row_separator_func(const SlotRowSeparator& slot);
+  
+  /** Causes no separators to be drawn.
+   */
+  void unset_row_separator_func();
+  
+
+  /** Pops up the menu or dropdown list of @a combo_box . 
+   * 
+   * This function is mostly intended for use by accessibility technologies;
+   * applications should have little use for it.
+   * 
+   * Since: 2.4
+   */
+  void popup();
+  
+  /** Hides the menu or dropdown list of @a combo_box .
+   * 
+   * This function is mostly intended for use by accessibility technologies;
+   * applications should have little use for it.
+   * 
+   * Since: 2.4
+   */
+  void popdown();
+    
+  
+  /** Gets the accessible object corresponding to the combo box's popup.
+   * 
+   * This function is mostly intended for use by accessibility technologies;
+   * applications should have little use for it.
+   * @return The accessible object corresponding to the combo box's popup.
+   * 
+   * Since: 2.6.
+   */
+  Glib::RefPtr<Atk::Object> get_popup_accessible();
+  
+  /** Gets the accessible object corresponding to the combo box's popup.
+   * 
+   * This function is mostly intended for use by accessibility technologies;
+   * applications should have little use for it.
+   * @return The accessible object corresponding to the combo box's popup.
+   * 
+   * Since: 2.6.
+   */
+  Glib::RefPtr<const Atk::Object> get_popup_accessible() const;
+
+   //These are in ComboBoxText.
+
+  /** The model for the combo box.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy< Glib::RefPtr<TreeModel> > property_model() ;
+
+/** The model for the combo box.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly< Glib::RefPtr<TreeModel> > property_model() const;
+
+  /** Wrap width for layouting the items in a grid.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<int> property_wrap_width() ;
+
+/** Wrap width for layouting the items in a grid.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<int> property_wrap_width() const;
+
+  /** TreeModel column containing the row span values.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<int> property_row_span_column() ;
+
+/** TreeModel column containing the row span values.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<int> property_row_span_column() const;
+
+  /** TreeModel column containing the column span values.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<int> property_column_span_column() ;
+
+/** TreeModel column containing the column span values.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<int> property_column_span_column() const;
+
+  /** The item which is currently active.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<int> property_active() ;
+
+/** The item which is currently active.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<int> property_active() const;
+
+  /** Whether dropdowns should have a tearoff menu item.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_add_tearoffs() ;
+
+/** Whether dropdowns should have a tearoff menu item.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_add_tearoffs() const;
+
+  /** Whether the combo box draws a frame around the child.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_has_frame() ;
+
+/** Whether the combo box draws a frame around the child.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_has_frame() const;
+
+  /** Whether the combo box grabs focus when it is clicked with the mouse.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_focus_on_click() ;
+
+/** Whether the combo box grabs focus when it is clicked with the mouse.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_focus_on_click() const;
+
+
+  Glib::SignalProxy0< void > signal_changed();
+                                             
+
+};
+
+
+} // namespace Gtk
+
+
+namespace Glib
+{
+  /** @relates Gtk::ComboBox
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gtk::ComboBox* wrap(GtkComboBox* object, bool take_copy = false);
+}
+#endif /* _GTKMM_COMBOBOX_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/comboboxentry.cc b/libs/gtkmm2/gtk/gtkmm/comboboxentry.cc
new file mode 100644
index 0000000000..90a0bf6b39
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/comboboxentry.cc
@@ -0,0 +1,176 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/comboboxentry.h>
+#include <gtkmm/private/comboboxentry_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* 
+ *
+ * Copyright 2003 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtk/gtkcomboboxentry.h>
+
+namespace Gtk
+{
+
+
+Entry* ComboBoxEntry::get_entry()
+{
+  return Glib::wrap((GtkEntry*)(gtk_bin_get_child((GtkBin*)gobj())));
+}
+
+const Entry* ComboBoxEntry::get_entry() const
+{
+  GtkBin* base = (GtkBin*)const_cast<GtkComboBoxEntry*>(gobj());
+  return Glib::wrap((GtkEntry*)(gtk_bin_get_child(base)));
+}
+
+
+} // namespace Gtk
+
+
+namespace
+{
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Gtk::ComboBoxEntry* wrap(GtkComboBoxEntry* object, bool take_copy)
+{
+  return dynamic_cast<Gtk::ComboBoxEntry *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& ComboBoxEntry_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &ComboBoxEntry_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_combo_box_entry_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void ComboBoxEntry_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+}
+
+
+Glib::ObjectBase* ComboBoxEntry_Class::wrap_new(GObject* o)
+{
+  return manage(new ComboBoxEntry((GtkComboBoxEntry*)(o)));
+
+}
+
+
+/* The implementation: */
+
+ComboBoxEntry::ComboBoxEntry(const Glib::ConstructParams& construct_params)
+:
+  Gtk::ComboBox(construct_params)
+{
+  }
+
+ComboBoxEntry::ComboBoxEntry(GtkComboBoxEntry* castitem)
+:
+  Gtk::ComboBox((GtkComboBox*)(castitem))
+{
+  }
+
+ComboBoxEntry::~ComboBoxEntry()
+{
+  destroy_();
+}
+
+ComboBoxEntry::CppClassType ComboBoxEntry::comboboxentry_class_; // initialize static member
+
+GType ComboBoxEntry::get_type()
+{
+  return comboboxentry_class_.init().get_type();
+}
+
+GType ComboBoxEntry::get_base_type()
+{
+  return gtk_combo_box_entry_get_type();
+}
+
+
+ComboBoxEntry::ComboBoxEntry()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::ComboBox(Glib::ConstructParams(comboboxentry_class_.init()))
+{
+  }
+
+ComboBoxEntry::ComboBoxEntry(const Glib::RefPtr<TreeModel>& model, const TreeModelColumnBase& text_column)
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::ComboBox(Glib::ConstructParams(comboboxentry_class_.init(), "model", Glib::unwrap(model), "text_column", (text_column).index(), (char*) 0))
+{
+  }
+
+ComboBoxEntry::ComboBoxEntry(const Glib::RefPtr<TreeModel>& model, int text_column)
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::ComboBox(Glib::ConstructParams(comboboxentry_class_.init(), "model", Glib::unwrap(model), "text_column", text_column, (char*) 0))
+{
+  }
+
+void ComboBoxEntry::set_text_column(const TreeModelColumnBase& text_column) const
+{
+  gtk_combo_box_entry_set_text_column(const_cast<GtkComboBoxEntry*>(gobj()), (text_column).index());
+}
+
+void ComboBoxEntry::set_text_column(int text_column) const
+{
+  gtk_combo_box_entry_set_text_column(const_cast<GtkComboBoxEntry*>(gobj()), text_column);
+}
+
+int ComboBoxEntry::get_text_column() const
+{
+  return gtk_combo_box_entry_get_text_column(const_cast<GtkComboBoxEntry*>(gobj()));
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/comboboxentry.h b/libs/gtkmm2/gtk/gtkmm/comboboxentry.h
new file mode 100644
index 0000000000..dce4c67019
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/comboboxentry.h
@@ -0,0 +1,183 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_COMBOBOXENTRY_H
+#define _GTKMM_COMBOBOXENTRY_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* combobox.h
+ * 
+ * Copyright (C) 2003 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/combobox.h>
+#include <gtkmm/entry.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkComboBoxEntry GtkComboBoxEntry;
+typedef struct _GtkComboBoxEntryClass GtkComboBoxEntryClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class ComboBoxEntry_Class; } // namespace Gtk
+namespace Gtk
+{
+
+/** A text entry field with a dropdown list
+ * A ComboBoxEntry is a widget that allows the user to choose from a list of valid choices or enter a different 
+ * value. It is very similar to a ComboBox, but it displays the selected value in an entry to allow modifying it.
+ *
+ * In contrast to a ComboBox, the underlying model of a ComboBoxEntry must always have a text column (see 
+ * set_text_column()), and the entry will show the content of the text column in the selected row.
+ *
+ * See also ComboBoxEntryText, , which is specialised for a single text column.
+ *
+ * To add and remove strings from the list, just modify the model using its data manipulation API. You can get the * Entry by using get_child().
+ *
+ * @ingroup Widgets
+ */
+
+class ComboBoxEntry : public ComboBox
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef ComboBoxEntry CppObjectType;
+  typedef ComboBoxEntry_Class CppClassType;
+  typedef GtkComboBoxEntry BaseObjectType;
+  typedef GtkComboBoxEntryClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~ComboBoxEntry();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class ComboBoxEntry_Class;
+  static CppClassType comboboxentry_class_;
+
+  // noncopyable
+  ComboBoxEntry(const ComboBoxEntry&);
+  ComboBoxEntry& operator=(const ComboBoxEntry&);
+
+protected:
+  explicit ComboBoxEntry(const Glib::ConstructParams& construct_params);
+  explicit ComboBoxEntry(GtkComboBoxEntry* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GtkComboBoxEntry*       gobj()       { return reinterpret_cast<GtkComboBoxEntry*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GtkComboBoxEntry* gobj() const { return reinterpret_cast<GtkComboBoxEntry*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+private:
+
+public:
+  ComboBoxEntry();
+   //See ComboBoxEntryText for an equivalent of gtk_combo_box_entry_new_text().
+
+  /** Creates a new ComboBoxEntry which has an Entry as child and a list of strings as popup. You can get the 
+   * Entry from a ComboBoxEntry using get_entry(). To add and remove strings from the list, just modify @a model 
+   * using its data manipulation API.
+   *
+   * @param model A TreeModel.
+   * @param text_column A column in @a model to get the strings from.
+   */
+  explicit ComboBoxEntry(const Glib::RefPtr<TreeModel>& model, const TreeModelColumnBase& text_column);
+  
+  /** Creates a new ComboBoxEntry which has an Entry as child and a list of strings as popup. You can get the 
+   * Entry from a ComboBoxEntry using get_entry(). To add and remove strings from the list, just modify @a model 
+   * using its data manipulation API.
+   *
+   * @param model A TreeModel.
+   * @param text_column A column in @a model to get the strings from.
+   */
+  explicit ComboBoxEntry(const Glib::RefPtr<TreeModel>& model, int text_column = 0);
+
+  
+  /** Sets the model column which @a entry_box  should use to get strings from
+   * to be @a text_column .
+   * 
+   * Since: 2.4.
+   * @param text_column A column in @a model  to get the strings from.
+   */
+  void set_text_column(const TreeModelColumnBase& text_column) const;   
+  
+  /** Sets the model column which @a entry_box  should use to get strings from
+   * to be @a text_column .
+   * 
+   * Since: 2.4.
+   * @param text_column A column in @a model  to get the strings from.
+   */
+  void set_text_column(int text_column) const; 
+  
+  /** Returns the column which @a entry_box  is using to get the strings from.
+   * @return A column in the data source model of @a entry_box .
+   * 
+   * Since: 2.4.
+   */
+  int get_text_column() const; 
+
+  //The child is always an entry:
+
+  /** See Bin::get_entry().
+   */
+  Entry* get_entry();
+
+  /** See Bin::get_entry().
+   */
+  const Entry* get_entry() const;                                      
+
+
+};
+
+
+} // namespace Gtk
+
+
+namespace Glib
+{
+  /** @relates Gtk::ComboBoxEntry
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gtk::ComboBoxEntry* wrap(GtkComboBoxEntry* object, bool take_copy = false);
+}
+#endif /* _GTKMM_COMBOBOXENTRY_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/comboboxentrytext.cc b/libs/gtkmm2/gtk/gtkmm/comboboxentrytext.cc
new file mode 100644
index 0000000000..d74c01ae72
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/comboboxentrytext.cc
@@ -0,0 +1,134 @@
+// -*- c++ -*-
+/* $Id$ */
+
+/* 
+ *
+ * Copyright 2003 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/comboboxentrytext.h>
+
+#include <gtkmm/liststore.h>
+#include <gtkmm/cellrenderertext.h>
+#include <gtk/gtkcombobox.h>
+#include <gtk/gtkcelllayout.h>
+
+namespace Gtk
+{
+
+ComboBoxEntryText::ComboBoxEntryText()
+{
+  set_model( Gtk::ListStore::create(m_text_columns) );
+  set_text_column(m_text_columns.m_column);
+}
+
+ComboBoxEntryText::ComboBoxEntryText(GtkComboBoxEntry* castitem)
+: Gtk::ComboBoxEntry(castitem)
+{
+  set_model( Gtk::ListStore::create(m_text_columns) );
+  set_text_column(m_text_columns.m_column);
+}
+
+void ComboBoxEntryText::append_text(const Glib::ustring& text)
+{
+  //We can not use gtk_combo_box_append_text() here, because that can only be used if gtk_combo_box_new_text() has been used.
+
+  //Ideally, we would just store the ListStore as a member variable, but we forgot to do that and not it would break the ABI.
+  Glib::RefPtr<Gtk::TreeModel> model = get_model();
+  Glib::RefPtr<Gtk::ListStore> list_model = Glib::RefPtr<ListStore>::cast_dynamic(model);
+  
+  if(list_model)
+  {
+    Gtk::TreeModel::iterator iter = list_model->append();
+    Gtk::TreeModel::Row row = *iter;
+    row[m_text_columns.m_column] = text;
+  }
+}
+
+void ComboBoxEntryText::insert_text(int position, const Glib::ustring& text)
+{
+  //TODO: We should not use gtk_combo_box_insert_text() here, because that can only be used if gtk_combo_box_new_text() has been used.
+  gtk_combo_box_insert_text(GTK_COMBO_BOX(gobj()), position, text.c_str());
+}
+
+void ComboBoxEntryText::prepend_text(const Glib::ustring& text)
+{
+  //We can not use gtk_combo_box_prepend_text() here, because that can only be used if gtk_combo_box_new_text() has been used.
+
+  //Ideally, we would just store the ListStore as a member variable, but we forgot to do that and not it would break the ABI.
+  Glib::RefPtr<Gtk::TreeModel> model = get_model();
+  Glib::RefPtr<Gtk::ListStore> list_model = Glib::RefPtr<ListStore>::cast_dynamic(model);
+  
+  if(list_model)
+  {
+    Gtk::TreeModel::iterator iter = list_model->prepend();
+    Gtk::TreeModel::Row row = *iter;
+    row[m_text_columns.m_column] = text;
+  }
+}
+
+void ComboBoxEntryText::clear()
+{
+  //Ideally, we would just store the ListStore as a member variable, but we forgot to do that and not it would break the ABI.
+  Glib::RefPtr<Gtk::TreeModel> model = get_model();
+  Glib::RefPtr<Gtk::ListStore> list_model = Glib::RefPtr<ListStore>::cast_dynamic(model);
+  
+  if(list_model)  
+    list_model->clear();
+}
+
+Glib::ustring ComboBoxEntryText::get_active_text() const
+{
+  Glib::ustring result;
+
+  //Get the active row:
+  TreeModel::iterator active_row = get_active();
+  if(active_row)
+  {
+    Gtk::TreeModel::Row row = *active_row;
+    result = row[m_text_columns.m_column];
+  }
+
+  return result;
+}
+
+void ComboBoxEntryText::set_active_text(const Glib::ustring& text)
+{
+  //Look for the row with this text, and activate it:
+  Glib::RefPtr<Gtk::TreeModel> model = get_model();
+  if(model)
+  {
+    for(Gtk::TreeModel::iterator iter = model->children().begin(); iter != model->children().end(); ++iter)
+    {
+      const Glib::ustring& this_text = (*iter)[m_text_columns.m_column];
+
+      if(this_text == text)
+      {
+        set_active(iter);
+        return; //success
+      }
+    }
+  }
+
+  //Not found, so mark it as blank:
+  unset_active();
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/comboboxentrytext.h b/libs/gtkmm2/gtk/gtkmm/comboboxentrytext.h
new file mode 100644
index 0000000000..fe9e6bbdf8
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/comboboxentrytext.h
@@ -0,0 +1,89 @@
+// -*- c++ -*-
+#ifndef _GTKMM_COMBOBOXENTRYTEXT_H
+#define _GTKMM_COMBOBOXENTRYTEXT_H
+
+/* comboboxentrytext.h
+ * 
+ * Copyright (C) 2003 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/comboboxentry.h>
+
+namespace Gtk
+{
+
+//This is a C++ convenience class that is equivalent to the gtk_combo_box_entry_new_text() C convenience function.
+//This is copy/paste/search/replaced from ComboBoxText, but the only alternative I see is to use multiple inheritance.
+//murrayc.
+
+/** This is a specialisation of the ComboBoxEntry which has one column of text (a simple list),
+ * and appropriate methods for setting and getting the text.
+ *
+ * @ingroup Widgets
+ */
+
+class ComboBoxEntryText
+: public ComboBoxEntry
+{
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+private:
+  // noncopyable
+  ComboBoxEntryText(const ComboBoxEntryText&);
+  ComboBoxEntryText& operator=(const ComboBoxEntryText&);
+
+protected:
+  explicit ComboBoxEntryText(const Glib::ConstructParams& construct_params);
+  explicit ComboBoxEntryText(GtkComboBoxEntry* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+  ComboBoxEntryText();
+  
+  void append_text(const Glib::ustring& text);
+  
+  void insert_text(int position, const Glib::ustring& text);
+  
+  void prepend_text(const Glib::ustring& text);
+
+  Glib::ustring get_active_text() const;
+  void set_active_text(const Glib::ustring& text);
+
+  void clear();
+
+protected:
+
+  //Tree model columns:
+  //These columns are used by the model that is created by the default constructor
+  class TextModelColumns : public Gtk::TreeModel::ColumnRecord
+  {
+  public:
+    TextModelColumns()
+    { add(m_column); }
+
+    Gtk::TreeModelColumn<Glib::ustring> m_column;
+  };
+
+  TextModelColumns m_text_columns;
+};
+
+
+} // namespace Gtk
+
+
+#endif /* _GTKMM_COMBOBOXENTRYTEXT_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/comboboxtext.cc b/libs/gtkmm2/gtk/gtkmm/comboboxtext.cc
new file mode 100644
index 0000000000..a9c8d20d5f
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/comboboxtext.cc
@@ -0,0 +1,138 @@
+// -*- c++ -*-
+/* $Id$ */
+
+/* 
+ *
+ * Copyright 2003 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/comboboxtext.h>
+
+#include <gtkmm/liststore.h>
+#include <gtkmm/cellrenderertext.h>
+#include <gtk/gtkcombobox.h>
+#include <gtk/gtkcelllayout.h>
+
+namespace Gtk
+{
+
+ComboBoxText::ComboBoxText()
+{
+  set_model( Gtk::ListStore::create(m_text_columns) );
+  pack_start(m_text_columns.m_column);
+}
+
+ComboBoxText::ComboBoxText(GtkComboBox* castitem)
+: Gtk::ComboBox(castitem)
+{
+  set_model( Gtk::ListStore::create(m_text_columns) );
+  pack_start(m_text_columns.m_column);
+}
+
+
+void ComboBoxText::append_text(const Glib::ustring& text)
+{
+  //We can not use gtk_combo_box_append_text() here, because that can only be used if gtk_combo_box_new_text() has been used.
+
+  //Ideally, we would just store the ListStore as a member variable, but we forgot to do that and not it would break the ABI.
+  Glib::RefPtr<Gtk::TreeModel> model = get_model();
+  Glib::RefPtr<Gtk::ListStore> list_model = Glib::RefPtr<ListStore>::cast_dynamic(model);
+  
+  if(list_model)
+  {
+    Gtk::TreeModel::iterator iter = list_model->append();
+    Gtk::TreeModel::Row row = *iter;
+    row[m_text_columns.m_column] = text;
+  }
+}
+
+void ComboBoxText::insert_text(int position, const Glib::ustring& text)
+{
+  //TODO: We should not use gtk_combo_box_insert_text() here, because that can only be used if gtk_combo_box_new_text() has been used.
+  gtk_combo_box_insert_text(gobj(), position, text.c_str());
+}
+
+void ComboBoxText::prepend_text(const Glib::ustring& text)
+{
+  //We can not use gtk_combo_box_prepend_text() here, because that can only be used if gtk_combo_box_new_text() has been used.
+
+  //Ideally, we would just store the ListStore as a member variable, but we forgot to do that and not it would break the ABI.
+  Glib::RefPtr<Gtk::TreeModel> model = get_model();
+  Glib::RefPtr<Gtk::ListStore> list_model = Glib::RefPtr<ListStore>::cast_dynamic(model);
+  
+  if(list_model)
+  {
+    Gtk::TreeModel::iterator iter = list_model->prepend();
+    Gtk::TreeModel::Row row = *iter;
+    row[m_text_columns.m_column] = text;
+  }
+}
+
+Glib::ustring ComboBoxText::get_active_text() const
+{
+  //We can not use gtk_combobox_get_active_text() here, because that can only be used if gtk_combo_box_new_text() has been used.
+
+  Glib::ustring result;
+
+  //Get the active row:
+  TreeModel::iterator active_row = get_active();
+  if(active_row)
+  {
+    Gtk::TreeModel::Row row = *active_row;
+    result = row[m_text_columns.m_column];
+  }
+
+  return result;
+}
+
+void ComboBoxText::clear()
+{
+  //Ideally, we would just store the ListStore as a member variable, but we forgot to do that and not it would break the ABI.
+  Glib::RefPtr<Gtk::TreeModel> model = get_model();
+  Glib::RefPtr<Gtk::ListStore> list_model = Glib::RefPtr<ListStore>::cast_dynamic(model);
+  
+  if(list_model)  
+    list_model->clear();
+}
+
+void ComboBoxText::set_active_text(const Glib::ustring& text)
+{
+  //Look for the row with this text, and activate it:
+  Glib::RefPtr<Gtk::TreeModel> model = get_model();
+  if(model)
+  {
+    for(Gtk::TreeModel::iterator iter = model->children().begin(); iter != model->children().end(); ++iter)
+    {
+      const Glib::ustring& this_text = (*iter)[m_text_columns.m_column];
+
+      if(this_text == text)
+      {
+        set_active(iter);
+        return; //success
+      }
+    }
+  }
+
+  //Not found, so mark it as blank:
+  unset_active();
+}
+
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/comboboxtext.h b/libs/gtkmm2/gtk/gtkmm/comboboxtext.h
new file mode 100644
index 0000000000..22b87f5f00
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/comboboxtext.h
@@ -0,0 +1,92 @@
+// -*- c++ -*-
+#ifndef _GTKMM_COMBOBOXTEXT_H
+#define _GTKMM_COMBOBOXTEXT_H
+
+/* comboboxtext.h
+ * 
+ * Copyright (C) 2003 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/combobox.h>
+
+namespace Gtk
+{
+
+//This is a C++ convenience class that is equivalent to the gtk_combo_box_new_text() C convenience function.
+
+/** This is a specialisation of the ComboBox which has one column of text (a simple list),
+ * and appropriate methods for setting and getting the text.
+ *
+ * Note that you can not use this class with Gnome::Glade::Xml::get_widget_derived() to wrap a GtkComboBox added 
+ * in the Glade user interface designer, because Glade adds its own TreeModel instead of using the TreeModel from 
+ * this class. You could use a normal Gtk::ComboBox instead, though you can not use Glade to add rows to a TreeModel 
+ * that is defined in your C++ code.
+ *
+ * @ingroup Widgets
+ */
+
+class ComboBoxText
+: public ComboBox
+{
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+private:
+  // noncopyable
+  ComboBoxText(const ComboBoxText&);
+  ComboBoxText& operator=(const ComboBoxText&);
+
+protected:
+  explicit ComboBoxText(const Glib::ConstructParams& construct_params);
+  explicit ComboBoxText(GtkComboBox* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+  ComboBoxText();
+  
+  void append_text(const Glib::ustring& text);
+  
+  void insert_text(int position, const Glib::ustring& text);
+  
+  void prepend_text(const Glib::ustring& text);
+
+  Glib::ustring get_active_text() const;
+  void set_active_text(const Glib::ustring& text);
+
+  void clear();
+
+protected:
+
+  //Tree model columns:
+  //These columns are used by the model that is created by the default constructor
+  class TextModelColumns : public Gtk::TreeModel::ColumnRecord
+  {
+  public:
+    TextModelColumns()
+    { add(m_column); }
+
+    Gtk::TreeModelColumn<Glib::ustring> m_column;
+  };
+
+  TextModelColumns m_text_columns;
+};
+
+
+} // namespace Gtk
+
+
+#endif /* _GTKMM_COMBOBOXTEXT_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/container.cc b/libs/gtkmm2/gtk/gtkmm/container.cc
new file mode 100644
index 0000000000..c3db4bd7ef
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/container.cc
@@ -0,0 +1,945 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/container.h>
+#include <gtkmm/private/container_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/adjustment.h>
+#include <gtk/gtkcontainer.h>
+
+
+namespace
+{
+
+
+void container_foreach_callback(GtkWidget* widget_gobj, void* data)
+{
+  try
+  {
+    Gtk::Container::ForeachSlot& slot = *static_cast<Gtk::Container::ForeachSlot*>(data);
+    Gtk::Widget *const widget = Glib::wrap(widget_gobj);
+
+    g_return_if_fail(widget != 0);
+
+    slot(*widget);
+  }
+  catch(...)
+  {
+    Glib::exception_handlers_invoke();
+  }
+}
+
+} // anonymous namespace
+
+
+namespace Gtk
+{
+
+void Container_Class::remove_callback_custom(GtkContainer* self, GtkWidget* p0)
+{
+  //GTKMM_LIFECYCLE
+
+#ifdef GLIBMM_DEBUG_REFCOUNTING
+  g_warning("Container_Class::remove_callback_custom() C self=%p: C child=%p\n", (void*)self, (void*)p0);
+  g_warning("gtypename self: %s\n, gtypename child: %s", G_OBJECT_TYPE_NAME(G_OBJECT(self)), G_OBJECT_TYPE_NAME(G_OBJECT(p0)));
+#endif
+  
+  //Don't call wrap() on a GTK+ instance whose gtkmm instance has been deleted - just call the original C callback.
+  bool gtkmm_child_already_deleted = Glib::_gobject_cppinstance_already_deleted((GObject*)p0);
+
+  if(!gtkmm_child_already_deleted)
+  {
+    //Call the regular, generated callback:
+    Container_Class::remove_callback(self, p0);
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    //Call the original underlying C function:
+    if(base && base->remove)
+      (*base->remove)(self, p0);
+  }
+}
+
+void Container::foreach(const Container::ForeachSlot& slot)
+{
+  ForeachSlot slot_copy (slot);
+  gtk_container_foreach(gobj(), &container_foreach_callback, &slot_copy);
+}
+
+void  Container::add(Widget& widget)
+{
+  gtk_container_add(gobj(), widget.gobj());
+}
+
+bool Container::has_focus_chain() const
+{
+  return gtk_container_get_focus_chain(const_cast<GtkContainer*>(gobj()), 0);
+}
+
+Glib::ListHandle<Widget*> Container::get_focus_chain()
+{
+  GList* list = 0;
+  gtk_container_get_focus_chain(gobj(), &list);
+
+  return Glib::ListHandle<Widget*>(list, Glib::OWNERSHIP_SHALLOW);
+}
+
+Glib::ListHandle<const Widget*> Container::get_focus_chain() const
+{
+  GList* list = 0;
+  gtk_container_get_focus_chain(const_cast<GtkContainer*>(gobj()), &list);
+
+  return Glib::ListHandle<const Widget*>(list, Glib::OWNERSHIP_SHALLOW);
+}
+
+
+void Container::show_all_children(bool recursive)
+{
+  // Plain C version if this turns out to be performance-critical:
+  //GtkCallback callback = (GtkCallback) ((recursive) ? &gtk_widget_show_all : &gtk_widget_show);
+  //gtk_container_foreach(gobj(), callback, 0);
+
+  // This could also be done with get_children() and an explicit loop,
+  // if any problems should arise.  In gtkmm-1.2, foreach() is known to
+  // cause segfaults eventually, but it seems to work now.
+
+  foreach(sigc::mem_fun((recursive) ? &Widget::show_all : &Widget::show));
+}
+
+void Container::remove(Widget& widget)
+{
+  //If this is a managed widget,
+  //then do an extra ref so that it will
+  //not be destroyed when adding to another container
+  //This should leave it in much the same state as when it was instantiated,
+  //before being added to the first container.
+  if(widget.is_managed_())
+    widget.reference();
+    
+  gtk_container_remove(gobj(), widget.gobj());
+}
+
+// static
+void Container_Class::destroy_callback(GtkObject* self)
+{
+#ifdef GLIBMM_DEBUG_REFCOUNTING
+  g_warning("Container_Class::destroy_callback() gobject_=%10X\n", self);
+  if(self)
+    g_warning("gtypename: %s\n", G_OBJECT_TYPE_NAME(G_OBJECT(self)));
+#endif
+
+  //Call the normal C destroy implementation, such as gtk_button_destroy:
+  //This will chain to gtk_container_destroy(), which will gtk_widget_destroy() any remaining child widgets.
+  GtkObjectClass *const base = static_cast<GtkObjectClass*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)));
+
+  if(base->destroy)
+    (*base->destroy)(self);
+}
+
+} // namespace Gtk
+
+
+namespace
+{
+
+void Container_signal_add_callback(GtkContainer* self, GtkWidget* p0,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,Widget* > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(Glib::wrap(p0)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+}
+
+const Glib::SignalProxyInfo Container_signal_add_info =
+{
+  "add",
+  (GCallback) &Container_signal_add_callback,
+  (GCallback) &Container_signal_add_callback
+};
+
+
+void Container_signal_remove_callback(GtkContainer* self, GtkWidget* p0,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,Widget* > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(Glib::wrap(p0)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+}
+
+const Glib::SignalProxyInfo Container_signal_remove_info =
+{
+  "remove",
+  (GCallback) &Container_signal_remove_callback,
+  (GCallback) &Container_signal_remove_callback
+};
+
+
+const Glib::SignalProxyInfo Container_signal_check_resize_info =
+{
+  "check_resize",
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
+};
+
+
+void Container_signal_set_focus_child_callback(GtkContainer* self, GtkWidget* p0,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,Widget* > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(Glib::wrap(p0)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+}
+
+const Glib::SignalProxyInfo Container_signal_set_focus_child_info =
+{
+  "set_focus_child",
+  (GCallback) &Container_signal_set_focus_child_callback,
+  (GCallback) &Container_signal_set_focus_child_callback
+};
+
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Gtk::Container* wrap(GtkContainer* object, bool take_copy)
+{
+  return dynamic_cast<Gtk::Container *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& Container_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &Container_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_container_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void Container_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+  klass->child_type = &child_type_vfunc_callback;
+  klass->forall = &forall_vfunc_callback;
+  klass->composite_name = &composite_name_vfunc_callback;
+  klass->set_child_property = &set_child_property_vfunc_callback;
+  klass->get_child_property = &get_child_property_vfunc_callback;
+  klass->add = &add_callback;
+  klass->remove = &remove_callback;
+  klass->check_resize = &check_resize_callback;
+  klass->set_focus_child = &set_focus_child_callback;
+    reinterpret_cast<GtkObjectClass*>(klass)->destroy = &destroy_callback;
+      klass->remove = &remove_callback_custom;
+
+    if(G_OBJECT_CLASS_TYPE(klass) == Gtk::Container::get_type())
+    { 
+      //Remove the parent class's (GtkContainer) remove callback - it just prints a warning.
+      //This prevents that warning when people derive directly from Gtk::Container.
+      BaseClassType *const base = static_cast<BaseClassType*>( g_type_class_peek_parent(klass) );
+      base->remove = 0;
+    }
+                
+  }
+
+GtkType Container_Class::child_type_vfunc_callback(GtkContainer* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return obj->child_type_vfunc();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->child_type)
+      return (*base->child_type)(self);
+  }
+
+  typedef GtkType RType;
+  return RType();
+}
+
+void Container_Class::forall_vfunc_callback(GtkContainer* self, gboolean include_internals, GtkCallback callback, gpointer callback_data)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->forall_vfunc(include_internals, callback, callback_data);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->forall)
+      (*base->forall)(self, include_internals, callback, callback_data);
+  }
+}
+
+gchar* Container_Class::composite_name_vfunc_callback(GtkContainer* self, GtkWidget* child)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return obj->composite_name_vfunc(child);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->composite_name)
+      return (*base->composite_name)(self, child);
+  }
+
+  typedef gchar* RType;
+  return RType();
+}
+
+void Container_Class::set_child_property_vfunc_callback(GtkContainer* self, GtkWidget* child, guint property_id, const GValue* value, GParamSpec* pspec)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->set_child_property_vfunc(child, property_id, value, pspec);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->set_child_property)
+      (*base->set_child_property)(self, child, property_id, value, pspec);
+  }
+}
+
+void Container_Class::get_child_property_vfunc_callback(GtkContainer* self, GtkWidget* child, guint property_id, GValue* value, GParamSpec* pspec)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->get_child_property_vfunc(child, property_id, value, pspec);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->get_child_property)
+      (*base->get_child_property)(self, child, property_id, value, pspec);
+  }
+}
+
+
+void Container_Class::add_callback(GtkContainer* self, GtkWidget* p0)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_add(Glib::wrap(p0)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->add)
+      (*base->add)(self, p0);
+  }
+}
+
+void Container_Class::remove_callback(GtkContainer* self, GtkWidget* p0)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_remove(Glib::wrap(p0)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->remove)
+      (*base->remove)(self, p0);
+  }
+}
+
+void Container_Class::check_resize_callback(GtkContainer* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_check_resize();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->check_resize)
+      (*base->check_resize)(self);
+  }
+}
+
+void Container_Class::set_focus_child_callback(GtkContainer* self, GtkWidget* p0)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_set_focus_child(Glib::wrap(p0)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->set_focus_child)
+      (*base->set_focus_child)(self, p0);
+  }
+}
+
+
+Glib::ObjectBase* Container_Class::wrap_new(GObject* o)
+{
+  return manage(new Container((GtkContainer*)(o)));
+
+}
+
+
+/* The implementation: */
+
+Container::Container(const Glib::ConstructParams& construct_params)
+:
+  Gtk::Widget(construct_params)
+{
+  }
+
+Container::Container(GtkContainer* castitem)
+:
+  Gtk::Widget((GtkWidget*)(castitem))
+{
+  }
+
+Container::~Container()
+{
+  destroy_();
+}
+
+Container::CppClassType Container::container_class_; // initialize static member
+
+GType Container::get_type()
+{
+  return container_class_.init().get_type();
+}
+
+GType Container::get_base_type()
+{
+  return gtk_container_get_type();
+}
+
+
+void Container::set_border_width(guint border_width)
+{
+  gtk_container_set_border_width(gobj(), border_width);
+}
+
+guint Container::get_border_width() const
+{
+  return gtk_container_get_border_width(const_cast<GtkContainer*>(gobj()));
+}
+
+void Container::set_resize_mode(ResizeMode resize_mode)
+{
+  gtk_container_set_resize_mode(gobj(), ((GtkResizeMode)(resize_mode)));
+}
+
+ResizeMode Container::get_resize_mode() const
+{
+  return ((ResizeMode)(gtk_container_get_resize_mode(const_cast<GtkContainer*>(gobj()))));
+}
+
+void Container::check_resize()
+{
+  gtk_container_check_resize(gobj());
+}
+
+Glib::ListHandle<Widget*> Container::get_children()
+{
+  return Glib::ListHandle<Widget*>(gtk_container_get_children(gobj()), Glib::OWNERSHIP_SHALLOW);
+}
+
+Glib::ListHandle<const Widget*> Container::get_children() const
+{
+  return Glib::ListHandle<const Widget*>(gtk_container_get_children(const_cast<GtkContainer*>(gobj())), Glib::OWNERSHIP_SHALLOW);
+}
+
+void Container::propagate_expose(Widget& child, GdkEventExpose* event)
+{
+  gtk_container_propagate_expose(gobj(), (child).gobj(), event);
+}
+
+void Container::set_focus_chain(const Glib::ListHandle<Widget*>& focusable_widgets)
+{
+  gtk_container_set_focus_chain(gobj(), focusable_widgets.data());
+}
+
+void Container::unset_focus_chain()
+{
+  gtk_container_unset_focus_chain(gobj());
+}
+
+void Container::set_reallocate_redraws(bool needs_redraws)
+{
+  gtk_container_set_reallocate_redraws(gobj(), static_cast<int>(needs_redraws));
+}
+
+void Container::set_focus_child(Widget& widget)
+{
+  gtk_container_set_focus_child(gobj(), (widget).gobj());
+}
+
+void Container::set_focus_vadjustment(Adjustment& adjustment)
+{
+  gtk_container_set_focus_vadjustment(gobj(), (adjustment).gobj());
+}
+
+Adjustment* Container::get_focus_vadjustment()
+{
+  return Glib::wrap(gtk_container_get_focus_vadjustment(gobj()));
+}
+
+const Adjustment* Container::get_focus_vadjustment() const
+{
+  return Glib::wrap(gtk_container_get_focus_vadjustment(const_cast<GtkContainer*>(gobj())));
+}
+
+void Container::set_focus_hadjustment(Adjustment& adjustment)
+{
+  gtk_container_set_focus_hadjustment(gobj(), (adjustment).gobj());
+}
+
+Adjustment* Container::get_focus_hadjustment()
+{
+  return Glib::wrap(gtk_container_get_focus_hadjustment(gobj()));
+}
+
+const Adjustment* Container::get_focus_hadjustment() const
+{
+  return Glib::wrap(gtk_container_get_focus_hadjustment(const_cast<GtkContainer*>(gobj())));
+}
+
+void Container::resize_children()
+{
+  gtk_container_resize_children(gobj());
+}
+
+GType Container::child_type() const
+{
+  return gtk_container_child_type(const_cast<GtkContainer*>(gobj()));
+}
+
+Container::Container()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Widget(Glib::ConstructParams(container_class_.init()))
+{
+  }
+
+
+Glib::SignalProxy1< void,Widget* > Container::signal_add()
+{
+  return Glib::SignalProxy1< void,Widget* >(this, &Container_signal_add_info);
+}
+
+Glib::SignalProxy1< void,Widget* > Container::signal_remove()
+{
+  return Glib::SignalProxy1< void,Widget* >(this, &Container_signal_remove_info);
+}
+
+Glib::SignalProxy0< void > Container::signal_check_resize()
+{
+  return Glib::SignalProxy0< void >(this, &Container_signal_check_resize_info);
+}
+
+Glib::SignalProxy1< void,Widget* > Container::signal_set_focus_child()
+{
+  return Glib::SignalProxy1< void,Widget* >(this, &Container_signal_set_focus_child_info);
+}
+
+
+Glib::PropertyProxy<guint> Container::property_border_width() 
+{
+  return Glib::PropertyProxy<guint>(this, "border-width");
+}
+
+Glib::PropertyProxy_ReadOnly<guint> Container::property_border_width() const
+{
+  return Glib::PropertyProxy_ReadOnly<guint>(this, "border-width");
+}
+
+Glib::PropertyProxy<ResizeMode> Container::property_resize_mode() 
+{
+  return Glib::PropertyProxy<ResizeMode>(this, "resize-mode");
+}
+
+Glib::PropertyProxy_ReadOnly<ResizeMode> Container::property_resize_mode() const
+{
+  return Glib::PropertyProxy_ReadOnly<ResizeMode>(this, "resize-mode");
+}
+
+Glib::PropertyProxy_WriteOnly<Widget*> Container::property_child() 
+{
+  return Glib::PropertyProxy_WriteOnly<Widget*>(this, "child");
+}
+
+Glib::PropertyProxy_ReadOnly<Widget*> Container::property_child() const
+{
+  return Glib::PropertyProxy_ReadOnly<Widget*>(this, "child");
+}
+
+
+void Gtk::Container::on_add(Widget* widget)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->add)
+    (*base->add)(gobj(),(GtkWidget*)Glib::unwrap(widget));
+}
+
+void Gtk::Container::on_remove(Widget* widget)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->remove)
+    (*base->remove)(gobj(),(GtkWidget*)Glib::unwrap(widget));
+}
+
+void Gtk::Container::on_check_resize()
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->check_resize)
+    (*base->check_resize)(gobj());
+}
+
+void Gtk::Container::on_set_focus_child(Widget* widget)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->set_focus_child)
+    (*base->set_focus_child)(gobj(),(GtkWidget*)Glib::unwrap(widget));
+}
+
+
+GtkType Gtk::Container::child_type_vfunc() const
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->child_type)
+    return (*base->child_type)(const_cast<GtkContainer*>(gobj()));
+
+  typedef GtkType RType;
+  return RType();
+}
+
+void Gtk::Container::forall_vfunc(gboolean include_internals, GtkCallback callback, gpointer callback_data) 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->forall)
+    (*base->forall)(gobj(),include_internals,callback,callback_data);
+}
+
+char* Gtk::Container::composite_name_vfunc(GtkWidget* child) 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->composite_name)
+    return (*base->composite_name)(gobj(),child);
+
+  typedef char* RType;
+  return RType();
+}
+
+void Gtk::Container::set_child_property_vfunc(GtkWidget* child, guint property_id, const GValue* value, GParamSpec* pspec) 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->set_child_property)
+    (*base->set_child_property)(gobj(),child,property_id,value,pspec);
+}
+
+void Gtk::Container::get_child_property_vfunc(GtkWidget* child, guint property_id, GValue* value, GParamSpec* pspec) const
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->get_child_property)
+    (*base->get_child_property)(const_cast<GtkContainer*>(gobj()),child,property_id,value,pspec);
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/container.h b/libs/gtkmm2/gtk/gtkmm/container.h
new file mode 100644
index 0000000000..a555229bbf
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/container.h
@@ -0,0 +1,446 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_CONTAINER_H
+#define _GTKMM_CONTAINER_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* Copyright (C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+ 
+#include <glibmm/listhandle.h>
+#include <gtkmm/widget.h>
+
+
+/** @defgroup Containers Container Widgets
+ * These widgets can be used to group other widgets together.
+ */
+
+/* we'll include gtkfeatures because we dont want to include the whole
+   gtk/gtk.h - this file is used by almost ALL our widgets, so dependencies
+   in minimum - adding things here will increase compile times ALOT */
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkContainer GtkContainer;
+typedef struct _GtkContainerClass GtkContainerClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class Container_Class; } // namespace Gtk
+namespace Gtk
+{
+
+class Adjustment;
+class Label;
+
+/** Abstract container class
+ *
+ * This is the abstract container from which all gtk+ widgets which hold
+ * other items derive from.  It mainly houses virtual functions
+ * used for inserting and removing children.  Containers in gtk+
+ * may hold one item or many items depending on the implementation.
+ *
+ * This interface is used for all single item holding containers.
+ * Multi-item containers provide their own unique interface as their
+ * items are generally more complex.  The methods of the derived
+ * classes should be prefered over these.
+ *
+ * @ingroup Widgets
+ */
+
+class Container : public Widget
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Container CppObjectType;
+  typedef Container_Class CppClassType;
+  typedef GtkContainer BaseObjectType;
+  typedef GtkContainerClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~Container();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class Container_Class;
+  static CppClassType container_class_;
+
+  // noncopyable
+  Container(const Container&);
+  Container& operator=(const Container&);
+
+protected:
+  explicit Container(const Glib::ConstructParams& construct_params);
+  explicit Container(GtkContainer* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GtkContainer*       gobj()       { return reinterpret_cast<GtkContainer*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GtkContainer* gobj() const { return reinterpret_cast<GtkContainer*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+  virtual void on_add(Widget* widget);
+  virtual void on_remove(Widget* widget);
+  virtual void on_check_resize();
+  virtual void on_set_focus_child(Widget* widget);
+
+
+private:
+
+  
+public:
+
+/* Application-level methods */
+
+  
+  /** Sets the border width of the container.
+   * 
+   * The border width of a container is the amount of space to leave
+   * around the outside of the container. The only exception to this is
+   * Gtk::Window; because toplevel windows can't leave space outside,
+   * they leave the space inside. The border is added on all sides of
+   * the container. To add space to only one side, one approach is to
+   * create a Gtk::Alignment widget, call Gtk::Widget::set_usize() to give
+   * it a size, and place it on the side of the container as a spacer.
+   * @param border_width Amount of blank space to leave <em>outside</em> the container.
+   * Valid values are in the range 0-65535 pixels.
+   */
+  void set_border_width(guint border_width);
+
+  
+  /** Retrieves the border width of the container. See
+   * set_border_width().
+   * @return The current border width.
+   */
+  guint get_border_width() const;
+
+  //This is virtual so that we can override it in Gtk::ScrolledWindow:
+ virtual void add(Widget& widget);
+  
+
+  /** Removes @a widget  from @a container . @a widget  must be inside @a container .
+   * Note that @a container  will own a reference to @a widget , and that this
+   * may be the last reference held; so removing a widget from its
+   * container can destroy that widget. If you want to use @a widget 
+   * again, you need to add a reference to it while it's not inside
+   * a container, using Glib::object_ref(). If you don't want to use @a widget 
+   * again it's usually more efficient to simply destroy it directly
+   * using Gtk::Widget::destroy() since this will remove it from the
+   * container and help break any circular reference count cycles.
+   * @param widget A current child of @a container .
+   */
+
+  void remove(Widget& widget);
+  
+
+  /** Sets the resize mode for the container.
+   * 
+   * The resize mode of a container determines whether a resize request 
+   * will be passed to the container's parent, queued for later execution
+   * or executed immediately.
+   * @param resize_mode The new resize mode.
+   */
+  void set_resize_mode(ResizeMode resize_mode);
+
+  
+  /** Returns the resize mode for the container. See
+   * set_resize_mode().
+   * @return The current resize mode.
+   */
+  ResizeMode get_resize_mode() const;
+
+  /// Request that contained widgets check their size
+  
+  void check_resize();
+
+  /** For instance, 
+   * void on_foreach(Gtk::Widget* widget);
+   */
+  typedef sigc::slot<void, Widget&> ForeachSlot;
+
+  /** Operate on contained items
+   * This is largely an internal used mainly for things like
+   * creating duplicates of internal lists and other such
+   * operations.  The result is lossy as it only gets the
+   * the main child and not its external pieces.
+   *
+   * For example notebook pages contain a page, a label, and
+   * a menu item.  But this only operates on the pages.
+   */
+  void foreach(const ForeachSlot& slot);
+
+  /// (internal) Operate on contained items (see foreach())
+  //_WRAP_METHOD(void foreach_(GtkCallback callback,gpointer data),gtk_container_foreach)
+
+  /// (internal) Operate on contained items (see foreach())
+  //_WRAP_METHOD(void foreach_full_(GtkCallback callback,GtkCallbackMarshal marshal, gpointer data,GtkDestroyNotify notify),gtk_container_foreach_full)
+
+  
+  /** Returns the the container's non-internal children. See
+   * forall() for details on what constitutes an "internal" child.
+   * @return A newly-allocated list of the container's non-internal children.
+   */
+  Glib::ListHandle<Widget*> get_children();
+  
+  /** Returns the the container's non-internal children. See
+   * forall() for details on what constitutes an "internal" child.
+   * @return A newly-allocated list of the container's non-internal children.
+   */
+  Glib::ListHandle<const Widget*> get_children() const;
+
+  
+  /** When a container receives an expose event, it must send synthetic
+   * expose events to all children that don't have their own Gdk::Windows.
+   * This function provides a convenient way of doing this. A container,
+   * when it receives an expose event, calls propagate_expose() 
+   * once for each child, passing in the event the container received.
+   * 
+   * propagate_expose() takes care of deciding whether
+   * an expose event needs to be sent to the child, intersecting
+   * the event's area with the child area, and sending the event.
+   * 
+   * In most cases, a container can simply either simply inherit the
+   * ::expose implementation from Gtk::Container, or, do some drawing 
+   * and then chain to the ::expose implementation from Gtk::Container.
+   * @param child A child of @a container .
+   * @param event A expose event sent to container.
+   */
+  void propagate_expose(Widget& child, GdkEventExpose* event);
+
+  
+  /** Sets a focus chain, overriding the one computed automatically by GTK+.
+   * 
+   * In principle each widget in the chain should be a descendant of the 
+   * container, but this is not enforced by this method, since it's allowed 
+   * to set the focus chain before you pack the widgets, or have a widget 
+   * in the chain that isn't always packed. The necessary checks are done 
+   * when the focus chain is actually traversed.
+   * @param focusable_widgets The new focus chain.
+   */
+  void set_focus_chain(const Glib::ListHandle<Widget*>& focusable_widgets);
+
+  // gtk_container_get_focus_chain() has been split up into two
+  // functions in order to make implicit container conversion possible.
+  bool has_focus_chain() const;
+  Glib::ListHandle<Widget*> get_focus_chain();
+  Glib::ListHandle<const Widget*> get_focus_chain() const;
+
+  
+  /** Removes a focus chain explicitly set with set_focus_chain().
+   */
+  void unset_focus_chain();
+
+
+/* Widget-level methods */
+
+  
+  /** Sets the @a reallocate_redraws  flag of the container to the given value.
+   * 
+   * Containers requesting reallocation redraws get automatically
+   * redrawn if any of their children changed allocation.
+   * @param needs_redraws The new value for the container's @a reallocate_redraws  flag.
+   */
+  void set_reallocate_redraws(bool needs_redraws = true);
+
+  /// Sets the focus on a child
+  
+  void set_focus_child(Widget& widget);
+
+  
+  /** Hooks up an adjustment to focus handling in a container, so when a child of the 
+   * container is focused, the adjustment is scrolled to show that widget. This function
+   * sets the vertical alignment. See Gtk::ScrolledWindow::get_vadjustment() for a typical
+   * way of obtaining the adjustment and set_focus_hadjustment() for setting
+   * the horizontal adjustment.
+   * 
+   * The adjustments have to be in pixel units and in the same coordinate system as the 
+   * allocation for immediate children of the container.
+   * @param adjustment An adjustment which should be adjusted when the focus is moved among the
+   * descendents of @a container .
+   */
+  void set_focus_vadjustment(Adjustment& adjustment);
+
+  
+  /** Retrieves the vertical focus adjustment for the container. See
+   * set_focus_vadjustment().
+   * @return The vertical focus adjustment, or <tt>0</tt> if
+   * none has been set.
+   */
+  Adjustment* get_focus_vadjustment();
+  
+  /** Retrieves the vertical focus adjustment for the container. See
+   * set_focus_vadjustment().
+   * @return The vertical focus adjustment, or <tt>0</tt> if
+   * none has been set.
+   */
+  const Adjustment* get_focus_vadjustment() const;
+
+  
+  /** Hooks up an adjustment to focus handling in a container, so when a child of the 
+   * container is focused, the adjustment is scrolled to show that widget. This function
+   * sets the horizontal alignment. See Gtk::ScrolledWindow::get_hadjustment() for a typical
+   * way of obtaining the adjustment and set_focus_vadjustment() for setting
+   * the vertical adjustment.
+   * 
+   * The adjustments have to be in pixel units and in the same coordinate system as the 
+   * allocation for immediate children of the container.
+   * @param adjustment An adjustment which should be adjusted when the focus is moved among the
+   * descendents of @a container .
+   */
+  void set_focus_hadjustment(Adjustment& adjustment);
+
+  
+  /** Retrieves the horizontal focus adjustment for the container. See
+   * set_focus_hadjustment().
+   * @return The horizontal focus adjustment, or <tt>0</tt> if
+   * none has been set.
+   */
+  Adjustment* get_focus_hadjustment();
+  
+  /** Retrieves the horizontal focus adjustment for the container. See
+   * set_focus_hadjustment().
+   * @return The horizontal focus adjustment, or <tt>0</tt> if
+   * none has been set.
+   */
+  const Adjustment* get_focus_hadjustment() const;
+
+
+  void resize_children();
+  
+  
+  /** Returns the type of the children supported by the container.
+   * 
+   * Note that this may return G::TYPE_NONE to indicate that no more
+   * children can be added, e.g. for a Gtk::Paned which already has two 
+   * children.
+   * @return A G::Type.
+   */
+  GType child_type() const;
+
+  // Ignore functions such as gtk_container_class_install_child_property(),  which I think are for themes, like the GtkWidget style properties.
+  
+
+  Glib::SignalProxy1< void,Widget* > signal_add();
+
+  
+  Glib::SignalProxy1< void,Widget* > signal_remove();
+
+  
+  Glib::SignalProxy0< void > signal_check_resize();
+
+  
+  Glib::SignalProxy1< void,Widget* > signal_set_focus_child();
+
+
+  void show_all_children(bool recursive = true); 
+
+protected:
+  Container();
+
+    virtual GtkType child_type_vfunc() const;
+    virtual void forall_vfunc(gboolean include_internals, GtkCallback callback, gpointer callback_data);
+  //TODO: What is this?
+    virtual char* composite_name_vfunc(GtkWidget* child);
+    virtual void set_child_property_vfunc(GtkWidget* child, guint property_id, const GValue* value, GParamSpec* pspec);
+    virtual void get_child_property_vfunc(GtkWidget* child, guint property_id, GValue* value, GParamSpec* pspec) const;
+
+  /** The width of the empty border outside the containers children.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<guint> property_border_width() ;
+
+/** The width of the empty border outside the containers children.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<guint> property_border_width() const;
+
+  /** Specify how resize events are handled.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<ResizeMode> property_resize_mode() ;
+
+/** Specify how resize events are handled.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<ResizeMode> property_resize_mode() const;
+
+  /** Can be used to add a new child to the container.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_WriteOnly<Widget*> property_child() ;
+
+/** Can be used to add a new child to the container.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Widget*> property_child() const;
+
+
+};
+
+} // namespace Gtk
+
+
+namespace Glib
+{
+  /** @relates Gtk::Container
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gtk::Container* wrap(GtkContainer* object, bool take_copy = false);
+}
+#endif /* _GTKMM_CONTAINER_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/curve.cc b/libs/gtkmm2/gtk/gtkmm/curve.cc
new file mode 100644
index 0000000000..ed6b949ea3
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/curve.cc
@@ -0,0 +1,378 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/curve.h>
+#include <gtkmm/private/curve_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* 
+ *
+ * Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtk/gtkcurve.h>
+#include <gtk/gtkgamma.h>
+
+namespace Gtk
+{
+
+Glib::ArrayHandle<float> Curve::get_vector(int veclen) const
+{
+  float *const pdata = static_cast<float*>(g_malloc(veclen * sizeof(float)));
+  gtk_curve_get_vector(const_cast<GtkCurve*>(gobj()), veclen, pdata);
+
+  return Glib::ArrayHandle<float>(pdata, veclen, Glib::OWNERSHIP_SHALLOW);
+}
+
+void Curve::set_vector(const Glib::ArrayHandle<float>& array)
+{
+  gtk_curve_set_vector(gobj(), array.size(), const_cast<float*>(array.data()));
+}
+
+} /* namespace Gtk */
+
+
+namespace
+{
+
+const Glib::SignalProxyInfo Curve_signal_curve_type_changed_info =
+{
+  "curve_type_changed",
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
+};
+
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Gtk::Curve* wrap(GtkCurve* object, bool take_copy)
+{
+  return dynamic_cast<Gtk::Curve *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& Curve_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &Curve_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_curve_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void Curve_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+  klass->curve_type_changed = &curve_type_changed_callback;
+}
+
+
+void Curve_Class::curve_type_changed_callback(GtkCurve* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_curve_type_changed();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->curve_type_changed)
+      (*base->curve_type_changed)(self);
+  }
+}
+
+
+Glib::ObjectBase* Curve_Class::wrap_new(GObject* o)
+{
+  return manage(new Curve((GtkCurve*)(o)));
+
+}
+
+
+/* The implementation: */
+
+Curve::Curve(const Glib::ConstructParams& construct_params)
+:
+  Gtk::DrawingArea(construct_params)
+{
+  }
+
+Curve::Curve(GtkCurve* castitem)
+:
+  Gtk::DrawingArea((GtkDrawingArea*)(castitem))
+{
+  }
+
+Curve::~Curve()
+{
+  destroy_();
+}
+
+Curve::CppClassType Curve::curve_class_; // initialize static member
+
+GType Curve::get_type()
+{
+  return curve_class_.init().get_type();
+}
+
+GType Curve::get_base_type()
+{
+  return gtk_curve_get_type();
+}
+
+
+Curve::Curve()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::DrawingArea(Glib::ConstructParams(curve_class_.init()))
+{
+  }
+
+void Curve::reset()
+{
+  gtk_curve_reset(gobj());
+}
+
+void Curve::set_gamma(float gamma)
+{
+  gtk_curve_set_gamma(gobj(), gamma);
+}
+
+void Curve::set_range(float min_x, float max_x, float min_y, float max_y)
+{
+  gtk_curve_set_range(gobj(), min_x, max_x, min_y, max_y);
+}
+
+void Curve::get_vector(int veclen, float* data) const
+{
+  gtk_curve_get_vector(const_cast<GtkCurve*>(gobj()), veclen, data);
+}
+
+void Curve::set_curve_type(CurveType type)
+{
+  gtk_curve_set_curve_type(gobj(), ((GtkCurveType)(type)));
+}
+
+
+Glib::SignalProxy0< void > Curve::signal_curve_type_changed()
+{
+  return Glib::SignalProxy0< void >(this, &Curve_signal_curve_type_changed_info);
+}
+
+
+Glib::PropertyProxy<CurveType> Curve::property_curve_type() 
+{
+  return Glib::PropertyProxy<CurveType>(this, "curve-type");
+}
+
+Glib::PropertyProxy_ReadOnly<CurveType> Curve::property_curve_type() const
+{
+  return Glib::PropertyProxy_ReadOnly<CurveType>(this, "curve-type");
+}
+
+Glib::PropertyProxy<float> Curve::property_min_x() 
+{
+  return Glib::PropertyProxy<float>(this, "min-x");
+}
+
+Glib::PropertyProxy_ReadOnly<float> Curve::property_min_x() const
+{
+  return Glib::PropertyProxy_ReadOnly<float>(this, "min-x");
+}
+
+Glib::PropertyProxy<float> Curve::property_max_x() 
+{
+  return Glib::PropertyProxy<float>(this, "max-x");
+}
+
+Glib::PropertyProxy_ReadOnly<float> Curve::property_max_x() const
+{
+  return Glib::PropertyProxy_ReadOnly<float>(this, "max-x");
+}
+
+Glib::PropertyProxy<float> Curve::property_min_y() 
+{
+  return Glib::PropertyProxy<float>(this, "min-y");
+}
+
+Glib::PropertyProxy_ReadOnly<float> Curve::property_min_y() const
+{
+  return Glib::PropertyProxy_ReadOnly<float>(this, "min-y");
+}
+
+Glib::PropertyProxy<float> Curve::property_max_y() 
+{
+  return Glib::PropertyProxy<float>(this, "max-y");
+}
+
+Glib::PropertyProxy_ReadOnly<float> Curve::property_max_y() const
+{
+  return Glib::PropertyProxy_ReadOnly<float>(this, "max-y");
+}
+
+
+void Gtk::Curve::on_curve_type_changed()
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->curve_type_changed)
+    (*base->curve_type_changed)(gobj());
+}
+
+
+} // namespace Gtk
+
+
+namespace Glib
+{
+
+Gtk::GammaCurve* wrap(GtkGammaCurve* object, bool take_copy)
+{
+  return dynamic_cast<Gtk::GammaCurve *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& GammaCurve_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &GammaCurve_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_gamma_curve_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void GammaCurve_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+}
+
+
+Glib::ObjectBase* GammaCurve_Class::wrap_new(GObject* o)
+{
+  return manage(new GammaCurve((GtkGammaCurve*)(o)));
+
+}
+
+
+/* The implementation: */
+
+GammaCurve::GammaCurve(const Glib::ConstructParams& construct_params)
+:
+  Gtk::VBox(construct_params)
+{
+  }
+
+GammaCurve::GammaCurve(GtkGammaCurve* castitem)
+:
+  Gtk::VBox((GtkVBox*)(castitem))
+{
+  }
+
+GammaCurve::~GammaCurve()
+{
+  destroy_();
+}
+
+GammaCurve::CppClassType GammaCurve::gammacurve_class_; // initialize static member
+
+GType GammaCurve::get_type()
+{
+  return gammacurve_class_.init().get_type();
+}
+
+GType GammaCurve::get_base_type()
+{
+  return gtk_gamma_curve_get_type();
+}
+
+GammaCurve::GammaCurve()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::VBox(Glib::ConstructParams(gammacurve_class_.init()))
+{
+  }
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/curve.h b/libs/gtkmm2/gtk/gtkmm/curve.h
new file mode 100644
index 0000000000..eaddc1116b
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/curve.h
@@ -0,0 +1,303 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_CURVE_H
+#define _GTKMM_CURVE_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* curve.h
+ * 
+ * Copyright (C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <glibmm/arrayhandle.h>
+#include <gtkmm/box.h>
+#include <gtkmm/drawingarea.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkCurve GtkCurve;
+typedef struct _GtkCurveClass GtkCurveClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class Curve_Class; } // namespace Gtk
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkGammaCurve GtkGammaCurve;
+typedef struct _GtkGammaCurveClass GtkGammaCurveClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class GammaCurve_Class; } // namespace Gtk
+namespace Gtk
+{
+
+/** Allows direct editing of a curve.
+ *
+ * @ingroup Widgets
+ */
+
+class Curve : public DrawingArea
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Curve CppObjectType;
+  typedef Curve_Class CppClassType;
+  typedef GtkCurve BaseObjectType;
+  typedef GtkCurveClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~Curve();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class Curve_Class;
+  static CppClassType curve_class_;
+
+  // noncopyable
+  Curve(const Curve&);
+  Curve& operator=(const Curve&);
+
+protected:
+  explicit Curve(const Glib::ConstructParams& construct_params);
+  explicit Curve(GtkCurve* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GtkCurve*       gobj()       { return reinterpret_cast<GtkCurve*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GtkCurve* gobj() const { return reinterpret_cast<GtkCurve*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+  virtual void on_curve_type_changed();
+
+
+private:
+
+  
+public:
+
+  Curve();
+  
+
+  void reset();
+  
+  void set_gamma(float gamma);
+  
+  void set_range(float min_x, float max_x, float min_y, float max_y);
+  
+  void get_vector(int veclen, float* data) const;
+
+  Glib::ArrayHandle<float> get_vector(int veclen) const;
+  void set_vector(const Glib::ArrayHandle<float>& array);
+
+  
+  void set_curve_type(CurveType type);
+
+  
+  Glib::SignalProxy0< void > signal_curve_type_changed();
+
+
+  /** Is this curve linear
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<CurveType> property_curve_type() ;
+
+/** Is this curve linear
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<CurveType> property_curve_type() const;
+
+  /** Minimum possible value for X.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<float> property_min_x() ;
+
+/** Minimum possible value for X.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<float> property_min_x() const;
+
+  /** Maximum possible X value.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<float> property_max_x() ;
+
+/** Maximum possible X value.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<float> property_max_x() const;
+
+  /** Minimum possible value for Y.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<float> property_min_y() ;
+
+/** Minimum possible value for Y.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<float> property_min_y() const;
+
+  /** Maximum possible value for Y.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<float> property_max_y() ;
+
+/** Maximum possible value for Y.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<float> property_max_y() const;
+
+
+};
+
+/** A subclass of Gtk::Curve for editing gamma curves.
+ *
+ * @ingroup Widgets
+ */
+
+class GammaCurve : public VBox
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef GammaCurve CppObjectType;
+  typedef GammaCurve_Class CppClassType;
+  typedef GtkGammaCurve BaseObjectType;
+  typedef GtkGammaCurveClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~GammaCurve();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class GammaCurve_Class;
+  static CppClassType gammacurve_class_;
+
+  // noncopyable
+  GammaCurve(const GammaCurve&);
+  GammaCurve& operator=(const GammaCurve&);
+
+protected:
+  explicit GammaCurve(const Glib::ConstructParams& construct_params);
+  explicit GammaCurve(GtkGammaCurve* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GtkGammaCurve*       gobj()       { return reinterpret_cast<GtkGammaCurve*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GtkGammaCurve* gobj() const { return reinterpret_cast<GtkGammaCurve*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+private:
+
+public:
+  GammaCurve();
+  
+
+};
+
+} /* namespace Gtk */
+
+
+namespace Glib
+{
+  /** @relates Gtk::Curve
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gtk::Curve* wrap(GtkCurve* object, bool take_copy = false);
+}
+namespace Glib
+{
+  /** @relates Gtk::GammaCurve
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gtk::GammaCurve* wrap(GtkGammaCurve* object, bool take_copy = false);
+}
+#endif /* _GTKMM_CURVE_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/dialog.cc b/libs/gtkmm2/gtk/gtkmm/dialog.cc
new file mode 100644
index 0000000000..b55b84f645
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/dialog.cc
@@ -0,0 +1,331 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/dialog.h>
+#include <gtkmm/private/dialog_p.h>
+
+#include <gtk/gtktypebuiltins.h>
+// -*- c++ -*-
+/* $Id$ */
+
+/* Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtk/gtkdialog.h>
+
+namespace Gtk
+{
+
+Dialog::Dialog(const Glib::ustring& title, Gtk::Window& parent, bool modal, bool use_separator)
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Window(Glib::ConstructParams(dialog_class_.init(), "title",title.c_str(), (char*) 0))
+{
+  construct_(modal, use_separator);
+  set_transient_for(parent);
+}
+
+Dialog::Dialog(const Glib::ustring& title, bool modal, bool use_separator)
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Window(Glib::ConstructParams(dialog_class_.init(), "title",title.c_str(), (char*) 0))
+{
+  construct_(modal, use_separator);
+}
+
+void Dialog::construct_(bool modal, bool use_separator)
+{
+  set_modal(modal);
+  set_has_separator(use_separator);
+}
+
+void Dialog::set_alternative_button_order_from_array(const Glib::ArrayHandle<int>& new_order)
+{
+  gtk_dialog_set_alternative_button_order_from_array(gobj(), new_order.size(), const_cast<int*>(new_order.data()));
+}
+
+} // namespace Gtk
+
+
+namespace
+{
+
+void Dialog_signal_response_callback(GtkDialog* self, gint p0,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,int > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(p0
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+}
+
+const Glib::SignalProxyInfo Dialog_signal_response_info =
+{
+  "response",
+  (GCallback) &Dialog_signal_response_callback,
+  (GCallback) &Dialog_signal_response_callback
+};
+
+} // anonymous namespace
+
+// static
+GType Glib::Value<Gtk::ResponseType>::value_type()
+{
+  return gtk_response_type_get_type();
+}
+
+
+namespace Glib
+{
+
+Gtk::Dialog* wrap(GtkDialog* object, bool take_copy)
+{
+  return dynamic_cast<Gtk::Dialog *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& Dialog_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &Dialog_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_dialog_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void Dialog_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+  klass->response = &response_callback;
+}
+
+
+void Dialog_Class::response_callback(GtkDialog* self, gint p0)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_response(p0
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->response)
+      (*base->response)(self, p0);
+  }
+}
+
+
+Glib::ObjectBase* Dialog_Class::wrap_new(GObject* o)
+{
+  return new Dialog((GtkDialog*)(o)); //top-level windows can not be manage()ed.
+
+}
+
+
+/* The implementation: */
+
+Dialog::Dialog(const Glib::ConstructParams& construct_params)
+:
+  Gtk::Window(construct_params)
+{
+  }
+
+Dialog::Dialog(GtkDialog* castitem)
+:
+  Gtk::Window((GtkWindow*)(castitem))
+{
+  }
+
+Dialog::~Dialog()
+{
+  destroy_();
+}
+
+Dialog::CppClassType Dialog::dialog_class_; // initialize static member
+
+GType Dialog::get_type()
+{
+  return dialog_class_.init().get_type();
+}
+
+GType Dialog::get_base_type()
+{
+  return gtk_dialog_get_type();
+}
+
+
+Dialog::Dialog()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Window(Glib::ConstructParams(dialog_class_.init()))
+{
+  }
+
+void Dialog::add_action_widget(Widget& child, int response_id)
+{
+  gtk_dialog_add_action_widget(gobj(), (child).gobj(), response_id);
+}
+
+Button* Dialog::add_button(const Glib::ustring& button_text, int response_id)
+{
+  return Glib::wrap((GtkButton*)(gtk_dialog_add_button(gobj(), button_text.c_str(), response_id)));
+}
+
+Button* Dialog::add_button(const Gtk::StockID& stock_id, int response_id)
+{
+  return Glib::wrap((GtkButton*)(gtk_dialog_add_button(gobj(), (stock_id).get_c_str(), response_id)));
+}
+
+void Dialog::set_response_sensitive(int response_id, bool setting)
+{
+  gtk_dialog_set_response_sensitive(gobj(), response_id, static_cast<int>(setting));
+}
+
+void Dialog::set_default_response(int response_id)
+{
+  gtk_dialog_set_default_response(gobj(), response_id);
+}
+
+void Dialog::set_has_separator(bool setting)
+{
+  gtk_dialog_set_has_separator(gobj(), static_cast<int>(setting));
+}
+
+bool Dialog::get_has_separator() const
+{
+  return gtk_dialog_get_has_separator(const_cast<GtkDialog*>(gobj()));
+}
+
+bool Dialog::alternative_button_order(const Glib::RefPtr<const Gdk::Screen>& screen)
+{
+  return gtk_alternative_dialog_button_order(const_cast<GdkScreen*>(Glib::unwrap<Gdk::Screen>(screen)));
+}
+
+void Dialog::response(int response_id)
+{
+  gtk_dialog_response(gobj(), response_id);
+}
+
+int Dialog::run()
+{
+  return gtk_dialog_run(gobj());
+}
+
+VBox* Dialog::get_vbox()
+{
+  return Glib::wrap((GtkVBox*)(gobj()->vbox));
+}
+
+const VBox* Dialog::get_vbox() const
+{
+  return Glib::wrap((GtkVBox*)(gobj()->vbox));
+}
+
+HButtonBox* Dialog::get_action_area()
+{
+  return Glib::wrap((GtkHButtonBox*)(gobj()->action_area));
+}
+
+const HButtonBox* Dialog::get_action_area() const
+{
+  return Glib::wrap((GtkHButtonBox*)(gobj()->action_area));
+}
+
+
+Glib::SignalProxy1< void,int > Dialog::signal_response()
+{
+  return Glib::SignalProxy1< void,int >(this, &Dialog_signal_response_info);
+}
+
+
+Glib::PropertyProxy<bool> Dialog::property_has_separator() 
+{
+  return Glib::PropertyProxy<bool>(this, "has-separator");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> Dialog::property_has_separator() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "has-separator");
+}
+
+
+void Gtk::Dialog::on_response(int response_id)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->response)
+    (*base->response)(gobj(),response_id);
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/dialog.h b/libs/gtkmm2/gtk/gtkmm/dialog.h
new file mode 100644
index 0000000000..2b4ae3f461
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/dialog.h
@@ -0,0 +1,346 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_DIALOG_H
+#define _GTKMM_DIALOG_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* dialog.h
+ * 
+ * Copyright (C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/window.h>
+#include <gtkmm/box.h>
+#include <gtkmm/button.h>
+#include <gtkmm/buttonbox.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkDialog GtkDialog;
+typedef struct _GtkDialogClass GtkDialogClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class Dialog_Class; } // namespace Gtk
+namespace Gtk
+{
+
+/** @defgroup Dialogs Dialogs
+ */
+
+
+/** @addtogroup gtkmmEnums Enums and Flags */
+
+/**
+ * @ingroup gtkmmEnums
+ */
+enum ResponseType
+{
+  RESPONSE_NONE = -1,
+  RESPONSE_REJECT = -2,
+  RESPONSE_ACCEPT = -3,
+  RESPONSE_DELETE_EVENT = -4,
+  RESPONSE_OK = -5,
+  RESPONSE_CANCEL = -6,
+  RESPONSE_CLOSE = -7,
+  RESPONSE_YES = -8,
+  RESPONSE_NO = -9,
+  RESPONSE_APPLY = -10,
+  RESPONSE_HELP = -11
+};
+
+} // namespace Gtk
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Gtk::ResponseType> : public Glib::Value_Enum<Gtk::ResponseType>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{
+
+
+/** Create popup windows.
+ *
+ * Dialog boxes are a convenient way to prompt the user for a small amount
+ * of input, eg. to display a message, ask a question, or anything else that
+ * does not require extensive effort on the user's part. 
+ *
+ * gtkmm treats a dialog as a window split vertically. The top section is a
+ * Gtk::VBox, and is where widgets such as a Gtk::Label or a Gtk::Entry should be
+ * packed. The bottom area is known as the action_area. This is generally
+ * used for packing buttons into the dialog which may perform functions such
+ * as cancel, ok, or apply. The two areas are separated by a Gtk::HSeparator. 
+ *
+ * The dialog can be 'modal' (that is, one which freezes the rest of the
+ * application from user input) - this can be specified in the Gtk::Dialog
+ * constructor.
+ *
+ * When adding buttons using add_button(), clicking the button will emit
+ * signal_response() with a "response id" you specified. You are encouraged
+ * to use the Gtk::ResponseType enum. If a dialog receives a delete event,
+ * the "response" signal will be emitted with a response id of
+ * Gtk::RESPONSE_NONE.
+ *
+ * If you want to block waiting for a dialog to return before returning control
+ * flow to your code, you can call run(). This function enters a
+ * recursive main loop and waits for the user to respond to the dialog, returning
+ * the response ID corresponding to the button the user clicked. 
+ *
+ * @ingroup Dialogs
+ */
+
+class Dialog : public Window
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Dialog CppObjectType;
+  typedef Dialog_Class CppClassType;
+  typedef GtkDialog BaseObjectType;
+  typedef GtkDialogClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~Dialog();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class Dialog_Class;
+  static CppClassType dialog_class_;
+
+  // noncopyable
+  Dialog(const Dialog&);
+  Dialog& operator=(const Dialog&);
+
+protected:
+  explicit Dialog(const Glib::ConstructParams& construct_params);
+  explicit Dialog(GtkDialog* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GtkDialog*       gobj()       { return reinterpret_cast<GtkDialog*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GtkDialog* gobj() const { return reinterpret_cast<GtkDialog*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+  virtual void on_response(int response_id);
+
+
+private:
+
+  
+public:
+  Dialog();
+  explicit Dialog(const Glib::ustring& title, bool modal = false, bool use_separator = false);
+  Dialog(const Glib::ustring& title, Gtk::Window& parent, bool modal = false, bool use_separator = false);
+
+  
+  /** Adds an activatable widget to the action area of a Gtk::Dialog,
+   * connecting a signal handler that will emit the "response" signal on
+   * the dialog when the widget is activated.  The widget is appended to
+   * the end of the dialog's action area.  If you want to add a
+   * non-activatable widget, simply pack it into the
+   * <tt>action_area</tt> field of the Gtk::Dialog struct.
+   * @param child An activatable widget.
+   * @param response_id Response ID for @a child .
+   */
+  void add_action_widget(Widget& child, int response_id);
+  
+  /** Adds a button with the given text (or a stock button, if @a button_text  is a
+   * stock ID) and sets things up so that clicking the button will emit the
+   * "response" signal with the given @a response_id . The button is appended to the
+   * end of the dialog's action area. The button widget is returned, but usually
+   * you don't need it.
+   * @param button_text Text of button, or stock ID.
+   * @param response_id Response ID for the button.
+   * @return The button widget that was added.
+   */
+  Button* add_button(const Glib::ustring& button_text, int response_id);
+  
+  /** Adds a button with the given text (or a stock button, if @a button_text  is a
+   * stock ID) and sets things up so that clicking the button will emit the
+   * "response" signal with the given @a response_id . The button is appended to the
+   * end of the dialog's action area. The button widget is returned, but usually
+   * you don't need it.
+   * @param button_text Text of button, or stock ID.
+   * @param response_id Response ID for the button.
+   * @return The button widget that was added.
+   */
+  Button* add_button(const Gtk::StockID& stock_id, int response_id);
+  
+  /** Calls <tt>gtk_widget_set_sensitive (widget, @a setting )</tt> 
+   * for each widget in the dialog's action area with the given @a response_id .
+   * A convenient way to sensitize/desensitize dialog buttons.
+   * @param response_id A response ID.
+   * @param setting <tt>true</tt> for sensitive.
+   */
+  void set_response_sensitive(int response_id, bool setting = true);
+  
+  /** Sets the last widget in the dialog's action area with the given @a response_id 
+   * as the default widget for the dialog. Pressing "Enter" normally activates
+   * the default widget.
+   * @param response_id A response ID.
+   */
+  void set_default_response(int response_id);
+  
+  /** Sets whether the dialog has a separator above the buttons.
+   * <tt>true</tt> by default.
+   * @param setting <tt>true</tt> to have a separator.
+   */
+  void set_has_separator(bool setting = true);
+  
+  /** Accessor for whether the dialog has a separator.
+   * @return <tt>true</tt> if the dialog has a separator.
+   */
+  bool get_has_separator() const;
+  
+  
+  /** Returns <tt>true</tt> if dialogs are expected to use an alternative
+   * button order on the screen @a screen . See 
+   * Gtk::Dialog::set_alternative_button_order() for more details
+   * about alternative button order. 
+   * 
+   * If you need to use this function, you should probably connect
+   * to the ::notify:gtk-alternative-button-order signal on the
+   * Gtk::Settings object associated to @a screen , in order to be 
+   * notified if the button order setting changes.
+   * @param screen A Gdk::Screen, or <tt>0</tt> to use the default screen.
+   * @return Whether the alternative button order should be used
+   * 
+   * Since: 2.6.
+   */
+  static bool alternative_button_order(const Glib::RefPtr<const Gdk::Screen>& screen);
+  	
+  //TODO: Document this:   
+  void set_alternative_button_order_from_array(const Glib::ArrayHandle<int>& new_order);
+  
+
+  /** Emits the "response" signal with the given response ID. Used to
+   * indicate that the user has responded to the dialog in some way;
+   * typically either you or run() will be monitoring the
+   * "response" signal and take appropriate action.
+   * @param response_id Response ID.
+   */
+  void response(int response_id);
+  
+  /** Blocks in a recursive main loop until the @a dialog  emits the
+   * response signal. It returns the response ID from the "response" signal emission.
+   * Before entering the recursive main loop, run() calls
+   * Gtk::Widget::show() on the dialog for you. Note that you still
+   * need to show any children of the dialog yourself.
+   * 
+   * If the dialog receives "delete_event",  Gtk::Dialog::run() will return
+   * Gtk::RESPONSE_DELETE_EVENT. Also, during Gtk::Dialog::run() the dialog will be
+   * modal. You can force Gtk::Dialog::run() to return at any time by
+   * calling Gtk::Dialog::response() to emit the "response"
+   * signal.
+   * 
+   * After Gtk::Dialog::run() returns, you are responsible for hiding or
+   * destroying the dialog if you wish to do so.
+   * 
+   * Typical usage of this function might be:
+   * @code
+   * <tt>int</tt> result = dialog.run();
+   * switch (result)
+   * {
+   * case GTK_RESPONSE_ACCEPT:
+   * do_application_specific_something (&lt;!-- --&gt;);
+   * break;
+   * default:
+   * do_nothing_since_dialog_was_cancelled (&lt;!-- --&gt;);
+   * break;
+   * }
+   * @endcode
+   * @return Response ID.
+   */
+  int run();
+
+  VBox* get_vbox();
+  const VBox* get_vbox() const;
+  HButtonBox* get_action_area();
+  const HButtonBox* get_action_area() const;
+
+  /** The dialog has a separator bar above its buttons.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_has_separator() ;
+
+/** The dialog has a separator bar above its buttons.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_has_separator() const;
+
+
+  Glib::SignalProxy1< void,int > signal_response();
+
+
+protected:
+  void construct_(bool modal, bool use_separator);
+
+
+};
+
+} /* namespace Gtk */
+
+
+namespace Glib
+{
+  /** @relates Gtk::Dialog
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gtk::Dialog* wrap(GtkDialog* object, bool take_copy = false);
+}
+#endif /* _GTKMM_DIALOG_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/drawingarea.cc b/libs/gtkmm2/gtk/gtkmm/drawingarea.cc
new file mode 100644
index 0000000000..53c90ec888
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/drawingarea.cc
@@ -0,0 +1,129 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/drawingarea.h>
+#include <gtkmm/private/drawingarea_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* 
+ *
+ * Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtk/gtkdrawingarea.h>
+
+
+namespace
+{
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Gtk::DrawingArea* wrap(GtkDrawingArea* object, bool take_copy)
+{
+  return dynamic_cast<Gtk::DrawingArea *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& DrawingArea_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &DrawingArea_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_drawing_area_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void DrawingArea_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+}
+
+
+Glib::ObjectBase* DrawingArea_Class::wrap_new(GObject* o)
+{
+  return manage(new DrawingArea((GtkDrawingArea*)(o)));
+
+}
+
+
+/* The implementation: */
+
+DrawingArea::DrawingArea(const Glib::ConstructParams& construct_params)
+:
+  Gtk::Widget(construct_params)
+{
+  }
+
+DrawingArea::DrawingArea(GtkDrawingArea* castitem)
+:
+  Gtk::Widget((GtkWidget*)(castitem))
+{
+  }
+
+DrawingArea::~DrawingArea()
+{
+  destroy_();
+}
+
+DrawingArea::CppClassType DrawingArea::drawingarea_class_; // initialize static member
+
+GType DrawingArea::get_type()
+{
+  return drawingarea_class_.init().get_type();
+}
+
+GType DrawingArea::get_base_type()
+{
+  return gtk_drawing_area_get_type();
+}
+
+
+DrawingArea::DrawingArea()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Widget(Glib::ConstructParams(drawingarea_class_.init()))
+{
+  }
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/drawingarea.h b/libs/gtkmm2/gtk/gtkmm/drawingarea.h
new file mode 100644
index 0000000000..3d3774deb6
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/drawingarea.h
@@ -0,0 +1,120 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_DRAWINGAREA_H
+#define _GTKMM_DRAWINGAREA_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* drawingarea.h
+ * 
+ * Copyright (C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/widget.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkDrawingArea GtkDrawingArea;
+typedef struct _GtkDrawingAreaClass GtkDrawingAreaClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class DrawingArea_Class; } // namespace Gtk
+namespace Gtk
+{
+
+/** A widget for custom user interface elements.
+ *
+ * @ingroup Widgets
+ */
+
+class DrawingArea : public Widget
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef DrawingArea CppObjectType;
+  typedef DrawingArea_Class CppClassType;
+  typedef GtkDrawingArea BaseObjectType;
+  typedef GtkDrawingAreaClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~DrawingArea();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class DrawingArea_Class;
+  static CppClassType drawingarea_class_;
+
+  // noncopyable
+  DrawingArea(const DrawingArea&);
+  DrawingArea& operator=(const DrawingArea&);
+
+protected:
+  explicit DrawingArea(const Glib::ConstructParams& construct_params);
+  explicit DrawingArea(GtkDrawingArea* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GtkDrawingArea*       gobj()       { return reinterpret_cast<GtkDrawingArea*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GtkDrawingArea* gobj() const { return reinterpret_cast<GtkDrawingArea*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+private:
+
+public:
+
+  DrawingArea();
+  
+
+};
+
+} /* namespace Gtk */
+
+
+namespace Glib
+{
+  /** @relates Gtk::DrawingArea
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gtk::DrawingArea* wrap(GtkDrawingArea* object, bool take_copy = false);
+}
+#endif /* _GTKMM_DRAWINGAREA_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/editable.cc b/libs/gtkmm2/gtk/gtkmm/editable.cc
new file mode 100644
index 0000000000..9109009a2f
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/editable.cc
@@ -0,0 +1,770 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/editable.h>
+#include <gtkmm/private/editable_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtk/gtkeditable.h>
+
+
+namespace
+{
+
+void Editable_signal_insert_text_callback(GtkEditable* self, const gchar* text,gint length,gint* position,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,const Glib::ustring&,int* > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(      Glib::ustring(text, text + length), position);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+}
+
+const Glib::SignalProxyInfo Editable_signal_insert_text_info =
+{
+  "insert_text",
+  (GCallback) &Editable_signal_insert_text_callback,
+  (GCallback) &Editable_signal_insert_text_callback
+};
+
+
+void Editable_signal_delete_text_callback(GtkEditable* self, gint start_pos,gint end_pos,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,int,int > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(start_pos
+, end_pos
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+}
+
+const Glib::SignalProxyInfo Editable_signal_delete_text_info =
+{
+  "delete_text",
+  (GCallback) &Editable_signal_delete_text_callback,
+  (GCallback) &Editable_signal_delete_text_callback
+};
+
+
+const Glib::SignalProxyInfo Editable_signal_changed_info =
+{
+  "changed",
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
+};
+
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Glib::RefPtr<Gtk::Editable> wrap(GtkEditable* object, bool take_copy)
+{
+  return Glib::RefPtr<Gtk::Editable>( dynamic_cast<Gtk::Editable*> (Glib::wrap_auto ((GObject*)(object), take_copy)) );
+  //We use dynamic_cast<> in case of multiple inheritance.
+}
+
+} // namespace Glib
+
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Interface_Class& Editable_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Interface_Class has to know the interface init function
+    // in order to add interfaces to implementing types.
+    class_init_func_ = &Editable_Class::iface_init_function;
+
+    // We can not derive from another interface, and it is not necessary anyway.
+    gtype_ = gtk_editable_get_type();
+  }
+
+  return *this;
+}
+
+void Editable_Class::iface_init_function(void* g_iface, void*)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_iface);
+
+  //This is just to avoid an "unused variable" warning when there are no vfuncs or signal handlers to connect.
+  //This is a temporary fix until I find out why I can not seem to derive a GtkFileChooser interface. murrayc
+  g_assert(klass != 0); 
+
+  klass->do_insert_text = &do_insert_text_vfunc_callback;
+  klass->do_delete_text = &do_delete_text_vfunc_callback;
+  klass->get_chars = &get_chars_vfunc_callback;
+  klass->set_selection_bounds = &set_selection_bounds_vfunc_callback;
+  klass->get_selection_bounds = &get_selection_bounds_vfunc_callback;
+  klass->set_position = &set_position_vfunc_callback;
+  klass->get_position = &get_position_vfunc_callback;
+  klass->insert_text = &insert_text_callback;
+  klass->delete_text = &delete_text_callback;
+  klass->changed = &changed_callback;
+}
+
+void Editable_Class::do_insert_text_vfunc_callback(GtkEditable* self, const gchar* text, gint length, gint* position)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)      self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->insert_text_vfunc(      Glib::ustring(text, text + length), *position);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->do_insert_text)
+      (*base->do_insert_text)(      self, text, length, position);
+  }
+}
+
+void Editable_Class::do_delete_text_vfunc_callback(GtkEditable* self, gint start_pos, gint end_pos)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->delete_text_vfunc(start_pos
+, end_pos
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->do_delete_text)
+      (*base->do_delete_text)(self, start_pos, end_pos);
+  }
+}
+
+gchar* Editable_Class::get_chars_vfunc_callback(GtkEditable* self, gint start_pos, gint end_pos)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return g_strdup((obj->get_chars_vfunc(start_pos
+, end_pos
+)).c_str());
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->get_chars)
+      return (*base->get_chars)(self, start_pos, end_pos);
+  }
+
+  typedef gchar* RType;
+  return RType();
+}
+
+void Editable_Class::set_selection_bounds_vfunc_callback(GtkEditable* self, gint start_pos, gint end_pos)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->select_region_vfunc(start_pos
+, end_pos
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->set_selection_bounds)
+      (*base->set_selection_bounds)(self, start_pos, end_pos);
+  }
+}
+
+gboolean Editable_Class::get_selection_bounds_vfunc_callback(GtkEditable* self, gint* start_pos, gint* end_pos)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return static_cast<int>(obj->get_selection_bounds_vfunc(*(start_pos)
+, *(end_pos)
+));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->get_selection_bounds)
+      return (*base->get_selection_bounds)(self, start_pos, end_pos);
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+void Editable_Class::set_position_vfunc_callback(GtkEditable* self, gint position)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->set_position_vfunc(position
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->set_position)
+      (*base->set_position)(self, position);
+  }
+}
+
+gint Editable_Class::get_position_vfunc_callback(GtkEditable* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return obj->get_position_vfunc();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->get_position)
+      return (*base->get_position)(self);
+  }
+
+  typedef gint RType;
+  return RType();
+}
+
+
+void Editable_Class::insert_text_callback(GtkEditable* self, const gchar* text, gint length, gint* position)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)      self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_insert_text(      Glib::ustring(text, text + length), position);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->insert_text)
+      (*base->insert_text)(      self, text, length, position);
+  }
+}
+
+void Editable_Class::delete_text_callback(GtkEditable* self, gint start_pos, gint end_pos)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_delete_text(start_pos
+, end_pos
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->delete_text)
+      (*base->delete_text)(self, start_pos, end_pos);
+  }
+}
+
+void Editable_Class::changed_callback(GtkEditable* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_changed();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->changed)
+      (*base->changed)(self);
+  }
+}
+
+
+Glib::ObjectBase* Editable_Class::wrap_new(GObject* object)
+{
+  return new Editable((GtkEditable*)(object));
+}
+
+
+/* The implementation: */
+
+Editable::Editable()
+:
+  Glib::Interface(editable_class_.init())
+{}
+
+Editable::Editable(GtkEditable* castitem)
+:
+  Glib::Interface((GObject*)(castitem))
+{}
+
+Editable::~Editable()
+{}
+
+// static
+void Editable::add_interface(GType gtype_implementer)
+{
+  editable_class_.init().add_interface(gtype_implementer);
+}
+
+Editable::CppClassType Editable::editable_class_; // initialize static member
+
+GType Editable::get_type()
+{
+  return editable_class_.init().get_type();
+}
+
+GType Editable::get_base_type()
+{
+  return gtk_editable_get_type();
+}
+
+
+void Editable::cut_clipboard()
+{
+  gtk_editable_cut_clipboard(gobj());
+}
+
+void Editable::copy_clipboard()
+{
+  gtk_editable_copy_clipboard(gobj());
+}
+
+void Editable::paste_clipboard()
+{
+  gtk_editable_paste_clipboard(gobj());
+}
+
+void Editable::delete_selection()
+{
+  gtk_editable_delete_selection(gobj());
+}
+
+void Editable::set_editable(bool is_editable)
+{
+  gtk_editable_set_editable(gobj(), static_cast<int>(is_editable));
+}
+
+bool Editable::get_editable() const
+{
+  return gtk_editable_get_editable(const_cast<GtkEditable*>(gobj()));
+}
+
+void Editable::insert_text(const Glib::ustring& text, int length, int& position)
+{
+  gtk_editable_insert_text(gobj(), text.c_str(), length, &position);
+}
+
+void Editable::delete_text(int start_pos, int end_pos)
+{
+  gtk_editable_delete_text(gobj(), start_pos, end_pos);
+}
+
+Glib::ustring Editable::get_chars(int start_pos, int end_pos) const
+{
+  return Glib::convert_return_gchar_ptr_to_ustring(gtk_editable_get_chars(const_cast<GtkEditable*>(gobj()), start_pos, end_pos));
+}
+
+void Editable::select_region(int start_pos, int end_pos)
+{
+  gtk_editable_select_region(gobj(), start_pos, end_pos);
+}
+
+bool Editable::get_selection_bounds(int& start_pos, int& end_pos) const
+{
+  return gtk_editable_get_selection_bounds(const_cast<GtkEditable*>(gobj()), &start_pos, &end_pos);
+}
+
+void Editable::set_position(int position)
+{
+  gtk_editable_set_position(gobj(), position);
+}
+
+int Editable::get_position() const
+{
+  return gtk_editable_get_position(const_cast<GtkEditable*>(gobj()));
+}
+
+
+Glib::SignalProxy2< void,const Glib::ustring&,int* > Editable::signal_insert_text()
+{
+  return Glib::SignalProxy2< void,const Glib::ustring&,int* >(this, &Editable_signal_insert_text_info);
+}
+
+Glib::SignalProxy2< void,int,int > Editable::signal_delete_text()
+{
+  return Glib::SignalProxy2< void,int,int >(this, &Editable_signal_delete_text_info);
+}
+
+Glib::SignalProxy0< void > Editable::signal_changed()
+{
+  return Glib::SignalProxy0< void >(this, &Editable_signal_changed_info);
+}
+
+
+void Gtk::Editable::on_insert_text(const Glib::ustring& text, int* position)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->insert_text)
+    (*base->insert_text)(gobj(),text.data(),text.bytes(),position);
+}
+
+void Gtk::Editable::on_delete_text(int start_pos, int end_pos)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->delete_text)
+    (*base->delete_text)(gobj(),start_pos,end_pos);
+}
+
+void Gtk::Editable::on_changed()
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->changed)
+    (*base->changed)(gobj());
+}
+
+
+void Gtk::Editable::insert_text_vfunc(const Glib::ustring& text, int& position) 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->do_insert_text)
+    (*base->do_insert_text)(gobj(),text.data(),text.bytes(),&position);
+}
+
+void Gtk::Editable::delete_text_vfunc(int start_pos, int end_pos) 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->do_delete_text)
+    (*base->do_delete_text)(gobj(),start_pos,end_pos);
+}
+
+Glib::ustring Gtk::Editable::get_chars_vfunc(int start_pos, int end_pos) const
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->get_chars)
+    return Glib::convert_const_gchar_ptr_to_ustring((*base->get_chars)(const_cast<GtkEditable*>(gobj()),start_pos,end_pos));
+
+  typedef Glib::ustring RType;
+  return RType();
+}
+
+void Gtk::Editable::select_region_vfunc(int start_pos, int end_pos) 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->set_selection_bounds)
+    (*base->set_selection_bounds)(gobj(),start_pos,end_pos);
+}
+
+bool Gtk::Editable::get_selection_bounds_vfunc(int& start_pos, int& end_pos) const
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->get_selection_bounds)
+    return (*base->get_selection_bounds)(const_cast<GtkEditable*>(gobj()),&start_pos,&end_pos);
+
+  typedef bool RType;
+  return RType();
+}
+
+void Gtk::Editable::set_position_vfunc(int position) 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->set_position)
+    (*base->set_position)(gobj(),position);
+}
+
+int Gtk::Editable::get_position_vfunc() const
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->get_position)
+    return (*base->get_position)(const_cast<GtkEditable*>(gobj()));
+
+  typedef int RType;
+  return RType();
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/editable.h b/libs/gtkmm2/gtk/gtkmm/editable.h
new file mode 100644
index 0000000000..89832dcba7
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/editable.h
@@ -0,0 +1,190 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_EDITABLE_H
+#define _GTKMM_EDITABLE_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* Copyright (C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <glibmm/interface.h>
+#include <gtk/gtkeditable.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkEditable GtkEditable;
+typedef struct _GtkEditableClass GtkEditableClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class Editable_Class; } // namespace Gtk
+namespace Gtk
+{
+
+/** Base class for text-editing widgets.
+ *
+ * The Gtk::Editable class is a base class for widgets for editing text,
+ * such as Gtk::Entry. It cannot be instantiated by itself. The editable
+ * class contains functions for generically manipulating an editable widget,
+ * a large number of action signals used for key bindings, and several
+ * signals that an application can connect to to modify the behavior of a
+ * widget.
+ *
+ */
+
+class Editable : public Glib::Interface
+{
+  
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+public:
+  typedef Editable CppObjectType;
+  typedef Editable_Class CppClassType;
+  typedef GtkEditable BaseObjectType;
+  typedef GtkEditableClass BaseClassType;
+
+private:
+  friend class Editable_Class;
+  static CppClassType editable_class_;
+
+  // noncopyable
+  Editable(const Editable&);
+  Editable& operator=(const Editable&);
+
+protected:
+  Editable(); // you must derive from this class
+  explicit Editable(GtkEditable* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+  virtual ~Editable();
+
+  static void add_interface(GType gtype_implementer);
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GObject.
+  GtkEditable*       gobj()       { return reinterpret_cast<GtkEditable*>(gobject_); }
+
+  ///Provides access to the underlying C GObject.  
+  const GtkEditable* gobj() const { return reinterpret_cast<GtkEditable*>(gobject_); }
+
+private:
+
+
+public:
+  
+  void cut_clipboard();
+  
+  void copy_clipboard();
+  
+  void paste_clipboard();
+  
+  void delete_selection();
+  
+  void set_editable(bool is_editable = true);
+  
+  /** Retrieves whether @a editable  is editable. See
+   * set_editable().
+   * @return <tt>true</tt> if @a editable  is editable.
+   */
+  bool get_editable() const;
+
+  
+  void insert_text(const Glib::ustring& text, int length, int& position);
+  
+  void delete_text(int start_pos, int end_pos);
+
+  
+  Glib::ustring get_chars(int start_pos, int end_pos) const;
+
+  
+  void select_region(int start_pos, int end_pos);
+  
+  bool get_selection_bounds(int& start_pos, int& end_pos) const;
+
+  
+  void set_position(int position);
+  
+  int get_position() const;
+
+  
+  Glib::SignalProxy2< void,const Glib::ustring&,int* > signal_insert_text();
+
+    
+  Glib::SignalProxy2< void,int,int > signal_delete_text();
+
+  
+  Glib::SignalProxy0< void > signal_changed();
+
+
+protected:
+
+
+    virtual void delete_text_vfunc(int start_pos, int end_pos);
+
+
+    virtual Glib::ustring get_chars_vfunc(int start_pos, int end_pos) const;
+
+    virtual void select_region_vfunc(int start_pos, int end_pos);
+    virtual bool get_selection_bounds_vfunc(int& start_pos, int& end_pos) const;
+    virtual void set_position_vfunc(int position);
+    virtual int get_position_vfunc() const;
+
+
+public:
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+virtual void insert_text_vfunc(const Glib::ustring& text, int& position);
+
+ 
+  //Default Signal Handlers::
+  virtual void on_insert_text(const Glib::ustring& text, int* position);
+  virtual void on_delete_text(int start_pos, int end_pos);
+  virtual void on_changed();
+
+
+};
+
+} // namespace Gtk
+
+
+namespace Glib
+{
+  /** @relates Gtk::Editable
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Glib::RefPtr<Gtk::Editable> wrap(GtkEditable* object, bool take_copy = false);
+
+} // namespace Glib
+
+#endif /* _GTKMM_EDITABLE_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/entry.cc b/libs/gtkmm2/gtk/gtkmm/entry.cc
new file mode 100644
index 0000000000..6b08e95c3b
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/entry.cc
@@ -0,0 +1,598 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/entry.h>
+#include <gtkmm/private/entry_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* 
+ *
+ * Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtk/gtkentry.h>
+
+
+namespace
+{
+
+void Entry_signal_populate_popup_callback(GtkEntry* self, GtkMenu* p0,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,Menu* > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(Glib::wrap(p0)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+}
+
+const Glib::SignalProxyInfo Entry_signal_populate_popup_info =
+{
+  "populate_popup",
+  (GCallback) &Entry_signal_populate_popup_callback,
+  (GCallback) &Entry_signal_populate_popup_callback
+};
+
+
+void Entry_signal_insert_at_cursor_callback(GtkEntry* self, const gchar* p0,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,const Glib::ustring& > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(Glib::convert_const_gchar_ptr_to_ustring(p0)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+}
+
+const Glib::SignalProxyInfo Entry_signal_insert_at_cursor_info =
+{
+  "insert_at_cursor",
+  (GCallback) &Entry_signal_insert_at_cursor_callback,
+  (GCallback) &Entry_signal_insert_at_cursor_callback
+};
+
+
+const Glib::SignalProxyInfo Entry_signal_activate_info =
+{
+  "activate",
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
+};
+
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Gtk::Entry* wrap(GtkEntry* object, bool take_copy)
+{
+  return dynamic_cast<Gtk::Entry *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& Entry_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &Entry_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_entry_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  Editable::add_interface(get_type());
+  CellEditable::add_interface(get_type());
+  }
+
+  return *this;
+}
+
+void Entry_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+  klass->populate_popup = &populate_popup_callback;
+  klass->insert_at_cursor = &insert_at_cursor_callback;
+  klass->activate = &activate_callback;
+}
+
+
+void Entry_Class::populate_popup_callback(GtkEntry* self, GtkMenu* p0)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_populate_popup(Glib::wrap(p0)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->populate_popup)
+      (*base->populate_popup)(self, p0);
+  }
+}
+
+void Entry_Class::insert_at_cursor_callback(GtkEntry* self, const gchar* p0)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_insert_at_cursor(Glib::convert_const_gchar_ptr_to_ustring(p0)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->insert_at_cursor)
+      (*base->insert_at_cursor)(self, p0);
+  }
+}
+
+void Entry_Class::activate_callback(GtkEntry* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_activate();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->activate)
+      (*base->activate)(self);
+  }
+}
+
+
+Glib::ObjectBase* Entry_Class::wrap_new(GObject* o)
+{
+  return manage(new Entry((GtkEntry*)(o)));
+
+}
+
+
+/* The implementation: */
+
+Entry::Entry(const Glib::ConstructParams& construct_params)
+:
+  Gtk::Widget(construct_params)
+{
+  }
+
+Entry::Entry(GtkEntry* castitem)
+:
+  Gtk::Widget((GtkWidget*)(castitem))
+{
+  }
+
+Entry::~Entry()
+{
+  destroy_();
+}
+
+Entry::CppClassType Entry::entry_class_; // initialize static member
+
+GType Entry::get_type()
+{
+  return entry_class_.init().get_type();
+}
+
+GType Entry::get_base_type()
+{
+  return gtk_entry_get_type();
+}
+
+
+Entry::Entry()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Widget(Glib::ConstructParams(entry_class_.init()))
+{
+  }
+
+void Entry::set_visibility(bool visible)
+{
+  gtk_entry_set_visibility(gobj(), static_cast<int>(visible));
+}
+
+bool Entry::get_visibility() const
+{
+  return gtk_entry_get_visibility(const_cast<GtkEntry*>(gobj()));
+}
+
+void Entry::set_invisible_char(gunichar ch)
+{
+  gtk_entry_set_invisible_char(gobj(), ch);
+}
+
+gunichar Entry::get_invisible_char() const
+{
+  return gtk_entry_get_invisible_char(const_cast<GtkEntry*>(gobj()));
+}
+
+void Entry::set_has_frame(bool setting)
+{
+  gtk_entry_set_has_frame(gobj(), static_cast<int>(setting));
+}
+
+bool Entry::get_has_frame() const
+{
+  return gtk_entry_get_has_frame(const_cast<GtkEntry*>(gobj()));
+}
+
+void Entry::set_max_length(int max)
+{
+  gtk_entry_set_max_length(gobj(), max);
+}
+
+int Entry::get_max_length() const
+{
+  return gtk_entry_get_max_length(const_cast<GtkEntry*>(gobj()));
+}
+
+void Entry::set_activates_default(bool setting)
+{
+  gtk_entry_set_activates_default(gobj(), static_cast<int>(setting));
+}
+
+gboolean Entry::get_activates_default() const
+{
+  return gtk_entry_get_activates_default(const_cast<GtkEntry*>(gobj()));
+}
+
+void Entry::set_width_chars(int n_chars)
+{
+  gtk_entry_set_width_chars(gobj(), n_chars);
+}
+
+int Entry::get_width_chars() const
+{
+  return gtk_entry_get_width_chars(const_cast<GtkEntry*>(gobj()));
+}
+
+void Entry::set_text(const Glib::ustring & text)
+{
+  gtk_entry_set_text(gobj(), text.c_str());
+}
+
+Glib::ustring Entry::get_text() const
+{
+  return Glib::convert_const_gchar_ptr_to_ustring(gtk_entry_get_text(const_cast<GtkEntry*>(gobj())));
+}
+
+Glib::RefPtr<Pango::Layout> Entry::get_layout()
+{
+
+  Glib::RefPtr<Pango::Layout> retvalue = Glib::wrap(gtk_entry_get_layout(gobj()));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::RefPtr<const Pango::Layout> Entry::get_layout() const
+{
+
+  Glib::RefPtr<const Pango::Layout> retvalue = Glib::wrap(gtk_entry_get_layout(const_cast<GtkEntry*>(gobj())));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+void Entry::get_layout_offsets(int& x, int& y)
+{
+  gtk_entry_get_layout_offsets(gobj(), &x, &y);
+}
+
+int Entry::layout_index_to_text_index(int layout_index) const
+{
+  return gtk_entry_layout_index_to_text_index(const_cast<GtkEntry*>(gobj()), layout_index);
+}
+
+int Entry::text_index_to_layout_index(int text_index) const
+{
+  return gtk_entry_text_index_to_layout_index(const_cast<GtkEntry*>(gobj()), text_index);
+}
+
+void Entry::set_alignment(float xalign)
+{
+  gtk_entry_set_alignment(gobj(), xalign);
+}
+
+void Entry::set_alignment(AlignmentEnum xalign)
+{
+  gtk_entry_set_alignment(gobj(), _gtkmm_align_float_from_enum(xalign));
+}
+
+float Entry::get_alignment() const
+{
+  return gtk_entry_get_alignment(const_cast<GtkEntry*>(gobj()));
+}
+
+void Entry::set_completion(const Glib::RefPtr<EntryCompletion>& completion)
+{
+  gtk_entry_set_completion(gobj(), Glib::unwrap(completion));
+}
+
+Glib::RefPtr<EntryCompletion> Entry::get_completion()
+{
+
+  Glib::RefPtr<EntryCompletion> retvalue = Glib::wrap(gtk_entry_get_completion(gobj()));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::RefPtr<const EntryCompletion> Entry::get_completion() const
+{
+
+  Glib::RefPtr<const EntryCompletion> retvalue = Glib::wrap(gtk_entry_get_completion(const_cast<GtkEntry*>(gobj())));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+guint16 Entry::get_text_length() const
+{
+  return gobj()->text_length;
+}
+
+
+Glib::SignalProxy1< void,Menu* > Entry::signal_populate_popup()
+{
+  return Glib::SignalProxy1< void,Menu* >(this, &Entry_signal_populate_popup_info);
+}
+
+Glib::SignalProxy1< void,const Glib::ustring& > Entry::signal_insert_at_cursor()
+{
+  return Glib::SignalProxy1< void,const Glib::ustring& >(this, &Entry_signal_insert_at_cursor_info);
+}
+
+Glib::SignalProxy0< void > Entry::signal_activate()
+{
+  return Glib::SignalProxy0< void >(this, &Entry_signal_activate_info);
+}
+
+
+Glib::PropertyProxy_ReadOnly<int> Entry::property_cursor_position() const
+{
+  return Glib::PropertyProxy_ReadOnly<int>(this, "cursor-position");
+}
+
+Glib::PropertyProxy_ReadOnly<int> Entry::property_selection_bound() const
+{
+  return Glib::PropertyProxy_ReadOnly<int>(this, "selection-bound");
+}
+
+Glib::PropertyProxy<bool> Entry::property_editable() 
+{
+  return Glib::PropertyProxy<bool>(this, "editable");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> Entry::property_editable() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "editable");
+}
+
+Glib::PropertyProxy<int> Entry::property_max_length() 
+{
+  return Glib::PropertyProxy<int>(this, "max-length");
+}
+
+Glib::PropertyProxy_ReadOnly<int> Entry::property_max_length() const
+{
+  return Glib::PropertyProxy_ReadOnly<int>(this, "max-length");
+}
+
+Glib::PropertyProxy<bool> Entry::property_visibility() 
+{
+  return Glib::PropertyProxy<bool>(this, "visibility");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> Entry::property_visibility() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "visibility");
+}
+
+Glib::PropertyProxy<bool> Entry::property_has_frame() 
+{
+  return Glib::PropertyProxy<bool>(this, "has-frame");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> Entry::property_has_frame() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "has-frame");
+}
+
+Glib::PropertyProxy<gunichar> Entry::property_invisible_char() 
+{
+  return Glib::PropertyProxy<gunichar>(this, "invisible-char");
+}
+
+Glib::PropertyProxy_ReadOnly<gunichar> Entry::property_invisible_char() const
+{
+  return Glib::PropertyProxy_ReadOnly<gunichar>(this, "invisible-char");
+}
+
+Glib::PropertyProxy<bool> Entry::property_activates_default() 
+{
+  return Glib::PropertyProxy<bool>(this, "activates-default");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> Entry::property_activates_default() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "activates-default");
+}
+
+Glib::PropertyProxy<int> Entry::property_width_chars() 
+{
+  return Glib::PropertyProxy<int>(this, "width-chars");
+}
+
+Glib::PropertyProxy_ReadOnly<int> Entry::property_width_chars() const
+{
+  return Glib::PropertyProxy_ReadOnly<int>(this, "width-chars");
+}
+
+Glib::PropertyProxy_ReadOnly<int> Entry::property_scroll_offset() const
+{
+  return Glib::PropertyProxy_ReadOnly<int>(this, "scroll-offset");
+}
+
+Glib::PropertyProxy<Glib::ustring> Entry::property_text() 
+{
+  return Glib::PropertyProxy<Glib::ustring>(this, "text");
+}
+
+Glib::PropertyProxy_ReadOnly<Glib::ustring> Entry::property_text() const
+{
+  return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "text");
+}
+
+
+void Gtk::Entry::on_populate_popup(Menu* menu)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->populate_popup)
+    (*base->populate_popup)(gobj(),(GtkMenu*)Glib::unwrap(menu));
+}
+
+void Gtk::Entry::on_insert_at_cursor(const Glib::ustring& str)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->insert_at_cursor)
+    (*base->insert_at_cursor)(gobj(),str.c_str());
+}
+
+void Gtk::Entry::on_activate()
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->activate)
+    (*base->activate)(gobj());
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/entry.h b/libs/gtkmm2/gtk/gtkmm/entry.h
new file mode 100644
index 0000000000..d7b9a3fb3c
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/entry.h
@@ -0,0 +1,524 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_ENTRY_H
+#define _GTKMM_ENTRY_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* entry.h
+ * 
+ * Copyright (C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/widget.h>
+#include <gtkmm/editable.h>
+#include <gtkmm/menu.h>
+#include <gtkmm/celleditable.h>
+#include <gtkmm/entrycompletion.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkEntry GtkEntry;
+typedef struct _GtkEntryClass GtkEntryClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class Entry_Class; } // namespace Gtk
+namespace Gtk
+{
+
+/** A single line text entry field.
+ *
+ * The Gtk::Entry widget is a single line text entry widget. A fairly large
+ * set of key bindings are supported by default. If the entered text is
+ * longer than the allocation of the widget, the widget will scroll so that
+ * the cursor position is visible. 
+ *
+ * @ingroup Widgets
+ */
+
+class Entry
+: public Widget,
+  public Editable,
+  public CellEditable
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Entry CppObjectType;
+  typedef Entry_Class CppClassType;
+  typedef GtkEntry BaseObjectType;
+  typedef GtkEntryClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~Entry();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class Entry_Class;
+  static CppClassType entry_class_;
+
+  // noncopyable
+  Entry(const Entry&);
+  Entry& operator=(const Entry&);
+
+protected:
+  explicit Entry(const Glib::ConstructParams& construct_params);
+  explicit Entry(GtkEntry* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GtkEntry*       gobj()       { return reinterpret_cast<GtkEntry*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GtkEntry* gobj() const { return reinterpret_cast<GtkEntry*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+  virtual void on_populate_popup(Menu* menu);
+  virtual void on_insert_at_cursor(const Glib::ustring& str);
+  virtual void on_activate();
+
+
+private:
+
+  
+public:
+
+  Entry();
+  
+
+  void set_visibility(bool visible = true);
+  
+  /** Retrieves whether the text in @a entry  is visible. See
+   * set_visibility().
+   * @return <tt>true</tt> if the text is currently visible.
+   */
+  bool get_visibility() const;
+  
+  /** Sets the character to use in place of the actual text when
+   * set_visibility() has been called to set text visibility
+   * to <tt>false</tt>. i.e. this is the character used in "password mode" to
+   * show the user how many characters have been typed. The default
+   * invisible char is an asterisk ('*').  If you set the invisible char
+   * to 0, then the user will get no feedback at all; there will be
+   * no text on the screen as they type.
+   * @param ch A Unicode character.
+   */
+  void set_invisible_char(gunichar ch);
+  
+  /** Retrieves the character displayed in place of the real characters
+   * for entries with visisbility set to false. See set_invisible_char().
+   * @return The current invisible char, or 0, if the entry does not
+   * show invisible text at all.
+   */
+  gunichar get_invisible_char() const;	
+  
+  /** Sets whether the entry has a beveled frame around it.
+   * @param setting New value.
+   */
+  void set_has_frame(bool setting = true);
+  
+  /** Gets the value set by set_has_frame().
+   * @return Whether the entry has a beveled frame.
+   */
+  bool get_has_frame() const;
+  
+  /** Sets the maximum allowed length of the contents of the widget. If
+   * the current contents are longer than the given length, then they
+   * will be truncated to fit.
+   * @param max The maximum length of the entry, or 0 for no maximum.
+   * (other than the maximum length of entries.) The value passed in will
+   * be clamped to the range 0-65536.
+   */
+  void set_max_length(int max);
+  
+  /** Retrieves the maximum allowed length of the text in
+   *  @a entry . See set_max_length().
+   * @return The maximum allowed number of characters
+   * in Gtk::Entry, or 0 if there is no maximum.
+   */
+  int get_max_length() const;
+  
+  /** If @a setting  is <tt>true</tt>, pressing Enter in the @a entry  will activate the default
+   * widget for the window containing the entry. This usually means that
+   * the dialog box containing the entry will be closed, since the default
+   * widget is usually one of the dialog buttons.
+   * 
+   * (For experts: if @a setting  is <tt>true</tt>, the entry calls
+   * Gtk::Window::activate_default() on the window containing the entry, in
+   * the default handler for the "activate" signal.)
+   * @param setting <tt>true</tt> to activate window's default widget on Enter keypress.
+   */
+  void set_activates_default(bool setting = true);
+  
+  /** Retrieves the value set by set_activates_default().
+   * @return <tt>true</tt> if the entry will activate the default widget.
+   */
+  gboolean get_activates_default() const;
+  
+  /** Changes the size request of the entry to be about the right size
+   * for @a n_chars  characters. Note that it changes the size
+   * <em>request</em>, the size can still be affected by
+   * how you pack the widget into containers. If @a n_chars  is -1, the
+   * size reverts to the default entry size.
+   * @param n_chars Width in chars.
+   */
+  void set_width_chars(int n_chars);
+  
+  /** Gets the value set by set_width_chars().
+   * @return Number of chars to request space for, or negative if unset.
+   */
+  int get_width_chars() const;
+  
+  void set_text(const Glib::ustring &text);
+  
+  /** Retrieves the contents of the entry widget.
+   * See also Gtk::Editable::get_chars().
+   * @return A pointer to the contents of the widget as a
+   * string.  This string points to internally allocated
+   * storage in the widget and must not be freed, modified or
+   * stored.
+   */
+  Glib::ustring get_text() const;
+  
+  /** Gets the Pango::Layout used to display the entry.
+   * The layout is useful to e.g. convert text positions to
+   * pixel positions, in combination with get_layout_offsets().
+   * The returned layout is owned by the entry so need not be
+   * freed by the caller.
+   * 
+   * Keep in mind that the layout text may contain a preedit string, so
+   * layout_index_to_text_index() and
+   * text_index_to_layout_index() are needed to convert byte
+   * indices in the layout to byte indices in the entry contents.
+   * @return The Pango::Layout for this entry.
+   */
+  Glib::RefPtr<Pango::Layout> get_layout();
+  
+  /** Gets the Pango::Layout used to display the entry.
+   * The layout is useful to e.g. convert text positions to
+   * pixel positions, in combination with get_layout_offsets().
+   * The returned layout is owned by the entry so need not be
+   * freed by the caller.
+   * 
+   * Keep in mind that the layout text may contain a preedit string, so
+   * layout_index_to_text_index() and
+   * text_index_to_layout_index() are needed to convert byte
+   * indices in the layout to byte indices in the entry contents.
+   * @return The Pango::Layout for this entry.
+   */
+  Glib::RefPtr<const Pango::Layout> get_layout() const;
+  
+  /** Obtains the position of the Pango::Layout used to render text
+   * in the entry, in widget coordinates. Useful if you want to line
+   * up the text in an entry with some other text, e.g. when using the
+   * entry to implement editable cells in a sheet widget.
+   * 
+   * Also useful to convert mouse events into coordinates inside the
+   * Pango::Layout, e.g. to take some action if some part of the entry text
+   * is clicked.
+   * 
+   * Note that as the user scrolls around in the entry the offsets will
+   * change; you'll need to connect to the "notify::scroll-offset"
+   * signal to track this. Remember when using the Pango::Layout
+   * functions you need to convert to and from pixels using
+   * PANGO_PIXELS() or Pango::SCALE.
+   * 
+   * Keep in mind that the layout text may contain a preedit string, so
+   * layout_index_to_text_index() and
+   * text_index_to_layout_index() are needed to convert byte
+   * indices in the layout to byte indices in the entry contents.
+   * @param x Location to store X offset of layout, or <tt>0</tt>.
+   * @param y Location to store Y offset of layout, or <tt>0</tt>.
+   */
+  void get_layout_offsets(int& x, int& y);
+
+  
+  /** Converts from a position in the entry contents (returned
+   * by get_text()) to a position in the
+   * entry's Pango::Layout (returned by get_layout(),
+   * with text retrieved via pango_layout_get_text()).
+   * @param layout_index Byte index into the entry layout text.
+   * @return Byte index into the entry contents.
+   */
+  int layout_index_to_text_index(int layout_index) const;
+  
+  /** Converts from a position in the entry's Pango::Layout (returned by
+   * get_layout()) to a position in the entry contents
+   * (returned by get_text()).
+   * @param text_index Byte index into the entry contents.
+   * @return Byte index into the entry layout text.
+   */
+  int text_index_to_layout_index(int text_index) const;
+
+  
+  /** Sets the alignment for the contents of the entry. This controls
+   * the horizontal positioning of the contents when the displayed
+   * text is shorter than the width of the entry.
+   * 
+   * Since: 2.4
+   * @param xalign The horizontal alignment, from 0 (left) to 1 (right).
+   * Reversed for RTL layouts.
+   */
+  void set_alignment(float xalign);
+  
+  /** Sets the alignment for the contents of the entry. This controls
+   * the horizontal positioning of the contents when the displayed
+   * text is shorter than the width of the entry.
+   * 
+   * Since: 2.4
+   * @param xalign The horizontal alignment, from 0 (left) to 1 (right).
+   * Reversed for RTL layouts.
+   */
+  void set_alignment(AlignmentEnum xalign); 
+  
+  /** Gets the value set by set_alignment().
+   * @return The alignment
+   * 
+   * Since: 2.4.
+   */
+  float get_alignment() const;
+
+  
+  /** Sets @a completion  to be the auxiliary completion object to use with @a entry .
+   * All further configuration of the completion mechanism is done on
+   *  @a completion  using the Gtk::EntryCompletion API.
+   * 
+   * Since: 2.4
+   * @param completion The Gtk::EntryCompletion.
+   */
+  void set_completion(const Glib::RefPtr<EntryCompletion>& completion);
+  
+  /** Returns the auxiliary completion object currently in use by @a entry .
+   * @return The auxiliary completion object currently in use by @a entry .
+   * 
+   * Since: 2.4.
+   */
+  Glib::RefPtr<EntryCompletion> get_completion();
+  
+  /** Returns the auxiliary completion object currently in use by @a entry .
+   * @return The auxiliary completion object currently in use by @a entry .
+   * 
+   * Since: 2.4.
+   */
+  Glib::RefPtr<const EntryCompletion> get_completion() const;
+
+  guint16 get_text_length() const;
+
+  
+  Glib::SignalProxy1< void,Menu* > signal_populate_popup();
+
+  
+  Glib::SignalProxy1< void,const Glib::ustring& > signal_insert_at_cursor();
+
+
+  //Key-binding signals:
+  
+
+  Glib::SignalProxy0< void > signal_activate();
+ //TODO: ignore this too? It's used in an example.
+  
+  
+  /** The current position of the insertion cursor in chars.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<int> property_cursor_position() const;
+
+
+  /** The position of the opposite end of the selection from the cursor in chars.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<int> property_selection_bound() const;
+
+
+  /** Whether the entry contents can be edited.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_editable() ;
+
+/** Whether the entry contents can be edited.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_editable() const;
+
+  /** Maximum number of characters for this entry. Zero if no maximum.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<int> property_max_length() ;
+
+/** Maximum number of characters for this entry. Zero if no maximum.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<int> property_max_length() const;
+
+  /** FALSE displays the invisible char instead of the actual text (password mode).
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_visibility() ;
+
+/** FALSE displays the invisible char instead of the actual text (password mode).
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_visibility() const;
+
+  /** FALSE removes outside bevel from entry.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_has_frame() ;
+
+/** FALSE removes outside bevel from entry.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_has_frame() const;
+
+  /** The character to use when masking entry contents (in password mode).
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<gunichar> property_invisible_char() ;
+
+/** The character to use when masking entry contents (in password mode).
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<gunichar> property_invisible_char() const;
+
+  /** Whether to activate the default widget (such as the default button in a dialog) when Enter is pressed.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_activates_default() ;
+
+/** Whether to activate the default widget (such as the default button in a dialog) when Enter is pressed.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_activates_default() const;
+
+  /** Number of characters to leave space for in the entry.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<int> property_width_chars() ;
+
+/** Number of characters to leave space for in the entry.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<int> property_width_chars() const;
+
+  /** Number of pixels of the entry scrolled off the screen to the left.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<int> property_scroll_offset() const;
+
+
+  /** The contents of the entry.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Glib::ustring> property_text() ;
+
+/** The contents of the entry.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Glib::ustring> property_text() const;
+
+
+};
+
+} /* namespace Gtk */
+
+
+namespace Glib
+{
+  /** @relates Gtk::Entry
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gtk::Entry* wrap(GtkEntry* object, bool take_copy = false);
+}
+#endif /* _GTKMM_ENTRY_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/entrycompletion.cc b/libs/gtkmm2/gtk/gtkmm/entrycompletion.cc
new file mode 100644
index 0000000000..4b7d15975d
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/entrycompletion.cc
@@ -0,0 +1,611 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/entrycompletion.h>
+#include <gtkmm/private/entrycompletion_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* Copyright 2003 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/treeiter.h>
+#include <gtkmm/entry.h>
+#include <gtk/gtkentrycompletion.h>
+
+namespace //anonymous
+{
+
+// This Signal Proxy allows the C++ coder to specify
+// a sigc::slot instead of a static function.
+class SignalProxy_Match
+{
+public:
+  typedef Gtk::EntryCompletion::SlotMatch SlotType;
+
+  SignalProxy_Match(const SlotType& slot)
+  : slot_(slot) {}
+  
+  ~SignalProxy_Match();
+
+  static gboolean gtk_callback(GtkEntryCompletion* completion, const gchar* key, GtkTreeIter* iter, gpointer user_data);
+  static void gtk_callback_destroy(void* data);                                               
+
+private:
+  SlotType slot_;
+};
+
+SignalProxy_Match::~SignalProxy_Match()
+{}
+
+gboolean SignalProxy_Match::gtk_callback(GtkEntryCompletion* completion, const gchar* key, GtkTreeIter* iter, gpointer user_data)
+{
+  SignalProxy_Match *const self = static_cast<SignalProxy_Match*>(user_data);
+
+  try
+  {
+    GtkTreeModel* tree_model = gtk_entry_completion_get_model(completion);
+    return (self->slot_)(Glib::convert_const_gchar_ptr_to_ustring(key),
+                         Gtk::TreeModel::const_iterator(tree_model, iter)
+                         );
+  }
+  catch(...)
+  {
+    Glib::exception_handlers_invoke();
+  }
+
+  return FALSE; //An arbitary default, just to avoid the compiler warning.
+}
+
+void SignalProxy_Match::gtk_callback_destroy(void* data)
+{
+  delete static_cast<SignalProxy_Match*>(data);
+}
+
+} // anonymous namespace
+
+
+namespace Gtk
+{
+
+void EntryCompletion::set_match_func(const SlotMatch& slot)
+{
+  // Create a signal proxy.  A pointer to this will be passed
+  // through the callback's data parameter.  It will be deleted
+  // when SignalProxy_Match::gtk_callback_destroy() is called.
+  SignalProxy_Match *const pSignalProxy = new SignalProxy_Match(slot);
+
+  gtk_entry_completion_set_match_func(gobj(),
+      &SignalProxy_Match::gtk_callback, pSignalProxy,
+      &SignalProxy_Match::gtk_callback_destroy);
+}
+
+void EntryCompletion::insert_action_text(const Glib::ustring& text, int index)
+{
+  gtk_entry_completion_insert_action_text(gobj(), index, text.c_str());
+}
+
+void EntryCompletion::insert_action_markup(const Glib::ustring& markup, int index)
+{
+  gtk_entry_completion_insert_action_markup(gobj(), index, markup.c_str());
+}
+
+void EntryCompletion::prepend_action_text(const Glib::ustring& text)
+{
+  //We know that gtk_entry_completion_insert_action_text() uses gtk_list_store_insert(),
+  //and we know that gtk_list_store_insert() prepends if the position is 0, though
+  //this is not actually documented.
+  gtk_entry_completion_insert_action_text(gobj(), 0, text.c_str());
+}
+
+void EntryCompletion::prepend_action_markup(const Glib::ustring& markup)
+{
+  //We know that gtk_entry_completion_insert_action_markup() uses gtk_list_store_insert(),
+  //and we know that gtk_list_store_insert() prepends if the position is 0, though
+  //this is not actually documented.
+  gtk_entry_completion_insert_action_markup(gobj(), 0 /* See C docs */, markup.c_str());
+}
+
+} //namespace Gtk
+
+
+namespace //anonymous
+{
+
+gboolean Widget_signal_match_selected_callback(GtkEntryCompletion* self, GtkTreeModel* c_model, GtkTreeIter* c_iter, void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< bool, const TreeModel::iterator& > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+      {
+        //This conversion is the custom-written part:
+        Gtk::TreeModel::iterator cppIter(c_model, c_iter);
+        
+        return static_cast<int>( (*static_cast<SlotType*>(slot))(cppIter) );
+      }
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+gboolean Widget_signal_match_selected_notify_callback(GtkEntryCompletion* self, GtkTreeModel* c_model, GtkTreeIter* c_iter, void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void, const TreeModel::iterator& > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+      {
+        //This conversion is the custom-written part:
+        Gtk::TreeModel::iterator cppIter(c_model, c_iter);
+
+        (*static_cast<SlotType*>(slot))(cppIter);
+      }
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+const Glib::SignalProxyInfo EntryCompletion_signal_match_selected_info =
+{
+  "match_selected",
+  (GCallback) &Widget_signal_match_selected_callback,
+  (GCallback) &Widget_signal_match_selected_notify_callback
+};
+
+} //anonymous namespace
+
+
+namespace Gtk
+{
+
+
+//Hand-coded signal wrapping:
+
+bool Gtk::EntryCompletion::on_match_selected(const TreeModel::iterator& iter)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->match_selected)
+    return (*base->match_selected)(gobj(), iter.get_model_gobject(), const_cast<GtkTreeIter*>(iter.gobj()));
+  else
+  {
+    typedef bool RType;
+    return RType(); //There should always be an implementation in the C object, so this will never happen.
+  }
+}
+
+gboolean EntryCompletion_Class::match_selected_callback_custom(GtkEntryCompletion* self, GtkTreeModel* c_model, GtkTreeIter* c_iter)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+
+      //This conversion is the custom-written part:
+      Gtk::TreeModel::iterator cppIter(c_model, c_iter);
+      return obj->on_match_selected(cppIter);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->match_selected)
+      return (*base->match_selected)(self, c_model, c_iter);
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+Glib::SignalProxy1< bool, const TreeModel::iterator& > EntryCompletion::signal_match_selected()
+{
+  return Glib::SignalProxy1< bool, const TreeModel::iterator& >(this, &EntryCompletion_signal_match_selected_info);
+}
+
+
+} // namespace Gtk
+
+
+namespace
+{
+
+void EntryCompletion_signal_action_activated_callback(GtkEntryCompletion* self, gint p0,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,int > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(p0
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+}
+
+const Glib::SignalProxyInfo EntryCompletion_signal_action_activated_info =
+{
+  "action_activated",
+  (GCallback) &EntryCompletion_signal_action_activated_callback,
+  (GCallback) &EntryCompletion_signal_action_activated_callback
+};
+
+
+gboolean EntryCompletion_signal_insert_prefix_callback(GtkEntryCompletion* self, const gchar* p0,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< bool,const Glib::ustring& > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        return static_cast<int>((*static_cast<SlotType*>(slot))(Glib::convert_const_gchar_ptr_to_ustring(p0)
+));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+gboolean EntryCompletion_signal_insert_prefix_notify_callback(GtkEntryCompletion* self, const gchar* p0, void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,const Glib::ustring& > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(Glib::convert_const_gchar_ptr_to_ustring(p0)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+const Glib::SignalProxyInfo EntryCompletion_signal_insert_prefix_info =
+{
+  "insert_prefix",
+  (GCallback) &EntryCompletion_signal_insert_prefix_callback,
+  (GCallback) &EntryCompletion_signal_insert_prefix_notify_callback
+};
+
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Glib::RefPtr<Gtk::EntryCompletion> wrap(GtkEntryCompletion* object, bool take_copy)
+{
+  return Glib::RefPtr<Gtk::EntryCompletion>( dynamic_cast<Gtk::EntryCompletion*> (Glib::wrap_auto ((GObject*)(object), take_copy)) );
+  //We use dynamic_cast<> in case of multiple inheritance.
+}
+
+} /* namespace Glib */
+
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& EntryCompletion_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &EntryCompletion_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_entry_completion_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void EntryCompletion_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+  klass->action_activated = &action_activated_callback;
+    klass->match_selected = &match_selected_callback_custom;
+  }
+
+
+void EntryCompletion_Class::action_activated_callback(GtkEntryCompletion* self, gint p0)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_action_activated(p0
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->action_activated)
+      (*base->action_activated)(self, p0);
+  }
+}
+
+
+Glib::ObjectBase* EntryCompletion_Class::wrap_new(GObject* object)
+{
+  return new EntryCompletion((GtkEntryCompletion*)object);
+}
+
+
+/* The implementation: */
+
+GtkEntryCompletion* EntryCompletion::gobj_copy()
+{
+  reference();
+  return gobj();
+}
+
+EntryCompletion::EntryCompletion(const Glib::ConstructParams& construct_params)
+:
+  Glib::Object(construct_params)
+{}
+
+EntryCompletion::EntryCompletion(GtkEntryCompletion* castitem)
+:
+  Glib::Object((GObject*)(castitem))
+{}
+
+EntryCompletion::~EntryCompletion()
+{}
+
+
+EntryCompletion::CppClassType EntryCompletion::entrycompletion_class_; // initialize static member
+
+GType EntryCompletion::get_type()
+{
+  return entrycompletion_class_.init().get_type();
+}
+
+GType EntryCompletion::get_base_type()
+{
+  return gtk_entry_completion_get_type();
+}
+
+
+EntryCompletion::EntryCompletion()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Glib::Object(Glib::ConstructParams(entrycompletion_class_.init()))
+{
+  }
+
+Glib::RefPtr<EntryCompletion> EntryCompletion::create()
+{
+  return Glib::RefPtr<EntryCompletion>( new EntryCompletion() );
+}
+Entry* EntryCompletion::get_entry()
+{
+  return Glib::wrap((GtkEntry*)(gtk_entry_completion_get_entry(gobj())));
+}
+
+const Entry* EntryCompletion::get_entry() const
+{
+  return Glib::wrap((GtkEntry*)(gtk_entry_completion_get_entry(const_cast<GtkEntryCompletion*>(gobj()))));
+}
+
+void EntryCompletion::set_model(const Glib::RefPtr<TreeModel>& model)
+{
+  gtk_entry_completion_set_model(gobj(), Glib::unwrap(model));
+}
+
+Glib::RefPtr<TreeModel> EntryCompletion::get_model()
+{
+
+  Glib::RefPtr<TreeModel> retvalue = Glib::wrap(gtk_entry_completion_get_model(gobj()));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::RefPtr<const TreeModel> EntryCompletion::get_model() const
+{
+
+  Glib::RefPtr<const TreeModel> retvalue = Glib::wrap(gtk_entry_completion_get_model(const_cast<GtkEntryCompletion*>(gobj())));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+void EntryCompletion::set_minimum_key_length(int length)
+{
+  gtk_entry_completion_set_minimum_key_length(gobj(), length);
+}
+
+int EntryCompletion::get_minimum_key_length() const
+{
+  return gtk_entry_completion_get_minimum_key_length(const_cast<GtkEntryCompletion*>(gobj()));
+}
+
+void EntryCompletion::complete()
+{
+  gtk_entry_completion_complete(gobj());
+}
+
+void EntryCompletion::insert_prefix()
+{
+  gtk_entry_completion_insert_prefix(gobj());
+}
+
+void EntryCompletion::delete_action(int index)
+{
+  gtk_entry_completion_delete_action(gobj(), index);
+}
+
+void EntryCompletion::set_inline_completion(bool inline_completion)
+{
+  gtk_entry_completion_set_inline_completion(gobj(), static_cast<int>(inline_completion));
+}
+
+bool EntryCompletion::get_inline_completion() const
+{
+  return gtk_entry_completion_get_inline_completion(const_cast<GtkEntryCompletion*>(gobj()));
+}
+
+void EntryCompletion::set_popup_completion(bool popup_completion)
+{
+  gtk_entry_completion_set_popup_completion(gobj(), static_cast<int>(popup_completion));
+}
+
+bool EntryCompletion::get_popup_completion() const
+{
+  return gtk_entry_completion_get_popup_completion(const_cast<GtkEntryCompletion*>(gobj()));
+}
+
+void EntryCompletion::set_text_column(const TreeModelColumnBase& column)
+{
+  gtk_entry_completion_set_text_column(gobj(), (column).index());
+}
+
+void EntryCompletion::set_text_column(int column)
+{
+  gtk_entry_completion_set_text_column(gobj(), column);
+}
+
+int EntryCompletion::get_text_column()
+{
+  return gtk_entry_completion_get_text_column(gobj());
+}
+
+
+Glib::SignalProxy1< void,int > EntryCompletion::signal_action_activated()
+{
+  return Glib::SignalProxy1< void,int >(this, &EntryCompletion_signal_action_activated_info);
+}
+
+Glib::SignalProxy1< bool,const Glib::ustring& > EntryCompletion::signal_insert_prefix()
+{
+  return Glib::SignalProxy1< bool,const Glib::ustring& >(this, &EntryCompletion_signal_insert_prefix_info);
+}
+
+
+void Gtk::EntryCompletion::on_action_activated(int index)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->action_activated)
+    (*base->action_activated)(gobj(),index);
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/entrycompletion.h b/libs/gtkmm2/gtk/gtkmm/entrycompletion.h
new file mode 100644
index 0000000000..2d8e0c5bd0
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/entrycompletion.h
@@ -0,0 +1,323 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_ENTRYCOMPLETION_H
+#define _GTKMM_ENTRYCOMPLETION_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* Copyright (C) 2003 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/widget.h>
+#include <gtkmm/treemodel.h>
+ 
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkEntryCompletion GtkEntryCompletion;
+typedef struct _GtkEntryCompletionClass GtkEntryCompletionClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class EntryCompletion_Class; } // namespace Gtk
+namespace Gtk
+{
+
+class Entry;
+
+
+class EntryCompletion : public Glib::Object
+{
+  
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+public:
+  typedef EntryCompletion CppObjectType;
+  typedef EntryCompletion_Class CppClassType;
+  typedef GtkEntryCompletion BaseObjectType;
+  typedef GtkEntryCompletionClass BaseClassType;
+
+private:  friend class EntryCompletion_Class;
+  static CppClassType entrycompletion_class_;
+
+private:
+  // noncopyable
+  EntryCompletion(const EntryCompletion&);
+  EntryCompletion& operator=(const EntryCompletion&);
+
+protected:
+  explicit EntryCompletion(const Glib::ConstructParams& construct_params);
+  explicit EntryCompletion(GtkEntryCompletion* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+  virtual ~EntryCompletion();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GObject.
+  GtkEntryCompletion*       gobj()       { return reinterpret_cast<GtkEntryCompletion*>(gobject_); }
+
+  ///Provides access to the underlying C GObject.
+  const GtkEntryCompletion* gobj() const { return reinterpret_cast<GtkEntryCompletion*>(gobject_); }
+
+  ///Provides access to the underlying C instance. The caller is responsible for unrefing it. Use when directly setting fields in structs.
+  GtkEntryCompletion* gobj_copy();
+
+private:
+
+
+protected:
+  EntryCompletion();
+
+public:
+  
+  static Glib::RefPtr<EntryCompletion> create();
+
+
+  //Careful, this actually returns a GtkWidget*, so it might not always be a GtkEntry in future GTK+ versions.
+  
+  /** Gets the entry @a completion  has been attached to.
+   * @return The entry @a completion  has been attached to.
+   * 
+   * Since: 2.4.
+   */
+  Entry* get_entry();
+  
+  /** Gets the entry @a completion  has been attached to.
+   * @return The entry @a completion  has been attached to.
+   * 
+   * Since: 2.4.
+   */
+  const Entry* get_entry() const;
+
+  
+  /** Sets the model for a Gtk::EntryCompletion. If @a completion  already has
+   * a model set, it will remove it before setting the new model.
+   * If model is <tt>0</tt>, then it will unset the model.
+   * 
+   * Since: 2.4
+   * @param model The Gtk::TreeModel.
+   */
+  void set_model(const Glib::RefPtr<TreeModel>& model);
+  
+  /** Returns the model the Gtk::EntryCompletion is using as data source.
+   * Returns <tt>0</tt> if the model is unset.
+   * @return A Gtk::TreeModel, or <tt>0</tt> if none is currently being used.
+   * 
+   * Since: 2.4.
+   */
+  Glib::RefPtr<TreeModel> get_model();
+  
+  /** Returns the model the Gtk::EntryCompletion is using as data source.
+   * Returns <tt>0</tt> if the model is unset.
+   * @return A Gtk::TreeModel, or <tt>0</tt> if none is currently being used.
+   * 
+   * Since: 2.4.
+   */
+  Glib::RefPtr<const TreeModel> get_model() const;
+
+  /// For example, bool on_match(const Glib::ustring& key, const TreeModel::const_iterator& iter);
+  typedef sigc::slot<bool, const Glib::ustring&, const TreeModel::const_iterator&> SlotMatch;
+  
+  void set_match_func(const SlotMatch& slot);
+  
+  
+  /** Requires the length of the search key for @a completion  to be at least
+   *  @a length . This is useful for long lists, where completing using a small
+   * key takes a lot of time and will come up with meaningless results anyway
+   * (ie, a too large dataset).
+   * 
+   * Since: 2.4
+   * @param length The minimum length of the key in order to start completing.
+   */
+  void set_minimum_key_length(int length);
+  
+  /** Returns the minimum key length as set for @a completion .
+   * @return The currently used minimum key length.
+   * 
+   * Since: 2.4.
+   */
+  int get_minimum_key_length() const;
+  
+  /** Requests a completion operation, or in other words a refiltering of the
+   * current list with completions, using the current key. The completion list
+   * view will be updated accordingly.
+   * 
+   * Since: 2.4
+   */
+  void complete();
+
+  
+  /** Requests a prefix insertion. 
+   * 
+   * Since: 2.6
+   */
+  void insert_prefix();
+
+  //We reordered the parameters, compared to the C version, so that we can have method overloads without the index.
+
+  // TODO: We would really like an insert() which before-inserts an iterator, like ListStore::insert(),
+  // but there is no EntryCompletion::insert_before() for us to use.
+  void insert_action_text(const Glib::ustring& text, int index);
+  void prepend_action_text(const Glib::ustring& text);
+  //TODO: Add append_action_text() somehow? It would be slow if we count the children each time. murrayc.
+  
+  void insert_action_markup(const Glib::ustring& markup, int index);
+  void prepend_action_markup(const Glib::ustring& markup);
+  
+
+  //TODO: Change default - it would be nicer to delete the last action instead of the first.
+  
+  /** Deletes the action at @a index  from @a completion 's action list.
+   * 
+   * Since: 2.4
+   * @param index The index of the item to Delete.
+   */
+  void delete_action(int index = 0);
+
+  
+  /** Sets whether the common prefix of the possible completions should
+   * be automatically inserted in the entry.
+   * 
+   * Since: 2.6
+   * @param inline_completion <tt>true</tt> to do inline completion.
+   */
+  void set_inline_completion(bool inline_completion = true);
+  
+  /** Returns whether the common prefix of the possible completions should
+   * be automatically inserted in the entry.
+   * @return <tt>true</tt> if inline completion is turned on
+   * 
+   * Since: 2.6.
+   */
+  bool get_inline_completion() const;
+  
+  /** Sets whether the completions should be presented in a popup window.
+   * 
+   * Since: 2.6
+   * @param popup_completion <tt>true</tt> to do popup completion.
+   */
+  void set_popup_completion(bool popup_completion = true);
+  
+  /** Returns whether the completions should be presented in a popup window.
+   * @return <tt>true</tt> if popup completion is turned on
+   * 
+   * Since: 2.6.
+   */
+  bool get_popup_completion() const;
+
+  
+  /** Convenience function for setting up the most used case of this code: a
+   * completion list with just strings. This function will set up @a completion 
+   * to have a list displaying all (and just) strings in the completion list,
+   * and to get those strings from @a column  in the model of @a completion .
+   * 
+   * This functions creates and adds a Gtk::CellRendererText for the selected 
+   * column. If you need to set the text column, but don't want the cell 
+   * renderer, use Glib::object_set() to set the ::text_column property directly.
+   * 
+   * Since: 2.4
+   * @param column The column in the model of @a completion  to get strings from.
+   */
+  void set_text_column(const TreeModelColumnBase& column);
+  
+  /** Convenience function for setting up the most used case of this code: a
+   * completion list with just strings. This function will set up @a completion 
+   * to have a list displaying all (and just) strings in the completion list,
+   * and to get those strings from @a column  in the model of @a completion .
+   * 
+   * This functions creates and adds a Gtk::CellRendererText for the selected 
+   * column. If you need to set the text column, but don't want the cell 
+   * renderer, use Glib::object_set() to set the ::text_column property directly.
+   * 
+   * Since: 2.4
+   * @param column The column in the model of @a completion  to get strings from.
+   */
+  void set_text_column(int column);
+  
+  /** Returns the column in the model of @a completion  to get strings from.
+   * @return The column containing the strings
+   * 
+   * Since: 2.6.
+   */
+  int get_text_column();
+
+  
+  Glib::SignalProxy1< void,int > signal_action_activated();
+
+
+  //We completely hand-code this signal because we want to change how the parameters are wrapped,
+  //because we need both the iter and the model to make the C++ iter.
+  
+
+  /**
+   * @par Prototype:
+   * <tt>bool %match_selected(const TreeModel::iterator& iter)</tt>
+   */
+  Glib::SignalProxy1< bool, const TreeModel::iterator& > signal_match_selected();
+
+  
+  //We use no_default_handler for this, because we can not add a new vfunc to 2.5 without breaking ABI.
+  //TODO: Remove no_default_handler when we do an ABI-break-with-parallel-install.
+  
+
+  Glib::SignalProxy1< bool,const Glib::ustring& > signal_insert_prefix();
+ 
+
+protected:
+
+  //Default Signal Handler:
+  virtual bool on_match_selected(const TreeModel::iterator& iter);        
+
+
+public:
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+  virtual void on_action_activated(int index);
+
+
+};
+
+} // namespace Gtk
+
+
+namespace Glib
+{
+  /** @relates Gtk::EntryCompletion
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Glib::RefPtr<Gtk::EntryCompletion> wrap(GtkEntryCompletion* object, bool take_copy = false);
+}
+
+
+#endif /* _GTKMM_ENTRYCOMPLETION_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/enums.cc b/libs/gtkmm2/gtk/gtkmm/enums.cc
new file mode 100644
index 0000000000..a20f39360f
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/enums.cc
@@ -0,0 +1,283 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/enums.h>
+#include <gtkmm/private/enums_p.h>
+
+#include <gtk/gtktypebuiltins.h>
+// -*- c++ -*-
+/* $Id$ */
+
+/* 
+ *
+ * Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/enums.h>
+
+// static
+GType Glib::Value<Gtk::IconSize>::value_type()
+{
+  return gtk_icon_size_get_type();
+}
+
+namespace Gtk
+{
+
+float _gtkmm_align_float_from_enum(AlignmentEnum value)
+{
+  //Choose the float alignment value appropriate for this human-readable enum value:
+  switch(value)
+  {
+    case ALIGN_LEFT:
+      return 0.0; break;
+    case ALIGN_CENTER:
+      return 0.5; break;
+    case ALIGN_RIGHT:
+      return 1.0; break;
+    case ALIGN_TOP:
+      return _gtkmm_align_float_from_enum(ALIGN_LEFT); break;
+    case ALIGN_BOTTOM:
+      return _gtkmm_align_float_from_enum(ALIGN_RIGHT); break;
+    default:
+      return _gtkmm_align_float_from_enum(ALIGN_LEFT); break;
+  }
+}
+
+} //namespace Gtk
+
+
+namespace
+{
+} // anonymous namespace
+
+// static
+GType Glib::Value<Gtk::AccelFlags>::value_type()
+{
+  return gtk_accel_flags_get_type();
+}
+
+// static
+GType Glib::Value<Gtk::AnchorType>::value_type()
+{
+  return gtk_anchor_type_get_type();
+}
+
+// static
+GType Glib::Value<Gtk::ArrowType>::value_type()
+{
+  return gtk_arrow_type_get_type();
+}
+
+// static
+GType Glib::Value<Gtk::AttachOptions>::value_type()
+{
+  return gtk_attach_options_get_type();
+}
+
+// static
+GType Glib::Value<Gtk::ButtonBoxStyle>::value_type()
+{
+  return gtk_button_box_style_get_type();
+}
+
+// static
+GType Glib::Value<Gtk::CurveType>::value_type()
+{
+  return gtk_curve_type_get_type();
+}
+
+// static
+GType Glib::Value<Gtk::DeleteType>::value_type()
+{
+  return gtk_delete_type_get_type();
+}
+
+// static
+GType Glib::Value<Gtk::DirectionType>::value_type()
+{
+  return gtk_direction_type_get_type();
+}
+
+// static
+GType Glib::Value<Gtk::ExpanderStyle>::value_type()
+{
+  return gtk_expander_style_get_type();
+}
+
+// static
+GType Glib::Value<Gtk::BuiltinIconSize>::value_type()
+{
+  return gtk_icon_size_get_type();
+}
+
+// static
+GType Glib::Value<Gtk::TextDirection>::value_type()
+{
+  return gtk_text_direction_get_type();
+}
+
+// static
+GType Glib::Value<Gtk::Justification>::value_type()
+{
+  return gtk_justification_get_type();
+}
+
+// static
+GType Glib::Value<Gtk::MenuDirectionType>::value_type()
+{
+  return gtk_menu_direction_type_get_type();
+}
+
+// static
+GType Glib::Value<Gtk::MetricType>::value_type()
+{
+  return gtk_metric_type_get_type();
+}
+
+// static
+GType Glib::Value<Gtk::MovementStep>::value_type()
+{
+  return gtk_movement_step_get_type();
+}
+
+// static
+GType Glib::Value<Gtk::Orientation>::value_type()
+{
+  return gtk_orientation_get_type();
+}
+
+// static
+GType Glib::Value<Gtk::CornerType>::value_type()
+{
+  return gtk_corner_type_get_type();
+}
+
+// static
+GType Glib::Value<Gtk::PackType>::value_type()
+{
+  return gtk_pack_type_get_type();
+}
+
+// static
+GType Glib::Value<Gtk::PathPriorityType>::value_type()
+{
+  return gtk_path_priority_type_get_type();
+}
+
+// static
+GType Glib::Value<Gtk::PathType>::value_type()
+{
+  return gtk_path_type_get_type();
+}
+
+// static
+GType Glib::Value<Gtk::PolicyType>::value_type()
+{
+  return gtk_policy_type_get_type();
+}
+
+// static
+GType Glib::Value<Gtk::PositionType>::value_type()
+{
+  return gtk_position_type_get_type();
+}
+
+// static
+GType Glib::Value<Gtk::ReliefStyle>::value_type()
+{
+  return gtk_relief_style_get_type();
+}
+
+// static
+GType Glib::Value<Gtk::ResizeMode>::value_type()
+{
+  return gtk_resize_mode_get_type();
+}
+
+// static
+GType Glib::Value<Gtk::ScrollType>::value_type()
+{
+  return gtk_scroll_type_get_type();
+}
+
+// static
+GType Glib::Value<Gtk::SelectionMode>::value_type()
+{
+  return gtk_selection_mode_get_type();
+}
+
+// static
+GType Glib::Value<Gtk::ShadowType>::value_type()
+{
+  return gtk_shadow_type_get_type();
+}
+
+// static
+GType Glib::Value<Gtk::StateType>::value_type()
+{
+  return gtk_state_type_get_type();
+}
+
+// static
+GType Glib::Value<Gtk::TargetFlags>::value_type()
+{
+  return gtk_target_flags_get_type();
+}
+
+// static
+GType Glib::Value<Gtk::ToolbarStyle>::value_type()
+{
+  return gtk_toolbar_style_get_type();
+}
+
+// static
+GType Glib::Value<Gtk::UpdateType>::value_type()
+{
+  return gtk_update_type_get_type();
+}
+
+// static
+GType Glib::Value<Gtk::Visibility>::value_type()
+{
+  return gtk_visibility_get_type();
+}
+
+// static
+GType Glib::Value<Gtk::WindowPosition>::value_type()
+{
+  return gtk_window_position_get_type();
+}
+
+// static
+GType Glib::Value<Gtk::WindowType>::value_type()
+{
+  return gtk_window_type_get_type();
+}
+
+// static
+GType Glib::Value<Gtk::WrapMode>::value_type()
+{
+  return gtk_wrap_mode_get_type();
+}
+
+// static
+GType Glib::Value<Gtk::SortType>::value_type()
+{
+  return gtk_sort_type_get_type();
+}
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/enums.h b/libs/gtkmm2/gtk/gtkmm/enums.h
new file mode 100644
index 0000000000..07d0830d40
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/enums.h
@@ -0,0 +1,1422 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_ENUMS_H
+#define _GTKMM_ENUMS_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* enums.h
+ * 
+ * Copyright (C) 2002 The gtkmm Development Team 
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+
+namespace Gtk
+{
+
+
+/** @addtogroup gtkmmEnums Enums and Flags */
+
+/**
+ * @ingroup gtkmmEnums
+ * @par Bitwise operators:
+ * <tt>%AccelFlags operator|(AccelFlags, AccelFlags)</tt><br>
+ * <tt>%AccelFlags operator&(AccelFlags, AccelFlags)</tt><br>
+ * <tt>%AccelFlags operator^(AccelFlags, AccelFlags)</tt><br>
+ * <tt>%AccelFlags operator~(AccelFlags)</tt><br>
+ * <tt>%AccelFlags& operator|=(AccelFlags&, AccelFlags)</tt><br>
+ * <tt>%AccelFlags& operator&=(AccelFlags&, AccelFlags)</tt><br>
+ * <tt>%AccelFlags& operator^=(AccelFlags&, AccelFlags)</tt><br>
+ */
+enum AccelFlags
+{
+  ACCEL_VISIBLE = 1 << 0,
+  ACCEL_LOCKED = 1 << 1,
+  ACCEL_MASK = 0x07
+};
+
+/** @ingroup gtkmmEnums */
+inline AccelFlags operator|(AccelFlags lhs, AccelFlags rhs)
+  { return static_cast<AccelFlags>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs)); }
+
+/** @ingroup gtkmmEnums */
+inline AccelFlags operator&(AccelFlags lhs, AccelFlags rhs)
+  { return static_cast<AccelFlags>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs)); }
+
+/** @ingroup gtkmmEnums */
+inline AccelFlags operator^(AccelFlags lhs, AccelFlags rhs)
+  { return static_cast<AccelFlags>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs)); }
+
+/** @ingroup gtkmmEnums */
+inline AccelFlags operator~(AccelFlags flags)
+  { return static_cast<AccelFlags>(~static_cast<unsigned>(flags)); }
+
+/** @ingroup gtkmmEnums */
+inline AccelFlags& operator|=(AccelFlags& lhs, AccelFlags rhs)
+  { return (lhs = static_cast<AccelFlags>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs))); }
+
+/** @ingroup gtkmmEnums */
+inline AccelFlags& operator&=(AccelFlags& lhs, AccelFlags rhs)
+  { return (lhs = static_cast<AccelFlags>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs))); }
+
+/** @ingroup gtkmmEnums */
+inline AccelFlags& operator^=(AccelFlags& lhs, AccelFlags rhs)
+  { return (lhs = static_cast<AccelFlags>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs))); }
+
+} // namespace Gtk
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Gtk::AccelFlags> : public Glib::Value_Flags<Gtk::AccelFlags>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{
+
+/**
+ * @ingroup gtkmmEnums
+ */
+enum AnchorType
+{
+  ANCHOR_CENTER,
+  ANCHOR_NORTH,
+  ANCHOR_NORTH_WEST,
+  ANCHOR_NORTH_EAST,
+  ANCHOR_SOUTH,
+  ANCHOR_SOUTH_WEST,
+  ANCHOR_SOUTH_EAST,
+  ANCHOR_WEST,
+  ANCHOR_EAST,
+  ANCHOR_N = ANCHOR_NORTH,
+  ANCHOR_NW = ANCHOR_NORTH_WEST,
+  ANCHOR_NE = ANCHOR_NORTH_EAST,
+  ANCHOR_S = ANCHOR_SOUTH,
+  ANCHOR_SW = ANCHOR_SOUTH_WEST,
+  ANCHOR_SE = ANCHOR_SOUTH_EAST,
+  ANCHOR_W = ANCHOR_WEST,
+  ANCHOR_E = ANCHOR_EAST
+};
+
+} // namespace Gtk
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Gtk::AnchorType> : public Glib::Value_Enum<Gtk::AnchorType>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{
+
+
+/** Used to indicate the direction in which a Gtk::Arrow should point.
+ * @ingroup gtkmmEnums
+ */
+enum ArrowType
+{
+  ARROW_UP,
+  ARROW_DOWN,
+  ARROW_LEFT,
+  ARROW_RIGHT
+};
+
+} // namespace Gtk
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Gtk::ArrowType> : public Glib::Value_Enum<Gtk::ArrowType>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{
+
+
+// TODO: There must be a better way to document the enum values.
+//       Extract them from the GTK+ docs as well?
+
+/*! @var ArrowType ARROW_UP
+ * Represents an upward pointing arrow.
+ */
+/*! @var ArrowType ARROW_DOWN
+ * Represents a downward pointing arrow.
+ */
+/*! @var ArrowType ARROW_LEFT
+ * Represents a left pointing arrow.
+ */
+/*! @var ArrowType ARROW_RIGHT
+ * Represents a right pointing arrow.
+ */
+
+/** Denotes the expansion properties that a widget will have when it (or its parent) is resized.
+ * @ingroup gtkmmEnums
+ * @par Bitwise operators:
+ * <tt>%AttachOptions operator|(AttachOptions, AttachOptions)</tt><br>
+ * <tt>%AttachOptions operator&(AttachOptions, AttachOptions)</tt><br>
+ * <tt>%AttachOptions operator^(AttachOptions, AttachOptions)</tt><br>
+ * <tt>%AttachOptions operator~(AttachOptions)</tt><br>
+ * <tt>%AttachOptions& operator|=(AttachOptions&, AttachOptions)</tt><br>
+ * <tt>%AttachOptions& operator&=(AttachOptions&, AttachOptions)</tt><br>
+ * <tt>%AttachOptions& operator^=(AttachOptions&, AttachOptions)</tt><br>
+ */
+enum AttachOptions
+{
+  EXPAND = 1 << 0,
+  SHRINK = 1 << 1,
+  FILL = 1 << 2
+};
+
+/** @ingroup gtkmmEnums */
+inline AttachOptions operator|(AttachOptions lhs, AttachOptions rhs)
+  { return static_cast<AttachOptions>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs)); }
+
+/** @ingroup gtkmmEnums */
+inline AttachOptions operator&(AttachOptions lhs, AttachOptions rhs)
+  { return static_cast<AttachOptions>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs)); }
+
+/** @ingroup gtkmmEnums */
+inline AttachOptions operator^(AttachOptions lhs, AttachOptions rhs)
+  { return static_cast<AttachOptions>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs)); }
+
+/** @ingroup gtkmmEnums */
+inline AttachOptions operator~(AttachOptions flags)
+  { return static_cast<AttachOptions>(~static_cast<unsigned>(flags)); }
+
+/** @ingroup gtkmmEnums */
+inline AttachOptions& operator|=(AttachOptions& lhs, AttachOptions rhs)
+  { return (lhs = static_cast<AttachOptions>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs))); }
+
+/** @ingroup gtkmmEnums */
+inline AttachOptions& operator&=(AttachOptions& lhs, AttachOptions rhs)
+  { return (lhs = static_cast<AttachOptions>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs))); }
+
+/** @ingroup gtkmmEnums */
+inline AttachOptions& operator^=(AttachOptions& lhs, AttachOptions rhs)
+  { return (lhs = static_cast<AttachOptions>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs))); }
+
+} // namespace Gtk
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Gtk::AttachOptions> : public Glib::Value_Flags<Gtk::AttachOptions>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{
+
+
+/*! @var AttachOptions EXPAND
+ * The widget should expand to take up any extra space in its container that has been allocated.
+ */
+/*! @var AttachOptions SHRINK
+ * The widget should shrink as and when possible.
+ */
+/*! @var AttachOptions FILL
+ * The widget should fill the space allocated to it.
+ */
+
+/**
+ * @ingroup gtkmmEnums
+ */
+enum ButtonBoxStyle
+{
+  BUTTONBOX_DEFAULT_STYLE,
+  BUTTONBOX_SPREAD,
+  BUTTONBOX_EDGE,
+  BUTTONBOX_START,
+  BUTTONBOX_END
+};
+
+} // namespace Gtk
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Gtk::ButtonBoxStyle> : public Glib::Value_Enum<Gtk::ButtonBoxStyle>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{
+
+/**
+ * @ingroup gtkmmEnums
+ */
+enum CurveType
+{
+  CURVE_TYPE_LINEAR,
+  CURVE_TYPE_SPLINE,
+  CURVE_TYPE_FREE
+};
+
+} // namespace Gtk
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Gtk::CurveType> : public Glib::Value_Enum<Gtk::CurveType>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{
+
+/**
+ * @ingroup gtkmmEnums
+ */
+enum DeleteType
+{
+  DELETE_CHARS,
+  DELETE_WORDS,
+  DELETE_DISPLAY_LINES,
+  DELETE_DISPLAY_LINE_ENDS,
+  DELETE_PARAGRAPH_ENDS,
+  DELETE_PARAGRAPHS,
+  DELETE_WHITESPACE
+};
+
+} // namespace Gtk
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Gtk::DeleteType> : public Glib::Value_Enum<Gtk::DeleteType>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{
+
+/**
+ * @ingroup gtkmmEnums
+ */
+enum DirectionType
+{
+  DIR_TAB_FORWARD,
+  DIR_TAB_BACKWARD,
+  DIR_UP,
+  DIR_DOWN,
+  DIR_LEFT,
+  DIR_RIGHT
+};
+
+} // namespace Gtk
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Gtk::DirectionType> : public Glib::Value_Enum<Gtk::DirectionType>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{
+
+/**
+ * @ingroup gtkmmEnums
+ */
+enum ExpanderStyle
+{
+  EXPANDER_COLLAPSED,
+  EXPANDER_SEMI_COLLAPSED,
+  EXPANDER_SEMI_EXPANDED,
+  EXPANDER_EXPANDED
+};
+
+} // namespace Gtk
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Gtk::ExpanderStyle> : public Glib::Value_Enum<Gtk::ExpanderStyle>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{
+
+/**
+ * @ingroup gtkmmEnums
+ */
+enum BuiltinIconSize
+{
+  ICON_SIZE_INVALID,
+  ICON_SIZE_MENU,
+  ICON_SIZE_SMALL_TOOLBAR,
+  ICON_SIZE_LARGE_TOOLBAR,
+  ICON_SIZE_BUTTON,
+  ICON_SIZE_DND,
+  ICON_SIZE_DIALOG
+};
+
+} // namespace Gtk
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Gtk::BuiltinIconSize> : public Glib::Value_Enum<Gtk::BuiltinIconSize>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{
+
+/**
+ * @ingroup gtkmmEnums
+ */
+enum TextDirection
+{
+  TEXT_DIR_NONE,
+  TEXT_DIR_LTR,
+  TEXT_DIR_RTL
+};
+
+} // namespace Gtk
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Gtk::TextDirection> : public Glib::Value_Enum<Gtk::TextDirection>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{
+
+/**
+ * @ingroup gtkmmEnums
+ */
+enum Justification
+{
+  JUSTIFY_LEFT,
+  JUSTIFY_RIGHT,
+  JUSTIFY_CENTER,
+  JUSTIFY_FILL
+};
+
+} // namespace Gtk
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Gtk::Justification> : public Glib::Value_Enum<Gtk::Justification>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{
+
+/**
+ * @ingroup gtkmmEnums
+ */
+enum MenuDirectionType
+{
+  MENU_DIR_PARENT,
+  MENU_DIR_CHILD,
+  MENU_DIR_NEXT,
+  MENU_DIR_PREV
+};
+
+} // namespace Gtk
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Gtk::MenuDirectionType> : public Glib::Value_Enum<Gtk::MenuDirectionType>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{
+
+/**
+ * @ingroup gtkmmEnums
+ */
+enum MetricType
+{
+  PIXELS,
+  INCHES,
+  CENTIMETERS
+};
+
+} // namespace Gtk
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Gtk::MetricType> : public Glib::Value_Enum<Gtk::MetricType>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{
+
+/**
+ * @ingroup gtkmmEnums
+ */
+enum MovementStep
+{
+  MOVEMENT_LOGICAL_POSITIONS,
+  MOVEMENT_VISUAL_POSITIONS,
+  MOVEMENT_WORDS,
+  MOVEMENT_DISPLAY_LINES,
+  MOVEMENT_DISPLAY_LINE_ENDS,
+  MOVEMENT_PARAGRAPHS,
+  MOVEMENT_PARAGRAPH_ENDS,
+  MOVEMENT_PAGES,
+  MOVEMENT_BUFFER_ENDS,
+  MOVEMENT_HORIZONTAL_PAGES
+};
+
+} // namespace Gtk
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Gtk::MovementStep> : public Glib::Value_Enum<Gtk::MovementStep>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{
+
+/**
+ * @ingroup gtkmmEnums
+ */
+enum Orientation
+{
+  ORIENTATION_HORIZONTAL,
+  ORIENTATION_VERTICAL
+};
+
+} // namespace Gtk
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Gtk::Orientation> : public Glib::Value_Enum<Gtk::Orientation>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{
+
+/**
+ * @ingroup gtkmmEnums
+ */
+enum CornerType
+{
+  CORNER_TOP_LEFT,
+  CORNER_BOTTOM_LEFT,
+  CORNER_TOP_RIGHT,
+  CORNER_BOTTOM_RIGHT
+};
+
+} // namespace Gtk
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Gtk::CornerType> : public Glib::Value_Enum<Gtk::CornerType>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{
+
+/**
+ * @ingroup gtkmmEnums
+ */
+enum PackType
+{
+  PACK_START,
+  PACK_END
+};
+
+} // namespace Gtk
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Gtk::PackType> : public Glib::Value_Enum<Gtk::PackType>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{
+
+/**
+ * @ingroup gtkmmEnums
+ */
+enum PathPriorityType
+{
+  PATH_PRIO_LOWEST = 0,
+  PATH_PRIO_GTK = 4,
+  PATH_PRIO_APPLICATION = 8,
+  PATH_PRIO_THEME = 10,
+  PATH_PRIO_RC = 12,
+  PATH_PRIO_HIGHEST = 15
+};
+
+} // namespace Gtk
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Gtk::PathPriorityType> : public Glib::Value_Enum<Gtk::PathPriorityType>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{
+
+/**
+ * @ingroup gtkmmEnums
+ */
+enum PathType
+{
+  PATH_WIDGET,
+  PATH_WIDGET_CLASS,
+  PATH_CLASS
+};
+
+} // namespace Gtk
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Gtk::PathType> : public Glib::Value_Enum<Gtk::PathType>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{
+
+/**
+ * @ingroup gtkmmEnums
+ */
+enum PolicyType
+{
+  POLICY_ALWAYS,
+  POLICY_AUTOMATIC,
+  POLICY_NEVER
+};
+
+} // namespace Gtk
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Gtk::PolicyType> : public Glib::Value_Enum<Gtk::PolicyType>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{
+
+/**
+ * @ingroup gtkmmEnums
+ */
+enum PositionType
+{
+  POS_LEFT,
+  POS_RIGHT,
+  POS_TOP,
+  POS_BOTTOM
+};
+
+} // namespace Gtk
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Gtk::PositionType> : public Glib::Value_Enum<Gtk::PositionType>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{
+
+/**
+ * @ingroup gtkmmEnums
+ */
+enum ReliefStyle
+{
+  RELIEF_NORMAL,
+  RELIEF_HALF,
+  RELIEF_NONE
+};
+
+} // namespace Gtk
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Gtk::ReliefStyle> : public Glib::Value_Enum<Gtk::ReliefStyle>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{
+
+/**
+ * @ingroup gtkmmEnums
+ */
+enum ResizeMode
+{
+  RESIZE_PARENT,
+  RESIZE_QUEUE,
+  RESIZE_IMMEDIATE
+};
+
+} // namespace Gtk
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Gtk::ResizeMode> : public Glib::Value_Enum<Gtk::ResizeMode>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{
+
+/**
+ * @ingroup gtkmmEnums
+ */
+enum ScrollType
+{
+  SCROLL_NONE,
+  SCROLL_JUMP,
+  SCROLL_STEP_BACKWARD,
+  SCROLL_STEP_FORWARD,
+  SCROLL_PAGE_BACKWARD,
+  SCROLL_PAGE_FORWARD,
+  SCROLL_STEP_UP,
+  SCROLL_STEP_DOWN,
+  SCROLL_PAGE_UP,
+  SCROLL_PAGE_DOWN,
+  SCROLL_STEP_LEFT,
+  SCROLL_STEP_RIGHT,
+  SCROLL_PAGE_LEFT,
+  SCROLL_PAGE_RIGHT,
+  SCROLL_START,
+  SCROLL_END
+};
+
+} // namespace Gtk
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Gtk::ScrollType> : public Glib::Value_Enum<Gtk::ScrollType>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{
+
+/**
+ * @ingroup gtkmmEnums
+ */
+enum SelectionMode
+{
+  SELECTION_NONE,
+  SELECTION_SINGLE,
+  SELECTION_BROWSE,
+  SELECTION_MULTIPLE,
+  SELECTION_EXTENDED = SELECTION_MULTIPLE
+};
+
+} // namespace Gtk
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Gtk::SelectionMode> : public Glib::Value_Enum<Gtk::SelectionMode>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{
+
+/**
+ * @ingroup gtkmmEnums
+ */
+enum ShadowType
+{
+  SHADOW_NONE,
+  SHADOW_IN,
+  SHADOW_OUT,
+  SHADOW_ETCHED_IN,
+  SHADOW_ETCHED_OUT
+};
+
+} // namespace Gtk
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Gtk::ShadowType> : public Glib::Value_Enum<Gtk::ShadowType>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{
+
+/**
+ * @ingroup gtkmmEnums
+ */
+enum StateType
+{
+  STATE_NORMAL,
+  STATE_ACTIVE,
+  STATE_PRELIGHT,
+  STATE_SELECTED,
+  STATE_INSENSITIVE
+};
+
+} // namespace Gtk
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Gtk::StateType> : public Glib::Value_Enum<Gtk::StateType>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{
+
+/**
+ * @ingroup gtkmmEnums
+ * @par Bitwise operators:
+ * <tt>%TargetFlags operator|(TargetFlags, TargetFlags)</tt><br>
+ * <tt>%TargetFlags operator&(TargetFlags, TargetFlags)</tt><br>
+ * <tt>%TargetFlags operator^(TargetFlags, TargetFlags)</tt><br>
+ * <tt>%TargetFlags operator~(TargetFlags)</tt><br>
+ * <tt>%TargetFlags& operator|=(TargetFlags&, TargetFlags)</tt><br>
+ * <tt>%TargetFlags& operator&=(TargetFlags&, TargetFlags)</tt><br>
+ * <tt>%TargetFlags& operator^=(TargetFlags&, TargetFlags)</tt><br>
+ */
+enum TargetFlags
+{
+  TARGET_SAME_APP = 1 << 0,
+  TARGET_SAME_WIDGET = 1 << 1
+};
+
+/** @ingroup gtkmmEnums */
+inline TargetFlags operator|(TargetFlags lhs, TargetFlags rhs)
+  { return static_cast<TargetFlags>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs)); }
+
+/** @ingroup gtkmmEnums */
+inline TargetFlags operator&(TargetFlags lhs, TargetFlags rhs)
+  { return static_cast<TargetFlags>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs)); }
+
+/** @ingroup gtkmmEnums */
+inline TargetFlags operator^(TargetFlags lhs, TargetFlags rhs)
+  { return static_cast<TargetFlags>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs)); }
+
+/** @ingroup gtkmmEnums */
+inline TargetFlags operator~(TargetFlags flags)
+  { return static_cast<TargetFlags>(~static_cast<unsigned>(flags)); }
+
+/** @ingroup gtkmmEnums */
+inline TargetFlags& operator|=(TargetFlags& lhs, TargetFlags rhs)
+  { return (lhs = static_cast<TargetFlags>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs))); }
+
+/** @ingroup gtkmmEnums */
+inline TargetFlags& operator&=(TargetFlags& lhs, TargetFlags rhs)
+  { return (lhs = static_cast<TargetFlags>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs))); }
+
+/** @ingroup gtkmmEnums */
+inline TargetFlags& operator^=(TargetFlags& lhs, TargetFlags rhs)
+  { return (lhs = static_cast<TargetFlags>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs))); }
+
+} // namespace Gtk
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Gtk::TargetFlags> : public Glib::Value_Flags<Gtk::TargetFlags>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{
+
+/**
+ * @ingroup gtkmmEnums
+ */
+enum ToolbarStyle
+{
+  TOOLBAR_ICONS,
+  TOOLBAR_TEXT,
+  TOOLBAR_BOTH,
+  TOOLBAR_BOTH_HORIZ
+};
+
+} // namespace Gtk
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Gtk::ToolbarStyle> : public Glib::Value_Enum<Gtk::ToolbarStyle>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{
+
+/**
+ * @ingroup gtkmmEnums
+ */
+enum UpdateType
+{
+  UPDATE_CONTINUOUS,
+  UPDATE_DISCONTINUOUS,
+  UPDATE_DELAYED
+};
+
+} // namespace Gtk
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Gtk::UpdateType> : public Glib::Value_Enum<Gtk::UpdateType>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{
+
+/**
+ * @ingroup gtkmmEnums
+ */
+enum Visibility
+{
+  VISIBILITY_NONE,
+  VISIBILITY_PARTIAL,
+  VISIBILITY_FULL
+};
+
+} // namespace Gtk
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Gtk::Visibility> : public Glib::Value_Enum<Gtk::Visibility>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{
+
+/**
+ * @ingroup gtkmmEnums
+ */
+enum WindowPosition
+{
+  WIN_POS_NONE,
+  WIN_POS_CENTER,
+  WIN_POS_MOUSE,
+  WIN_POS_CENTER_ALWAYS,
+  WIN_POS_CENTER_ON_PARENT
+};
+
+} // namespace Gtk
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Gtk::WindowPosition> : public Glib::Value_Enum<Gtk::WindowPosition>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{
+
+/**
+ * @ingroup gtkmmEnums
+ */
+enum WindowType
+{
+  WINDOW_TOPLEVEL,
+  WINDOW_POPUP
+};
+
+} // namespace Gtk
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Gtk::WindowType> : public Glib::Value_Enum<Gtk::WindowType>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{
+
+/**
+ * @ingroup gtkmmEnums
+ */
+enum WrapMode
+{
+  WRAP_NONE,
+  WRAP_CHAR,
+  WRAP_WORD,
+  WRAP_WORD_CHAR
+};
+
+} // namespace Gtk
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Gtk::WrapMode> : public Glib::Value_Enum<Gtk::WrapMode>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{
+
+/**
+ * @ingroup gtkmmEnums
+ */
+enum SortType
+{
+  SORT_ASCENDING,
+  SORT_DESCENDING
+};
+
+} // namespace Gtk
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Gtk::SortType> : public Glib::Value_Enum<Gtk::SortType>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{
+
+
+/* We use a class to implement the GtkIconSize enum, because you can register
+ * new "enum" values.  The strict type rules of C++ don't allow using an enum
+ * like that.  Gtk::BuiltinIconSize is the actual GtkIconSize wrapper enum.
+ */
+
+/**
+ * Represents registered icon sizes.
+ * You can also use a Gtk::BuiltinIconSize instead of an IconSize.
+ */
+class IconSize
+{
+private:
+  int size_;
+
+public:
+  IconSize()                     : size_ (0)    {}
+  IconSize(BuiltinIconSize size) : size_ (size) {}
+
+  // Behave like an ordinary enum.
+  explicit IconSize(int size) : size_ (size) {}
+  operator int() const { return size_; }
+
+  // These static methods are implement in iconfactory.ccg.
+  static bool lookup(IconSize size, int& width, int& height);
+  static IconSize register_new(const Glib::ustring& name, int width, int height);
+  static void register_alias(const Glib::ustring& alias, IconSize target);
+  static IconSize from_name(const Glib::ustring& name);
+  static Glib::ustring get_name(IconSize size);
+};
+
+} // namespace Gtk
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Gtk::IconSize> : public Glib::Value_Enum<Gtk::IconSize>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+namespace Gtk
+{
+
+  /** Methods are overriden so you can use these simple enums, or floats for more precision.
+   * @ingroup gtkmmEnums
+   */
+  enum AlignmentEnum
+  {
+    ALIGN_LEFT,   /**< Same as 0.0 */
+    ALIGN_CENTER,  /**< Same as 0.5 */
+    ALIGN_RIGHT,  /**< Same as 1.0 */
+    ALIGN_TOP,   /**< Same as ALIGN_LEFT */
+    ALIGN_BOTTOM  /**< Same as ALIGN_RIGHT */
+  };
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+//We need this because we can't just use floats for enum value.
+float _gtkmm_align_float_from_enum(AlignmentEnum value);
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+} //namespace Gtk
+
+
+#endif /* _GTKMM_ENUMS_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/eventbox.cc b/libs/gtkmm2/gtk/gtkmm/eventbox.cc
new file mode 100644
index 0000000000..9b15790c9d
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/eventbox.cc
@@ -0,0 +1,170 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/eventbox.h>
+#include <gtkmm/private/eventbox_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* 
+ *
+ * Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtk/gtkeventbox.h>
+
+
+namespace
+{
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Gtk::EventBox* wrap(GtkEventBox* object, bool take_copy)
+{
+  return dynamic_cast<Gtk::EventBox *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& EventBox_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &EventBox_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_event_box_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void EventBox_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+}
+
+
+Glib::ObjectBase* EventBox_Class::wrap_new(GObject* o)
+{
+  return manage(new EventBox((GtkEventBox*)(o)));
+
+}
+
+
+/* The implementation: */
+
+EventBox::EventBox(const Glib::ConstructParams& construct_params)
+:
+  Gtk::Bin(construct_params)
+{
+  }
+
+EventBox::EventBox(GtkEventBox* castitem)
+:
+  Gtk::Bin((GtkBin*)(castitem))
+{
+  }
+
+EventBox::~EventBox()
+{
+  destroy_();
+}
+
+EventBox::CppClassType EventBox::eventbox_class_; // initialize static member
+
+GType EventBox::get_type()
+{
+  return eventbox_class_.init().get_type();
+}
+
+GType EventBox::get_base_type()
+{
+  return gtk_event_box_get_type();
+}
+
+
+EventBox::EventBox()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Bin(Glib::ConstructParams(eventbox_class_.init()))
+{
+  }
+
+bool EventBox::get_visible_window() const
+{
+  return gtk_event_box_get_visible_window(const_cast<GtkEventBox*>(gobj()));
+}
+
+void EventBox::set_visible_window(bool visible_window)
+{
+  gtk_event_box_set_visible_window(gobj(), static_cast<int>(visible_window));
+}
+
+bool EventBox::get_above_child() const
+{
+  return gtk_event_box_get_above_child(const_cast<GtkEventBox*>(gobj()));
+}
+
+void EventBox::set_above_child(bool above_child)
+{
+  gtk_event_box_set_above_child(gobj(), static_cast<int>(above_child));
+}
+
+
+Glib::PropertyProxy<bool> EventBox::property_visible_window() 
+{
+  return Glib::PropertyProxy<bool>(this, "visible-window");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> EventBox::property_visible_window() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "visible-window");
+}
+
+Glib::PropertyProxy<bool> EventBox::property_above_child() 
+{
+  return Glib::PropertyProxy<bool>(this, "above-child");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> EventBox::property_above_child() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "above-child");
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/eventbox.h b/libs/gtkmm2/gtk/gtkmm/eventbox.h
new file mode 100644
index 0000000000..927f196888
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/eventbox.h
@@ -0,0 +1,232 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_EVENTBOX_H
+#define _GTKMM_EVENTBOX_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* eventbox.h
+ * 
+ * Copyright (C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/bin.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkEventBox GtkEventBox;
+typedef struct _GtkEventBoxClass GtkEventBoxClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class EventBox_Class; } // namespace Gtk
+namespace Gtk
+{
+
+/** Event capturing box.
+ *
+ * This widget adds an X Window where one does not
+ * normally appear, allowing you to capture events.
+ * It will receive any event which is specified
+ * with set_events().
+ *
+ * This widget is generally used to add Gtk::Tooltips, button presses,
+ * and clipping to widgets derived from Gtk::Misc.
+ *
+ * @ingroup Widgets
+ */
+
+class EventBox : public Bin
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef EventBox CppObjectType;
+  typedef EventBox_Class CppClassType;
+  typedef GtkEventBox BaseObjectType;
+  typedef GtkEventBoxClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~EventBox();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class EventBox_Class;
+  static CppClassType eventbox_class_;
+
+  // noncopyable
+  EventBox(const EventBox&);
+  EventBox& operator=(const EventBox&);
+
+protected:
+  explicit EventBox(const Glib::ConstructParams& construct_params);
+  explicit EventBox(GtkEventBox* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GtkEventBox*       gobj()       { return reinterpret_cast<GtkEventBox*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GtkEventBox* gobj() const { return reinterpret_cast<GtkEventBox*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+private:
+
+public:
+  EventBox();
+
+  
+  /** Returns whether the event box has a visible window.
+   * See set_visible_window() for details.
+   * @return <tt>true</tt> if the event box window is visible
+   * 
+   * Since: 2.4.
+   */
+  bool get_visible_window() const;
+  
+  /** Set whether the event box uses a visible or invisible child
+   * window. The default is to use visible windows.
+   * 
+   * In an invisible window event box, the window that that the
+   * event box creates is a Gdk::INPUT_ONLY window, which 
+   * means that it is invisible and only serves to receive
+   * events.
+   * 
+   * A visible window event box creates a visible (Gdk::INPUT_OUTPUT)
+   * window that acts as the parent window for all the widgets  
+   * contained in the event box.
+   * 
+   * You should generally make your event box invisible if
+   * you just want to trap events. Creating a visible window
+   * may cause artifacts that are visible to the user, especially
+   * if the user is using a theme with gradients or pixmaps.
+   * 
+   * The main reason to create a non input-only event box is if
+   * you want to set the background to a different color or
+   * draw on it.
+   * 
+   * &lt;note&gt;
+   * There is one unexpected issue for an invisible event box that has its
+   * window below the child. (See set_above_child().)
+   * Since the input-only window is not an ancestor window of any windows
+   * that descendent widgets of the event box create, events on these 
+   * windows aren't propagated up by the windowing system, but only by GTK+.
+   * The practical effect of this is if an event isn't in the event
+   * mask for the descendant window (see Gtk::Widget::add_events()),  
+   * it won't be received by the event box. 
+   * 
+   * This problem doesn't occur for visible event boxes, because in
+   * that case, the event box window is actually the ancestor of the
+   * descendant windows, not just at the same place on the screen.
+   * &lt;/note&gt;
+   * 
+   * Since: 2.4
+   * @param visible_window Boolean value.
+   */
+  void set_visible_window(bool visible_window = true);
+  
+  /** Returns whether the event box window is above or below the
+   * windows of its child. See set_above_child() for
+   * details.
+   * @return <tt>true</tt> if the event box window is above the window
+   * of its child.
+   * 
+   * Since: 2.4.
+   */
+  bool get_above_child() const;
+  
+  /** Set whether the event box window is positioned above the windows of its child,
+   * as opposed to below it. If the window is above, all events inside the
+   * event box will go to the event box. If the window is below, events
+   * in windows of child widgets will first got to that widget, and then
+   * to its parents.
+   * 
+   * The default is to keep the window below the child.
+   * 
+   * Since: 2.4
+   * @param above_child <tt>true</tt> if the event box window is above the windows of its child.
+   */
+  void set_above_child(bool above_child = true);
+
+  /** Whether the event box is visible
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_visible_window() ;
+
+/** Whether the event box is visible
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_visible_window() const;
+ 
+  /** Whether the event-trapping window of the eventbox is above the window of the child widget as opposed to below it.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_above_child() ;
+
+/** Whether the event-trapping window of the eventbox is above the window of the child widget as opposed to below it.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_above_child() const;
+ 
+
+};
+
+} /* namespace Gtk */
+
+
+namespace Glib
+{
+  /** @relates Gtk::EventBox
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gtk::EventBox* wrap(GtkEventBox* object, bool take_copy = false);
+}
+#endif /* _GTKMM_EVENTBOX_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/expander.cc b/libs/gtkmm2/gtk/gtkmm/expander.cc
new file mode 100644
index 0000000000..e2c7f83908
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/expander.cc
@@ -0,0 +1,266 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/expander.h>
+#include <gtkmm/private/expander_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* 
+ *
+ * Copyright 2003 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtk/gtkexpander.h>
+
+namespace Gtk
+{
+
+Expander::Expander(const Glib::ustring& label, bool mnemonic)
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Bin(Glib::ConstructParams(expander_class_.init(), "label",label.c_str(),"use_underline",gboolean(mnemonic), (char*) 0))
+{}
+
+} // namespace Gtk
+
+
+namespace
+{
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Gtk::Expander* wrap(GtkExpander* object, bool take_copy)
+{
+  return dynamic_cast<Gtk::Expander *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& Expander_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &Expander_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_expander_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void Expander_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+}
+
+
+Glib::ObjectBase* Expander_Class::wrap_new(GObject* o)
+{
+  return manage(new Expander((GtkExpander*)(o)));
+
+}
+
+
+/* The implementation: */
+
+Expander::Expander(const Glib::ConstructParams& construct_params)
+:
+  Gtk::Bin(construct_params)
+{
+  }
+
+Expander::Expander(GtkExpander* castitem)
+:
+  Gtk::Bin((GtkBin*)(castitem))
+{
+  }
+
+Expander::~Expander()
+{
+  destroy_();
+}
+
+Expander::CppClassType Expander::expander_class_; // initialize static member
+
+GType Expander::get_type()
+{
+  return expander_class_.init().get_type();
+}
+
+GType Expander::get_base_type()
+{
+  return gtk_expander_get_type();
+}
+
+
+Expander::Expander()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Bin(Glib::ConstructParams(expander_class_.init()))
+{
+  }
+
+void Expander::set_expanded(bool expanded)
+{
+  gtk_expander_set_expanded(gobj(), static_cast<int>(expanded));
+}
+
+bool Expander::get_expanded() const
+{
+  return gtk_expander_get_expanded(const_cast<GtkExpander*>(gobj()));
+}
+
+void Expander::set_spacing(int spacing)
+{
+  gtk_expander_set_spacing(gobj(), spacing);
+}
+
+int Expander::get_spacing() const
+{
+  return gtk_expander_get_spacing(const_cast<GtkExpander*>(gobj()));
+}
+
+void Expander::set_label(const Glib::ustring& label)
+{
+  gtk_expander_set_label(gobj(), label.c_str());
+}
+
+Glib::ustring Expander::get_label() const
+{
+  return Glib::convert_const_gchar_ptr_to_ustring(gtk_expander_get_label(const_cast<GtkExpander*>(gobj())));
+}
+
+void Expander::set_use_underline(bool use_underline)
+{
+  gtk_expander_set_use_underline(gobj(), static_cast<int>(use_underline));
+}
+
+bool Expander::get_use_underline() const
+{
+  return gtk_expander_get_use_underline(const_cast<GtkExpander*>(gobj()));
+}
+
+void Expander::set_use_markup(bool use_markup)
+{
+  gtk_expander_set_use_markup(gobj(), static_cast<int>(use_markup));
+}
+
+bool Expander::get_use_markup() const
+{
+  return gtk_expander_get_use_markup(const_cast<GtkExpander*>(gobj()));
+}
+
+void Expander::set_label_widget(Widget& label_widget)
+{
+  gtk_expander_set_label_widget(gobj(), (label_widget).gobj());
+}
+
+Widget* Expander::get_label_widget()
+{
+  return Glib::wrap(gtk_expander_get_label_widget(gobj()));
+}
+
+const Widget* Expander::get_label_widget() const
+{
+  return Glib::wrap(gtk_expander_get_label_widget(const_cast<GtkExpander*>(gobj())));
+}
+
+
+Glib::PropertyProxy<bool> Expander::property_expanded() 
+{
+  return Glib::PropertyProxy<bool>(this, "expanded");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> Expander::property_expanded() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "expanded");
+}
+
+Glib::PropertyProxy<Glib::ustring> Expander::property_label() 
+{
+  return Glib::PropertyProxy<Glib::ustring>(this, "label");
+}
+
+Glib::PropertyProxy_ReadOnly<Glib::ustring> Expander::property_label() const
+{
+  return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "label");
+}
+
+Glib::PropertyProxy<bool> Expander::property_use_underline() 
+{
+  return Glib::PropertyProxy<bool>(this, "use-underline");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> Expander::property_use_underline() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "use-underline");
+}
+
+Glib::PropertyProxy<bool> Expander::property_use_markup() 
+{
+  return Glib::PropertyProxy<bool>(this, "use-markup");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> Expander::property_use_markup() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "use-markup");
+}
+
+Glib::PropertyProxy<int> Expander::property_spacing() 
+{
+  return Glib::PropertyProxy<int>(this, "spacing");
+}
+
+Glib::PropertyProxy_ReadOnly<int> Expander::property_spacing() const
+{
+  return Glib::PropertyProxy_ReadOnly<int>(this, "spacing");
+}
+
+Glib::PropertyProxy<Widget*> Expander::property_label_widget() 
+{
+  return Glib::PropertyProxy<Widget*>(this, "label-widget");
+}
+
+Glib::PropertyProxy_ReadOnly<Widget*> Expander::property_label_widget() const
+{
+  return Glib::PropertyProxy_ReadOnly<Widget*>(this, "label-widget");
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/expander.h b/libs/gtkmm2/gtk/gtkmm/expander.h
new file mode 100644
index 0000000000..8f4d52b425
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/expander.h
@@ -0,0 +1,362 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_EXPANDER_H
+#define _GTKMM_EXPANDER_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* expander.h
+ * 
+ * Copyright (C) 2003 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/bin.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkExpander GtkExpander;
+typedef struct _GtkExpanderClass GtkExpanderClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class Expander_Class; } // namespace Gtk
+namespace Gtk
+{
+
+/** A container which can hide its child.
+ *
+ * A Expander allows the user to hide or show its child by clicking on an
+ * expander triangle similar to the triangles used in a Gtk::TreeView.
+ *
+ * @ingroup Widgets
+ */
+
+class Expander : public Bin
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Expander CppObjectType;
+  typedef Expander_Class CppClassType;
+  typedef GtkExpander BaseObjectType;
+  typedef GtkExpanderClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~Expander();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class Expander_Class;
+  static CppClassType expander_class_;
+
+  // noncopyable
+  Expander(const Expander&);
+  Expander& operator=(const Expander&);
+
+protected:
+  explicit Expander(const Glib::ConstructParams& construct_params);
+  explicit Expander(GtkExpander* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GtkExpander*       gobj()       { return reinterpret_cast<GtkExpander*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GtkExpander* gobj() const { return reinterpret_cast<GtkExpander*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+private:
+
+public:
+
+  /** Creates a new Expander.
+   *
+   * The Expander has an empty label.
+   * 
+   * Since: 2.4
+   */
+  Expander();
+
+  /** Creates a new Expander with a label.
+   *
+   * Creates a new expander using label as the text of the label. Settin @a mnemonic to true
+   * will allow you to precede characters in the label with an underscore which will make them
+   * underlined. If you need a literal underscore character in a label, use '__' (two underscores).
+   * The first underlined character represents a keyboard accelerator called a mnemonic.
+   * Pressing Alt and that key activates the button.
+   * 
+   * @param label The string for the label describing the Expander.
+   * @param mnemonic Wether the label may contain underscores to set up accelerators.
+   
+   * Since: 2.4
+   */
+  explicit Expander(const Glib::ustring& label, bool mnemonic = false);
+  
+
+  /** Sets the state of the expander. Set to <tt>true</tt>, if you want
+   * the child widget to be revealed, and <tt>false</tt> if you want the
+   * child widget to be hidden.
+   * 
+   * Since: 2.4
+   * @param expanded Whether the child widget is revealed.
+   */
+  void set_expanded(bool expanded = true);
+  
+  /** Queries a Gtk::Expander and returns its current state. Returns <tt>true</tt>
+   * if the child widget is revealed.
+   * 
+   * See set_expanded().
+   * @return The current state of the expander.
+   * 
+   * Since: 2.4.
+   */
+  bool get_expanded() const;
+
+  
+  /** Sets the spacing field of @a expander , which is the number of pixels to
+   * place between expander and the child.
+   * 
+   * Since: 2.4
+   * @param spacing Distance between the expander and child in pixels.
+   */
+  void set_spacing(int spacing);
+  
+  /** Gets the value set by set_spacing().
+   * @return Spacing between the expander and child.
+   * 
+   * Since: 2.4.
+   */
+  int get_spacing() const;
+
+  
+  /** Sets the text of the label of the expander to @a label .
+   * 
+   * This will also clear any previously set labels.
+   * 
+   * Since: 2.4
+   * @param label A string.
+   */
+  void set_label(const Glib::ustring& label);
+  
+  /** Fetches the text from the label of the expander, as set by
+   * set_label(). If the label text has not
+   * been set the return value will be <tt>0</tt>. This will be the
+   * case if you create an empty button with Gtk::Button::new() to
+   * use as a container.
+   * @return The text of the label widget. This string is owned
+   * by the widget and must not be modified or freed.
+   * 
+   * Since: 2.4.
+   */
+  Glib::ustring get_label() const;
+
+  
+  /** If true, an underline in the text of the expander label indicates
+   * the next character should be used for the mnemonic accelerator key.
+   * 
+   * Since: 2.4
+   * @param use_underline <tt>true</tt> if underlines in the text indicate mnemonics.
+   */
+  void set_use_underline(bool use_underline = true);
+  
+  /** Returns whether an embedded underline in the expander label indicates a
+   * mnemonic. See set_use_underline().
+   * @return <tt>true</tt> if an embedded underline in the expander label
+   * indicates the mnemonic accelerator keys.
+   * 
+   * Since: 2.4.
+   */
+  bool get_use_underline() const;
+
+  
+  /** Sets whether the text of the label contains markup in Pango's text markup
+   * language. See Gtk::Label::set_markup().
+   * 
+   * Since: 2.4
+   * @param use_markup <tt>true</tt> if the label's text should be parsed for markup.
+   */
+  void set_use_markup(bool use_markup = true);
+  
+  /** Returns whether the label's text is interpreted as marked up with
+   * the Pango text markup
+   * language. See set_use_markup().
+   * @return <tt>true</tt> if the label's text will be parsed for markup
+   * 
+   * Since: 2.4.
+   */
+  bool get_use_markup() const;
+
+  
+  /** Set the label widget for the expander. This is the widget
+   * that will appear embedded alongside the expander arrow.
+   * 
+   * Since: 2.4
+   * @param label_widget The new label widget.
+   */
+  void set_label_widget(Widget& label_widget);
+  
+  /** Retrieves the label widget for the frame. See
+   * set_label_widget().
+   * @return The label widget, or <tt>0</tt> if there is none.
+   * 
+   * Since: 2.4.
+   */
+  Widget* get_label_widget();
+  
+  /** Retrieves the label widget for the frame. See
+   * set_label_widget().
+   * @return The label widget, or <tt>0</tt> if there is none.
+   * 
+   * Since: 2.4.
+   */
+  const Widget* get_label_widget() const;
+
+   //keybinding
+
+  /** Whether the expander has been opened to reveal the child widget.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_expanded() ;
+
+/** Whether the expander has been opened to reveal the child widget.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_expanded() const;
+
+  /** Text of the expander's label.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Glib::ustring> property_label() ;
+
+/** Text of the expander's label.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Glib::ustring> property_label() const;
+
+  /** If set
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_use_underline() ;
+
+/** If set
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_use_underline() const;
+
+  /** The text of the label includes XML markup. See pango_parse_markup.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_use_markup() ;
+
+/** The text of the label includes XML markup. See pango_parse_markup.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_use_markup() const;
+
+  /** Space to put between the label and the child.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<int> property_spacing() ;
+
+/** Space to put between the label and the child.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<int> property_spacing() const;
+
+  /** A widget to display in place of the usual expander label.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Widget*> property_label_widget() ;
+
+/** A widget to display in place of the usual expander label.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Widget*> property_label_widget() const;
+            
+
+};
+
+
+} // namespace Gtk
+
+
+namespace Glib
+{
+  /** @relates Gtk::Expander
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gtk::Expander* wrap(GtkExpander* object, bool take_copy = false);
+}
+#endif /* _GTKMM_EXPANDER_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/filechooser.cc b/libs/gtkmm2/gtk/gtkmm/filechooser.cc
new file mode 100644
index 0000000000..708a94365c
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/filechooser.cc
@@ -0,0 +1,581 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/filechooser.h>
+#include <gtkmm/private/filechooser_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* Copyright 2003 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtk/gtkfilechooser.h>
+//#include <gtk/gtkfilesystem.h> //We include this semi-private header just to get GTK_FILE_SYSTEM_ERROR.
+
+
+namespace
+{
+
+const Glib::SignalProxyInfo FileChooser_signal_current_folder_changed_info =
+{
+  "current_folder_changed",
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
+};
+
+
+const Glib::SignalProxyInfo FileChooser_signal_selection_changed_info =
+{
+  "selection_changed",
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
+};
+
+
+const Glib::SignalProxyInfo FileChooser_signal_update_preview_info =
+{
+  "update_preview",
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
+};
+
+
+const Glib::SignalProxyInfo FileChooser_signal_file_activated_info =
+{
+  "file_activated",
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
+};
+
+} // anonymous namespace
+
+// static
+GType Glib::Value<Gtk::FileChooserAction>::value_type()
+{
+  return gtk_file_chooser_action_get_type();
+}
+
+
+Gtk::FileChooserError::FileChooserError(Gtk::FileChooserError::Code error_code, const Glib::ustring& error_message)
+:
+  Glib::Error (GTK_FILE_CHOOSER_ERROR, error_code, error_message)
+{}
+
+Gtk::FileChooserError::FileChooserError(GError* gobject)
+:
+  Glib::Error (gobject)
+{}
+
+Gtk::FileChooserError::Code Gtk::FileChooserError::code() const
+{
+  return static_cast<Code>(Glib::Error::code());
+}
+
+void Gtk::FileChooserError::throw_func(GError* gobject)
+{
+  throw Gtk::FileChooserError(gobject);
+}
+
+// static
+GType Glib::Value<Gtk::FileChooserError::Code>::value_type()
+{
+  return gtk_file_chooser_error_get_type();
+}
+
+
+namespace Glib
+{
+
+Glib::RefPtr<Gtk::FileChooser> wrap(GtkFileChooser* object, bool take_copy)
+{
+  return Glib::RefPtr<Gtk::FileChooser>( dynamic_cast<Gtk::FileChooser*> (Glib::wrap_auto ((GObject*)(object), take_copy)) );
+  //We use dynamic_cast<> in case of multiple inheritance.
+}
+
+} // namespace Glib
+
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Interface_Class& FileChooser_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Interface_Class has to know the interface init function
+    // in order to add interfaces to implementing types.
+    class_init_func_ = &FileChooser_Class::iface_init_function;
+
+    // We can not derive from another interface, and it is not necessary anyway.
+    gtype_ = gtk_file_chooser_get_type();
+  }
+
+  return *this;
+}
+
+void FileChooser_Class::iface_init_function(void* g_iface, void*)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_iface);
+
+  //This is just to avoid an "unused variable" warning when there are no vfuncs or signal handlers to connect.
+  //This is a temporary fix until I find out why I can not seem to derive a GtkFileChooser interface. murrayc
+  g_assert(klass != 0); 
+
+}
+
+
+Glib::ObjectBase* FileChooser_Class::wrap_new(GObject* object)
+{
+  return new FileChooser((GtkFileChooser*)(object));
+}
+
+
+/* The implementation: */
+
+FileChooser::FileChooser()
+:
+  Glib::Interface(filechooser_class_.init())
+{}
+
+FileChooser::FileChooser(GtkFileChooser* castitem)
+:
+  Glib::Interface((GObject*)(castitem))
+{}
+
+FileChooser::~FileChooser()
+{}
+
+// static
+void FileChooser::add_interface(GType gtype_implementer)
+{
+  filechooser_class_.init().add_interface(gtype_implementer);
+}
+
+FileChooser::CppClassType FileChooser::filechooser_class_; // initialize static member
+
+GType FileChooser::get_type()
+{
+  return filechooser_class_.init().get_type();
+}
+
+GType FileChooser::get_base_type()
+{
+  return gtk_file_chooser_get_type();
+}
+
+
+void FileChooser::set_action(FileChooserAction action)
+{
+  gtk_file_chooser_set_action(gobj(), ((GtkFileChooserAction)(action)));
+}
+
+FileChooserAction FileChooser::get_action() const
+{
+  return ((FileChooserAction)(gtk_file_chooser_get_action(const_cast<GtkFileChooser*>(gobj()))));
+}
+
+void FileChooser::set_local_only(bool local_only)
+{
+  gtk_file_chooser_set_local_only(gobj(), static_cast<int>(local_only));
+}
+
+bool FileChooser::get_local_only() const
+{
+  return gtk_file_chooser_get_local_only(const_cast<GtkFileChooser*>(gobj()));
+}
+
+void FileChooser::set_select_multiple(bool select_multiple)
+{
+  gtk_file_chooser_set_select_multiple(gobj(), static_cast<int>(select_multiple));
+}
+
+bool FileChooser::get_select_multiple() const
+{
+  return gtk_file_chooser_get_select_multiple(const_cast<GtkFileChooser*>(gobj()));
+}
+
+void FileChooser::set_show_hidden(bool show_hidden)
+{
+  gtk_file_chooser_set_show_hidden(gobj(), static_cast<int>(show_hidden));
+}
+
+bool FileChooser::get_show_hidden() const
+{
+  return gtk_file_chooser_get_show_hidden(const_cast<GtkFileChooser*>(gobj()));
+}
+
+void FileChooser::set_current_name(const Glib::ustring& name)
+{
+  gtk_file_chooser_set_current_name(gobj(), name.c_str());
+}
+
+Glib::ustring FileChooser::get_filename() const
+{
+  return Glib::convert_return_gchar_ptr_to_ustring(gtk_file_chooser_get_filename(const_cast<GtkFileChooser*>(gobj())));
+}
+
+bool FileChooser::set_filename(const Glib::ustring& filename)
+{
+  return gtk_file_chooser_set_filename(gobj(), filename.c_str());
+}
+
+bool FileChooser::select_filename(const Glib::ustring& filename)
+{
+  return gtk_file_chooser_select_filename(gobj(), filename.c_str());
+}
+
+void FileChooser::unselect_filename(const Glib::ustring& filename)
+{
+  gtk_file_chooser_unselect_filename(gobj(), filename.c_str());
+}
+
+void FileChooser::select_all()
+{
+  gtk_file_chooser_select_all(gobj());
+}
+
+void FileChooser::unselect_all()
+{
+  gtk_file_chooser_unselect_all(gobj());
+}
+
+Glib::SListHandle<Glib::ustring> FileChooser::get_filenames() const
+{
+  return Glib::SListHandle<Glib::ustring>(gtk_file_chooser_get_filenames(const_cast<GtkFileChooser*>(gobj())), Glib::OWNERSHIP_DEEP);
+}
+
+bool FileChooser::set_current_folder(const Glib::ustring& filename)
+{
+  return gtk_file_chooser_set_current_folder(gobj(), filename.c_str());
+}
+
+Glib::ustring FileChooser::get_current_folder() const
+{
+  return Glib::convert_return_gchar_ptr_to_ustring(gtk_file_chooser_get_current_folder(const_cast<GtkFileChooser*>(gobj())));
+}
+
+Glib::ustring FileChooser::get_uri() const
+{
+  return Glib::convert_return_gchar_ptr_to_ustring(gtk_file_chooser_get_uri(const_cast<GtkFileChooser*>(gobj())));
+}
+
+bool FileChooser::set_uri(const Glib::ustring& uri)
+{
+  return gtk_file_chooser_set_uri(gobj(), uri.c_str());
+}
+
+bool FileChooser::select_uri(const Glib::ustring& uri)
+{
+  return gtk_file_chooser_select_uri(gobj(), uri.c_str());
+}
+
+void FileChooser::unselect_uri(const Glib::ustring& uri)
+{
+  gtk_file_chooser_unselect_uri(gobj(), uri.c_str());
+}
+
+Glib::SListHandle<Glib::ustring> FileChooser::get_uris() const
+{
+  return Glib::SListHandle<Glib::ustring>(gtk_file_chooser_get_uris(const_cast<GtkFileChooser*>(gobj())), Glib::OWNERSHIP_DEEP);
+}
+
+bool FileChooser::set_current_folder_uri(const Glib::ustring& uri)
+{
+  return gtk_file_chooser_set_current_folder_uri(gobj(), uri.c_str());
+}
+
+Glib::ustring FileChooser::get_current_folder_uri() const
+{
+  return Glib::convert_return_gchar_ptr_to_ustring(gtk_file_chooser_get_current_folder_uri(const_cast<GtkFileChooser*>(gobj())));
+}
+
+void FileChooser::set_preview_widget(Gtk::Widget& preview_widget)
+{
+  gtk_file_chooser_set_preview_widget(gobj(), (preview_widget).gobj());
+}
+
+const Gtk::Widget* FileChooser::get_preview_widget() const
+{
+  return Glib::wrap(gtk_file_chooser_get_preview_widget(const_cast<GtkFileChooser*>(gobj())));
+}
+
+Gtk::Widget* FileChooser::get_preview_widget()
+{
+  return Glib::wrap(gtk_file_chooser_get_preview_widget(gobj()));
+}
+
+void FileChooser::set_preview_widget_active(bool active)
+{
+  gtk_file_chooser_set_preview_widget_active(gobj(), static_cast<int>(active));
+}
+
+bool FileChooser::get_preview_widget_active() const
+{
+  return gtk_file_chooser_get_preview_widget_active(const_cast<GtkFileChooser*>(gobj()));
+}
+
+void FileChooser::set_use_preview_label(bool use_label)
+{
+  gtk_file_chooser_set_use_preview_label(gobj(), static_cast<int>(use_label));
+}
+
+bool FileChooser::get_use_preview_label() const
+{
+  return gtk_file_chooser_get_use_preview_label(const_cast<GtkFileChooser*>(gobj()));
+}
+
+Glib::ustring FileChooser::get_preview_filename() const
+{
+  return Glib::convert_return_gchar_ptr_to_ustring(gtk_file_chooser_get_preview_filename(const_cast<GtkFileChooser*>(gobj())));
+}
+
+Glib::ustring FileChooser::get_preview_uri() const
+{
+  return Glib::convert_return_gchar_ptr_to_ustring(gtk_file_chooser_get_preview_uri(const_cast<GtkFileChooser*>(gobj())));
+}
+
+void FileChooser::set_extra_widget(Gtk::Widget& extra_widget)
+{
+  gtk_file_chooser_set_extra_widget(gobj(), (extra_widget).gobj());
+}
+
+Gtk::Widget* FileChooser::get_extra_widget()
+{
+  return Glib::wrap(gtk_file_chooser_get_extra_widget(gobj()));
+}
+
+const Gtk::Widget* FileChooser::get_extra_widget() const
+{
+  return Glib::wrap(gtk_file_chooser_get_extra_widget(const_cast<GtkFileChooser*>(gobj())));
+}
+
+void FileChooser::add_filter(const FileFilter& filter)
+{
+  gtk_file_chooser_add_filter(gobj(), const_cast<GtkFileFilter*>((filter).gobj()));
+}
+
+void FileChooser::remove_filter(const FileFilter& filter)
+{
+  gtk_file_chooser_remove_filter(gobj(), const_cast<GtkFileFilter*>((filter).gobj()));
+}
+
+Glib::SListHandle< FileFilter* > FileChooser::list_filters()
+{
+  return Glib::SListHandle< FileFilter* >(gtk_file_chooser_list_filters(gobj()), Glib::OWNERSHIP_SHALLOW);
+}
+
+Glib::SListHandle< const FileFilter* > FileChooser::list_filters() const
+{
+  return Glib::SListHandle< const FileFilter* >(gtk_file_chooser_list_filters(const_cast<GtkFileChooser*>(gobj())), Glib::OWNERSHIP_SHALLOW);
+}
+
+void FileChooser::set_filter(const FileFilter& filter)
+{
+  gtk_file_chooser_set_filter(gobj(), const_cast<GtkFileFilter*>((filter).gobj()));
+}
+
+FileFilter* FileChooser::get_filter()
+{
+
+  FileFilter* retvalue = Glib::wrap(gtk_file_chooser_get_filter(gobj()));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+const FileFilter* FileChooser::get_filter() const
+{
+
+  const FileFilter* retvalue = Glib::wrap(gtk_file_chooser_get_filter(const_cast<GtkFileChooser*>(gobj())));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+bool FileChooser::add_shortcut_folder(const Glib::ustring& folder)
+{
+  GError *error = 0;
+  bool retvalue = gtk_file_chooser_add_shortcut_folder(gobj(), folder.c_str(), &(error));
+  if(error) ::Glib::Error::throw_exception(error);
+  return retvalue;
+}
+
+bool FileChooser::remove_shortcut_folder(const Glib::ustring& folder)
+{
+  GError *error = 0;
+  bool retvalue = gtk_file_chooser_remove_shortcut_folder(gobj(), folder.c_str(), &(error));
+  if(error) ::Glib::Error::throw_exception(error);
+  return retvalue;
+}
+
+Glib::SListHandle<Glib::ustring> FileChooser::list_shortcut_folders() const
+{
+  return Glib::SListHandle<Glib::ustring>(gtk_file_chooser_list_shortcut_folders(const_cast<GtkFileChooser*>(gobj())), Glib::OWNERSHIP_DEEP);
+}
+
+bool FileChooser::add_shortcut_folder_uri(const Glib::ustring& uri)
+{
+  GError *error = 0;
+  bool retvalue = gtk_file_chooser_add_shortcut_folder_uri(gobj(), uri.c_str(), &(error));
+  if(error) ::Glib::Error::throw_exception(error);
+  return retvalue;
+}
+
+bool FileChooser::remove_shortcut_folder_uri(const Glib::ustring& uri)
+{
+  GError *error = 0;
+  bool retvalue = gtk_file_chooser_remove_shortcut_folder_uri(gobj(), uri.c_str(), &(error));
+  if(error) ::Glib::Error::throw_exception(error);
+  return retvalue;
+}
+
+Glib::SListHandle<Glib::ustring> FileChooser::list_shortcut_folder_uris() const
+{
+  return Glib::SListHandle<Glib::ustring>(gtk_file_chooser_list_shortcut_folder_uris(const_cast<GtkFileChooser*>(gobj())), Glib::OWNERSHIP_DEEP);
+}
+
+
+Glib::SignalProxy0< void > FileChooser::signal_current_folder_changed()
+{
+  return Glib::SignalProxy0< void >(this, &FileChooser_signal_current_folder_changed_info);
+}
+
+Glib::SignalProxy0< void > FileChooser::signal_selection_changed()
+{
+  return Glib::SignalProxy0< void >(this, &FileChooser_signal_selection_changed_info);
+}
+
+Glib::SignalProxy0< void > FileChooser::signal_update_preview()
+{
+  return Glib::SignalProxy0< void >(this, &FileChooser_signal_update_preview_info);
+}
+
+Glib::SignalProxy0< void > FileChooser::signal_file_activated()
+{
+  return Glib::SignalProxy0< void >(this, &FileChooser_signal_file_activated_info);
+}
+
+
+Glib::PropertyProxy<FileChooserAction> FileChooser::property_action() 
+{
+  return Glib::PropertyProxy<FileChooserAction>(this, "action");
+}
+
+Glib::PropertyProxy_ReadOnly<FileChooserAction> FileChooser::property_action() const
+{
+  return Glib::PropertyProxy_ReadOnly<FileChooserAction>(this, "action");
+}
+
+Glib::PropertyProxy<FileFilter*> FileChooser::property_filter() 
+{
+  return Glib::PropertyProxy<FileFilter*>(this, "filter");
+}
+
+Glib::PropertyProxy_ReadOnly<FileFilter*> FileChooser::property_filter() const
+{
+  return Glib::PropertyProxy_ReadOnly<FileFilter*>(this, "filter");
+}
+
+Glib::PropertyProxy<bool> FileChooser::property_folder_mode() 
+{
+  return Glib::PropertyProxy<bool>(this, "folder-mode");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> FileChooser::property_folder_mode() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "folder-mode");
+}
+
+Glib::PropertyProxy<bool> FileChooser::property_local_only() 
+{
+  return Glib::PropertyProxy<bool>(this, "local-only");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> FileChooser::property_local_only() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "local-only");
+}
+
+Glib::PropertyProxy<Widget*> FileChooser::property_preview_widget() 
+{
+  return Glib::PropertyProxy<Widget*>(this, "preview-widget");
+}
+
+Glib::PropertyProxy_ReadOnly<Widget*> FileChooser::property_preview_widget() const
+{
+  return Glib::PropertyProxy_ReadOnly<Widget*>(this, "preview-widget");
+}
+
+Glib::PropertyProxy<bool> FileChooser::property_preview_widget_active() 
+{
+  return Glib::PropertyProxy<bool>(this, "preview-widget-active");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> FileChooser::property_preview_widget_active() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "preview-widget-active");
+}
+
+Glib::PropertyProxy<bool> FileChooser::property_use_preview_label() 
+{
+  return Glib::PropertyProxy<bool>(this, "use-preview-label");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> FileChooser::property_use_preview_label() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "use-preview-label");
+}
+
+Glib::PropertyProxy<Widget*> FileChooser::property_extra_widget() 
+{
+  return Glib::PropertyProxy<Widget*>(this, "extra-widget");
+}
+
+Glib::PropertyProxy_ReadOnly<Widget*> FileChooser::property_extra_widget() const
+{
+  return Glib::PropertyProxy_ReadOnly<Widget*>(this, "extra-widget");
+}
+
+Glib::PropertyProxy<bool> FileChooser::property_select_multiple() 
+{
+  return Glib::PropertyProxy<bool>(this, "select-multiple");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> FileChooser::property_select_multiple() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "select-multiple");
+}
+
+Glib::PropertyProxy<bool> FileChooser::property_show_hidden() 
+{
+  return Glib::PropertyProxy<bool>(this, "show-hidden");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> FileChooser::property_show_hidden() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "show-hidden");
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/filechooser.h b/libs/gtkmm2/gtk/gtkmm/filechooser.h
new file mode 100644
index 0000000000..2bbc5954ab
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/filechooser.h
@@ -0,0 +1,935 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_FILECHOOSER_H
+#define _GTKMM_FILECHOOSER_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* Copyright (C) 2003 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/widget.h>
+#include <gtkmm/filefilter.h>
+#include <glibmm/interface.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkFileChooser GtkFileChooser;
+typedef struct _GtkFileChooserClass GtkFileChooserClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class FileChooser_Class; } // namespace Gtk
+namespace Gtk
+{
+
+/** @addtogroup gtkmmEnums Enums and Flags */
+
+/**
+ * @ingroup gtkmmEnums
+ */
+enum FileChooserAction
+{
+  FILE_CHOOSER_ACTION_OPEN,
+  FILE_CHOOSER_ACTION_SAVE,
+  FILE_CHOOSER_ACTION_SELECT_FOLDER,
+  FILE_CHOOSER_ACTION_CREATE_FOLDER
+};
+
+} // namespace Gtk
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Gtk::FileChooserAction> : public Glib::Value_Enum<Gtk::FileChooserAction>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{
+
+
+//TODO: //Is GTK_FILE_SYSTEM_ERROR really part of the public API? For instance, do app writers ever need to check for it?.
+//If so, then it needs to have a generated get_type() function, like the others. murrayc.
+//_TODO_GERROR(FileSystemError,GtkFileSystemError,GTK_FILE_SYSTEM_ERROR)
+
+/** Exception class for Gdk::FileChooser errors.
+ */
+class FileChooserError : public Glib::Error
+{
+public:
+  enum Code
+  {
+    NONEXISTENT,
+    BAD_FILENAME
+  };
+
+  FileChooserError(Code error_code, const Glib::ustring& error_message);
+  explicit FileChooserError(GError* gobject);
+  Code code() const;
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+private:
+  static void throw_func(GError* gobject);
+  friend void wrap_init(); // uses throw_func()
+#endif
+};
+
+} // namespace Gtk
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Gtk::FileChooserError::Code> : public Glib::Value_Enum<Gtk::FileChooserError::Code>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{
+
+
+/**
+ * Gtk::FileChooser is an interface that can be implemented by file selection
+ * widgets. In gtkmm, the main objects that implement this interface are
+ * FileChooserWidget and FileChooserDialog. You do not need to write an
+ * object that implements the FileChooser interface unless you are trying to
+ * adapt an existing file selector to expose a standard programming interface.
+ *
+ * @par File Names and Encodings
+ * When the user is finished selecting files in a FileChooser, your program
+ * can get the selected names either as filenames or as URIs. For URIs, the
+ * normal escaping rules are applied if the URI contains non-ASCII characters.
+ * However, filenames are always returned in the character set specified by the
+ * G_FILENAME_ENCODING environment variable. Please see the Glib documentation
+ * for more details about this variable.
+ *
+ * @par Important
+ * This means that while you can pass the result of FileChooser::get_filename()
+ * to <tt>open(2)</tt> or <tt>fopen(3)</tt>, you may not be able to directly
+ * set it as the text of a Gtk::Label widget unless you convert it first to
+ * UTF-8, which all gtkmm widgets expect. You should use
+ * Glib::filename_to_utf8() to convert filenames into strings that can be
+ * passed to gtkmm widgets.
+ *
+ * @note
+ * The gtkmm FileChooser API is broken in that methods return Glib::ustring
+ * even though the returned string is not necessarily UTF-8 encoded.  Any
+ * FileChooser method that takes or returns a filename (not a URI) should
+ * have std::string as parameter or return type.  Fortunately this mistake
+ * doesn't prevent you from handling filenames correctly in your application.
+ * Just pretend that the API uses std::string and call Glib::filename_to_utf8()
+ * or Glib::filename_from_utf8() as appropriate.
+ *
+ * See http://bugzilla.gnome.org/show_bug.cgi?id=142138 for more information.
+ */
+
+class FileChooser : public Glib::Interface
+{
+  
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+public:
+  typedef FileChooser CppObjectType;
+  typedef FileChooser_Class CppClassType;
+  typedef GtkFileChooser BaseObjectType;
+  typedef GtkFileChooserClass BaseClassType;
+
+private:
+  friend class FileChooser_Class;
+  static CppClassType filechooser_class_;
+
+  // noncopyable
+  FileChooser(const FileChooser&);
+  FileChooser& operator=(const FileChooser&);
+
+protected:
+  FileChooser(); // you must derive from this class
+  explicit FileChooser(GtkFileChooser* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+  virtual ~FileChooser();
+
+  static void add_interface(GType gtype_implementer);
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GObject.
+  GtkFileChooser*       gobj()       { return reinterpret_cast<GtkFileChooser*>(gobject_); }
+
+  ///Provides access to the underlying C GObject.  
+  const GtkFileChooser* gobj() const { return reinterpret_cast<GtkFileChooser*>(gobject_); }
+
+private:
+
+public:
+
+  
+  /** Sets the type of operation that that the chooser is performing; the
+   * user interface is adapted to suit the selected action. For example,
+   * an option to create a new folder might be shown if the action is
+   * Gtk::FILE_CHOOSER_ACTION_SAVE but not if the action is
+   * Gtk::FILE_CHOOSER_ACTION_OPEN.
+   * 
+   * Since: 2.4
+   * @param action The action that the file selector is performing.
+   */
+  void set_action(FileChooserAction action);
+  
+  /** Gets the type of operation that the file chooser is performing; see
+   * set_action().
+   * @return The action that the file selector is performing
+   * 
+   * Since: 2.4.
+   */
+  FileChooserAction get_action() const;
+  
+  /** Sets whether only local files can be selected in the
+   * file selector. If @a local_only  is <tt>true</tt> (the default),
+   * then the selected file are files are guaranteed to be
+   * accessible through the operating systems native file
+   * file system and therefore the application only
+   * needs to worry about the filename functions in
+   * Gtk::FileChooser, like get_filename(),
+   * rather than the URI functions like
+   * get_uri(),
+   * 
+   * Since: 2.4
+   * @param local_only <tt>true</tt> if only local files can be selected.
+   */
+  void set_local_only(bool local_only = true);
+  
+  /** Gets whether only local files can be selected in the
+   * file selector. See set_local_only()
+   * @return <tt>true</tt> if only local files can be selected.
+   * 
+   * Since: 2.4.
+   */
+  bool get_local_only() const;
+  
+  /** Sets whether multiple files can be selected in the file selector.  This is
+   * only relevant if the action is set to be GTK_FILE_CHOOSER_ACTION_OPEN or
+   * GTK_FILE_CHOOSER_ACTION_SAVE.  It cannot be set with either of the folder
+   * actions.
+   * 
+   * Since: 2.4
+   * @param select_multiple <tt>true</tt> if multiple files can be selected.
+   */
+  void set_select_multiple(bool select_multiple = true);
+  
+  /** Gets whether multiple files can be selected in the file
+   * selector. See set_select_multiple().
+   * @return <tt>true</tt> if multiple files can be selected.
+   * 
+   * Since: 2.4.
+   */
+  bool get_select_multiple() const;
+
+  
+  /** Sets whether hidden files and folders are displayed in the file selector.  
+   * 
+   * Since: 2.6
+   * @param show_hidden <tt>true</tt> if hidden files and folders should be displayed.
+   */
+  void set_show_hidden(bool show_hidden = true);
+  
+  /** Gets whether hidden files and folders are displayed in the file selector.   
+   * See set_show_hidden().
+   * @return <tt>true</tt> if hidden files and folders are displayed.
+   * 
+   * Since: 2.6.
+   */
+  bool get_show_hidden() const;
+
+  
+  /** Sets the current name in the file selector, as if entered
+   * by the user. Note that the name passed in here is a UTF-8
+   * string rather than a filename. This function is meant for
+   * such uses as a suggested name in a "Save As..." dialog.
+   * 
+   * If you want to preselect a particular existing file, you
+   * should use set_filename() instead.
+   * 
+   * Since: 2.4
+   * @param name The filename to use, as a UTF-8 string.
+   */
+  void set_current_name(const Glib::ustring& name);
+  
+  /** Gets the filename for the currently selected file in
+   * the file selector. If multiple files are selected,
+   * one of the filenames will be returned at random.
+   * 
+   * If the file chooser is in folder mode, this function returns the selected
+   * folder.
+   * @return The currently selected filename, or an empty string
+   * if no file is selected, or the selected file can't
+   * be represented with a local filename.
+   */
+  Glib::ustring get_filename() const;
+  
+  /** Sets @a filename  as the current filename for the the file chooser;
+   * If the file name isn't in the current folder of @a chooser , then the
+   * current folder of @a chooser  will be changed to the folder containing
+   *  @a filename . This is equivalent to a sequence of
+   * unselect_all() followed by select_filename().
+   * 
+   * Note that the file must exist, or nothing will be done except
+   * for the directory change. To pre-enter a filename for the user, as in
+   * a save-as dialog, use set_current_name()
+   * @param filename The filename to set as current.
+   * @return <tt>true</tt> if both the folder could be changed and the file was
+   * selected successfully, <tt>false</tt> otherwise.
+   * 
+   * Since: 2.4.
+   */
+  bool set_filename(const Glib::ustring& filename);
+  
+  /** Selects a filename. If the file name isn't in the current
+   * folder of @a chooser , then the current folder of @a chooser  will
+   * be changed to the folder containing @a filename .
+   * @param filename The filename to select.
+   * @return <tt>true</tt> if both the folder could be changed and the file was
+   * selected successfully, <tt>false</tt> otherwise.
+   * 
+   * Since: 2.4.
+   */
+  bool select_filename(const Glib::ustring& filename);
+  
+  /** Unselects a currently selected filename. If the filename
+   * is not in the current directory, does not exist, or
+   * is otherwise not currently selected, does nothing.
+   * 
+   * Since: 2.4
+   * @param filename The filename to unselect.
+   */
+  void unselect_filename(const Glib::ustring& filename);
+  
+  /** Selects all the files in the current folder of a file chooser.
+   * 
+   * Since: 2.4
+   */
+  void select_all();
+  
+  /** Unselects all the files in the current folder of a file chooser.
+   * 
+   * Since: 2.4
+   */
+  void unselect_all();
+  
+  /** Lists all the selected files and subfolders in the current folder of
+   *  @a chooser . The returned names are full absolute paths. If files in the current
+   * folder cannot be represented as local filenames they will be ignored. (See
+   * get_uris())
+   * @return A G::SList containing the filenames of all selected
+   * files and subfolders in the current folder. Free the returned list
+   * with Glib::slist_free(), and the filenames with Glib::free().
+   * 
+   * Since: 2.4.
+   */
+  Glib::SListHandle<Glib::ustring> get_filenames() const;
+  
+  /** Sets the current folder for @a chooser  from a local filename.
+   * The user will be shown the full contents of the current folder,
+   * plus user interface elements for navigating to other folders.
+   * @param filename The full path of the new current folder.
+   * @return <tt>true</tt> if the folder could be changed successfully, <tt>false</tt>
+   * otherwise.
+   * 
+   * Since: 2.4.
+   */
+  bool set_current_folder(const Glib::ustring& filename);
+  
+  /** Gets the current folder of @a chooser  as a local filename.
+   * See set_current_folder().
+   * @return The full path of the current folder, or <tt>0</tt>
+   * if the current path cannot be represented as a local filename.
+   * Free with Glib::free().
+   * 
+   * Since: 2.4.
+   */
+  Glib::ustring get_current_folder() const;
+
+
+/* URI manipulation
+ */
+  
+  /** Gets the URI for the currently selected file in
+   * the file selector. If multiple files are selected,
+   * one of the filenames will be returned at random.
+   * 
+   * If the file chooser is in folder mode, this function returns the selected
+   * folder.
+   * @return The currently selected URI, or an empty string
+   * if no file is selected.
+   */
+  Glib::ustring get_uri() const;
+  
+  /** Sets the file referred to by @a uri  as the current file for the the
+   * file chooser; If the file name isn't in the current folder of @a chooser ,
+   * then the current folder of @a chooser  will be changed to the folder containing
+   *  @a uri . This is equivalent to a sequence of unselect_all()
+   * followed by select_uri().
+   * 
+   * Note that the file must exist, or nothing will be done except
+   * for the directory change. To pre-enter a filename for the user, as in
+   * a save-as dialog, use set_current_name()
+   * @param uri The URI to set as current.
+   * @return <tt>true</tt> if both the folder could be changed and the URI was
+   * selected successfully, <tt>false</tt> otherwise.
+   * 
+   * Since: 2.4.
+   */
+  bool set_uri(const Glib::ustring& uri);
+  
+  /** Selects the file to by @a uri . If the URI doesn't refer to a
+   * file in the current folder of @a chooser , then the current folder of
+   *  @a chooser  will be changed to the folder containing @a filename .
+   * @param uri The URI to select.
+   * @return <tt>true</tt> if both the folder could be changed and the URI was
+   * selected successfully, <tt>false</tt> otherwise.
+   * 
+   * Since: 2.4.
+   */
+  bool select_uri(const Glib::ustring& uri);
+  
+  /** Unselects the file referred to by @a uri . If the file
+   * is not in the current directory, does not exist, or
+   * is otherwise not currently selected, does nothing.
+   * 
+   * Since: 2.4
+   * @param uri The URI to unselect.
+   */
+  void unselect_uri(const Glib::ustring& uri);
+  
+  /** Lists all the selected files and subfolders in the current folder of
+   *  @a chooser . The returned names are full absolute URIs.
+   * @return A G::SList containing the URIs of all selected
+   * files and subfolders in the current folder. Free the returned list
+   * with Glib::slist_free(), and the filenames with Glib::free().
+   * 
+   * Since: 2.4.
+   */
+  Glib::SListHandle<Glib::ustring> get_uris() const;
+
+  
+  /** Sets the current folder for @a chooser  from an URI.
+   * The user will be shown the full contents of the current folder,
+   * plus user interface elements for navigating to other folders.
+   * @param uri The URI for the new current folder.
+   * @return <tt>true</tt> if the folder could be changed successfully, <tt>false</tt>
+   * otherwise.
+   * 
+   * Since: 2.4.
+   */
+  bool set_current_folder_uri(const Glib::ustring& uri);
+  
+  /** Gets the current folder of @a chooser  as an URI.
+   * See set_current_folder_uri().
+   * @return The URI for the current folder.
+   */
+  Glib::ustring get_current_folder_uri() const;
+
+/* Preview widget
+ */
+  
+  /** Sets an application-supplied widget to use to display a custom preview
+   * of the currently selected file. To implement a preview, after setting the
+   * preview widget, you connect to the ::update-preview
+   * signal, and call get_preview_filename() or
+   * get_preview_uri() on each change. If you can
+   * display a preview of the new file, update your widget and
+   * set the preview active using set_preview_widget_active().
+   * Otherwise, set the preview inactive.
+   * 
+   * When there is no application-supplied preview widget, or the
+   * application-supplied preview widget is not active, the file chooser
+   * may display an internally generated preview of the current file or
+   * it may display no preview at all.
+   * 
+   * Since: 2.4
+   * @param preview_widget Widget for displaying preview.
+   */
+  void set_preview_widget(Gtk::Widget& preview_widget);
+  
+  /** Gets the current preview widget; see
+   * set_preview_widget().
+   * @return The current preview widget, or <tt>0</tt>
+   * 
+   * Since: 2.4.
+   */
+  const Gtk::Widget* get_preview_widget() const;
+  
+  /** Gets the current preview widget; see
+   * set_preview_widget().
+   * @return The current preview widget, or <tt>0</tt>
+   * 
+   * Since: 2.4.
+   */
+  Gtk::Widget* get_preview_widget();
+  
+  /** Sets whether the preview widget set by
+   * set_preview_widget_active() should be shown for the
+   * current filename. When @a active  is set to false, the file chooser
+   * may display an internally generated preview of the current file
+   * or it may display no preview at all. See
+   * set_preview_widget() for more details.
+   * 
+   * Since: 2.4
+   * @param active Whether to display the user-specified preview widget.
+   */
+  void set_preview_widget_active(bool active = true);
+  
+  /** Gets whether the preview widget set by set_preview_widget()
+   * should be shown for the current filename. See
+   * set_preview_widget_active().
+   * @return <tt>true</tt> if the preview widget is active for the current filename.
+   * 
+   * Since: 2.4.
+   */
+  bool get_preview_widget_active() const;
+
+  
+  /** Sets whether the file chooser should display a stock label with the name of
+   * the file that is being previewed; the default is <tt>true</tt>.  Applications that
+   * want to draw the whole preview area themselves should set this to <tt>false</tt> and
+   * display the name themselves in their preview widget.
+   * 
+   * See also: set_preview_widget()
+   * 
+   * Since: 2.4
+   * @param use_label Whether to display a stock label with the name of the previewed file.
+   */
+  void set_use_preview_label(bool use_label = true);
+  
+  /** Gets whether a stock label should be drawn with the name of the previewed
+   * file.  See set_use_preview_label().
+   * @return <tt>true</tt> if the file chooser is set to display a label with the
+   * name of the previewed file, <tt>false</tt> otherwise.
+   */
+  bool get_use_preview_label() const;
+
+  
+  /** Gets the filename that should be previewed in a custom preview
+   * widget. See set_preview_widget().
+   * @return The filename to preview, or an empty string if no file
+   * is selected, or if the selected file cannot be represented
+   * as a local filename.
+   */
+  Glib::ustring get_preview_filename() const;
+  
+  /** Gets the URI that should be previewed in a custom preview
+   * widget. See set_preview_widget().
+   * @return The URI for the file to preview, or an empty string if no file is
+   * selected.
+   */
+  Glib::ustring get_preview_uri() const;
+
+/* Extra widget
+ */
+  
+  /** Sets an application-supplied widget to provide extra options to the user.
+   * 
+   * Since: 2.4
+   * @param extra_widget Widget for extra options.
+   */
+  void set_extra_widget(Gtk::Widget& extra_widget);
+  
+  /** Gets the current preview widget; see
+   * set_extra_widget().
+   * @return The current extra widget, or <tt>0</tt>
+   * 
+   * Since: 2.4.
+   */
+  Gtk::Widget* get_extra_widget();
+  
+  /** Gets the current preview widget; see
+   * set_extra_widget().
+   * @return The current extra widget, or <tt>0</tt>
+   * 
+   * Since: 2.4.
+   */
+  const Gtk::Widget* get_extra_widget() const;
+
+/* List of user selectable filters
+ */
+  
+  /** Adds @a filter  to the list of filters that the user can select between.
+   * When a filter is selected, only files that are passed by that
+   * filter are displayed.
+   * 
+   * Since: 2.4
+   * @param filter A Gtk::FileFilter.
+   */
+  void add_filter(const FileFilter& filter);
+  
+  /** Removes @a filter  from the list of filters that the user can select between.
+   * 
+   * Since: 2.4
+   * @param filter A Gtk::FileFilter.
+   */
+  void remove_filter (const FileFilter& filter);
+
+  
+  /** Lists the current set of user-selectable filters; see
+   * add_filter(), remove_filter().
+   * @return A G::SList containing the current set of
+   * user selectable filters. The contents of the list are
+   * owned by GTK+, but you must free the list itself with
+   * Glib::slist_free() when you are done with it.
+   * 
+   * Since: 2.4.
+   */
+  Glib::SListHandle< FileFilter* > list_filters();
+  
+  /** Lists the current set of user-selectable filters; see
+   * add_filter(), remove_filter().
+   * @return A G::SList containing the current set of
+   * user selectable filters. The contents of the list are
+   * owned by GTK+, but you must free the list itself with
+   * Glib::slist_free() when you are done with it.
+   * 
+   * Since: 2.4.
+   */
+  Glib::SListHandle< const FileFilter* > list_filters() const;
+  
+/* Current filter
+ */
+  
+  /** Sets the current filter; only the files that pass the
+   * filter will be displayed. If the user-selectable list of filters
+   * is non-empty, then the filter should be one of the filters
+   * in that list. Setting the current filter when the list of
+   * filters is empty is useful if you want to restrict the displayed
+   * set of files without letting the user change it.
+   * 
+   * Since: 2.4
+   * @param filter A Gtk::FileFilter.
+   */
+  void set_filter(const FileFilter& filter);
+  
+  /** Gets the current filter; see set_filter().
+   * @return The current filter, or <tt>0</tt>
+   * 
+   * Since: 2.4.
+   */
+  FileFilter* get_filter();
+  
+  /** Gets the current filter; see set_filter().
+   * @return The current filter, or <tt>0</tt>
+   * 
+   * Since: 2.4.
+   */
+  const FileFilter* get_filter() const;
+  
+/* Per-application shortcut folders */
+
+  
+  /** Adds a folder to be displayed with the shortcut folders in a file chooser.
+   * Note that shortcut folders do not get saved, as they are provided by the
+   * application.  For example, you can use this to add a
+   * "/usr/share/mydrawprogram/Clipart" folder to the volume list.
+   * @param folder Filename of the folder to add.
+   * @return <tt>true</tt> if the folder could be added successfully, <tt>false</tt>
+   * otherwise.  In the latter case, the @a error  will be set as appropriate.
+   * 
+   * Since: 2.4.
+   */
+  bool add_shortcut_folder(const Glib::ustring& folder);
+  
+  /** Removes a folder from a file chooser's list of shortcut folders.
+   * @param folder Filename of the folder to remove.
+   * @return <tt>true</tt> if the operation succeeds, <tt>false</tt> otherwise.  
+   * In the latter case, the @a error  will be set as appropriate.
+   * 
+   * See also: add_shortcut_folder()
+   * 
+   * Since: 2.4.
+   */
+  bool remove_shortcut_folder(const Glib::ustring& folder);
+  
+  /** Queries the list of shortcut folders in the file chooser, as set by
+   * add_shortcut_folder().
+   * @return A list of folder filenames, or <tt>0</tt> if there are no shortcut
+   * folders.  Free the returned list with Glib::slist_free(), and the filenames with
+   * Glib::free().
+   * 
+   * Since: 2.4.
+   */
+  Glib::SListHandle<Glib::ustring> list_shortcut_folders() const;
+
+  
+  /** Adds a folder URI to be displayed with the shortcut folders in a file
+   * chooser.  Note that shortcut folders do not get saved, as they are provided
+   * by the application.  For example, you can use this to add a
+   * "file:///usr/share/mydrawprogram/Clipart" folder to the volume list.
+   * @param uri URI of the folder to add.
+   * @return <tt>true</tt> if the folder could be added successfully, <tt>false</tt>
+   * otherwise.  In the latter case, the @a error  will be set as appropriate.
+   * 
+   * Since: 2.4.
+   */
+  bool add_shortcut_folder_uri(const Glib::ustring& uri);
+  
+  /** Removes a folder URI from a file chooser's list of shortcut folders.
+   * @param uri URI of the folder to remove.
+   * @return <tt>true</tt> if the operation succeeds, <tt>false</tt> otherwise.  
+   * In the latter case, the @a error  will be set as appropriate.
+   * 
+   * See also: add_shortcut_folder_uri()
+   * 
+   * Since: 2.4.
+   */
+  bool remove_shortcut_folder_uri(const Glib::ustring& uri);
+  
+  /** Queries the list of shortcut folders in the file chooser, as set by
+   * add_shortcut_folder_uri().
+   * @return A list of folder URIs, or <tt>0</tt> if there are no shortcut
+   * folders.  Free the returned list with Glib::slist_free(), and the URIs with
+   * Glib::free().
+   * 
+   * Since: 2.4.
+   */
+  Glib::SListHandle<Glib::ustring> list_shortcut_folder_uris() const;
+
+
+  Glib::SignalProxy0< void > signal_current_folder_changed();
+
+  
+  Glib::SignalProxy0< void > signal_selection_changed();
+
+  
+  Glib::SignalProxy0< void > signal_update_preview();
+
+  
+  Glib::SignalProxy0< void > signal_file_activated();
+
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<FileChooserAction> property_action() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<FileChooserAction> property_action() const;
+
+  //TODO: _WRAP_PROPERTY("file-system", FileSystem) //FileSystem is not really public API.
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<FileFilter*> property_filter() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<FileFilter*> property_filter() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_folder_mode() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_folder_mode() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_local_only() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_local_only() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Widget*> property_preview_widget() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Widget*> property_preview_widget() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_preview_widget_active() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_preview_widget_active() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_use_preview_label() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_use_preview_label() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Widget*> property_extra_widget() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Widget*> property_extra_widget() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_select_multiple() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_select_multiple() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_show_hidden() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_show_hidden() const;
+
+
+public:
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+};
+
+} // namespace Gtk
+
+
+namespace Glib
+{
+  /** @relates Gtk::FileChooser
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Glib::RefPtr<Gtk::FileChooser> wrap(GtkFileChooser* object, bool take_copy = false);
+
+} // namespace Glib
+
+#endif /* _GTKMM_FILECHOOSER_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/filechooserbutton.cc b/libs/gtkmm2/gtk/gtkmm/filechooserbutton.cc
new file mode 100644
index 0000000000..ebdc540ddd
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/filechooserbutton.cc
@@ -0,0 +1,203 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/filechooserbutton.h>
+#include <gtkmm/private/filechooserbutton_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/*
+ *
+ * Copyright 2003 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtk/gtkfilechooserbutton.h>
+
+namespace Gtk
+{
+
+FileChooserButton::FileChooserButton(FileChooserAction action)
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::HBox(Glib::ConstructParams(filechooserbutton_class_.init(), "action",action, (char*) 0))
+{
+}
+  
+
+} // namespace Gtk
+
+
+namespace
+{
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Gtk::FileChooserButton* wrap(GtkFileChooserButton* object, bool take_copy)
+{
+  return dynamic_cast<Gtk::FileChooserButton *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& FileChooserButton_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &FileChooserButton_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_file_chooser_button_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  FileChooser::add_interface(get_type());
+  }
+
+  return *this;
+}
+
+void FileChooserButton_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+}
+
+
+Glib::ObjectBase* FileChooserButton_Class::wrap_new(GObject* o)
+{
+  return manage(new FileChooserButton((GtkFileChooserButton*)(o)));
+
+}
+
+
+/* The implementation: */
+
+FileChooserButton::FileChooserButton(const Glib::ConstructParams& construct_params)
+:
+  Gtk::HBox(construct_params)
+{
+  }
+
+FileChooserButton::FileChooserButton(GtkFileChooserButton* castitem)
+:
+  Gtk::HBox((GtkHBox*)(castitem))
+{
+  }
+
+FileChooserButton::~FileChooserButton()
+{
+  destroy_();
+}
+
+FileChooserButton::CppClassType FileChooserButton::filechooserbutton_class_; // initialize static member
+
+GType FileChooserButton::get_type()
+{
+  return filechooserbutton_class_.init().get_type();
+}
+
+GType FileChooserButton::get_base_type()
+{
+  return gtk_file_chooser_button_get_type();
+}
+
+
+FileChooserButton::FileChooserButton(const Glib::ustring& title, FileChooserAction action)
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::HBox(Glib::ConstructParams(filechooserbutton_class_.init(), "title", title.c_str(), "action", ((GtkFileChooserAction)(action)), (char*) 0))
+{
+  }
+
+FileChooserButton::FileChooserButton(const Glib::ustring& title, FileChooserAction action, const Glib::ustring& backend)
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::HBox(Glib::ConstructParams(filechooserbutton_class_.init(), "title", title.c_str(), "action", ((GtkFileChooserAction)(action)), "backend", backend.c_str(), (char*) 0))
+{
+  }
+
+FileChooserButton::FileChooserButton(FileChooserDialog& dialog)
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::HBox(Glib::ConstructParams(filechooserbutton_class_.init(), "dialog", (dialog).Gtk::Widget::gobj(), (char*) 0))
+{
+  }
+
+Glib::ustring FileChooserButton::get_title() const
+{
+  return Glib::convert_const_gchar_ptr_to_ustring(gtk_file_chooser_button_get_title(const_cast<GtkFileChooserButton*>(gobj())));
+}
+
+void FileChooserButton::set_title(const Glib::ustring& title)
+{
+  gtk_file_chooser_button_set_title(gobj(), title.c_str());
+}
+
+int FileChooserButton::get_width_chars() const
+{
+  return gtk_file_chooser_button_get_width_chars(const_cast<GtkFileChooserButton*>(gobj()));
+}
+
+void FileChooserButton::set_width_chars(int n_chars)
+{
+  gtk_file_chooser_button_set_width_chars(gobj(), n_chars);
+}
+
+
+Glib::PropertyProxy_ReadOnly<FileChooserDialog*> FileChooserButton::property_dialog() const
+{
+  return Glib::PropertyProxy_ReadOnly<FileChooserDialog*>(this, "dialog");
+}
+
+Glib::PropertyProxy<Glib::ustring> FileChooserButton::property_title() 
+{
+  return Glib::PropertyProxy<Glib::ustring>(this, "title");
+}
+
+Glib::PropertyProxy_ReadOnly<Glib::ustring> FileChooserButton::property_title() const
+{
+  return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "title");
+}
+
+Glib::PropertyProxy<int> FileChooserButton::property_width_chars() 
+{
+  return Glib::PropertyProxy<int>(this, "width-chars");
+}
+
+Glib::PropertyProxy_ReadOnly<int> FileChooserButton::property_width_chars() const
+{
+  return Glib::PropertyProxy_ReadOnly<int>(this, "width-chars");
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/filechooserbutton.h b/libs/gtkmm2/gtk/gtkmm/filechooserbutton.h
new file mode 100644
index 0000000000..0865ac58e6
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/filechooserbutton.h
@@ -0,0 +1,234 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_FILECHOOSERBUTTON_H
+#define _GTKMM_FILECHOOSERBUTTON_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* filechooserbutton.h
+ * 
+ * Copyright (C) 2003 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/box.h>
+#include <gtkmm/filechooserdialog.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkFileChooserButton GtkFileChooserButton;
+typedef struct _GtkFileChooserButtonClass GtkFileChooserButtonClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class FileChooserButton_Class; } // namespace Gtk
+namespace Gtk
+{
+
+/** A button to launch a file chooser dialog.
+ * 
+ * This widget lets the user select a file. It implements the FileChooser interface. Visually, it is a file name with a 
+ * button to bring up a FileChooserDialog. The user can then use that dialog to change the file associated with that 
+ * button. This widget does not support setting the "select_multiple" property to true.
+ *
+ * The FileChooserButton supports the FileChooserActions FILE_CHOOSER_ACTION_OPEN and FILE_CHOOSER_ACTION_SELECT_FOLDER.
+ *
+ * The FileChooserButton will ellipsize the label, and will thus request little horizontal space. To give the button more 
+ * space, you should call size_request(), set_width_chars(), or pack the button in such a way that other interface 
+ * elements give space to the widget.
+ *
+ * @ingroup Widgets
+ */
+
+class FileChooserButton
+  : public HBox,
+    public FileChooser
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef FileChooserButton CppObjectType;
+  typedef FileChooserButton_Class CppClassType;
+  typedef GtkFileChooserButton BaseObjectType;
+  typedef GtkFileChooserButtonClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~FileChooserButton();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class FileChooserButton_Class;
+  static CppClassType filechooserbutton_class_;
+
+  // noncopyable
+  FileChooserButton(const FileChooserButton&);
+  FileChooserButton& operator=(const FileChooserButton&);
+
+protected:
+  explicit FileChooserButton(const Glib::ConstructParams& construct_params);
+  explicit FileChooserButton(GtkFileChooserButton* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GtkFileChooserButton*       gobj()       { return reinterpret_cast<GtkFileChooserButton*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GtkFileChooserButton* gobj() const { return reinterpret_cast<GtkFileChooserButton*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+private:
+
+  
+public:
+
+  /** Creates a new file-selecting button widget with the default title.
+   * @param title The title of the browse dialog.
+   * @param action The open mode for the widget.
+   * @param backend The name of the Gtk::FileSystem backend to use.
+   */
+  explicit FileChooserButton(FileChooserAction action = FILE_CHOOSER_ACTION_OPEN);
+  
+  /** Creates a new file-selecting button widget.
+   *
+   * @param title The title of the browse dialog.
+   * @param action The open mode for the widget.
+   */
+  explicit FileChooserButton(const Glib::ustring& title, FileChooserAction action = FILE_CHOOSER_ACTION_OPEN);
+  
+  /** Creates a new file-selecting button widget using backend.
+   *
+   * @param title The title of the browse dialog.
+   * @param action The open mode for the widget.
+   * @param backend The name of the Gtk::FileSystem backend to use.
+   */ 
+  explicit FileChooserButton(const Glib::ustring& title, FileChooserAction action, const Glib::ustring& backend);
+  
+  /** Creates a new file-selecting button widget which uses dialog as its file-picking window.
+   *
+   * @param dialog The dialog to use.
+   */
+  explicit FileChooserButton(FileChooserDialog& dialog);
+  
+  
+  /** Retrieves the title of the browse dialog used by @a button . The returned value
+   * should not be modified or freed.
+   * @return A pointer to the browse dialog's title.
+   * 
+   * Since: 2.6.
+   */
+  Glib::ustring get_title() const;
+  
+  /** Modifies the @a title  of the browse dialog used by @a button .
+   * 
+   * Since: 2.6
+   * @param title The new browse dialog title.
+   */
+  void set_title(const Glib::ustring& title);
+ 
+  
+  /** Retrieves the width in characters of the @a button  widget's entry and/or label.
+   * @return An integer width (in characters) that the button will use to size itself.
+   * 
+   * Since: 2.6.
+   */
+  int get_width_chars() const;
+  
+  /** Sets the width (in characters) that @a button  will use to @a n_chars .
+   * 
+   * Since: 2.6
+   * @param n_chars The new width, in chracters.
+   */
+  void set_width_chars(int n_chars);
+
+
+  /** The file chooser dialog to use.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<FileChooserDialog*> property_dialog() const;
+
+
+  /** The title of the file chooser dialog.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Glib::ustring> property_title() ;
+
+/** The title of the file chooser dialog.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Glib::ustring> property_title() const;
+                                          
+  /** The desired width of the button widget
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<int> property_width_chars() ;
+
+/** The desired width of the button widget
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<int> property_width_chars() const;
+    
+
+};
+
+
+} // namespace Gtk
+
+
+namespace Glib
+{
+  /** @relates Gtk::FileChooserButton
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gtk::FileChooserButton* wrap(GtkFileChooserButton* object, bool take_copy = false);
+}
+#endif /* _GTKMM_FILECHOOSERBUTTON_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/filechooserdialog.cc b/libs/gtkmm2/gtk/gtkmm/filechooserdialog.cc
new file mode 100644
index 0000000000..88dc4078e5
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/filechooserdialog.cc
@@ -0,0 +1,158 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/filechooserdialog.h>
+#include <gtkmm/private/filechooserdialog_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/*
+ *
+ * Copyright 2003 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtk/gtkfilechooserdialog.h>
+
+
+namespace Gtk
+{
+
+FileChooserDialog::FileChooserDialog(Gtk::Window& parent, const Glib::ustring& title, FileChooserAction action)
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Dialog(Glib::ConstructParams(filechooserdialog_class_.init(), "title",title.c_str(),"action",(GtkFileChooserAction)action, (char*) 0))
+{
+  set_transient_for(parent);
+}
+
+FileChooserDialog::FileChooserDialog(const Glib::ustring& title, FileChooserAction action)
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Dialog(Glib::ConstructParams(filechooserdialog_class_.init(), "title",title.c_str(),"action",(GtkFileChooserAction)action, (char*) 0))
+{
+}
+
+FileChooserDialog::FileChooserDialog(const Glib::ustring& title, FileChooserAction action, const Glib::ustring& backend)
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Dialog(Glib::ConstructParams(filechooserdialog_class_.init(), "title",title.c_str(),"action",(GtkFileChooserAction)action,"file-system-backend",backend.c_str(), (char*) 0))
+{
+}
+
+FileChooserDialog::FileChooserDialog(Gtk::Window& parent, const Glib::ustring& title, FileChooserAction action, const Glib::ustring& backend)
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Dialog(Glib::ConstructParams(filechooserdialog_class_.init(), "title",title.c_str(),"action",(GtkFileChooserAction)action,"file-system-backend",backend.c_str(), (char*) 0))
+{
+  set_transient_for(parent);
+}
+
+} // namespace Gtk
+
+
+namespace
+{
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Gtk::FileChooserDialog* wrap(GtkFileChooserDialog* object, bool take_copy)
+{
+  return dynamic_cast<Gtk::FileChooserDialog *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& FileChooserDialog_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &FileChooserDialog_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_file_chooser_dialog_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  FileChooser::add_interface(get_type());
+  }
+
+  return *this;
+}
+
+void FileChooserDialog_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+}
+
+
+Glib::ObjectBase* FileChooserDialog_Class::wrap_new(GObject* o)
+{
+  return new FileChooserDialog((GtkFileChooserDialog*)(o)); //top-level windows can not be manage()ed.
+
+}
+
+
+/* The implementation: */
+
+FileChooserDialog::FileChooserDialog(const Glib::ConstructParams& construct_params)
+:
+  Gtk::Dialog(construct_params)
+{
+  }
+
+FileChooserDialog::FileChooserDialog(GtkFileChooserDialog* castitem)
+:
+  Gtk::Dialog((GtkDialog*)(castitem))
+{
+  }
+
+FileChooserDialog::~FileChooserDialog()
+{
+  destroy_();
+}
+
+FileChooserDialog::CppClassType FileChooserDialog::filechooserdialog_class_; // initialize static member
+
+GType FileChooserDialog::get_type()
+{
+  return filechooserdialog_class_.init().get_type();
+}
+
+GType FileChooserDialog::get_base_type()
+{
+  return gtk_file_chooser_dialog_get_type();
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/filechooserdialog.h b/libs/gtkmm2/gtk/gtkmm/filechooserdialog.h
new file mode 100644
index 0000000000..08ba746815
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/filechooserdialog.h
@@ -0,0 +1,129 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_FILECHOOSERDIALOG_H
+#define _GTKMM_FILECHOOSERDIALOG_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* filechooserdialog.h
+ *
+ * Copyright (C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/dialog.h>
+#include <gtkmm/filechooser.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkFileChooserDialog GtkFileChooserDialog;
+typedef struct _GtkFileChooserDialogClass GtkFileChooserDialogClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class FileChooserDialog_Class; } // namespace Gtk
+namespace Gtk
+{
+
+/** Convenient file chooser window.
+ *
+ * @ingroup Dialogs
+ */
+
+class FileChooserDialog
+  : public Dialog,
+    public FileChooser
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef FileChooserDialog CppObjectType;
+  typedef FileChooserDialog_Class CppClassType;
+  typedef GtkFileChooserDialog BaseObjectType;
+  typedef GtkFileChooserDialogClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~FileChooserDialog();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class FileChooserDialog_Class;
+  static CppClassType filechooserdialog_class_;
+
+  // noncopyable
+  FileChooserDialog(const FileChooserDialog&);
+  FileChooserDialog& operator=(const FileChooserDialog&);
+
+protected:
+  explicit FileChooserDialog(const Glib::ConstructParams& construct_params);
+  explicit FileChooserDialog(GtkFileChooserDialog* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GtkFileChooserDialog*       gobj()       { return reinterpret_cast<GtkFileChooserDialog*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GtkFileChooserDialog* gobj() const { return reinterpret_cast<GtkFileChooserDialog*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+private:
+
+  
+public:
+  
+  explicit FileChooserDialog(Gtk::Window& parent, const Glib::ustring& title, FileChooserAction action = FILE_CHOOSER_ACTION_OPEN);
+  explicit FileChooserDialog(const Glib::ustring& title, FileChooserAction action = FILE_CHOOSER_ACTION_OPEN);
+
+  
+  explicit FileChooserDialog(Gtk::Window& parent, const Glib::ustring& title, FileChooserAction action, const Glib::ustring& backend);
+  explicit FileChooserDialog(const Glib::ustring& title, FileChooserAction action, const Glib::ustring& backend);
+
+
+};
+
+} // namespace Gtk
+
+
+namespace Glib
+{
+  /** @relates Gtk::FileChooserDialog
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gtk::FileChooserDialog* wrap(GtkFileChooserDialog* object, bool take_copy = false);
+}
+#endif /* _GTKMM_FILECHOOSERDIALOG_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/filechooserwidget.cc b/libs/gtkmm2/gtk/gtkmm/filechooserwidget.cc
new file mode 100644
index 0000000000..db14e802eb
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/filechooserwidget.cc
@@ -0,0 +1,150 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/filechooserwidget.h>
+#include <gtkmm/private/filechooserwidget_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/*
+ *
+ * Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtk/gtkfilechooserwidget.h>
+
+namespace Gtk
+{
+
+
+} // namespace Gtk
+
+
+namespace
+{
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Gtk::FileChooserWidget* wrap(GtkFileChooserWidget* object, bool take_copy)
+{
+  return dynamic_cast<Gtk::FileChooserWidget *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& FileChooserWidget_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &FileChooserWidget_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_file_chooser_widget_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  FileChooser::add_interface(get_type());
+  }
+
+  return *this;
+}
+
+void FileChooserWidget_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+}
+
+
+Glib::ObjectBase* FileChooserWidget_Class::wrap_new(GObject* o)
+{
+  return manage(new FileChooserWidget((GtkFileChooserWidget*)(o)));
+
+}
+
+
+/* The implementation: */
+
+FileChooserWidget::FileChooserWidget(const Glib::ConstructParams& construct_params)
+:
+  Gtk::VBox(construct_params)
+{
+  }
+
+FileChooserWidget::FileChooserWidget(GtkFileChooserWidget* castitem)
+:
+  Gtk::VBox((GtkVBox*)(castitem))
+{
+  }
+
+FileChooserWidget::~FileChooserWidget()
+{
+  destroy_();
+}
+
+FileChooserWidget::CppClassType FileChooserWidget::filechooserwidget_class_; // initialize static member
+
+GType FileChooserWidget::get_type()
+{
+  return filechooserwidget_class_.init().get_type();
+}
+
+GType FileChooserWidget::get_base_type()
+{
+  return gtk_file_chooser_widget_get_type();
+}
+
+
+FileChooserWidget::FileChooserWidget()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::VBox(Glib::ConstructParams(filechooserwidget_class_.init()))
+{
+  }
+
+FileChooserWidget::FileChooserWidget(FileChooserAction action)
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::VBox(Glib::ConstructParams(filechooserwidget_class_.init(), "action", ((GtkFileChooserAction)(action)), (char*) 0))
+{
+  }
+
+FileChooserWidget::FileChooserWidget(FileChooserAction action, const Glib::ustring& backend)
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::VBox(Glib::ConstructParams(filechooserwidget_class_.init(), "action", ((GtkFileChooserAction)(action)), "backend", backend.c_str(), (char*) 0))
+{
+  }
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/filechooserwidget.h b/libs/gtkmm2/gtk/gtkmm/filechooserwidget.h
new file mode 100644
index 0000000000..fa8afffd6c
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/filechooserwidget.h
@@ -0,0 +1,140 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_FILECHOOSERWIDGET_H
+#define _GTKMM_FILECHOOSERWIDGET_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* box.h
+ *
+ * Copyright (C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/box.h>
+#include <gtkmm/filechooser.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkFileChooserWidget GtkFileChooserWidget;
+typedef struct _GtkFileChooserWidgetClass GtkFileChooserWidgetClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class FileChooserWidget_Class; } // namespace Gtk
+namespace Gtk
+{
+
+/** File chooser widget that can be embedded in other widgets.
+ *
+ * FileChooserWidget is a widget suitable for selecting files. It is the main
+ * building block of a Gtk::FileChooserDialog. Most applications will only need to use
+ * the latter; you can use FileChooserWidget as part of a larger window if you have
+ * special needs.
+ *
+ * @ingroup Widgets
+ */
+
+class FileChooserWidget
+: public VBox,
+  public FileChooser
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef FileChooserWidget CppObjectType;
+  typedef FileChooserWidget_Class CppClassType;
+  typedef GtkFileChooserWidget BaseObjectType;
+  typedef GtkFileChooserWidgetClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~FileChooserWidget();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class FileChooserWidget_Class;
+  static CppClassType filechooserwidget_class_;
+
+  // noncopyable
+  FileChooserWidget(const FileChooserWidget&);
+  FileChooserWidget& operator=(const FileChooserWidget&);
+
+protected:
+  explicit FileChooserWidget(const Glib::ConstructParams& construct_params);
+  explicit FileChooserWidget(GtkFileChooserWidget* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GtkFileChooserWidget*       gobj()       { return reinterpret_cast<GtkFileChooserWidget*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GtkFileChooserWidget* gobj() const { return reinterpret_cast<GtkFileChooserWidget*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+private:
+
+  
+public:
+  FileChooserWidget();
+  
+  /** Creates a file chooser widget that can be embedded in other widgets.
+   *
+   * Creates a new FileChooserWidget. This is a file chooser widget that can be embedded in
+   * custom windows, and it is the same widget that is used by Gtk::FileChooserDialog.
+   *
+   * @param action Open or save mode for the widget
+   * 
+   * Since: 2.4
+   */
+  explicit FileChooserWidget(FileChooserAction action);
+  explicit FileChooserWidget(FileChooserAction action, const Glib::ustring& backend);
+
+
+};
+
+} // namespace Gtk
+
+
+namespace Glib
+{
+  /** @relates Gtk::FileChooserWidget
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gtk::FileChooserWidget* wrap(GtkFileChooserWidget* object, bool take_copy = false);
+}
+#endif /* _GTKMM_FILECHOOSERWIDGET_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/filefilter.cc b/libs/gtkmm2/gtk/gtkmm/filefilter.cc
new file mode 100644
index 0000000000..72c921934d
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/filefilter.cc
@@ -0,0 +1,240 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/filefilter.h>
+#include <gtkmm/private/filefilter_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* Copyright 2003 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtk/gtkfilefilter.h>
+#include <gtk/gtktypebuiltins.h> //For gtk_file_filter_flags_get_type().
+
+namespace
+{
+
+//SignalProxy_Custom:
+
+//This Signal Proxy allows the C++ coder to specify a sigc::slot instead of a static function.
+class SignalProxy_Custom
+{
+public:
+  typedef Gtk::FileFilter::SlotCustom SlotType;
+
+  SignalProxy_Custom(const SlotType& slot);
+  ~SignalProxy_Custom();
+
+  static gboolean gtk_callback(const GtkFileFilterInfo* filter_info, gpointer data);
+  static void gtk_callback_destroy(void* data);
+  
+protected:
+  SlotType slot_;
+};
+
+SignalProxy_Custom::SignalProxy_Custom(const SlotType& slot)
+:
+  slot_ (slot)
+{}
+
+SignalProxy_Custom::~SignalProxy_Custom()
+{}
+
+gboolean SignalProxy_Custom::gtk_callback(const GtkFileFilterInfo* filter_info, gpointer data)
+{
+  SignalProxy_Custom *const self = static_cast<SignalProxy_Custom*>(data);
+
+  try
+  {
+    //Create a suitable C++ instance to pass to the C++ method:
+    Gtk::FileFilter::Info cppInfo;
+    cppInfo.contains = (Gtk::FileFilterFlags)filter_info->contains;
+    cppInfo.filename = Glib::convert_const_gchar_ptr_to_ustring(filter_info->filename);
+    cppInfo.uri = Glib::convert_const_gchar_ptr_to_ustring(filter_info->uri);
+    cppInfo.display_name = Glib::convert_const_gchar_ptr_to_ustring(filter_info->display_name);
+    cppInfo.mime_type = Glib::convert_const_gchar_ptr_to_ustring(filter_info->mime_type);
+  
+    return (self->slot_)(cppInfo);
+  }
+  catch(...)
+  {
+    Glib::exception_handlers_invoke();
+    return false; //arbitrary default;
+  }
+}
+
+void SignalProxy_Custom::gtk_callback_destroy(void* data)
+{
+  delete static_cast<SignalProxy_Custom*>(data);
+}
+
+} //anonymous namespace
+
+namespace Gtk
+{
+
+void FileFilter::add_custom(FileFilterFlags needed, const SlotCustom& slot)
+{
+  //Create a signal proxy. A pointer to this will be passed through the callback's data parameter.
+  //It will be deleted when SignalProxy_Custom::gtk_callback_destroy() is called.
+  SignalProxy_Custom *const pSignalProxy = new SignalProxy_Custom(slot);
+      
+  gtk_file_filter_add_custom(gobj(), (GtkFileFilterFlags)needed,
+                             &SignalProxy_Custom::gtk_callback,
+                             pSignalProxy,
+                             &SignalProxy_Custom::gtk_callback_destroy);     
+}
+ 
+} // namespace Gtk
+
+
+namespace
+{
+} // anonymous namespace
+
+// static
+GType Glib::Value<Gtk::FileFilterFlags>::value_type()
+{
+  return gtk_file_filter_flags_get_type();
+}
+
+
+namespace Glib
+{
+
+Gtk::FileFilter* wrap(GtkFileFilter* object, bool take_copy)
+{
+  return dynamic_cast<Gtk::FileFilter *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& FileFilter_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &FileFilter_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_file_filter_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void FileFilter_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+}
+
+
+Glib::ObjectBase* FileFilter_Class::wrap_new(GObject* o)
+{
+  return manage(new FileFilter((GtkFileFilter*)(o)));
+
+}
+
+
+/* The implementation: */
+
+FileFilter::FileFilter(const Glib::ConstructParams& construct_params)
+:
+  Gtk::Object(construct_params)
+{
+  }
+
+FileFilter::FileFilter(GtkFileFilter* castitem)
+:
+  Gtk::Object((GtkObject*)(castitem))
+{
+  }
+
+FileFilter::~FileFilter()
+{
+  destroy_();
+}
+
+FileFilter::CppClassType FileFilter::filefilter_class_; // initialize static member
+
+GType FileFilter::get_type()
+{
+  return filefilter_class_.init().get_type();
+}
+
+GType FileFilter::get_base_type()
+{
+  return gtk_file_filter_get_type();
+}
+
+
+FileFilter::FileFilter()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Object(Glib::ConstructParams(filefilter_class_.init()))
+{
+  }
+
+void FileFilter::set_name(const Glib::ustring& name)
+{
+  gtk_file_filter_set_name(gobj(), name.c_str());
+}
+
+Glib::ustring FileFilter::get_name() const
+{
+  return Glib::convert_const_gchar_ptr_to_ustring(gtk_file_filter_get_name(const_cast<GtkFileFilter*>(gobj())));
+}
+
+void FileFilter::add_mime_type(const Glib::ustring& mime_type)
+{
+  gtk_file_filter_add_mime_type(gobj(), mime_type.c_str());
+}
+
+void FileFilter::add_pattern(const Glib::ustring& pattern)
+{
+  gtk_file_filter_add_pattern(gobj(), pattern.c_str());
+}
+
+void FileFilter::add_pixbuf_formats()
+{
+  gtk_file_filter_add_pixbuf_formats(gobj());
+}
+
+FileFilterFlags FileFilter::get_needed() const
+{
+  return ((FileFilterFlags)(gtk_file_filter_get_needed(const_cast<GtkFileFilter*>(gobj()))));
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/filefilter.h b/libs/gtkmm2/gtk/gtkmm/filefilter.h
new file mode 100644
index 0000000000..1800856266
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/filefilter.h
@@ -0,0 +1,264 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_FILEFILTER_H
+#define _GTKMM_FILEFILTER_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* Copyright (C) 2003 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/object.h>
+
+
+//TODO: remove this if we wrap this in a C++ type:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+//typedef struct _GtkFileFilterInfo GtkFileFilterInfo;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkFileFilter GtkFileFilter;
+typedef struct _GtkFileFilterClass GtkFileFilterClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class FileFilter_Class; } // namespace Gtk
+namespace Gtk
+{
+
+/** @addtogroup gtkmmEnums Enums and Flags */
+
+/**
+ * @ingroup gtkmmEnums
+ * @par Bitwise operators:
+ * <tt>%FileFilterFlags operator|(FileFilterFlags, FileFilterFlags)</tt><br>
+ * <tt>%FileFilterFlags operator&(FileFilterFlags, FileFilterFlags)</tt><br>
+ * <tt>%FileFilterFlags operator^(FileFilterFlags, FileFilterFlags)</tt><br>
+ * <tt>%FileFilterFlags operator~(FileFilterFlags)</tt><br>
+ * <tt>%FileFilterFlags& operator|=(FileFilterFlags&, FileFilterFlags)</tt><br>
+ * <tt>%FileFilterFlags& operator&=(FileFilterFlags&, FileFilterFlags)</tt><br>
+ * <tt>%FileFilterFlags& operator^=(FileFilterFlags&, FileFilterFlags)</tt><br>
+ */
+enum FileFilterFlags
+{
+  FILE_FILTER_FILENAME = 1 << 0,
+  FILE_FILTER_URI = 1 << 1,
+  FILE_FILTER_DISPLAY_NAME = 1 << 2,
+  FILE_FILTER_MIME_TYPE = 1 << 3
+};
+
+/** @ingroup gtkmmEnums */
+inline FileFilterFlags operator|(FileFilterFlags lhs, FileFilterFlags rhs)
+  { return static_cast<FileFilterFlags>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs)); }
+
+/** @ingroup gtkmmEnums */
+inline FileFilterFlags operator&(FileFilterFlags lhs, FileFilterFlags rhs)
+  { return static_cast<FileFilterFlags>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs)); }
+
+/** @ingroup gtkmmEnums */
+inline FileFilterFlags operator^(FileFilterFlags lhs, FileFilterFlags rhs)
+  { return static_cast<FileFilterFlags>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs)); }
+
+/** @ingroup gtkmmEnums */
+inline FileFilterFlags operator~(FileFilterFlags flags)
+  { return static_cast<FileFilterFlags>(~static_cast<unsigned>(flags)); }
+
+/** @ingroup gtkmmEnums */
+inline FileFilterFlags& operator|=(FileFilterFlags& lhs, FileFilterFlags rhs)
+  { return (lhs = static_cast<FileFilterFlags>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs))); }
+
+/** @ingroup gtkmmEnums */
+inline FileFilterFlags& operator&=(FileFilterFlags& lhs, FileFilterFlags rhs)
+  { return (lhs = static_cast<FileFilterFlags>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs))); }
+
+/** @ingroup gtkmmEnums */
+inline FileFilterFlags& operator^=(FileFilterFlags& lhs, FileFilterFlags rhs)
+  { return (lhs = static_cast<FileFilterFlags>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs))); }
+
+} // namespace Gtk
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Gtk::FileFilterFlags> : public Glib::Value_Flags<Gtk::FileFilterFlags>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{
+
+
+class FileFilter : public Gtk::Object
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef FileFilter CppObjectType;
+  typedef FileFilter_Class CppClassType;
+  typedef GtkFileFilter BaseObjectType;
+  typedef GtkFileFilterClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~FileFilter();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class FileFilter_Class;
+  static CppClassType filefilter_class_;
+
+  // noncopyable
+  FileFilter(const FileFilter&);
+  FileFilter& operator=(const FileFilter&);
+
+protected:
+  explicit FileFilter(const Glib::ConstructParams& construct_params);
+  explicit FileFilter(GtkFileFilter* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GtkFileFilter*       gobj()       { return reinterpret_cast<GtkFileFilter*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GtkFileFilter* gobj() const { return reinterpret_cast<GtkFileFilter*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+private:
+
+public:
+ FileFilter();
+
+  
+  /** Sets the human-readable name of the filter; this is the string
+   * that will be displayed in the file selector user interface if
+   * there is a selectable list of filters.
+   * 
+   * Since: 2.4
+   * @param name The human-readable-name for the filter, or <tt>0</tt>
+   * to remove any existing name.
+   */
+  void set_name(const Glib::ustring& name);
+  
+  /** Gets the human-readable name for the filter. See gtk_file_filter_set_name().
+   * @return The human-readable name of the filter,
+   * or <tt>0</tt>. This value is owned by GTK+ and must not
+   * be modified or freed.
+   * 
+   * Since: 2.4.
+   */
+  Glib::ustring get_name() const;
+
+  
+  /** Adds a rule allowing a given mime type to @a filter .
+   * 
+   * Since: 2.4
+   * @param mime_type Name of a MIME type.
+   */
+  void add_mime_type(const Glib::ustring& mime_type);
+  
+  /** Adds a rule allowing a shell style glob to a filter.
+   * 
+   * Since: 2.4
+   * @param pattern A shell style glob.
+   */
+  void add_pattern(const Glib::ustring& pattern);
+  
+  /** Adds a rule allowing image files in the formats supported
+   * by GdkPixbuf.
+   * 
+   * Since: 2.6
+   */
+  void add_pixbuf_formats();
+
+  class Info
+  {
+  public:
+    FileFilterFlags contains;
+    Glib::ustring filename;
+    Glib::ustring uri;
+    Glib::ustring display_name;
+    Glib::ustring mime_type;
+  };
+
+  /// For instance, bool on_custom(const Gtk::FileFilter::Info& filter_info);
+  typedef sigc::slot<bool, const Info&> SlotCustom;
+  
+  void add_custom(FileFilterFlags needed, const SlotCustom& slot);
+  
+
+  /** Gets the fields that need to be filled in for the structure
+   * passed to gtk_file_filter_filter()
+   * 
+   * This function will not typically be used by applications; it
+   * is intended principally for use in the implementation of
+   * Gtk::FileChooser.
+   * @return Bitfield of flags indicating needed fields when
+   * calling gtk_file_filter_filter()
+   * 
+   * Since: 2.4.
+   */
+  FileFilterFlags get_needed() const;
+
+  //TODO: This method is used by FileChooser implementors, so we don't need to wrap it.
+  
+  //_WRAP_METHOD(bool filter(const GtkFileFilterInfo* filter_info), gtk_file_filter_filter)
+
+
+};
+
+} // namespace Gtk
+
+
+namespace Glib
+{
+  /** @relates Gtk::FileFilter
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gtk::FileFilter* wrap(GtkFileFilter* object, bool take_copy = false);
+}
+#endif /* _GTKMM_FILEFILTER_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/fileselection.cc b/libs/gtkmm2/gtk/gtkmm/fileselection.cc
new file mode 100644
index 0000000000..9379da1c9f
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/fileselection.cc
@@ -0,0 +1,324 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/fileselection.h>
+#include <gtkmm/private/fileselection_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtk/gtkfilesel.h>
+#include <gtkmm/entry.h>
+#include <gtkmm/label.h>
+#include <gtkmm/box.h>
+#include <gtkmm/button.h>
+
+
+namespace Gtk
+{
+
+FileSelection::FileSelection()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Dialog(Glib::ConstructParams(fileselection_class_.init(), "title",(char*) 0, (char*) 0))
+{}
+
+} // namespace Gtk
+
+
+namespace
+{
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Gtk::FileSelection* wrap(GtkFileSelection* object, bool take_copy)
+{
+  return dynamic_cast<Gtk::FileSelection *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& FileSelection_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &FileSelection_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_file_selection_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void FileSelection_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+}
+
+
+Glib::ObjectBase* FileSelection_Class::wrap_new(GObject* o)
+{
+  return new FileSelection((GtkFileSelection*)(o)); //top-level windows can not be manage()ed.
+
+}
+
+
+/* The implementation: */
+
+FileSelection::FileSelection(const Glib::ConstructParams& construct_params)
+:
+  Gtk::Dialog(construct_params)
+{
+  }
+
+FileSelection::FileSelection(GtkFileSelection* castitem)
+:
+  Gtk::Dialog((GtkDialog*)(castitem))
+{
+  }
+
+FileSelection::~FileSelection()
+{
+  destroy_();
+}
+
+FileSelection::CppClassType FileSelection::fileselection_class_; // initialize static member
+
+GType FileSelection::get_type()
+{
+  return fileselection_class_.init().get_type();
+}
+
+GType FileSelection::get_base_type()
+{
+  return gtk_file_selection_get_type();
+}
+
+
+FileSelection::FileSelection(const Glib::ustring& title)
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Dialog(Glib::ConstructParams(fileselection_class_.init(), "title", title.c_str(), (char*) 0))
+{
+  }
+
+void FileSelection::set_filename(const std::string& filename)
+{
+  gtk_file_selection_set_filename(gobj(), (filename).c_str());
+}
+
+std::string FileSelection::get_filename() const
+{
+  return std::string(gtk_file_selection_get_filename(const_cast<GtkFileSelection*>(gobj())));
+}
+
+void FileSelection::complete(const Glib::ustring& pattern)
+{
+  gtk_file_selection_complete(gobj(), pattern.c_str());
+}
+
+void FileSelection::show_fileop_buttons()
+{
+  gtk_file_selection_show_fileop_buttons(gobj());
+}
+
+void FileSelection::hide_fileop_buttons()
+{
+  gtk_file_selection_hide_fileop_buttons(gobj());
+}
+
+Glib::ArrayHandle<std::string> FileSelection::get_selections() const
+{
+  return Glib::ArrayHandle<std::string>(gtk_file_selection_get_selections(const_cast<GtkFileSelection*>(gobj())), Glib::OWNERSHIP_DEEP);
+}
+
+void FileSelection::set_select_multiple(bool select_multiple)
+{
+  gtk_file_selection_set_select_multiple(gobj(), static_cast<int>(select_multiple));
+}
+
+bool FileSelection::get_select_multiple() const
+{
+  return gtk_file_selection_get_select_multiple(const_cast<GtkFileSelection*>(gobj()));
+}
+
+TreeView* FileSelection::get_dir_list()
+{
+  return Glib::wrap((GtkTreeView*)(gobj()->dir_list));
+}
+
+const TreeView* FileSelection::get_dir_list() const
+{
+  return Glib::wrap((GtkTreeView*)(gobj()->dir_list));
+}
+
+TreeView* FileSelection::get_file_list()
+{
+  return Glib::wrap((GtkTreeView*)(gobj()->file_list));
+}
+
+const TreeView* FileSelection::get_file_list() const
+{
+  return Glib::wrap((GtkTreeView*)(gobj()->file_list));
+}
+
+OptionMenu* FileSelection::get_history_pulldown()
+{
+  return Glib::wrap((GtkOptionMenu*)(gobj()->history_pulldown));
+}
+
+const OptionMenu* FileSelection::get_history_pulldown() const
+{
+  return Glib::wrap((GtkOptionMenu*)(gobj()->history_pulldown));
+}
+
+Entry* FileSelection::get_selection_entry()
+{
+  return Glib::wrap((GtkEntry*)(gobj()->selection_entry));
+}
+
+const Entry* FileSelection::get_selection_entry() const
+{
+  return Glib::wrap((GtkEntry*)(gobj()->selection_entry));
+}
+
+Label* FileSelection::get_selection_text()
+{
+  return Glib::wrap((GtkLabel*)(gobj()->selection_text));
+}
+
+const Label* FileSelection::get_selection_text() const
+{
+  return Glib::wrap((GtkLabel*)(gobj()->selection_text));
+}
+
+VBox* FileSelection::get_main_vbox()
+{
+  return Glib::wrap((GtkVBox*)(gobj()->main_vbox));
+}
+
+const VBox* FileSelection::get_main_vbox() const
+{
+  return Glib::wrap((GtkVBox*)(gobj()->main_vbox));
+}
+
+Button* FileSelection::get_ok_button()
+{
+  return Glib::wrap((GtkButton*)(gobj()->ok_button));
+}
+
+const Button* FileSelection::get_ok_button() const
+{
+  return Glib::wrap((GtkButton*)(gobj()->ok_button));
+}
+
+Button* FileSelection::get_cancel_button()
+{
+  return Glib::wrap((GtkButton*)(gobj()->cancel_button));
+}
+
+const Button* FileSelection::get_cancel_button() const
+{
+  return Glib::wrap((GtkButton*)(gobj()->cancel_button));
+}
+
+Button* FileSelection::get_help_button()
+{
+  return Glib::wrap((GtkButton*)(gobj()->help_button));
+}
+
+const Button* FileSelection::get_help_button() const
+{
+  return Glib::wrap((GtkButton*)(gobj()->help_button));
+}
+
+HButtonBox* FileSelection::get_button_area()
+{
+  return Glib::wrap((GtkHButtonBox*)(gobj()->button_area));
+}
+
+const HButtonBox* FileSelection::get_button_area() const
+{
+  return Glib::wrap((GtkHButtonBox*)(gobj()->button_area));
+}
+
+HBox* FileSelection::get_action_area()
+{
+  return Glib::wrap((GtkHBox*)(gobj()->action_area));
+}
+
+const HBox* FileSelection::get_action_area() const
+{
+  return Glib::wrap((GtkHBox*)(gobj()->action_area));
+}
+
+
+Glib::PropertyProxy<bool> FileSelection::property_show_fileops() 
+{
+  return Glib::PropertyProxy<bool>(this, "show-fileops");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> FileSelection::property_show_fileops() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "show-fileops");
+}
+
+Glib::PropertyProxy<std::string> FileSelection::property_filename() 
+{
+  return Glib::PropertyProxy<std::string>(this, "filename");
+}
+
+Glib::PropertyProxy_ReadOnly<std::string> FileSelection::property_filename() const
+{
+  return Glib::PropertyProxy_ReadOnly<std::string>(this, "filename");
+}
+
+Glib::PropertyProxy<bool> FileSelection::property_select_multiple() 
+{
+  return Glib::PropertyProxy<bool>(this, "select-multiple");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> FileSelection::property_select_multiple() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "select-multiple");
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/fileselection.h b/libs/gtkmm2/gtk/gtkmm/fileselection.h
new file mode 100644
index 0000000000..6a5e734362
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/fileselection.h
@@ -0,0 +1,270 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_FILESELECTION_H
+#define _GTKMM_FILESELECTION_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+
+/* fileselection.h
+ * 
+ * Copyright (C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/dialog.h>
+#include <gtkmm/button.h>
+#include <gtkmm/entry.h>
+#include <gtkmm/label.h>
+#include <gtkmm/box.h>
+#include <gtkmm/treeview.h>
+#include <gtkmm/buttonbox.h>
+#include <gtkmm/optionmenu.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkFileSelection GtkFileSelection;
+typedef struct _GtkFileSelectionClass GtkFileSelectionClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class FileSelection_Class; } // namespace Gtk
+namespace Gtk
+{
+
+/** Prompt the user for a file or directory name.
+ *
+ * Gtk::FileSelection should be used to retrieve file or directory names from
+ * the user. It will create a new dialog window containing a directory list,
+ * and a file list corresponding to the current working directory. The
+ * filesystem can be navigated using the directory list or the drop-down
+ * history menu. Alternatively, the TAB key can be used to navigate using
+ * filename completion - common in text based editors such as emacs and jed.
+ *
+ * @deprecated Use the FileChooserDialog instead.
+ */
+
+class FileSelection : public Dialog
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef FileSelection CppObjectType;
+  typedef FileSelection_Class CppClassType;
+  typedef GtkFileSelection BaseObjectType;
+  typedef GtkFileSelectionClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~FileSelection();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class FileSelection_Class;
+  static CppClassType fileselection_class_;
+
+  // noncopyable
+  FileSelection(const FileSelection&);
+  FileSelection& operator=(const FileSelection&);
+
+protected:
+  explicit FileSelection(const Glib::ConstructParams& construct_params);
+  explicit FileSelection(GtkFileSelection* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GtkFileSelection*       gobj()       { return reinterpret_cast<GtkFileSelection*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GtkFileSelection* gobj() const { return reinterpret_cast<GtkFileSelection*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+private:
+
+  
+public:
+
+  FileSelection();
+  explicit FileSelection(const Glib::ustring& title);
+
+  
+  /** Sets a default path for the file requestor. If @a filename  includes a
+   * directory path, then the requestor will open with that path as its
+   * current working directory.
+   * 
+   * This has the consequence that in order to open the requestor with a 
+   * working directory and an empty filename, @a filename  must have a trailing
+   * directory separator.
+   * 
+   * The encoding of @a filename  is preferred GLib file name encoding, which
+   * may not be UTF-8. See Glib::filename_from_utf8().
+   * @param filename A string to set as the default file name.
+   */
+  void set_filename(const std::string& filename);
+
+  
+  /** This function returns the selected filename in the GLib file name
+   * encoding. To convert to UTF-8, call Glib::filename_to_utf8(). The
+   * returned string points to a statically allocated buffer and should
+   * be copied if you plan to keep it around.
+   * 
+   * If no file is selected then the selected directory path is returned.
+   * @return Currently-selected filename in the on-disk encoding.
+   */
+  std::string get_filename() const;
+
+  
+  void complete(const Glib::ustring& pattern);
+  
+  void show_fileop_buttons();
+  
+  void hide_fileop_buttons();
+
+  
+  /** Retrieves the list of file selections the user has made in the dialog box.
+   * This function is intended for use when the user can select multiple files
+   * in the file list. 
+   * 
+   * The filenames are in the GLib file name encoding. To convert to
+   * UTF-8, call Glib::filename_to_utf8() on each string.
+   * @return A newly-allocated <tt>0</tt>-terminated array of strings. Use
+   * Glib::strfreev() to free it.
+   */
+  Glib::ArrayHandle<std::string> get_selections() const;
+
+  
+  /** Sets whether the user is allowed to select multiple files in the file list.
+   * Use get_selections() to get the list of selected files.
+   * @param select_multiple Whether or not the user is allowed to select multiple
+   * files in the file list.
+   */
+  void set_select_multiple(bool select_multiple = true);
+  
+  /** Determines whether or not the user is allowed to select multiple files in
+   * the file list. See set_select_multiple().
+   * @return <tt>true</tt> if the user is allowed to select multiple files in the
+   * file list.
+   */
+  bool get_select_multiple() const;
+
+  //: Accessors
+  TreeView* get_dir_list();
+  const TreeView* get_dir_list() const;
+  TreeView* get_file_list();
+  const TreeView* get_file_list() const;
+  OptionMenu* get_history_pulldown();
+  const OptionMenu* get_history_pulldown() const;
+  Entry* get_selection_entry();
+  const Entry* get_selection_entry() const;
+  Label* get_selection_text();
+  const Label* get_selection_text() const;
+  VBox* get_main_vbox();
+  const VBox* get_main_vbox() const;
+  Button* get_ok_button();
+  const Button* get_ok_button() const;
+  Button* get_cancel_button();
+  const Button* get_cancel_button() const;
+  Button* get_help_button();
+  const Button* get_help_button() const;
+  HButtonBox* get_button_area();
+  const HButtonBox* get_button_area() const;
+  HBox* get_action_area();
+  const HBox* get_action_area() const;
+
+  /** Whether buttons for creating/manipulating files should be displayed.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_show_fileops() ;
+
+/** Whether buttons for creating/manipulating files should be displayed.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_show_fileops() const;
+
+  /** The currently selected filename.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<std::string> property_filename() ;
+
+/** The currently selected filename.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<std::string> property_filename() const;
+
+  /** Whether to allow multiple files to be selected.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_select_multiple() ;
+
+/** Whether to allow multiple files to be selected.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_select_multiple() const;
+
+
+};
+
+
+} // namespace Gtk
+
+
+namespace Glib
+{
+  /** @relates Gtk::FileSelection
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gtk::FileSelection* wrap(GtkFileSelection* object, bool take_copy = false);
+}
+#endif /* _GTKMM_FILESELECTION_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/fixed.cc b/libs/gtkmm2/gtk/gtkmm/fixed.cc
new file mode 100644
index 0000000000..9edbae969a
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/fixed.cc
@@ -0,0 +1,153 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/fixed.h>
+#include <gtkmm/private/fixed_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* 
+ *
+ * Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtk/gtkfixed.h>
+
+namespace Gtk
+{
+}
+
+
+namespace
+{
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Gtk::Fixed* wrap(GtkFixed* object, bool take_copy)
+{
+  return dynamic_cast<Gtk::Fixed *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& Fixed_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &Fixed_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_fixed_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void Fixed_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+}
+
+
+Glib::ObjectBase* Fixed_Class::wrap_new(GObject* o)
+{
+  return manage(new Fixed((GtkFixed*)(o)));
+
+}
+
+
+/* The implementation: */
+
+Fixed::Fixed(const Glib::ConstructParams& construct_params)
+:
+  Gtk::Container(construct_params)
+{
+  }
+
+Fixed::Fixed(GtkFixed* castitem)
+:
+  Gtk::Container((GtkContainer*)(castitem))
+{
+  }
+
+Fixed::~Fixed()
+{
+  destroy_();
+}
+
+Fixed::CppClassType Fixed::fixed_class_; // initialize static member
+
+GType Fixed::get_type()
+{
+  return fixed_class_.init().get_type();
+}
+
+GType Fixed::get_base_type()
+{
+  return gtk_fixed_get_type();
+}
+
+
+Fixed::Fixed()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Container(Glib::ConstructParams(fixed_class_.init()))
+{
+  }
+
+void Fixed::put(Widget& widget, int x, int y)
+{
+  gtk_fixed_put(gobj(), (widget).gobj(), x, y);
+}
+
+void Fixed::move(Widget& widget, int x, int y)
+{
+  gtk_fixed_move(gobj(), (widget).gobj(), x, y);
+}
+
+void Fixed::set_has_window(bool has_window)
+{
+  gtk_fixed_set_has_window(gobj(), static_cast<int>(has_window));
+}
+
+bool Fixed::get_has_window() const
+{
+  return gtk_fixed_get_has_window(const_cast<GtkFixed*>(gobj()));
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/fixed.h b/libs/gtkmm2/gtk/gtkmm/fixed.h
new file mode 100644
index 0000000000..c7b334a238
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/fixed.h
@@ -0,0 +1,149 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_FIXED_H
+#define _GTKMM_FIXED_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* fixed.h
+ * 
+ * Copyright (C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/container.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkFixed GtkFixed;
+typedef struct _GtkFixedClass GtkFixedClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class Fixed_Class; } // namespace Gtk
+namespace Gtk
+{
+
+/** A container which allows you to position widgets at fixed coordinates.
+ *
+ * The Gtk::Fixed widget is a container which can place child widgets at fixed positions and with fixed sizes, given in pixels. It performs no automatic layout management.
+ * For most applications, you should not use this container, because it will result in truncated text, overlapping widgets, and other display bugs:
+ * - Themes may change widget sizes.
+ * - Fonts other than the one you used to write the app will of course change the size of widgets containing text; keep in mind that users may use a larger font because of difficulty reading the default, or they may be using Windows or the framebuffer port of GTK+, where different fonts are available.
+ * - Translation of text into other languages changes its size. Also, display of non-English text will use a different font in many cases.
+ * In addition, the fixed widget can't properly be mirrored in right-to-left languages such as Hebrew and Arabic. i.e. normally GTK+ will flip the interface to put labels to the right of the thing they label, but it can't do that with Gtk::Fixed. So your application will not be usable in right-to-left languages.
+ * Finally, fixed positioning makes it kind of annoying to add/remove GUI elements, since you have to reposition all the other elements. This is a long-term maintenance problem for your application.
+ * If you know none of these things are an issue for your application, and prefer the simplicity of Gtk::Fixed, by all means use the widget. But you should be aware of the tradeoffs.
+ *
+ * @ingroup Widgets
+ * @ingroup Containers
+ */
+
+class Fixed : public Container
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Fixed CppObjectType;
+  typedef Fixed_Class CppClassType;
+  typedef GtkFixed BaseObjectType;
+  typedef GtkFixedClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~Fixed();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class Fixed_Class;
+  static CppClassType fixed_class_;
+
+  // noncopyable
+  Fixed(const Fixed&);
+  Fixed& operator=(const Fixed&);
+
+protected:
+  explicit Fixed(const Glib::ConstructParams& construct_params);
+  explicit Fixed(GtkFixed* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GtkFixed*       gobj()       { return reinterpret_cast<GtkFixed*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GtkFixed* gobj() const { return reinterpret_cast<GtkFixed*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+private:
+
+public:
+  Fixed();
+
+  
+  void put(Widget& widget, int x, int y);
+  
+  void move(Widget& widget, int x, int y);
+  
+  /** Sets whether a Gtk::Fixed widget is created with a separate
+   * Gdk::Window for widget->window or not. (By default, it will be
+   * created with no separate Gdk::Window). This function must be called
+   * while the Gtk::Fixed is not realized, for instance, immediately after the
+   * window is created.
+   * @param has_window <tt>true</tt> if a separate window should be created.
+   */
+  void set_has_window(bool has_window = true);
+  
+  /** Gets whether the Gtk::Fixed has its own Gdk::Window.
+   * See gdk_fixed_set_has_window().
+   * @return <tt>true</tt> if @a fixed  has its own window.
+   */
+  bool get_has_window() const;
+
+
+};
+
+} /* namespace Gtk */
+
+
+namespace Glib
+{
+  /** @relates Gtk::Fixed
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gtk::Fixed* wrap(GtkFixed* object, bool take_copy = false);
+}
+#endif /* _GTKMM_FIXED_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/fontbutton.cc b/libs/gtkmm2/gtk/gtkmm/fontbutton.cc
new file mode 100644
index 0000000000..4644534f21
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/fontbutton.cc
@@ -0,0 +1,324 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/fontbutton.h>
+#include <gtkmm/private/fontbutton_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/*
+ *
+ * Copyright 2003 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtk/gtkfontbutton.h>
+
+namespace Gtk
+{
+
+
+} // namespace Gtk
+
+
+namespace
+{
+
+const Glib::SignalProxyInfo FontButton_signal_font_set_info =
+{
+  "font-set",
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
+};
+
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Gtk::FontButton* wrap(GtkFontButton* object, bool take_copy)
+{
+  return dynamic_cast<Gtk::FontButton *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& FontButton_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &FontButton_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_font_button_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void FontButton_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+  klass->font_set = &font_set_callback;
+}
+
+
+void FontButton_Class::font_set_callback(GtkFontButton* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_font_set();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->font_set)
+      (*base->font_set)(self);
+  }
+}
+
+
+Glib::ObjectBase* FontButton_Class::wrap_new(GObject* o)
+{
+  return manage(new FontButton((GtkFontButton*)(o)));
+
+}
+
+
+/* The implementation: */
+
+FontButton::FontButton(const Glib::ConstructParams& construct_params)
+:
+  Gtk::Button(construct_params)
+{
+  }
+
+FontButton::FontButton(GtkFontButton* castitem)
+:
+  Gtk::Button((GtkButton*)(castitem))
+{
+  }
+
+FontButton::~FontButton()
+{
+  destroy_();
+}
+
+FontButton::CppClassType FontButton::fontbutton_class_; // initialize static member
+
+GType FontButton::get_type()
+{
+  return fontbutton_class_.init().get_type();
+}
+
+GType FontButton::get_base_type()
+{
+  return gtk_font_button_get_type();
+}
+
+
+FontButton::FontButton()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Button(Glib::ConstructParams(fontbutton_class_.init()))
+{
+  }
+
+FontButton::FontButton(const Glib::ustring& fontname)
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Button(Glib::ConstructParams(fontbutton_class_.init(), "fontname", fontname.c_str(), (char*) 0))
+{
+  }
+
+Glib::ustring FontButton::get_title() const
+{
+  return Glib::convert_const_gchar_ptr_to_ustring(gtk_font_button_get_title(const_cast<GtkFontButton*>(gobj())));
+}
+
+void FontButton::set_title(const Glib::ustring& title)
+{
+  gtk_font_button_set_title(gobj(), title.c_str());
+}
+
+bool FontButton::get_use_font() const
+{
+  return gtk_font_button_get_use_font(const_cast<GtkFontButton*>(gobj()));
+}
+
+void FontButton::set_use_font(bool use_font)
+{
+  gtk_font_button_set_use_font(gobj(), static_cast<int>(use_font));
+}
+
+bool FontButton::get_use_size() const
+{
+  return gtk_font_button_get_use_size(const_cast<GtkFontButton*>(gobj()));
+}
+
+void FontButton::set_use_size(bool use_size)
+{
+  gtk_font_button_set_use_size(gobj(), static_cast<int>(use_size));
+}
+
+Glib::ustring FontButton::get_font_name() const
+{
+  return Glib::convert_const_gchar_ptr_to_ustring(gtk_font_button_get_font_name(const_cast<GtkFontButton*>(gobj())));
+}
+
+bool FontButton::set_font_name(const Glib::ustring& fontname)
+{
+  return gtk_font_button_set_font_name(gobj(), fontname.c_str());
+}
+
+bool FontButton::get_show_style() const
+{
+  return gtk_font_button_get_show_style(const_cast<GtkFontButton*>(gobj()));
+}
+
+void FontButton::set_show_style(bool show_style)
+{
+  gtk_font_button_set_show_style(gobj(), static_cast<int>(show_style));
+}
+
+bool FontButton::get_show_size() const
+{
+  return gtk_font_button_get_show_size(const_cast<GtkFontButton*>(gobj()));
+}
+
+void FontButton::set_show_size(bool show_size)
+{
+  gtk_font_button_set_show_size(gobj(), static_cast<int>(show_size));
+}
+
+
+Glib::SignalProxy0< void > FontButton::signal_font_set()
+{
+  return Glib::SignalProxy0< void >(this, &FontButton_signal_font_set_info);
+}
+
+
+Glib::PropertyProxy<Glib::ustring> FontButton::property_title() 
+{
+  return Glib::PropertyProxy<Glib::ustring>(this, "title");
+}
+
+Glib::PropertyProxy_ReadOnly<Glib::ustring> FontButton::property_title() const
+{
+  return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "title");
+}
+
+Glib::PropertyProxy<Glib::ustring> FontButton::property_font_name() 
+{
+  return Glib::PropertyProxy<Glib::ustring>(this, "font-name");
+}
+
+Glib::PropertyProxy_ReadOnly<Glib::ustring> FontButton::property_font_name() const
+{
+  return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "font-name");
+}
+
+Glib::PropertyProxy<bool> FontButton::property_use_font() 
+{
+  return Glib::PropertyProxy<bool>(this, "use-font");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> FontButton::property_use_font() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "use-font");
+}
+
+Glib::PropertyProxy<bool> FontButton::property_use_size() 
+{
+  return Glib::PropertyProxy<bool>(this, "use-size");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> FontButton::property_use_size() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "use-size");
+}
+
+Glib::PropertyProxy<bool> FontButton::property_show_style() 
+{
+  return Glib::PropertyProxy<bool>(this, "show-style");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> FontButton::property_show_style() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "show-style");
+}
+
+Glib::PropertyProxy<bool> FontButton::property_show_size() 
+{
+  return Glib::PropertyProxy<bool>(this, "show-size");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> FontButton::property_show_size() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "show-size");
+}
+
+
+void Gtk::FontButton::on_font_set()
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->font_set)
+    (*base->font_set)(gobj());
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/fontbutton.h b/libs/gtkmm2/gtk/gtkmm/fontbutton.h
new file mode 100644
index 0000000000..79edaa1d02
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/fontbutton.h
@@ -0,0 +1,311 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_FONTBUTTON_H
+#define _GTKMM_FONTBUTTON_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* fontbutton.h
+ * 
+ * Copyright (C) 2003 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/button.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkFontButton GtkFontButton;
+typedef struct _GtkFontButtonClass GtkFontButtonClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class FontButton_Class; } // namespace Gtk
+namespace Gtk
+{
+
+/** A button to launch a font selection dialog.
+ * 
+ * The Gtk::FontButton is a button which displays the currently selected font and
+ * allows to open a font selection dialog to change the font. It is suitable widget
+ * for selecting a font in a preference dialog.
+ * @ingroup Widgets
+ */
+
+class FontButton : public Button
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef FontButton CppObjectType;
+  typedef FontButton_Class CppClassType;
+  typedef GtkFontButton BaseObjectType;
+  typedef GtkFontButtonClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~FontButton();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class FontButton_Class;
+  static CppClassType fontbutton_class_;
+
+  // noncopyable
+  FontButton(const FontButton&);
+  FontButton& operator=(const FontButton&);
+
+protected:
+  explicit FontButton(const Glib::ConstructParams& construct_params);
+  explicit FontButton(GtkFontButton* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GtkFontButton*       gobj()       { return reinterpret_cast<GtkFontButton*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GtkFontButton* gobj() const { return reinterpret_cast<GtkFontButton*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+  virtual void on_font_set();
+
+
+private:
+
+public:
+  FontButton();
+  explicit FontButton(const Glib::ustring& fontname);
+  
+  
+  /** Retrieves the title of the font selection dialog.
+   * @return An internal copy of the title string which must not be freed.
+   * 
+   * Since: 2.4.
+   */
+  Glib::ustring get_title() const;
+  
+  /** Sets the title for the font selection dialog.  
+   * 
+   * Since: 2.4
+   * @param title A string containing the font selection dialog title.
+   */
+  void set_title(const Glib::ustring& title);
+  
+  /** Returns whether the selected font is used in the label.
+   * @return Whether the selected font is used in the label.
+   * 
+   * Since: 2.4.
+   */
+  bool get_use_font() const;
+  
+  /** If @a use_font  is <tt>true</tt>, the font name will be written using the selected font.  
+   * 
+   * Since: 2.4
+   * @param use_font If <tt>true</tt>, font name will be written using font chosen.
+   */
+  void set_use_font(bool use_font = true);
+  
+  /** Returns whether the selected size is used in the label.
+   * @return Whether the selected size is used in the label.
+   * 
+   * Since: 2.4.
+   */
+  bool get_use_size() const;
+  
+  /** If @a use_size  is <tt>true</tt>, the font name will be written using the selected size.
+   * 
+   * Since: 2.4
+   * @param use_size If <tt>true</tt>, font name will be written using the selected size.
+   */
+  void set_use_size(bool use_size = true);
+  
+  /** Retrieves the name of the currently selected font.
+   * @return An internal copy of the font name which must not be freed.
+   * 
+   * Since: 2.4.
+   */
+  Glib::ustring get_font_name() const;
+  
+  /** Sets or updates the currently-displayed font in font picker dialog.
+   * @param fontname Name of font to display in font selection dialog.
+   * @return Return value of Gtk::FontSelectionDialog::set_font_name() if the
+   * font selection dialog exists, otherwise <tt>false</tt>.
+   * 
+   * Since: 2.4.
+   */
+  bool set_font_name(const Glib::ustring& fontname);
+  
+  /** Returns whether the name of the font style will be shown in the label.
+   * @return Whether the font style will be shown in the label.
+   * 
+   * Since: 2.4.
+   */
+  bool get_show_style() const;
+  
+  /** If @a show_style  is <tt>true</tt>, the font style will be displayed along with name of the selected font.
+   * 
+   * Since: 2.4
+   * @param show_style <tt>true</tt> if font style should be displayed in label.
+   */
+  void set_show_style(bool show_style = true);
+  
+  /** Returns whether the font size will be shown in the label.
+   * @return Whether the font size will be shown in the label.
+   * 
+   * Since: 2.4.
+   */
+  bool get_show_size() const;
+  
+  /** If @a show_size  is <tt>true</tt>, the font size will be displayed along with the name of the selected font.
+   * 
+   * Since: 2.4
+   * @param show_size <tt>true</tt> if font size should be displayed in dialog.
+   */
+  void set_show_size(bool show_size = true);
+
+  /** The title of the font selection dialog.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Glib::ustring> property_title() ;
+
+/** The title of the font selection dialog.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Glib::ustring> property_title() const;
+
+  /** The name of the selected font.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Glib::ustring> property_font_name() ;
+
+/** The name of the selected font.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Glib::ustring> property_font_name() const;
+
+  /** Whether the label is drawn in the selected font.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_use_font() ;
+
+/** Whether the label is drawn in the selected font.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_use_font() const;
+
+  /** Whether the label is drawn with the selected font size.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_use_size() ;
+
+/** Whether the label is drawn with the selected font size.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_use_size() const;
+
+  /** Whether the selected font style is shown in the label.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_show_style() ;
+
+/** Whether the selected font style is shown in the label.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_show_style() const;
+
+  /** Whether selected font size is shown in the label.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_show_size() ;
+
+/** Whether selected font size is shown in the label.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_show_size() const;
+
+
+  Glib::SignalProxy0< void > signal_font_set();
+                                             
+
+};
+
+
+} // namespace Gtk
+
+
+namespace Glib
+{
+  /** @relates Gtk::FontButton
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gtk::FontButton* wrap(GtkFontButton* object, bool take_copy = false);
+}
+#endif /* _GTKMM_FONTBUTTON_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/fontselection.cc b/libs/gtkmm2/gtk/gtkmm/fontselection.cc
new file mode 100644
index 0000000000..45ccfcee76
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/fontselection.cc
@@ -0,0 +1,401 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/fontselection.h>
+#include <gtkmm/private/fontselection_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/button.h>
+#include <gtkmm/entry.h>
+#include <gtkmm/radiobutton.h>
+#include <gtk/gtkfontsel.h>
+
+
+namespace
+{
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Gtk::FontSelection* wrap(GtkFontSelection* object, bool take_copy)
+{
+  return dynamic_cast<Gtk::FontSelection *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& FontSelection_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &FontSelection_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_font_selection_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void FontSelection_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+}
+
+
+Glib::ObjectBase* FontSelection_Class::wrap_new(GObject* o)
+{
+  return manage(new FontSelection((GtkFontSelection*)(o)));
+
+}
+
+
+/* The implementation: */
+
+FontSelection::FontSelection(const Glib::ConstructParams& construct_params)
+:
+  Gtk::VBox(construct_params)
+{
+  }
+
+FontSelection::FontSelection(GtkFontSelection* castitem)
+:
+  Gtk::VBox((GtkVBox*)(castitem))
+{
+  }
+
+FontSelection::~FontSelection()
+{
+  destroy_();
+}
+
+FontSelection::CppClassType FontSelection::fontselection_class_; // initialize static member
+
+GType FontSelection::get_type()
+{
+  return fontselection_class_.init().get_type();
+}
+
+GType FontSelection::get_base_type()
+{
+  return gtk_font_selection_get_type();
+}
+
+
+FontSelection::FontSelection()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::VBox(Glib::ConstructParams(fontselection_class_.init()))
+{
+  }
+
+Glib::ustring FontSelection::get_font_name() const
+{
+  return Glib::convert_return_gchar_ptr_to_ustring(gtk_font_selection_get_font_name(const_cast<GtkFontSelection*>(gobj())));
+}
+
+bool FontSelection::set_font_name(const Glib::ustring& fontname)
+{
+  return gtk_font_selection_set_font_name(gobj(), fontname.c_str());
+}
+
+Glib::ustring FontSelection::get_preview_text() const
+{
+  return Glib::convert_const_gchar_ptr_to_ustring(gtk_font_selection_get_preview_text(const_cast<GtkFontSelection*>(gobj())));
+}
+
+void FontSelection::set_preview_text(const Glib::ustring& fontname)
+{
+  gtk_font_selection_set_preview_text(gobj(), fontname.c_str());
+}
+
+Entry* FontSelection::get_font_entry()
+{
+  return Glib::wrap((GtkEntry*)(gobj()->font_entry));
+}
+
+const Entry* FontSelection::get_font_entry() const
+{
+  return Glib::wrap((GtkEntry*)(gobj()->font_entry));
+}
+
+Entry* FontSelection::get_font_style_entry()
+{
+  return Glib::wrap((GtkEntry*)(gobj()->font_style_entry));
+}
+
+const Entry* FontSelection::get_font_style_entry() const
+{
+  return Glib::wrap((GtkEntry*)(gobj()->font_style_entry));
+}
+
+Entry* FontSelection::get_size_entry()
+{
+  return Glib::wrap((GtkEntry*)(gobj()->size_entry));
+}
+
+const Entry* FontSelection::get_size_entry() const
+{
+  return Glib::wrap((GtkEntry*)(gobj()->size_entry));
+}
+
+RadioButton* FontSelection::get_pixels_button()
+{
+  return Glib::wrap((GtkRadioButton*)(gobj()->pixels_button));
+}
+
+const RadioButton* FontSelection::get_pixels_button() const
+{
+  return Glib::wrap((GtkRadioButton*)(gobj()->pixels_button));
+}
+
+RadioButton* FontSelection::get_points_button()
+{
+  return Glib::wrap((GtkRadioButton*)(gobj()->points_button));
+}
+
+const RadioButton* FontSelection::get_points_button() const
+{
+  return Glib::wrap((GtkRadioButton*)(gobj()->points_button));
+}
+
+Button* FontSelection::get_filter_button()
+{
+  return Glib::wrap((GtkButton*)(gobj()->filter_button));
+}
+
+const Button* FontSelection::get_filter_button() const
+{
+  return Glib::wrap((GtkButton*)(gobj()->filter_button));
+}
+
+Entry* FontSelection::get_preview_entry()
+{
+  return Glib::wrap((GtkEntry*)(gobj()->preview_entry));
+}
+
+const Entry* FontSelection::get_preview_entry() const
+{
+  return Glib::wrap((GtkEntry*)(gobj()->preview_entry));
+}
+
+
+Glib::PropertyProxy<Glib::ustring> FontSelection::property_font_name() 
+{
+  return Glib::PropertyProxy<Glib::ustring>(this, "font-name");
+}
+
+Glib::PropertyProxy_ReadOnly<Glib::ustring> FontSelection::property_font_name() const
+{
+  return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "font-name");
+}
+
+Glib::PropertyProxy<Glib::ustring> FontSelection::property_preview_text() 
+{
+  return Glib::PropertyProxy<Glib::ustring>(this, "preview-text");
+}
+
+Glib::PropertyProxy_ReadOnly<Glib::ustring> FontSelection::property_preview_text() const
+{
+  return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "preview-text");
+}
+
+
+} // namespace Gtk
+
+
+namespace Glib
+{
+
+Gtk::FontSelectionDialog* wrap(GtkFontSelectionDialog* object, bool take_copy)
+{
+  return dynamic_cast<Gtk::FontSelectionDialog *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& FontSelectionDialog_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &FontSelectionDialog_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_font_selection_dialog_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void FontSelectionDialog_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+}
+
+
+Glib::ObjectBase* FontSelectionDialog_Class::wrap_new(GObject* o)
+{
+  return new FontSelectionDialog((GtkFontSelectionDialog*)(o)); //top-level windows can not be manage()ed.
+
+}
+
+
+/* The implementation: */
+
+FontSelectionDialog::FontSelectionDialog(const Glib::ConstructParams& construct_params)
+:
+  Gtk::Dialog(construct_params)
+{
+  }
+
+FontSelectionDialog::FontSelectionDialog(GtkFontSelectionDialog* castitem)
+:
+  Gtk::Dialog((GtkDialog*)(castitem))
+{
+  }
+
+FontSelectionDialog::~FontSelectionDialog()
+{
+  destroy_();
+}
+
+FontSelectionDialog::CppClassType FontSelectionDialog::fontselectiondialog_class_; // initialize static member
+
+GType FontSelectionDialog::get_type()
+{
+  return fontselectiondialog_class_.init().get_type();
+}
+
+GType FontSelectionDialog::get_base_type()
+{
+  return gtk_font_selection_dialog_get_type();
+}
+
+FontSelectionDialog::FontSelectionDialog()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Dialog(Glib::ConstructParams(fontselectiondialog_class_.init()))
+{
+  }
+
+FontSelectionDialog::FontSelectionDialog(const Glib::ustring& title)
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Dialog(Glib::ConstructParams(fontselectiondialog_class_.init(), "title", title.c_str(), (char*) 0))
+{
+  }
+
+bool FontSelectionDialog::set_font_name(const Glib::ustring& fontname)
+{
+  return gtk_font_selection_dialog_set_font_name(gobj(), fontname.c_str());
+}
+
+Glib::ustring FontSelectionDialog::get_font_name() const
+{
+  return Glib::convert_return_gchar_ptr_to_ustring(gtk_font_selection_dialog_get_font_name(const_cast<GtkFontSelectionDialog*>(gobj())));
+}
+
+Glib::ustring FontSelectionDialog::get_preview_text() const
+{
+  return Glib::convert_const_gchar_ptr_to_ustring(gtk_font_selection_dialog_get_preview_text(const_cast<GtkFontSelectionDialog*>(gobj())));
+}
+
+void FontSelectionDialog::set_preview_text(const Glib::ustring& fontname)
+{
+  gtk_font_selection_dialog_set_preview_text(gobj(), fontname.c_str());
+}
+
+FontSelection* FontSelectionDialog::get_font_selection()
+{
+  return Glib::wrap((GtkFontSelection*)(gobj()->fontsel));
+}
+
+const FontSelection* FontSelectionDialog::get_font_selection() const
+{
+  return Glib::wrap((GtkFontSelection*)(gobj()->fontsel));
+}
+
+Button* FontSelectionDialog::get_ok_button()
+{
+  return Glib::wrap((GtkButton*)(gobj()->ok_button));
+}
+
+const Button* FontSelectionDialog::get_ok_button() const
+{
+  return Glib::wrap((GtkButton*)(gobj()->ok_button));
+}
+
+Button* FontSelectionDialog::get_apply_button()
+{
+  return Glib::wrap((GtkButton*)(gobj()->apply_button));
+}
+
+const Button* FontSelectionDialog::get_apply_button() const
+{
+  return Glib::wrap((GtkButton*)(gobj()->apply_button));
+}
+
+Button* FontSelectionDialog::get_cancel_button()
+{
+  return Glib::wrap((GtkButton*)(gobj()->cancel_button));
+}
+
+const Button* FontSelectionDialog::get_cancel_button() const
+{
+  return Glib::wrap((GtkButton*)(gobj()->cancel_button));
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/fontselection.h b/libs/gtkmm2/gtk/gtkmm/fontselection.h
new file mode 100644
index 0000000000..ae0b9045d6
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/fontselection.h
@@ -0,0 +1,292 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_FONTSELECTION_H
+#define _GTKMM_FONTSELECTION_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* Copyright (C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+
+#include <gtkmm/dialog.h>
+#include <gtkmm/box.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkFontSelection GtkFontSelection;
+typedef struct _GtkFontSelectionClass GtkFontSelectionClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class FontSelection_Class; } // namespace Gtk
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkFontSelectionDialog GtkFontSelectionDialog;
+typedef struct _GtkFontSelectionDialogClass GtkFontSelectionDialogClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class FontSelectionDialog_Class; } // namespace Gtk
+namespace Gtk
+{
+
+class Button;
+class Entry;
+class RadioButton;
+
+
+/** A widget for selecting fonts.
+ *
+ * The Gtk::FontSelection widget lists the available fonts, styles and
+ * sizes, allowing the user to select a font. It is used in the
+ * Gtk::FontSelectionDialog widget to provide a dialog box for selecting
+ * fonts. 
+ * 
+ * @ingroup Widgets
+ */
+
+class FontSelection : public VBox
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef FontSelection CppObjectType;
+  typedef FontSelection_Class CppClassType;
+  typedef GtkFontSelection BaseObjectType;
+  typedef GtkFontSelectionClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~FontSelection();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class FontSelection_Class;
+  static CppClassType fontselection_class_;
+
+  // noncopyable
+  FontSelection(const FontSelection&);
+  FontSelection& operator=(const FontSelection&);
+
+protected:
+  explicit FontSelection(const Glib::ConstructParams& construct_params);
+  explicit FontSelection(GtkFontSelection* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GtkFontSelection*       gobj()       { return reinterpret_cast<GtkFontSelection*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GtkFontSelection* gobj() const { return reinterpret_cast<GtkFontSelection*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+private:
+
+  
+public:
+  FontSelection();
+
+  
+  Glib::ustring get_font_name() const;
+  
+  bool set_font_name(const Glib::ustring& fontname);
+  
+  Glib::ustring get_preview_text() const;
+  
+  void set_preview_text(const Glib::ustring& fontname);
+
+  // Font page
+  Entry* get_font_entry();
+  const Entry* get_font_entry() const;
+  Entry* get_font_style_entry();
+  const Entry* get_font_style_entry() const;
+  Entry* get_size_entry();
+  const Entry* get_size_entry() const;
+
+  RadioButton* get_pixels_button();
+  const RadioButton* get_pixels_button() const;
+  RadioButton* get_points_button();
+  const RadioButton* get_points_button() const;
+  Button* get_filter_button();
+  const Button* get_filter_button() const;
+
+  Entry* get_preview_entry();
+  const Entry* get_preview_entry() const;
+
+  /** The X string that represents this font.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Glib::ustring> property_font_name() ;
+
+/** The X string that represents this font.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Glib::ustring> property_font_name() const;
+
+  /** The text to display in order to demonstrate the selected font.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Glib::ustring> property_preview_text() ;
+
+/** The text to display in order to demonstrate the selected font.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Glib::ustring> property_preview_text() const;
+
+
+};
+
+/** A dialog box for selecting fonts.
+ *
+ * The Gtk::FontSelectionDialog widget is a dialog box for selecting a font. 
+ *
+ * @ingroup Dialogs
+ */
+
+class FontSelectionDialog : public Dialog
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef FontSelectionDialog CppObjectType;
+  typedef FontSelectionDialog_Class CppClassType;
+  typedef GtkFontSelectionDialog BaseObjectType;
+  typedef GtkFontSelectionDialogClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~FontSelectionDialog();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class FontSelectionDialog_Class;
+  static CppClassType fontselectiondialog_class_;
+
+  // noncopyable
+  FontSelectionDialog(const FontSelectionDialog&);
+  FontSelectionDialog& operator=(const FontSelectionDialog&);
+
+protected:
+  explicit FontSelectionDialog(const Glib::ConstructParams& construct_params);
+  explicit FontSelectionDialog(GtkFontSelectionDialog* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GtkFontSelectionDialog*       gobj()       { return reinterpret_cast<GtkFontSelectionDialog*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GtkFontSelectionDialog* gobj() const { return reinterpret_cast<GtkFontSelectionDialog*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+private:
+
+  
+public:
+
+  FontSelectionDialog();
+  explicit FontSelectionDialog(const Glib::ustring& title);
+
+  
+  bool set_font_name(const Glib::ustring& fontname);
+  
+  Glib::ustring get_font_name() const;
+  
+  Glib::ustring get_preview_text() const;
+  
+  void set_preview_text(const Glib::ustring& fontname);
+
+  FontSelection* get_font_selection();
+  const FontSelection* get_font_selection() const;
+  Button* get_ok_button();
+  const Button* get_ok_button() const;
+  Button* get_apply_button();
+  const Button* get_apply_button() const;
+  Button* get_cancel_button();
+  const Button* get_cancel_button() const;
+
+
+};
+
+} // namespace Gtk
+
+
+namespace Glib
+{
+  /** @relates Gtk::FontSelection
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gtk::FontSelection* wrap(GtkFontSelection* object, bool take_copy = false);
+}
+namespace Glib
+{
+  /** @relates Gtk::FontSelectionDialog
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gtk::FontSelectionDialog* wrap(GtkFontSelectionDialog* object, bool take_copy = false);
+}
+#endif /* _GTKMM_FONTSELECTION_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/frame.cc b/libs/gtkmm2/gtk/gtkmm/frame.cc
new file mode 100644
index 0000000000..d24fa422c7
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/frame.cc
@@ -0,0 +1,292 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/frame.h>
+#include <gtkmm/private/frame_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtk/gtkframe.h>
+
+namespace Gtk
+{
+
+void Frame::unset_label()
+{
+  gtk_frame_set_label(gobj(), 0);
+}
+
+} // namespace Gtk
+
+
+namespace
+{
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Gtk::Frame* wrap(GtkFrame* object, bool take_copy)
+{
+  return dynamic_cast<Gtk::Frame *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& Frame_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &Frame_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_frame_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void Frame_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+  klass->compute_child_allocation = &compute_child_allocation_vfunc_callback;
+}
+
+void Frame_Class::compute_child_allocation_vfunc_callback(GtkFrame* self, GtkAllocation* allocation)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->compute_child_allocation_vfunc((Allocation&)(Glib::wrap(allocation))
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->compute_child_allocation)
+      (*base->compute_child_allocation)(self, allocation);
+  }
+}
+
+
+Glib::ObjectBase* Frame_Class::wrap_new(GObject* o)
+{
+  return manage(new Frame((GtkFrame*)(o)));
+
+}
+
+
+/* The implementation: */
+
+Frame::Frame(const Glib::ConstructParams& construct_params)
+:
+  Gtk::Bin(construct_params)
+{
+  }
+
+Frame::Frame(GtkFrame* castitem)
+:
+  Gtk::Bin((GtkBin*)(castitem))
+{
+  }
+
+Frame::~Frame()
+{
+  destroy_();
+}
+
+Frame::CppClassType Frame::frame_class_; // initialize static member
+
+GType Frame::get_type()
+{
+  return frame_class_.init().get_type();
+}
+
+GType Frame::get_base_type()
+{
+  return gtk_frame_get_type();
+}
+
+
+Frame::Frame()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Bin(Glib::ConstructParams(frame_class_.init()))
+{
+  }
+
+Frame::Frame(const Glib::ustring& label)
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Bin(Glib::ConstructParams(frame_class_.init(), "label", label.c_str(), (char*) 0))
+{
+  }
+
+void Frame::set_label(const Glib::ustring& label)
+{
+  gtk_frame_set_label(gobj(), label.c_str());
+}
+
+Glib::ustring Frame::get_label() const
+{
+  return Glib::convert_const_gchar_ptr_to_ustring(gtk_frame_get_label(const_cast<GtkFrame*>(gobj())));
+}
+
+void Frame::set_label_widget(Widget& label_widget)
+{
+  gtk_frame_set_label_widget(gobj(), (label_widget).gobj());
+}
+
+Widget* Frame::get_label_widget()
+{
+  return Glib::wrap(gtk_frame_get_label_widget(gobj()));
+}
+
+const Widget* Frame::get_label_widget() const
+{
+  return Glib::wrap(gtk_frame_get_label_widget(const_cast<GtkFrame*>(gobj())));
+}
+
+void Frame::set_label_align(float xalign, float yalign)
+{
+  gtk_frame_set_label_align(gobj(), xalign, yalign);
+}
+
+void Frame::set_label_align(AlignmentEnum xalign, AlignmentEnum yalign)
+{
+  gtk_frame_set_label_align(gobj(), _gtkmm_align_float_from_enum(xalign), _gtkmm_align_float_from_enum(yalign));
+}
+
+void Frame::get_label_align(float& xalign, float& yalign) const
+{
+  gtk_frame_get_label_align(const_cast<GtkFrame*>(gobj()), &(xalign), &(yalign));
+}
+
+void Frame::set_shadow_type(ShadowType type)
+{
+  gtk_frame_set_shadow_type(gobj(), ((GtkShadowType)(type)));
+}
+
+ShadowType Frame::get_shadow_type() const
+{
+  return ((ShadowType)(gtk_frame_get_shadow_type(const_cast<GtkFrame*>(gobj()))));
+}
+
+
+Glib::PropertyProxy<Glib::ustring> Frame::property_label() 
+{
+  return Glib::PropertyProxy<Glib::ustring>(this, "label");
+}
+
+Glib::PropertyProxy_ReadOnly<Glib::ustring> Frame::property_label() const
+{
+  return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "label");
+}
+
+Glib::PropertyProxy<double> Frame::property_label_xalign() 
+{
+  return Glib::PropertyProxy<double>(this, "label-xalign");
+}
+
+Glib::PropertyProxy_ReadOnly<double> Frame::property_label_xalign() const
+{
+  return Glib::PropertyProxy_ReadOnly<double>(this, "label-xalign");
+}
+
+Glib::PropertyProxy<double> Frame::property_label_yalign() 
+{
+  return Glib::PropertyProxy<double>(this, "label-yalign");
+}
+
+Glib::PropertyProxy_ReadOnly<double> Frame::property_label_yalign() const
+{
+  return Glib::PropertyProxy_ReadOnly<double>(this, "label-yalign");
+}
+
+Glib::PropertyProxy<ShadowType> Frame::property_shadow_type() 
+{
+  return Glib::PropertyProxy<ShadowType>(this, "shadow-type");
+}
+
+Glib::PropertyProxy_ReadOnly<ShadowType> Frame::property_shadow_type() const
+{
+  return Glib::PropertyProxy_ReadOnly<ShadowType>(this, "shadow-type");
+}
+
+Glib::PropertyProxy<Widget*> Frame::property_label_widget() 
+{
+  return Glib::PropertyProxy<Widget*>(this, "label-widget");
+}
+
+Glib::PropertyProxy_ReadOnly<Widget*> Frame::property_label_widget() const
+{
+  return Glib::PropertyProxy_ReadOnly<Widget*>(this, "label-widget");
+}
+
+
+void Gtk::Frame::compute_child_allocation_vfunc(Allocation& allocation) 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->compute_child_allocation)
+    (*base->compute_child_allocation)(gobj(),(GtkAllocation*)(allocation.gobj()));
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/frame.h b/libs/gtkmm2/gtk/gtkmm/frame.h
new file mode 100644
index 0000000000..aaac3dd63c
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/frame.h
@@ -0,0 +1,305 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_FRAME_H
+#define _GTKMM_FRAME_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* frame.h
+ * 
+ * Copyright (C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+
+#include <gtkmm/bin.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkFrame GtkFrame;
+typedef struct _GtkFrameClass GtkFrameClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class Frame_Class; } // namespace Gtk
+namespace Gtk
+{
+
+/** A Gtk::Bin with a decorative frame and optional label.
+ *
+ * The Frame widget surrounds its single child with a decorative frame and
+ * an optional label.  If present, the label is drawn in a gap in the top
+ * side of the frame. The position of the label can be controlled with
+ * set_label_align().
+ *
+ * @ingroup Widgets
+ * @ingroup Containers
+ */
+
+class Frame : public Bin
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Frame CppObjectType;
+  typedef Frame_Class CppClassType;
+  typedef GtkFrame BaseObjectType;
+  typedef GtkFrameClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~Frame();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class Frame_Class;
+  static CppClassType frame_class_;
+
+  // noncopyable
+  Frame(const Frame&);
+  Frame& operator=(const Frame&);
+
+protected:
+  explicit Frame(const Glib::ConstructParams& construct_params);
+  explicit Frame(GtkFrame* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GtkFrame*       gobj()       { return reinterpret_cast<GtkFrame*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GtkFrame* gobj() const { return reinterpret_cast<GtkFrame*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+private:
+
+public:
+
+  Frame();
+  explicit Frame(const Glib::ustring& label);
+
+  //TODO: Add a bool use_markup arg to set_label() as a convenience - it would have to use set_label_widget().
+    
+  /** Set the label to appear in the top edge of the frame.
+   * Label alignment defaults to the upper left corner of the frame.
+   */
+  
+  /** Sets the text of the label. If @a label  is <tt>0</tt>,
+   * the current label is removed.
+   * @param label The text to use as the label of the frame.
+   */
+  void set_label(const Glib::ustring& label);
+  void unset_label();
+  
+  /** If the frame's label widget is a Gtk::Label, returns the
+   * text in the label widget. (The frame will have a Gtk::Label
+   * for the label widget if a non-<tt>0</tt> argument was passed
+   * to new().)
+   * @return The text in the label, or <tt>0</tt> if there
+   * was no label widget or the lable widget was not
+   * a Gtk::Label. This string is owned by GTK+ and
+   * must not be modified or freed.
+   */
+  Glib::ustring get_label() const;
+
+  
+  /** Sets the label widget for the frame. This is the widget that
+   * will appear embedded in the top edge of the frame as a
+   * title.
+   * @param label_widget The new label widget.
+   */
+  void set_label_widget(Widget& label_widget);
+  
+  /** Retrieves the label widget for the frame. See
+   * set_label_widget().
+   * @return The label widget, or <tt>0</tt> if there is none.
+   */
+  Widget* get_label_widget();
+  
+  /** Retrieves the label widget for the frame. See
+   * set_label_widget().
+   * @return The label widget, or <tt>0</tt> if there is none.
+   */
+  const Widget* get_label_widget() const;
+
+  /** Set the alignment of the Frame's label.
+   * @param xalign The position of the label along the top edge of the widget.
+   * A value of 0.0 represents left alignment; 1.0 represents right alignment.
+   * The default value for a newly created Frame is 0.0.
+   * @param yalign The y alignment of the label. Currently ignored.
+   */
+  
+  /** Sets the alignment of the frame widget's label. The
+   * default values for a newly created frame are 0.0 and 0.5.
+   * @param xalign The position of the label along the top edge
+   * of the widget. A value of 0.0 represents left alignment;
+   * 1.0 represents right alignment.
+   * @param yalign The y alignment of the label. A value of 0.0 aligns under 
+   * the frame; 1.0 aligns above the frame.
+   */
+  void set_label_align(float xalign = 0.0, float yalign = 0.5);
+  
+  /** Sets the alignment of the frame widget's label. The
+   * default values for a newly created frame are 0.0 and 0.5.
+   * @param xalign The position of the label along the top edge
+   * of the widget. A value of 0.0 represents left alignment;
+   * 1.0 represents right alignment.
+   * @param yalign The y alignment of the label. A value of 0.0 aligns under 
+   * the frame; 1.0 aligns above the frame.
+   */
+  void set_label_align(AlignmentEnum xalign, AlignmentEnum yalign = Gtk::ALIGN_CENTER);
+
+  
+  /** Retrieves the X and Y alignment of the frame's label. See
+   * set_label_align().
+   * @param xalign Location to store X alignment of frame's label, or <tt>0</tt>.
+   * @param yalign Location to store X alignment of frame's label, or <tt>0</tt>.
+   */
+  void get_label_align(float& xalign, float& yalign) const;
+
+  /** Sets shadow type of the frame.
+   */
+  
+  /** Sets the shadow type for @a frame .
+   * @param type The new Gtk::ShadowType.
+   */
+  void set_shadow_type(ShadowType type);
+  
+  /** Retrieves the shadow type of the frame. See
+   * set_shadow_type().
+   * @return The current shadow type of the frame.
+   */
+  ShadowType get_shadow_type() const;
+
+  /** Text of the frame's label.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Glib::ustring> property_label() ;
+
+/** Text of the frame's label.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Glib::ustring> property_label() const;
+
+  /** The horizontal alignment of the label.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<double> property_label_xalign() ;
+
+/** The horizontal alignment of the label.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<double> property_label_xalign() const;
+
+  /** The vertical alignment of the label.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<double> property_label_yalign() ;
+
+/** The vertical alignment of the label.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<double> property_label_yalign() const;
+
+  /** Appearance of the frame border.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<ShadowType> property_shadow_type() ;
+
+/** Appearance of the frame border.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<ShadowType> property_shadow_type() const;
+
+  /** A widget to display in place of the usual frame label.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Widget*> property_label_widget() ;
+
+/** A widget to display in place of the usual frame label.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Widget*> property_label_widget() const;
+
+
+protected:
+    virtual void compute_child_allocation_vfunc(Allocation& allocation);
+
+
+};
+
+} // namespace Gtk
+
+
+namespace Glib
+{
+  /** @relates Gtk::Frame
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gtk::Frame* wrap(GtkFrame* object, bool take_copy = false);
+}
+#endif /* _GTKMM_FRAME_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/handlebox.cc b/libs/gtkmm2/gtk/gtkmm/handlebox.cc
new file mode 100644
index 0000000000..86c2a0fe9c
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/handlebox.cc
@@ -0,0 +1,419 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/handlebox.h>
+#include <gtkmm/private/handlebox_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* 
+ *
+ * Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtk/gtkhandlebox.h>
+#include <gdkmm/window.h>
+
+namespace Gtk
+{
+
+bool HandleBox::is_child_detached() const
+{
+  return gobj()->child_detached;
+}
+
+bool HandleBox::is_float_window_mapped() const
+{
+  return gobj()->float_window_mapped;
+}
+
+bool HandleBox::is_in_drag() const
+{
+  return gobj()->in_drag;
+}
+
+bool HandleBox::shrinks_on_detach() const
+{
+  return gobj()->shrink_on_detach;
+}
+
+} /* namespace Gtk */
+
+
+namespace
+{
+
+void HandleBox_signal_child_attached_callback(GtkHandleBox* self, GtkWidget* p0,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,Widget* > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(Glib::wrap(p0)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+}
+
+const Glib::SignalProxyInfo HandleBox_signal_child_attached_info =
+{
+  "child_attached",
+  (GCallback) &HandleBox_signal_child_attached_callback,
+  (GCallback) &HandleBox_signal_child_attached_callback
+};
+
+
+void HandleBox_signal_child_detached_callback(GtkHandleBox* self, GtkWidget* p0,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,Widget* > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(Glib::wrap(p0)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+}
+
+const Glib::SignalProxyInfo HandleBox_signal_child_detached_info =
+{
+  "child_detached",
+  (GCallback) &HandleBox_signal_child_detached_callback,
+  (GCallback) &HandleBox_signal_child_detached_callback
+};
+
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Gtk::HandleBox* wrap(GtkHandleBox* object, bool take_copy)
+{
+  return dynamic_cast<Gtk::HandleBox *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& HandleBox_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &HandleBox_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_handle_box_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void HandleBox_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+  klass->child_attached = &child_attached_callback;
+  klass->child_detached = &child_detached_callback;
+}
+
+
+void HandleBox_Class::child_attached_callback(GtkHandleBox* self, GtkWidget* p0)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_child_attached(Glib::wrap(p0)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->child_attached)
+      (*base->child_attached)(self, p0);
+  }
+}
+
+void HandleBox_Class::child_detached_callback(GtkHandleBox* self, GtkWidget* p0)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_child_detached(Glib::wrap(p0)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->child_detached)
+      (*base->child_detached)(self, p0);
+  }
+}
+
+
+Glib::ObjectBase* HandleBox_Class::wrap_new(GObject* o)
+{
+  return manage(new HandleBox((GtkHandleBox*)(o)));
+
+}
+
+
+/* The implementation: */
+
+HandleBox::HandleBox(const Glib::ConstructParams& construct_params)
+:
+  Gtk::Bin(construct_params)
+{
+  }
+
+HandleBox::HandleBox(GtkHandleBox* castitem)
+:
+  Gtk::Bin((GtkBin*)(castitem))
+{
+  }
+
+HandleBox::~HandleBox()
+{
+  destroy_();
+}
+
+HandleBox::CppClassType HandleBox::handlebox_class_; // initialize static member
+
+GType HandleBox::get_type()
+{
+  return handlebox_class_.init().get_type();
+}
+
+GType HandleBox::get_base_type()
+{
+  return gtk_handle_box_get_type();
+}
+
+
+HandleBox::HandleBox()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Bin(Glib::ConstructParams(handlebox_class_.init()))
+{
+  }
+
+void HandleBox::set_shadow_type(ShadowType type)
+{
+  gtk_handle_box_set_shadow_type(gobj(), ((GtkShadowType)(type)));
+}
+
+ShadowType HandleBox::get_shadow_type() const
+{
+  return ((ShadowType)(gtk_handle_box_get_shadow_type(const_cast<GtkHandleBox*>(gobj()))));
+}
+
+void HandleBox::set_handle_position(PositionType position)
+{
+  gtk_handle_box_set_handle_position(gobj(), ((GtkPositionType)(position)));
+}
+
+PositionType HandleBox::get_handle_position() const
+{
+  return ((PositionType)(gtk_handle_box_get_handle_position(const_cast<GtkHandleBox*>(gobj()))));
+}
+
+void HandleBox::set_snap_edge(PositionType edge)
+{
+  gtk_handle_box_set_snap_edge(gobj(), ((GtkPositionType)(edge)));
+}
+
+PositionType HandleBox::get_snap_edge() const
+{
+  return ((PositionType)(gtk_handle_box_get_snap_edge(const_cast<GtkHandleBox*>(gobj()))));
+}
+
+Glib::RefPtr<Gdk::Window> HandleBox::get_bin_window()
+{
+  Glib::RefPtr<Gdk::Window> ref_ptr(Glib::wrap((GdkWindowObject*)(gobj()->bin_window)));
+
+  if(ref_ptr)
+    ref_ptr->reference();
+
+  return ref_ptr;
+}
+
+Glib::RefPtr<const Gdk::Window> HandleBox::get_bin_window() const
+{
+  Glib::RefPtr<const Gdk::Window> ref_ptr(Glib::wrap((GdkWindowObject*)(gobj()->bin_window)));
+
+  if(ref_ptr)
+    ref_ptr->reference();
+
+  return ref_ptr;
+}
+
+Glib::RefPtr<Gdk::Window> HandleBox::get_float_window()
+{
+  Glib::RefPtr<Gdk::Window> ref_ptr(Glib::wrap((GdkWindowObject*)(gobj()->float_window)));
+
+  if(ref_ptr)
+    ref_ptr->reference();
+
+  return ref_ptr;
+}
+
+Glib::RefPtr<const Gdk::Window> HandleBox::get_float_window() const
+{
+  Glib::RefPtr<const Gdk::Window> ref_ptr(Glib::wrap((GdkWindowObject*)(gobj()->float_window)));
+
+  if(ref_ptr)
+    ref_ptr->reference();
+
+  return ref_ptr;
+}
+
+
+Glib::SignalProxy1< void,Widget* > HandleBox::signal_child_attached()
+{
+  return Glib::SignalProxy1< void,Widget* >(this, &HandleBox_signal_child_attached_info);
+}
+
+Glib::SignalProxy1< void,Widget* > HandleBox::signal_child_detached()
+{
+  return Glib::SignalProxy1< void,Widget* >(this, &HandleBox_signal_child_detached_info);
+}
+
+
+Glib::PropertyProxy<ShadowType> HandleBox::property_shadow_type() 
+{
+  return Glib::PropertyProxy<ShadowType>(this, "shadow-type");
+}
+
+Glib::PropertyProxy_ReadOnly<ShadowType> HandleBox::property_shadow_type() const
+{
+  return Glib::PropertyProxy_ReadOnly<ShadowType>(this, "shadow-type");
+}
+
+Glib::PropertyProxy<PositionType> HandleBox::property_handle_position() 
+{
+  return Glib::PropertyProxy<PositionType>(this, "handle-position");
+}
+
+Glib::PropertyProxy_ReadOnly<PositionType> HandleBox::property_handle_position() const
+{
+  return Glib::PropertyProxy_ReadOnly<PositionType>(this, "handle-position");
+}
+
+Glib::PropertyProxy<PositionType> HandleBox::property_snap_edge() 
+{
+  return Glib::PropertyProxy<PositionType>(this, "snap-edge");
+}
+
+Glib::PropertyProxy_ReadOnly<PositionType> HandleBox::property_snap_edge() const
+{
+  return Glib::PropertyProxy_ReadOnly<PositionType>(this, "snap-edge");
+}
+
+
+void Gtk::HandleBox::on_child_attached(Widget* child)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->child_attached)
+    (*base->child_attached)(gobj(),(GtkWidget*)Glib::unwrap(child));
+}
+
+void Gtk::HandleBox::on_child_detached(Widget* child)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->child_detached)
+    (*base->child_detached)(gobj(),(GtkWidget*)Glib::unwrap(child));
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/handlebox.h b/libs/gtkmm2/gtk/gtkmm/handlebox.h
new file mode 100644
index 0000000000..89d4614bfc
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/handlebox.h
@@ -0,0 +1,220 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_HANDLEBOX_H
+#define _GTKMM_HANDLEBOX_H
+
+#include <glibmm.h>
+
+ /* $Id$ */
+
+/* handlebox.h
+ * 
+ * Copyright (C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/eventbox.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkHandleBox GtkHandleBox;
+typedef struct _GtkHandleBoxClass GtkHandleBoxClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class HandleBox_Class; } // namespace Gtk
+namespace Gtk
+{
+
+/** A widget for detachable window portions.
+ *
+ * The Gtk::HandleBox widget allows a portion of a window to be "torn off".
+ * It displays its child and a handle that the user can drag to tear off a separate window (the float window) containing the child widget. A thin ghost is drawn in the original location of the handlebox. By dragging the separate window back to its original location, it can be reattached.
+ * When reattaching, the ghost and float window must be aligned along one of the edges, the snap edge. This can be specified by the application programmer explicitely, or GTK+ will pick a reasonable default based on the handle position.
+ * To make detaching and reattaching the handlebox as minimally confusing as possible to the user, it is important to set the snap edge so that the snap edge does not move when the handlebox is deattached.
+ * For instance, if the handlebox is packed at the bottom of a VBox, then when the handlebox is detached, the bottom edge of the handlebox's allocation will remain fixed as the height of the handlebox shrinks, so the snap edge should be set to GTK_POS_BOTTOM.
+ *
+ * @ingroup Widgets
+ * @ingroup Containers
+ */
+
+class HandleBox : public Bin
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef HandleBox CppObjectType;
+  typedef HandleBox_Class CppClassType;
+  typedef GtkHandleBox BaseObjectType;
+  typedef GtkHandleBoxClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~HandleBox();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class HandleBox_Class;
+  static CppClassType handlebox_class_;
+
+  // noncopyable
+  HandleBox(const HandleBox&);
+  HandleBox& operator=(const HandleBox&);
+
+protected:
+  explicit HandleBox(const Glib::ConstructParams& construct_params);
+  explicit HandleBox(GtkHandleBox* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GtkHandleBox*       gobj()       { return reinterpret_cast<GtkHandleBox*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GtkHandleBox* gobj() const { return reinterpret_cast<GtkHandleBox*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+  virtual void on_child_attached(Widget* child);
+  virtual void on_child_detached(Widget* child);
+
+
+private:
+
+public:
+  HandleBox();
+  
+
+  void set_shadow_type(ShadowType type);
+  
+  /** Gets the type of shadow drawn around the handle box. See
+   * set_shadow_type().
+   * @return The type of shadow currently drawn around the handle box.
+   */
+  ShadowType get_shadow_type() const;
+  
+  void set_handle_position(PositionType position);
+  
+  /** Gets the handle position of the handle box. See
+   * set_handle_position().
+   * @return The current handle position.
+   */
+  PositionType get_handle_position() const;
+  
+  void set_snap_edge(PositionType edge);
+  
+  /** Gets the edge used for determining reattachment of the handle box. See
+   * set_snap_edge().
+   * @return The edge used for determining reattachment, or (GtkPositionType)-1 if this
+   * is determined (as per default) from the handle position.
+   */
+  PositionType get_snap_edge() const;
+
+  
+  Glib::SignalProxy1< void,Widget* > signal_child_attached();
+
+  
+  Glib::SignalProxy1< void,Widget* > signal_child_detached();
+
+
+  Glib::RefPtr<Gdk::Window> get_bin_window();
+  Glib::RefPtr<const Gdk::Window> get_bin_window() const;
+  Glib::RefPtr<Gdk::Window> get_float_window();
+  Glib::RefPtr<const Gdk::Window> get_float_window() const;
+
+  bool is_child_detached() const;
+  bool is_float_window_mapped() const;
+  bool is_in_drag() const;
+  bool shrinks_on_detach() const;
+
+  //_WRAP_PROPERTY("shadow", ShadowType); //deprecated.
+  /** Appearance of the shadow that surrounds the container.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<ShadowType> property_shadow_type() ;
+
+/** Appearance of the shadow that surrounds the container.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<ShadowType> property_shadow_type() const;
+
+  /** Position of the handle relative to the child widget.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<PositionType> property_handle_position() ;
+
+/** Position of the handle relative to the child widget.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<PositionType> property_handle_position() const;
+
+  /** Side of the handlebox that's lined up with the docking point to dock the handlebox.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<PositionType> property_snap_edge() ;
+
+/** Side of the handlebox that's lined up with the docking point to dock the handlebox.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<PositionType> property_snap_edge() const;
+
+
+};
+
+} /* namespace Gtk */
+
+
+namespace Glib
+{
+  /** @relates Gtk::HandleBox
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gtk::HandleBox* wrap(GtkHandleBox* object, bool take_copy = false);
+}
+#endif /* _GTKMM_HANDLEBOX_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/iconfactory.cc b/libs/gtkmm2/gtk/gtkmm/iconfactory.cc
new file mode 100644
index 0000000000..4a305d1291
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/iconfactory.cc
@@ -0,0 +1,189 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/iconfactory.h>
+#include <gtkmm/private/iconfactory_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* 
+ *
+ * Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtk/gtkiconfactory.h>
+
+namespace Gtk
+{
+
+// static
+bool IconSize::lookup(IconSize size, int& width, int& height)
+{
+  return gtk_icon_size_lookup((GtkIconSize) int(size), &width, &height);
+}
+
+// static
+IconSize IconSize::register_new(const Glib::ustring& name, int width, int height)
+{
+  const int size = gtk_icon_size_register(name.c_str(), width, height);
+  return IconSize(size);
+}
+
+// static
+void IconSize::register_alias(const Glib::ustring& alias, IconSize target)
+{
+  gtk_icon_size_register_alias(alias.c_str(), (GtkIconSize) int(target));
+}
+
+// static
+IconSize IconSize::from_name(const Glib::ustring& name)
+{
+  const int size = gtk_icon_size_from_name(name.c_str());
+  return IconSize(size);
+}
+
+// static
+Glib::ustring IconSize::get_name(IconSize size)
+{
+  return gtk_icon_size_get_name((GtkIconSize) int(size));
+}
+
+} // namespace Gtk
+
+
+namespace
+{
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Glib::RefPtr<Gtk::IconFactory> wrap(GtkIconFactory* object, bool take_copy)
+{
+  return Glib::RefPtr<Gtk::IconFactory>( dynamic_cast<Gtk::IconFactory*> (Glib::wrap_auto ((GObject*)(object), take_copy)) );
+  //We use dynamic_cast<> in case of multiple inheritance.
+}
+
+} /* namespace Glib */
+
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& IconFactory_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &IconFactory_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_icon_factory_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void IconFactory_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+}
+
+
+Glib::ObjectBase* IconFactory_Class::wrap_new(GObject* object)
+{
+  return new IconFactory((GtkIconFactory*)object);
+}
+
+
+/* The implementation: */
+
+GtkIconFactory* IconFactory::gobj_copy()
+{
+  reference();
+  return gobj();
+}
+
+IconFactory::IconFactory(const Glib::ConstructParams& construct_params)
+:
+  Glib::Object(construct_params)
+{}
+
+IconFactory::IconFactory(GtkIconFactory* castitem)
+:
+  Glib::Object((GObject*)(castitem))
+{}
+
+IconFactory::~IconFactory()
+{}
+
+
+IconFactory::CppClassType IconFactory::iconfactory_class_; // initialize static member
+
+GType IconFactory::get_type()
+{
+  return iconfactory_class_.init().get_type();
+}
+
+GType IconFactory::get_base_type()
+{
+  return gtk_icon_factory_get_type();
+}
+
+
+IconFactory::IconFactory()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Glib::Object(Glib::ConstructParams(iconfactory_class_.init()))
+{
+  }
+
+Glib::RefPtr<IconFactory> IconFactory::create()
+{
+  return Glib::RefPtr<IconFactory>( new IconFactory() );
+}
+void IconFactory::add(const Gtk::StockID& stock_id, const IconSet& icon_set)
+{
+  gtk_icon_factory_add(gobj(), (stock_id).get_c_str(), const_cast<GtkIconSet*>((icon_set).gobj()));
+}
+
+void IconFactory::add_default()
+{
+  gtk_icon_factory_add_default(gobj());
+}
+
+void IconFactory::remove_default()
+{
+  gtk_icon_factory_remove_default(gobj());
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/iconfactory.h b/libs/gtkmm2/gtk/gtkmm/iconfactory.h
new file mode 100644
index 0000000000..39b98e792f
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/iconfactory.h
@@ -0,0 +1,160 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_ICONFACTORY_H
+#define _GTKMM_ICONFACTORY_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* Copyright (C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+
+#include <gtkmm/enums.h>
+#include <gtkmm/object.h>
+#include <gtkmm/enums.h>
+#include <gtkmm/iconset.h>
+#include <gtkmm/stockid.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkIconFactory GtkIconFactory;
+typedef struct _GtkIconFactoryClass GtkIconFactoryClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class IconFactory_Class; } // namespace Gtk
+namespace Gtk
+{
+
+
+class IconFactory : public Glib::Object
+{
+   
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+public:
+  typedef IconFactory CppObjectType;
+  typedef IconFactory_Class CppClassType;
+  typedef GtkIconFactory BaseObjectType;
+  typedef GtkIconFactoryClass BaseClassType;
+
+private:  friend class IconFactory_Class;
+  static CppClassType iconfactory_class_;
+
+private:
+  // noncopyable
+  IconFactory(const IconFactory&);
+  IconFactory& operator=(const IconFactory&);
+
+protected:
+  explicit IconFactory(const Glib::ConstructParams& construct_params);
+  explicit IconFactory(GtkIconFactory* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+  virtual ~IconFactory();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GObject.
+  GtkIconFactory*       gobj()       { return reinterpret_cast<GtkIconFactory*>(gobject_); }
+
+  ///Provides access to the underlying C GObject.
+  const GtkIconFactory* gobj() const { return reinterpret_cast<GtkIconFactory*>(gobject_); }
+
+  ///Provides access to the underlying C instance. The caller is responsible for unrefing it. Use when directly setting fields in structs.
+  GtkIconFactory* gobj_copy();
+
+private:
+
+   
+protected:
+
+  IconFactory();
+
+public:
+  
+  static Glib::RefPtr<IconFactory> create();
+
+
+  /** Adds the given @a icon_set  to the icon factory, under the name
+   *  @a stock_id .  @a stock_id  should be namespaced for your application,
+   * e.g. "myapp-whatever-icon".  Normally applications create a
+   * Gtk::IconFactory, then add it to the list of default factories with
+   * add_default(). Then they pass the @a stock_id  to
+   * widgets such as Gtk::Image to display the icon. Themes can provide
+   * an icon with the same name (such as "myapp-whatever-icon") to
+   * override your application's default icons. If an icon already
+   * existed in @a factory  for @a stock_id , it is unreferenced and replaced
+   * with the new @a icon_set .
+   * @param stock_id Icon name.
+   * @param icon_set Icon set.
+   */
+  void add(const Gtk::StockID& stock_id, const IconSet& icon_set);
+  
+  /** Adds an icon factory to the list of icon factories searched by
+   * Gtk::Style::lookup_icon_set(). This means that, for example,
+   * Gtk::Image::new_from_stock() will be able to find icons in @a factory .
+   * There will normally be an icon factory added for each library or
+   * application that comes with icons. The default icon factories
+   * can be overridden by themes.
+   */
+  void add_default();
+  
+  /** Removes an icon factory from the list of default icon
+   * factories. Not normally used; you might use it for a library that
+   * can be unloaded or shut down.
+   */
+  void remove_default();
+
+
+public:
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+};
+
+} // namespace Gtk
+
+
+namespace Glib
+{
+  /** @relates Gtk::IconFactory
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Glib::RefPtr<Gtk::IconFactory> wrap(GtkIconFactory* object, bool take_copy = false);
+}
+
+
+#endif /* _GTKMM_ICONFACTORY_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/iconinfo.cc b/libs/gtkmm2/gtk/gtkmm/iconinfo.cc
new file mode 100644
index 0000000000..7dfaa15c79
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/iconinfo.cc
@@ -0,0 +1,177 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/iconinfo.h>
+#include <gtkmm/private/iconinfo_p.h>
+
+/* Copyright 2003 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtk/gtkicontheme.h>
+ 
+namespace Gtk
+{
+
+bool IconInfo::get_attach_points(Glib::ArrayHandle<Gdk::Point>& /* points */) const
+{
+  GdkPoint* c_attach_points = 0;
+  gint n_points = 0;
+  bool result = gtk_icon_info_get_attach_points (const_cast<GtkIconInfo*>(gobj()), &c_attach_points, &n_points);
+
+  if(c_attach_points)
+  {
+    //TODO: Why doesn't this compile?
+    //points = Glib::ArrayHandle<Gdk::Point>(c_attach_points, n_points, Glib::OWNERSHIP_SHALLOW); //We use OWNERSHIP_SHALLOW because we just need to g_free() the array and nothing more.        
+  }
+  return result;
+}
+
+IconInfo::operator bool()
+{
+  return gobj() != 0;
+}
+  
+
+} // namespace Gtk
+
+
+namespace
+{
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Gtk::IconInfo wrap(GtkIconInfo* object, bool take_copy)
+{
+  return Gtk::IconInfo(object, take_copy);
+}
+
+} // namespace Glib
+
+
+namespace Gtk
+{
+
+
+// static
+GType IconInfo::get_type()
+{
+  return gtk_icon_info_get_type();
+}
+
+IconInfo::IconInfo()
+:
+  gobject_ (0) // Allows creation of invalid wrapper, e.g. for output arguments to methods.
+{}
+
+IconInfo::IconInfo(const IconInfo& other)
+:
+  gobject_ ((other.gobject_) ? gtk_icon_info_copy(other.gobject_) : 0)
+{}
+
+IconInfo::IconInfo(GtkIconInfo* gobject, bool make_a_copy)
+:
+  // For BoxedType wrappers, make_a_copy is true by default.  The static
+  // BoxedType wrappers must always take a copy, thus make_a_copy = true
+  // ensures identical behaviour if the default argument is used.
+  gobject_ ((make_a_copy && gobject) ? gtk_icon_info_copy(gobject) : gobject)
+{}
+
+IconInfo& IconInfo::operator=(const IconInfo& other)
+{
+  IconInfo temp (other);
+  swap(temp);
+  return *this;
+}
+
+IconInfo::~IconInfo()
+{
+  if(gobject_)
+    gtk_icon_info_free(gobject_);
+}
+
+void IconInfo::swap(IconInfo& other)
+{
+  GtkIconInfo *const temp = gobject_;
+  gobject_ = other.gobject_;
+  other.gobject_ = temp;
+}
+
+GtkIconInfo* IconInfo::gobj_copy() const
+{
+  return gtk_icon_info_copy(gobject_);
+}
+
+
+int IconInfo::get_base_size() const
+{
+  return gtk_icon_info_get_base_size(const_cast<GtkIconInfo*>(gobj()));
+}
+
+Glib::ustring IconInfo::get_filename() const
+{
+  return Glib::convert_const_gchar_ptr_to_ustring(gtk_icon_info_get_filename(const_cast<GtkIconInfo*>(gobj())));
+}
+
+Glib::RefPtr<Gdk::Pixbuf> IconInfo::get_builtin_pixbuf()
+{
+
+  Glib::RefPtr<Gdk::Pixbuf> retvalue = Glib::wrap(gtk_icon_info_get_builtin_pixbuf(gobj()));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::RefPtr<const Gdk::Pixbuf> IconInfo::get_builtin_pixbuf() const
+{
+
+  Glib::RefPtr<const Gdk::Pixbuf> retvalue = Glib::wrap(gtk_icon_info_get_builtin_pixbuf(const_cast<GtkIconInfo*>(gobj())));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::RefPtr<Gdk::Pixbuf> IconInfo::load_icon() const
+{
+  GError *error = 0;
+  Glib::RefPtr<Gdk::Pixbuf> retvalue = Glib::wrap(gtk_icon_info_load_icon(const_cast<GtkIconInfo*>(gobj()), &(error)));
+  if(error) ::Glib::Error::throw_exception(error);
+  return retvalue;
+}
+
+void IconInfo::set_raw_coordinates(bool raw_coordinates)
+{
+  gtk_icon_info_set_raw_coordinates(gobj(), static_cast<int>(raw_coordinates));
+}
+
+bool IconInfo::get_embedded_rect(Gdk::Rectangle& rectangle) const
+{
+  return gtk_icon_info_get_embedded_rect(const_cast<GtkIconInfo*>(gobj()), (rectangle).gobj());
+}
+
+Glib::ustring IconInfo::get_display_name() const
+{
+  return Glib::convert_const_gchar_ptr_to_ustring(gtk_icon_info_get_display_name(const_cast<GtkIconInfo*>(gobj())));
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/iconinfo.h b/libs/gtkmm2/gtk/gtkmm/iconinfo.h
new file mode 100644
index 0000000000..73f36a2f6f
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/iconinfo.h
@@ -0,0 +1,227 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_ICONINFO_H
+#define _GTKMM_ICONINFO_H
+
+#include <glibmm.h>
+
+/* Copyright (C) 2003 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gdkmm/rectangle.h>
+#include <gdkmm/pixbuf.h>
+#include <gdkmm/types.h>
+
+//#include <gtk/gtkicontheme.h>
+ 
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+extern "C" { typedef struct _GtkIconInfo GtkIconInfo; }
+#endif
+
+namespace Gtk
+{
+
+class IconInfo
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef IconInfo CppObjectType;
+  typedef GtkIconInfo BaseObjectType;
+
+  static GType get_type() G_GNUC_CONST;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  IconInfo();
+
+  explicit IconInfo(GtkIconInfo* gobject, bool make_a_copy = true);
+
+  IconInfo(const IconInfo& other);
+  IconInfo& operator=(const IconInfo& other);
+
+  ~IconInfo();
+
+  void swap(IconInfo& other);
+
+  ///Provides access to the underlying C instance.
+  GtkIconInfo*       gobj()       { return gobject_; }
+
+  ///Provides access to the underlying C instance.
+  const GtkIconInfo* gobj() const { return gobject_; }
+
+  ///Provides access to the underlying C instance. The caller is responsible for freeing it. Use when directly setting fields in structs.
+  GtkIconInfo* gobj_copy() const;
+
+protected:
+  GtkIconInfo* gobject_;
+
+private:
+
+  
+public:
+
+  ///Tests whether the IconInfo is valid.
+  operator bool();
+
+  
+  /** Gets the base size for the icon. The base size
+   * is a size for the icon that was specified by
+   * the icon theme creator. This may be different
+   * than the actual size of image; an example of
+   * this is small emblem icons that can be attached
+   * to a larger icon. These icons will be given
+   * the same base size as the larger icons to which
+   * they are attached.
+   * @return The base size, or 0, if no base
+   * size is known for the icon.
+   * 
+   * Since: 2.4.
+   */
+  int get_base_size() const;
+  
+  /** Gets the filename for the icon. If the
+   * Gtk::ICON_LOOKUP_USE_BUILTIN flag was passed
+   * to Gtk::IconTheme::lookup_icon(), there may be
+   * no filename if a builtin icon is returned; in this
+   * case, you should use gtk_icon_info_get_builtin_pixbuf().
+   * @return The filename for the icon, or <tt>0</tt>
+   * if gtk_icon_info_get_builtin_pixbuf() should
+   * be used instead.
+   */
+  Glib::ustring get_filename() const;
+  
+  /** Gets the built-in image for this icon, if any. To allow
+   * GTK+ to use built in icon images, you must pass the
+   * Gtk::ICON_LOOKUP_USE_BUILTIN to
+   * Gtk::IconTheme::lookup_icon().
+   * @return The built-in image pixbuf, or <tt>0</tt>.
+   * The returned image must not be modified.
+   */
+  Glib::RefPtr<Gdk::Pixbuf> get_builtin_pixbuf();
+  
+  /** Gets the built-in image for this icon, if any. To allow
+   * GTK+ to use built in icon images, you must pass the
+   * Gtk::ICON_LOOKUP_USE_BUILTIN to
+   * Gtk::IconTheme::lookup_icon().
+   * @return The built-in image pixbuf, or <tt>0</tt>.
+   * The returned image must not be modified.
+   */
+  Glib::RefPtr<const Gdk::Pixbuf> get_builtin_pixbuf() const;
+  
+  /** Renders an icon previously looked up in an icon theme using
+   * Gtk::IconTheme::lookup_icon(); the size will be based on the size
+   * passed to Gtk::IconTheme::lookup_icon(). Note that the resulting
+   * pixbuf may not be exactly this size; an icon theme may have icons
+   * that differ slightly from their nominal sizes, and in addition GTK+
+   * will avoid scaling icons that it considers sufficiently close to the
+   * requested size or for which the source image would have to be scaled
+   * up too far. (This maintains sharpness.)
+   * @return The rendered icon; this may be a newly created icon
+   * or a new reference to an internal icon, so you must not modify
+   * the icon. Use Glib::object_unref() to release your reference to the
+   * icon.
+   * 
+   * Since: 2.4.
+   */
+  Glib::RefPtr<Gdk::Pixbuf> load_icon() const;
+  
+  /** Sets whether the coordinates returned by gtk_icon_info_get_embedded_rect()
+   * and gtk_icon_info_get_attach_points() should be returned in their
+   * original form as specified in the icon theme, instead of scaled
+   * appropriately for the pixbuf returned by gtk_icon_info_load_icon().
+   * 
+   * Raw coordinates are somewhat strange; they are specified to be with
+   * respect to the unscaled pixmap for PNG and XPM icons, but for SVG
+   * icons, they are in a 1000x1000 coordinate space that is scaled
+   * to the final size of the icon.  You can determine if the icon is an SVG
+   * icon by using gtk_icon_info_get_filename(), and seeing if it is non-<tt>0</tt>
+   * and ends in '.svg'.
+   * 
+   * This function is provided primarily to allow compatibility wrappers
+   * for older API's, and is not expected to be useful for applications.
+   * 
+   * Since: 2.4
+   * @param raw_coordinates Whether the coordinates of embedded rectangles
+   * and attached points should be returned in their original
+   * (unscaled) form.
+   */
+  void set_raw_coordinates(bool raw_coordinates = true);
+  
+  /** Gets the coordinates of a rectangle within the icon
+   * that can be used for display of information such
+   * as a preview of the contents of a text file.
+   * See gtk_icon_info_set_raw_coordinates() for further
+   * information about the coordinate system.
+   * @param rectangle Gdk::Rectangle in which to store embedded
+   * rectangle coordinates; coordinates are only stored
+   * when this function returns <tt>true</tt>.
+   * @return <tt>true</tt> if the icon has an embedded rectangle
+   * 
+   * Since: 2.4.
+   */
+  bool get_embedded_rect(Gdk::Rectangle& rectangle) const;
+  bool get_attach_points(Glib::ArrayHandle<Gdk::Point>& points) const;
+  
+  /** Gets the display name for an icon. A display name is a
+   * string to be used in place of the icon name in a user
+   * visible context like a list of icons.
+   * @return The display name for the icon or <tt>0</tt>, if
+   * the icon doesn't have a specified display name. This value
+   * is owned @a icon_info  and must not be modified or free.
+   * 
+   * Since: 2.4.
+   */
+  Glib::ustring get_display_name() const;
+
+
+};
+
+} // namespace Gtk
+
+
+namespace Gtk
+{
+
+/** @relates Gtk::IconInfo
+ * @param lhs The left-hand side
+ * @param rhs The right-hand side
+ */
+inline void swap(IconInfo& lhs, IconInfo& rhs)
+  { lhs.swap(rhs); }
+
+} // namespace Gtk
+
+namespace Glib
+{
+
+/** @relates Gtk::IconInfo
+ * @param object The C instance
+ * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+ * @result A C++ instance that wraps this C instance.
+ */
+Gtk::IconInfo wrap(GtkIconInfo* object, bool take_copy = false);
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+template <>
+class Value<Gtk::IconInfo> : public Glib::Value_Boxed<Gtk::IconInfo>
+{};
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+} // namespace Glib
+
+#endif /* _GTKMM_ICONINFO_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/iconset.cc b/libs/gtkmm2/gtk/gtkmm/iconset.cc
new file mode 100644
index 0000000000..7546b7d7d2
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/iconset.cc
@@ -0,0 +1,146 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/iconset.h>
+#include <gtkmm/private/iconset_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/*
+ *
+ * Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/widget.h>
+#include <gtkmm/style.h>
+#include <gtk/gtkiconfactory.h>
+
+namespace Gtk
+{
+
+IconSet::IconSet(const Glib::RefPtr<Gdk::Pixbuf>& pixbuf)
+{
+  gobject_ = gtk_icon_set_new_from_pixbuf(pixbuf->gobj());
+}
+
+Glib::ArrayHandle<IconSize> IconSet::get_sizes() const
+{
+  GtkIconSize* pSizes = 0;
+  int n_sizes = 0;
+  gtk_icon_set_get_sizes(const_cast<GtkIconSet*>(gobj()), &pSizes, &n_sizes);
+
+  return Glib::ArrayHandle<IconSize>((IconSize*) pSizes, n_sizes, Glib::OWNERSHIP_SHALLOW);
+}
+
+IconSet IconSet::lookup_default(const Gtk::StockID& stock_id) //static
+{
+  GtkIconSet* pIconSet = gtk_icon_factory_lookup_default(stock_id.get_string().c_str());
+  return IconSet(pIconSet, true); //true = take_copy.
+}
+
+} /* namespace Gtk */
+
+
+namespace
+{
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Gtk::IconSet wrap(GtkIconSet* object, bool take_copy)
+{
+  return Gtk::IconSet(object, take_copy);
+}
+
+} // namespace Glib
+
+
+namespace Gtk
+{
+
+
+// static
+GType IconSet::get_type()
+{
+  return gtk_icon_set_get_type();
+}
+
+IconSet::IconSet()
+:
+  gobject_ (gtk_icon_set_new())
+{}
+
+IconSet::IconSet(const IconSet& other)
+:
+  gobject_ ((other.gobject_) ? gtk_icon_set_ref(other.gobject_) : 0)
+{}
+
+IconSet::IconSet(GtkIconSet* gobject, bool make_a_copy)
+:
+  // For BoxedType wrappers, make_a_copy is true by default.  The static
+  // BoxedType wrappers must always take a copy, thus make_a_copy = true
+  // ensures identical behaviour if the default argument is used.
+  gobject_ ((make_a_copy && gobject) ? gtk_icon_set_ref(gobject) : gobject)
+{}
+
+IconSet& IconSet::operator=(const IconSet& other)
+{
+  IconSet temp (other);
+  swap(temp);
+  return *this;
+}
+
+IconSet::~IconSet()
+{
+  if(gobject_)
+    gtk_icon_set_unref(gobject_);
+}
+
+void IconSet::swap(IconSet& other)
+{
+  GtkIconSet *const temp = gobject_;
+  gobject_ = other.gobject_;
+  other.gobject_ = temp;
+}
+
+GtkIconSet* IconSet::gobj_copy() const
+{
+  return gtk_icon_set_ref(gobject_);
+}
+
+
+IconSet IconSet::copy() const
+{
+  return Glib::wrap(gtk_icon_set_copy(const_cast<GtkIconSet*>(gobj())));
+}
+
+Glib::RefPtr<Gdk::Pixbuf> IconSet::render_icon(const Glib::RefPtr<Style>& style, TextDirection direction, Gtk::StateType state, IconSize size, Widget& widget, const Glib::ustring& detail)
+{
+  return Glib::wrap(gtk_icon_set_render_icon(gobj(), Glib::unwrap(style), ((GtkTextDirection)(direction)), ((GtkStateType)(state)), static_cast<GtkIconSize>(int(size)), (widget).gobj(), detail.c_str()));
+}
+
+void IconSet::add_source(const IconSource& source)
+{
+  gtk_icon_set_add_source(gobj(), (source).gobj());
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/iconset.h b/libs/gtkmm2/gtk/gtkmm/iconset.h
new file mode 100644
index 0000000000..25ec3756ea
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/iconset.h
@@ -0,0 +1,188 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_ICONSET_H
+#define _GTKMM_ICONSET_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* iconset.h
+ *
+ * Copyright(C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software, ) you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library, ) if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+//#include <gtkmm/style.h>
+#include <gdkmm/pixbuf.h>
+#include <gtkmm/iconsource.h>
+//#include <gtkmm/widget.h>
+#include <gtkmm/stockid.h>
+#include <glibmm/arrayhandle.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+extern "C" { typedef struct _GtkIconSet GtkIconSet; }
+#endif
+
+namespace Gtk
+{
+
+class Style;
+class Widget;
+
+class IconSet
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef IconSet CppObjectType;
+  typedef GtkIconSet BaseObjectType;
+
+  static GType get_type() G_GNUC_CONST;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  IconSet();
+
+  explicit IconSet(GtkIconSet* gobject, bool make_a_copy = true);
+
+  IconSet(const IconSet& other);
+  IconSet& operator=(const IconSet& other);
+
+  ~IconSet();
+
+  void swap(IconSet& other);
+
+  ///Provides access to the underlying C instance.
+  GtkIconSet*       gobj()       { return gobject_; }
+
+  ///Provides access to the underlying C instance.
+  const GtkIconSet* gobj() const { return gobject_; }
+
+  ///Provides access to the underlying C instance. The caller is responsible for freeing it. Use when directly setting fields in structs.
+  GtkIconSet* gobj_copy() const;
+
+protected:
+  GtkIconSet* gobject_;
+
+private:
+
+  
+public:
+  explicit IconSet(const Glib::RefPtr<Gdk::Pixbuf>& pixbuf);
+
+  
+  /** Copies @a icon_set  by value.
+   * @return A new Gtk::IconSet identical to the first.
+   */
+  IconSet copy() const;
+
+  //Note that we use Gtk::StateType here instead of StateType, because there is an Atk::StateType too, and doxygen gets confused.
+  
+  /** Renders an icon using Gtk::Style::render_icon(). In most cases,
+   * Gtk::Widget::render_icon() is better, since it automatically provides
+   * most of the arguments from the current widget settings.  This
+   * function never returns <tt>0</tt>; if the icon can't be rendered
+   * (perhaps because an image file fails to load), a default "missing
+   * image" icon will be returned instead.
+   * @param style A Gtk::Style associated with @a widget , or <tt>0</tt>.
+   * @param direction Text direction.
+   * @param state Widget state.
+   * @param size Icon size. A size of (GtkIconSize)-1
+   * means render at the size of the source and don't scale.
+   * @param widget Widget that will display the icon, or <tt>0</tt>.
+   * The only use that is typically made of this
+   * is to determine the appropriate Gdk::Screen.
+   * @param detail Detail to pass to the theme engine, or <tt>0</tt>.
+   * Note that passing a detail of anything but <tt>0</tt>
+   * will disable caching.
+   * @return A Gdk::Pixbuf to be displayed.
+   */
+  Glib::RefPtr<Gdk::Pixbuf> render_icon(const Glib::RefPtr<Style>& style, TextDirection direction,
+                                          Gtk::StateType state, IconSize size,
+                                          Widget& widget, const Glib::ustring& detail);
+
+  
+  /** Icon sets have a list of Gtk::IconSource, which they use as base
+   * icons for rendering icons in different states and sizes. Icons are
+   * scaled, made to look insensitive, etc. in
+   * gtk_icon_set_render_icon(), but Gtk::IconSet needs base images to
+   * work with. The base images and when to use them are described by
+   * a Gtk::IconSource.
+   * 
+   * This function copies @a source , so you can reuse the same source immediately
+   * without affecting the icon set.
+   * 
+   * An example of when you'd use this function: a web browser's "Back
+   * to Previous Page" icon might point in a different direction in
+   * Hebrew and in English; it might look different when insensitive;
+   * and it might change size depending on toolbar mode (small/large
+   * icons). So a single icon set would contain all those variants of
+   * the icon, and you might add a separate source for each one.
+   * 
+   * You should nearly always add a "default" icon source with all
+   * fields wildcarded, which will be used as a fallback if no more
+   * specific source matches. Gtk::IconSet always prefers more specific
+   * icon sources to more generic icon sources. The order in which you
+   * add the sources to the icon set does not matter.
+   * 
+   * gtk_icon_set_new_from_pixbuf() creates a new icon set with a
+   * default icon source based on the given pixbuf.
+   * @param source A Gtk::IconSource.
+   */
+  void add_source(const IconSource& source);
+
+  Glib::ArrayHandle<IconSize> get_sizes() const;
+
+  static IconSet lookup_default(const Gtk::StockID& stock_id);
+
+
+};
+
+} /* namespace Gtk */
+
+
+namespace Gtk
+{
+
+/** @relates Gtk::IconSet
+ * @param lhs The left-hand side
+ * @param rhs The right-hand side
+ */
+inline void swap(IconSet& lhs, IconSet& rhs)
+  { lhs.swap(rhs); }
+
+} // namespace Gtk
+
+namespace Glib
+{
+
+/** @relates Gtk::IconSet
+ * @param object The C instance
+ * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+ * @result A C++ instance that wraps this C instance.
+ */
+Gtk::IconSet wrap(GtkIconSet* object, bool take_copy = false);
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+template <>
+class Value<Gtk::IconSet> : public Glib::Value_Boxed<Gtk::IconSet>
+{};
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+} // namespace Glib
+
+#endif /* _GTKMM_ICONSET_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/iconsource.cc b/libs/gtkmm2/gtk/gtkmm/iconsource.cc
new file mode 100644
index 0000000000..4ff332d9fd
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/iconsource.cc
@@ -0,0 +1,208 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/iconsource.h>
+#include <gtkmm/private/iconsource_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/*
+ *
+ * Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtk/gtkiconfactory.h>
+
+namespace
+{
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Gtk::IconSource wrap(GtkIconSource* object, bool take_copy)
+{
+  return Gtk::IconSource(object, take_copy);
+}
+
+} // namespace Glib
+
+
+namespace Gtk
+{
+
+
+// static
+GType IconSource::get_type()
+{
+  return gtk_icon_source_get_type();
+}
+
+IconSource::IconSource()
+:
+  gobject_ (gtk_icon_source_new())
+{}
+
+IconSource::IconSource(const IconSource& other)
+:
+  gobject_ ((other.gobject_) ? gtk_icon_source_copy(other.gobject_) : 0)
+{}
+
+IconSource::IconSource(GtkIconSource* gobject, bool make_a_copy)
+:
+  // For BoxedType wrappers, make_a_copy is true by default.  The static
+  // BoxedType wrappers must always take a copy, thus make_a_copy = true
+  // ensures identical behaviour if the default argument is used.
+  gobject_ ((make_a_copy && gobject) ? gtk_icon_source_copy(gobject) : gobject)
+{}
+
+IconSource& IconSource::operator=(const IconSource& other)
+{
+  IconSource temp (other);
+  swap(temp);
+  return *this;
+}
+
+IconSource::~IconSource()
+{
+  if(gobject_)
+    gtk_icon_source_free(gobject_);
+}
+
+void IconSource::swap(IconSource& other)
+{
+  GtkIconSource *const temp = gobject_;
+  gobject_ = other.gobject_;
+  other.gobject_ = temp;
+}
+
+GtkIconSource* IconSource::gobj_copy() const
+{
+  return gtk_icon_source_copy(gobject_);
+}
+
+
+void IconSource::set_filename(const Glib::ustring& filename)
+{
+  gtk_icon_source_set_filename(gobj(), filename.c_str());
+}
+
+void IconSource::set_pixbuf(const Glib::RefPtr<Gdk::Pixbuf>& pixbuf)
+{
+  gtk_icon_source_set_pixbuf(gobj(), Glib::unwrap(pixbuf));
+}
+
+Glib::ustring IconSource::get_filename() const
+{
+  return Glib::convert_const_gchar_ptr_to_ustring(gtk_icon_source_get_filename(const_cast<GtkIconSource*>(gobj())));
+}
+
+Glib::RefPtr<Gdk::Pixbuf> IconSource::get_pixbuf()
+{
+
+  Glib::RefPtr<Gdk::Pixbuf> retvalue = Glib::wrap(gtk_icon_source_get_pixbuf(gobj()));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::RefPtr<const Gdk::Pixbuf> IconSource::get_pixbuf() const
+{
+
+  Glib::RefPtr<const Gdk::Pixbuf> retvalue = Glib::wrap(gtk_icon_source_get_pixbuf(const_cast<GtkIconSource*>(gobj())));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+void IconSource::set_direction_wildcarded(bool setting)
+{
+  gtk_icon_source_set_direction_wildcarded(gobj(), static_cast<int>(setting));
+}
+
+void IconSource::set_state_wildcarded(bool setting)
+{
+  gtk_icon_source_set_state_wildcarded(gobj(), static_cast<int>(setting));
+}
+
+void IconSource::set_size_wildcarded(bool setting)
+{
+  gtk_icon_source_set_size_wildcarded(gobj(), static_cast<int>(setting));
+}
+
+bool IconSource::get_size_wildcarded() const
+{
+  return gtk_icon_source_get_size_wildcarded(const_cast<GtkIconSource*>(gobj()));
+}
+
+bool IconSource::get_state_wildcarded() const
+{
+  return gtk_icon_source_get_state_wildcarded(const_cast<GtkIconSource*>(gobj()));
+}
+
+bool IconSource::get_direction_wildcarded() const
+{
+  return gtk_icon_source_get_direction_wildcarded(const_cast<GtkIconSource*>(gobj()));
+}
+
+void IconSource::set_direction(TextDirection direction)
+{
+  gtk_icon_source_set_direction(gobj(), ((GtkTextDirection)(direction)));
+}
+
+void IconSource::set_state(Gtk::StateType state)
+{
+  gtk_icon_source_set_state(gobj(), ((GtkStateType)(state)));
+}
+
+void IconSource::set_size(IconSize size)
+{
+  gtk_icon_source_set_size(gobj(), static_cast<GtkIconSize>(int(size)));
+}
+
+TextDirection IconSource::get_direction() const
+{
+  return ((TextDirection)(gtk_icon_source_get_direction(const_cast<GtkIconSource*>(gobj()))));
+}
+
+Gtk::StateType IconSource::get_state() const
+{
+  return ((Gtk::StateType)(gtk_icon_source_get_state(const_cast<GtkIconSource*>(gobj()))));
+}
+
+IconSize IconSource::get_size() const
+{
+  return IconSize(static_cast<int>(gtk_icon_source_get_size(const_cast<GtkIconSource*>(gobj()))));
+}
+
+void IconSource::set_icon_name(const Glib::ustring& icon_name)
+{
+  gtk_icon_source_set_icon_name(gobj(), icon_name.c_str());
+}
+
+Glib::ustring IconSource::get_icon_name() const
+{
+  return Glib::convert_const_gchar_ptr_to_ustring(gtk_icon_source_get_icon_name(const_cast<GtkIconSource*>(gobj())));
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/iconsource.h b/libs/gtkmm2/gtk/gtkmm/iconsource.h
new file mode 100644
index 0000000000..67622aa2c7
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/iconsource.h
@@ -0,0 +1,288 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_ICONSOURCE_H
+#define _GTKMM_ICONSOURCE_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* iconsource.h
+ *
+ * Copyright(C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software, ) you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library, ) if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gdkmm/pixbuf.h>
+#include <gtkmm/enums.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+extern "C" { typedef struct _GtkIconSource GtkIconSource; }
+#endif
+
+namespace Gtk
+{
+
+class IconSource
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef IconSource CppObjectType;
+  typedef GtkIconSource BaseObjectType;
+
+  static GType get_type() G_GNUC_CONST;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  IconSource();
+
+  explicit IconSource(GtkIconSource* gobject, bool make_a_copy = true);
+
+  IconSource(const IconSource& other);
+  IconSource& operator=(const IconSource& other);
+
+  ~IconSource();
+
+  void swap(IconSource& other);
+
+  ///Provides access to the underlying C instance.
+  GtkIconSource*       gobj()       { return gobject_; }
+
+  ///Provides access to the underlying C instance.
+  const GtkIconSource* gobj() const { return gobject_; }
+
+  ///Provides access to the underlying C instance. The caller is responsible for freeing it. Use when directly setting fields in structs.
+  GtkIconSource* gobj_copy() const;
+
+protected:
+  GtkIconSource* gobject_;
+
+private:
+
+  
+public:
+
+  
+  /** Sets the name of an image file to use as a base image when creating
+   * icon variants for Gtk::IconSet. The filename must be absolute.
+   * @param filename Image file to use.
+   */
+  void set_filename(const Glib::ustring& filename);
+  
+  /** Sets a pixbuf to use as a base image when creating icon variants
+   * for Gtk::IconSet.
+   * @param pixbuf Pixbuf to use as a source.
+   */
+  void set_pixbuf(const Glib::RefPtr<Gdk::Pixbuf>&pixbuf);
+
+  
+  /** Retrieves the source filename, or <tt>0</tt> if none is set. The
+   * filename is not a copy, and should not be modified or expected to
+   * persist beyond the lifetime of the icon source.
+   * @return Image filename. This string must not be modified
+   * or freed.
+   */
+  Glib::ustring get_filename() const;
+  
+  /** Retrieves the source pixbuf, or <tt>0</tt> if none is set.
+   * In addition, if a filename source is in use, this
+   * function in some cases will return the pixbuf from
+   * loaded from the filename. This is, for example, true
+   * for the GtkIconSource passed to the GtkStyle::render_icon()
+   * virtual function. The reference count on the pixbuf is
+   * not incremented.
+   * @return Source pixbuf.
+   */
+  Glib::RefPtr<Gdk::Pixbuf> get_pixbuf();
+  
+  /** Retrieves the source pixbuf, or <tt>0</tt> if none is set.
+   * In addition, if a filename source is in use, this
+   * function in some cases will return the pixbuf from
+   * loaded from the filename. This is, for example, true
+   * for the GtkIconSource passed to the GtkStyle::render_icon()
+   * virtual function. The reference count on the pixbuf is
+   * not incremented.
+   * @return Source pixbuf.
+   */
+  Glib::RefPtr<const Gdk::Pixbuf> get_pixbuf() const;
+  
+  
+  /** If the text direction is wildcarded, this source can be used
+   * as the base image for an icon in any Gtk::TextDirection.
+   * If the text direction is not wildcarded, then the
+   * text direction the icon source applies to should be set
+   * with gtk_icon_source_set_direction(), and the icon source
+   * will only be used with that text direction.
+   * 
+   * Gtk::IconSet prefers non-wildcarded sources (exact matches) over
+   * wildcarded sources, and will use an exact match when possible.
+   * @param setting <tt>true</tt> to wildcard the text direction.
+   */
+  void set_direction_wildcarded(bool setting = true);
+  
+  /** If the widget state is wildcarded, this source can be used as the
+   * base image for an icon in any Gtk::StateType.  If the widget state
+   * is not wildcarded, then the state the source applies to should be
+   * set with gtk_icon_source_set_state() and the icon source will
+   * only be used with that specific state.
+   * 
+   * Gtk::IconSet prefers non-wildcarded sources (exact matches) over
+   * wildcarded sources, and will use an exact match when possible.
+   * 
+   * Gtk::IconSet will normally transform wildcarded source images to
+   * produce an appropriate icon for a given state, for example
+   * lightening an image on prelight, but will not modify source images
+   * that match exactly.
+   * @param setting <tt>true</tt> to wildcard the widget state.
+   */
+  void set_state_wildcarded(bool setting = true);
+  
+  /** If the icon size is wildcarded, this source can be used as the base
+   * image for an icon of any size.  If the size is not wildcarded, then
+   * the size the source applies to should be set with
+   * gtk_icon_source_set_size() and the icon source will only be used
+   * with that specific size.
+   * 
+   * Gtk::IconSet prefers non-wildcarded sources (exact matches) over
+   * wildcarded sources, and will use an exact match when possible.
+   * 
+   * Gtk::IconSet will normally scale wildcarded source images to produce
+   * an appropriate icon at a given size, but will not change the size
+   * of source images that match exactly.
+   * @param setting <tt>true</tt> to wildcard the widget state.
+   */
+  void set_size_wildcarded (bool setting = true);
+  
+  /** Gets the value set by gtk_icon_source_set_size_wildcarded().
+   * @return <tt>true</tt> if this icon source is a base for any icon size variant.
+   */
+  bool get_size_wildcarded() const;
+  
+  /** Gets the value set by gtk_icon_source_set_state_wildcarded().
+   * @return <tt>true</tt> if this icon source is a base for any widget state variant.
+   */
+  bool get_state_wildcarded() const;
+  
+  /** Gets the value set by gtk_icon_source_set_direction_wildcarded().
+   * @return <tt>true</tt> if this icon source is a base for any text direction variant.
+   */
+  bool get_direction_wildcarded() const;
+  
+  /** Sets the text direction this icon source is intended to be used
+   * with.
+   * 
+   * Setting the text direction on an icon source makes no difference
+   * if the text direction is wildcarded. Therefore, you should usually
+   * call gtk_icon_source_set_direction_wildcarded() to un-wildcard it
+   * in addition to calling this function.
+   * @param direction Text direction this source applies to.
+   */
+  void set_direction(TextDirection direction);
+  
+  /** Sets the widget state this icon source is intended to be used
+   * with.
+   * 
+   * Setting the widget state on an icon source makes no difference
+   * if the state is wildcarded. Therefore, you should usually
+   * call gtk_icon_source_set_state_wildcarded() to un-wildcard it
+   * in addition to calling this function.
+   * @param state Widget state this source applies to.
+   */
+  void set_state(Gtk::StateType state);
+  
+  /** Sets the icon size this icon source is intended to be used
+   * with.
+   * 
+   * Setting the icon size on an icon source makes no difference
+   * if the size is wildcarded. Therefore, you should usually
+   * call gtk_icon_source_set_size_wildcarded() to un-wildcard it
+   * in addition to calling this function.
+   * @param size Icon size this source applies to.
+   */
+  void set_size(IconSize size);
+  
+  /** Obtains the text direction this icon source applies to. The return
+   * value is only useful/meaningful if the text direction is <em>not</em> 
+   * wildcarded.
+   * @return Text direction this source matches.
+   */
+  TextDirection get_direction() const;
+  
+  /** Obtains the widget state this icon source applies to. The return
+   * value is only useful/meaningful if the widget state is <em>not</em>
+   * wildcarded.
+   * @return Widget state this source matches.
+   */
+  Gtk::StateType get_state() const;
+  
+  /** Obtains the icon size this source applies to. The return value
+   * is only useful/meaningful if the icon size is <em>not</em> wildcarded.
+   * @return Icon size this source matches.
+   */
+  IconSize get_size() const;
+
+  
+  /** Sets the name of an icon to look up in the current icon theme
+   * to use as a base image when creating icon variants for Gtk::IconSet.
+   * @param icon_name Name of icon to use.
+   */
+  void set_icon_name(const Glib::ustring& icon_name);
+  
+  /** Retrieves the source icon name, or <tt>0</tt> if none is set. The
+   * icon_name is not a copy, and should not be modified or expected to
+   * persist beyond the lifetime of the icon source.
+   * @return Icon name. This string must not be modified or freed.
+   */
+  Glib::ustring get_icon_name() const;
+
+
+};
+
+} /* namespace Gtk */
+
+
+namespace Gtk
+{
+
+/** @relates Gtk::IconSource
+ * @param lhs The left-hand side
+ * @param rhs The right-hand side
+ */
+inline void swap(IconSource& lhs, IconSource& rhs)
+  { lhs.swap(rhs); }
+
+} // namespace Gtk
+
+namespace Glib
+{
+
+/** @relates Gtk::IconSource
+ * @param object The C instance
+ * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+ * @result A C++ instance that wraps this C instance.
+ */
+Gtk::IconSource wrap(GtkIconSource* object, bool take_copy = false);
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+template <>
+class Value<Gtk::IconSource> : public Glib::Value_Boxed<Gtk::IconSource>
+{};
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+} // namespace Glib
+
+#endif /* _GTKMM_ICONSOURCE_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/icontheme.cc b/libs/gtkmm2/gtk/gtkmm/icontheme.cc
new file mode 100644
index 0000000000..4403fe61f0
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/icontheme.cc
@@ -0,0 +1,327 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/icontheme.h>
+#include <gtkmm/private/icontheme_p.h>
+
+/* Copyright 2003 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtk/gtkicontheme.h>
+#include <gtk/gtktypebuiltins.h> //For gtk_icon_theme_error_get_type().
+
+
+namespace Gtk
+{
+
+void IconTheme::set_search_path(const Glib::ArrayHandle<Glib::ustring>& path)
+{
+  gtk_icon_theme_set_search_path(gobj(), const_cast<const char**>(path.data()), path.size());
+}
+
+Glib::ArrayHandle<Glib::ustring> IconTheme::get_search_path() const
+{
+  int* temp_int = 0;
+  gchar*** temp_path = 0;
+  gtk_icon_theme_get_search_path(const_cast<GtkIconTheme*>(gobj()), temp_path, temp_int);
+  return Glib::ArrayHandle<Glib::ustring>((const char**)(*temp_path), *temp_int, Glib::OWNERSHIP_SHALLOW);
+}
+
+Glib::ArrayHandle<int> IconTheme::get_icon_sizes(const Glib::ustring& icon_name) const
+{
+  int* pArrayInts = gtk_icon_theme_get_icon_sizes(const_cast<GtkIconTheme*>(gobj()), icon_name.c_str());
+  
+  //pArrayInts is null-terminated.
+  return Glib::ArrayHandle<int>(pArrayInts, Glib::OWNERSHIP_SHALLOW); //TODO: I'm not sure about the ownership. murrayc.
+}
+  
+
+} // namespace Gtk
+
+
+namespace
+{
+
+const Glib::SignalProxyInfo IconTheme_signal_changed_info =
+{
+  "changed",
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
+};
+
+} // anonymous namespace
+
+
+Gtk::IconThemeError::IconThemeError(Gtk::IconThemeError::Code error_code, const Glib::ustring& error_message)
+:
+  Glib::Error (GTK_ICON_THEME_ERROR, error_code, error_message)
+{}
+
+Gtk::IconThemeError::IconThemeError(GError* gobject)
+:
+  Glib::Error (gobject)
+{}
+
+Gtk::IconThemeError::Code Gtk::IconThemeError::code() const
+{
+  return static_cast<Code>(Glib::Error::code());
+}
+
+void Gtk::IconThemeError::throw_func(GError* gobject)
+{
+  throw Gtk::IconThemeError(gobject);
+}
+
+// static
+GType Glib::Value<Gtk::IconThemeError::Code>::value_type()
+{
+  return gtk_icon_theme_error_get_type();
+}
+
+
+namespace Glib
+{
+
+Glib::RefPtr<Gtk::IconTheme> wrap(GtkIconTheme* object, bool take_copy)
+{
+  return Glib::RefPtr<Gtk::IconTheme>( dynamic_cast<Gtk::IconTheme*> (Glib::wrap_auto ((GObject*)(object), take_copy)) );
+  //We use dynamic_cast<> in case of multiple inheritance.
+}
+
+} /* namespace Glib */
+
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& IconTheme_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &IconTheme_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_icon_theme_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void IconTheme_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+  klass->changed = &changed_callback;
+}
+
+
+void IconTheme_Class::changed_callback(GtkIconTheme* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_changed();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->changed)
+      (*base->changed)(self);
+  }
+}
+
+
+Glib::ObjectBase* IconTheme_Class::wrap_new(GObject* object)
+{
+  return new IconTheme((GtkIconTheme*)object);
+}
+
+
+/* The implementation: */
+
+GtkIconTheme* IconTheme::gobj_copy()
+{
+  reference();
+  return gobj();
+}
+
+IconTheme::IconTheme(const Glib::ConstructParams& construct_params)
+:
+  Glib::Object(construct_params)
+{}
+
+IconTheme::IconTheme(GtkIconTheme* castitem)
+:
+  Glib::Object((GObject*)(castitem))
+{}
+
+IconTheme::~IconTheme()
+{}
+
+
+IconTheme::CppClassType IconTheme::icontheme_class_; // initialize static member
+
+GType IconTheme::get_type()
+{
+  return icontheme_class_.init().get_type();
+}
+
+GType IconTheme::get_base_type()
+{
+  return gtk_icon_theme_get_type();
+}
+
+
+IconTheme::IconTheme()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Glib::Object(Glib::ConstructParams(icontheme_class_.init()))
+{
+  }
+
+Glib::RefPtr<IconTheme> IconTheme::create()
+{
+  return Glib::RefPtr<IconTheme>( new IconTheme() );
+}
+Glib::RefPtr<IconTheme> IconTheme::get_default()
+{
+
+  Glib::RefPtr<IconTheme> retvalue = Glib::wrap(gtk_icon_theme_get_default());
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::RefPtr<IconTheme> IconTheme::get_for_screen(const Glib::RefPtr<Gdk::Screen>& screen)
+{
+
+  Glib::RefPtr<IconTheme> retvalue = Glib::wrap(gtk_icon_theme_get_for_screen(Glib::unwrap(screen)));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+void IconTheme::set_screen(const Glib::RefPtr<Gdk::Screen>& screen)
+{
+  gtk_icon_theme_set_screen(gobj(), Glib::unwrap(screen));
+}
+
+void IconTheme::append_search_path(const Glib::ustring& path)
+{
+  gtk_icon_theme_append_search_path(gobj(), path.c_str());
+}
+
+void IconTheme::prepend_search_path(const Glib::ustring& path)
+{
+  gtk_icon_theme_prepend_search_path(gobj(), path.c_str());
+}
+
+void IconTheme::set_custom_theme(const Glib::ustring& theme_name)
+{
+  gtk_icon_theme_set_custom_theme(gobj(), theme_name.c_str());
+}
+
+bool IconTheme::has_icon(const Glib::ustring& icon_name) const
+{
+  return gtk_icon_theme_has_icon(const_cast<GtkIconTheme*>(gobj()), icon_name.c_str());
+}
+
+IconInfo IconTheme::lookup_icon(const Glib::ustring& icon_name, int size, IconLookupFlags flags) const
+{
+  return Glib::wrap(gtk_icon_theme_lookup_icon(const_cast<GtkIconTheme*>(gobj()), icon_name.c_str(), size, ((GtkIconLookupFlags)(flags))));
+}
+
+Glib::RefPtr<Gdk::Pixbuf> IconTheme::load_icon(const Glib::ustring& icon_name, int size, IconLookupFlags flags) const
+{
+  GError *error = 0;
+  Glib::RefPtr<Gdk::Pixbuf> retvalue = Glib::wrap(gtk_icon_theme_load_icon(const_cast<GtkIconTheme*>(gobj()), icon_name.c_str(), size, ((GtkIconLookupFlags)(flags)), &(error)));
+  if(error) ::Glib::Error::throw_exception(error);
+  return retvalue;
+}
+
+Glib::ListHandle<Glib::ustring> IconTheme::list_icons(const Glib::ustring& context) const
+{
+  return Glib::ListHandle<Glib::ustring>(gtk_icon_theme_list_icons(const_cast<GtkIconTheme*>(gobj()), context.c_str()), Glib::OWNERSHIP_SHALLOW);
+}
+
+Glib::ustring IconTheme::get_example_icon_name() const
+{
+  return Glib::convert_return_gchar_ptr_to_ustring(gtk_icon_theme_get_example_icon_name(const_cast<GtkIconTheme*>(gobj())));
+}
+
+bool IconTheme::rescan_if_needed()
+{
+  return gtk_icon_theme_rescan_if_needed(gobj());
+}
+
+void IconTheme::add_builtin_icon(const Glib::ustring& icon_name, int size, const Glib::RefPtr<Gdk::Pixbuf>& pixbuf)
+{
+  gtk_icon_theme_add_builtin_icon(icon_name.c_str(), size, Glib::unwrap(pixbuf));
+}
+
+
+Glib::SignalProxy0< void > IconTheme::signal_changed()
+{
+  return Glib::SignalProxy0< void >(this, &IconTheme_signal_changed_info);
+}
+
+
+void Gtk::IconTheme::on_changed()
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->changed)
+    (*base->changed)(gobj());
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/icontheme.h b/libs/gtkmm2/gtk/gtkmm/icontheme.h
new file mode 100644
index 0000000000..450ad2f9ea
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/icontheme.h
@@ -0,0 +1,394 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_ICONTHEME_H
+#define _GTKMM_ICONTHEME_H
+
+#include <glibmm.h>
+
+/* Copyright (C) 2003 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gdkmm/pixbuf.h>
+#include <gdkmm/screen.h>
+
+#include <gtkmm/iconinfo.h>
+ 
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkIconTheme GtkIconTheme;
+typedef struct _GtkIconThemeClass GtkIconThemeClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class IconTheme_Class; } // namespace Gtk
+namespace Gtk
+{
+
+/** @addtogroup gtkmmEnums Enums and Flags */
+
+/**
+ * @ingroup gtkmmEnums
+ * @par Bitwise operators:
+ * <tt>%IconLookupFlags operator|(IconLookupFlags, IconLookupFlags)</tt><br>
+ * <tt>%IconLookupFlags operator&(IconLookupFlags, IconLookupFlags)</tt><br>
+ * <tt>%IconLookupFlags operator^(IconLookupFlags, IconLookupFlags)</tt><br>
+ * <tt>%IconLookupFlags operator~(IconLookupFlags)</tt><br>
+ * <tt>%IconLookupFlags& operator|=(IconLookupFlags&, IconLookupFlags)</tt><br>
+ * <tt>%IconLookupFlags& operator&=(IconLookupFlags&, IconLookupFlags)</tt><br>
+ * <tt>%IconLookupFlags& operator^=(IconLookupFlags&, IconLookupFlags)</tt><br>
+ */
+enum IconLookupFlags
+{
+  ICON_LOOKUP_NO_SVG = 1 << 0,
+  ICON_LOOKUP_FORCE_SVG = 1 << 1,
+  ICON_LOOKUP_USE_BUILTIN = 1 << 2
+};
+
+/** @ingroup gtkmmEnums */
+inline IconLookupFlags operator|(IconLookupFlags lhs, IconLookupFlags rhs)
+  { return static_cast<IconLookupFlags>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs)); }
+
+/** @ingroup gtkmmEnums */
+inline IconLookupFlags operator&(IconLookupFlags lhs, IconLookupFlags rhs)
+  { return static_cast<IconLookupFlags>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs)); }
+
+/** @ingroup gtkmmEnums */
+inline IconLookupFlags operator^(IconLookupFlags lhs, IconLookupFlags rhs)
+  { return static_cast<IconLookupFlags>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs)); }
+
+/** @ingroup gtkmmEnums */
+inline IconLookupFlags operator~(IconLookupFlags flags)
+  { return static_cast<IconLookupFlags>(~static_cast<unsigned>(flags)); }
+
+/** @ingroup gtkmmEnums */
+inline IconLookupFlags& operator|=(IconLookupFlags& lhs, IconLookupFlags rhs)
+  { return (lhs = static_cast<IconLookupFlags>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs))); }
+
+/** @ingroup gtkmmEnums */
+inline IconLookupFlags& operator&=(IconLookupFlags& lhs, IconLookupFlags rhs)
+  { return (lhs = static_cast<IconLookupFlags>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs))); }
+
+/** @ingroup gtkmmEnums */
+inline IconLookupFlags& operator^=(IconLookupFlags& lhs, IconLookupFlags rhs)
+  { return (lhs = static_cast<IconLookupFlags>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs))); }
+
+
+/** Exception class for Gdk::IconTheme errors.
+ */
+class IconThemeError : public Glib::Error
+{
+public:
+  enum Code
+  {
+    ICON_THEME_NOT_FOUND,
+    ICON_THEME_FAILED
+  };
+
+  IconThemeError(Code error_code, const Glib::ustring& error_message);
+  explicit IconThemeError(GError* gobject);
+  Code code() const;
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+private:
+  static void throw_func(GError* gobject);
+  friend void wrap_init(); // uses throw_func()
+#endif
+};
+
+} // namespace Gtk
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Gtk::IconThemeError::Code> : public Glib::Value_Enum<Gtk::IconThemeError::Code>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{
+
+  
+class IconTheme : public Glib::Object
+{
+  
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+public:
+  typedef IconTheme CppObjectType;
+  typedef IconTheme_Class CppClassType;
+  typedef GtkIconTheme BaseObjectType;
+  typedef GtkIconThemeClass BaseClassType;
+
+private:  friend class IconTheme_Class;
+  static CppClassType icontheme_class_;
+
+private:
+  // noncopyable
+  IconTheme(const IconTheme&);
+  IconTheme& operator=(const IconTheme&);
+
+protected:
+  explicit IconTheme(const Glib::ConstructParams& construct_params);
+  explicit IconTheme(GtkIconTheme* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+  virtual ~IconTheme();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GObject.
+  GtkIconTheme*       gobj()       { return reinterpret_cast<GtkIconTheme*>(gobject_); }
+
+  ///Provides access to the underlying C GObject.
+  const GtkIconTheme* gobj() const { return reinterpret_cast<GtkIconTheme*>(gobject_); }
+
+  ///Provides access to the underlying C instance. The caller is responsible for unrefing it. Use when directly setting fields in structs.
+  GtkIconTheme* gobj_copy();
+
+private:
+
+  
+protected:
+  IconTheme();
+public:
+  
+  static Glib::RefPtr<IconTheme> create();
+
+  
+  /** Gets the icon theme for the default screen. See
+   * get_for_screen().
+   * @return A unique Gtk::IconTheme associated with
+   * the default screen. This icon theme is associated with
+   * the screen and can be used as long as the screen
+   * is open.
+   * 
+   * Since: 2.4.
+   */
+  static Glib::RefPtr<IconTheme> get_default();
+  
+  /** Gets the icon theme object associated with @a screen ; if this
+   * function has not previously been called for the given
+   * screen, a new icon theme object will be created and
+   * associated with the screen. Icon theme objects are
+   * fairly expensive to create, so using this function
+   * is usually a better choice than calling than new()
+   * and setting the screen yourself; by using this function
+   * a single icon theme object will be shared between users.
+   * @param screen A Gdk::Screen.
+   * @return A unique Gtk::IconTheme associated with
+   * the given screen. This icon theme is associated with
+   * the screen and can be used as long as the screen
+   * is open.
+   * 
+   * Since: 2.4.
+   */
+  static Glib::RefPtr<IconTheme> get_for_screen(const Glib::RefPtr<Gdk::Screen>& screen);
+  
+  /** Sets the screen for an icon theme; the screen is used
+   * to track the user's currently configured icon theme,
+   * which might be different for different screens.
+   * 
+   * Since: 2.4
+   * @param screen A Gdk::Screen.
+   */
+  void set_screen(const Glib::RefPtr<Gdk::Screen>& screen);
+  void set_search_path(const Glib::ArrayHandle<Glib::ustring>& path);
+  Glib::ArrayHandle<Glib::ustring> get_search_path() const;
+  
+  /** Appends a directory to the search path. 
+   * See set_search_path(). 
+   * 
+   * Since: 2.4
+   * @param path Directory name to append to the icon path.
+   */
+  void append_search_path(const Glib::ustring& path);
+  
+  /** Prepends a directory to the search path. 
+   * See set_search_path().
+   * 
+   * Since: 2.4
+   * @param path Directory name to prepend to the icon path.
+   */
+  void prepend_search_path(const Glib::ustring& path);
+  
+  /** Sets the name of the icon theme that the Gtk::IconTheme object uses
+   * overriding system configuration. This function cannot be called
+   * on the icon theme objects returned from get_default()
+   * and get_default().
+   * 
+   * Since: 2.4
+   * @param theme_name Name of icon theme to use instead of configured theme.
+   */
+  void set_custom_theme(const Glib::ustring& theme_name);
+  
+  /** Checks whether an icon theme includes an icon
+   * for a particular name.
+   * @param icon_name The name of an icon.
+   * @return <tt>true</tt> if @a icon_theme  includes an
+   * icon for @a icon_name .
+   * 
+   * Since: 2.4.
+   */
+  bool has_icon(const Glib::ustring& icon_name) const;
+
+  Glib::ArrayHandle<int> get_icon_sizes(const Glib::ustring& icon_name) const;
+  
+  
+//TODO: Update the docs for this, to suggest use of IconInfo::operator bool() instead of saying that it returns null.
+  
+  /** Looks up a named icon and returns a structure containing
+   * information such as the filename of the icon. The icon
+   * can then be rendered into a pixbuf using
+   * gtk_icon_info_load_icon(). (load_icon()
+   * combines these two steps if all you need is the pixbuf.)
+   * @param icon_name The name of the icon to lookup.
+   * @param size Desired icon size.
+   * @param flags Flags modifying the behavior of the icon lookup.
+   * @return A Gtk::IconInfo structure containing information
+   * about the icon, or <tt>0</tt> if the icon wasn't found. Free with
+   * gtk_icon_info_free()
+   * 
+   * Since: 2.4.
+   */
+  IconInfo lookup_icon(const Glib::ustring& icon_name, int size, IconLookupFlags flags) const;
+
+  
+  /** Looks up an icon in an icon theme, scales it to the given size
+   * and renders it into a pixbuf. This is a convenience function;
+   * if more details about the icon are needed, use
+   * lookup_icon() followed by gtk_icon_info_load_icon().
+   * @param icon_name The name of the icon to lookup.
+   * @param size The desired icon size. The resulting icon may not be exactly this size; see gtk_icon_info_load_icon().
+   * @param flags Flags modifying the behavior of the icon lookup.
+   * @return The rendered icon; this may be a newly created icon
+   * or a new reference to an internal icon, so you must not modify
+   * the icon. Use Glib::object_unref() to release your reference to the
+   * icon. <tt>0</tt> if the icon isn't found.
+   * 
+   * Since: 2.4.
+   */
+  Glib::RefPtr<Gdk::Pixbuf> load_icon(const Glib::ustring& icon_name, int size, IconLookupFlags flags) const;
+
+  
+  /** Lists the icons in the current icon theme. Only a subset
+   * of the icons can be listed by providing a context string.
+   * The set of values for the context string is system dependent,
+   * but will typically include such values as 'apps' and
+   * 'mimetypes'.
+   * @param context A string identifying a particular type of icon,
+   * or <tt>0</tt> to list all icons.
+   * @return A G::List list holding the names of all the
+   * icons in the theme. You must first free each element
+   * in the list with Glib::free(), then free the list itself
+   * with Glib::list_free().
+   * 
+   * Since: 2.4.
+   */
+  Glib::ListHandle<Glib::ustring> list_icons(const Glib::ustring& context) const;
+  
+  /** Gets the name of an icon that is representative of the
+   * current theme (for instance, to use when presenting
+   * a list of themes to the user.)
+   * @return The name of an example icon or <tt>0</tt>.
+   * Free with Glib::free().
+   * 
+   * Since: 2.4.
+   */
+  Glib::ustring get_example_icon_name() const;
+  
+  /** Checks to see if the icon theme has changed; if it has, any
+   * currently cached information is discarded and will be reloaded
+   * next time @a icon_theme  is accessed.
+   * @return <tt>true</tt> if the icon theme has changed and needed
+   * to be reloaded.
+   * 
+   * Since: 2.4.
+   */
+  bool rescan_if_needed();
+  
+  /** Registers a built-in icon for icon theme lookups. The idea
+   * of built-in icons is to allow an application or library
+   * that uses themed icons to function requiring files to
+   * be present in the file system. For instance, the default
+   * images for all of GTK+'s stock icons are registered
+   * as built-icons.
+   * 
+   * In general, if you use add_builtin_icon()
+   * you should also install the icon in the icon theme, so
+   * that the icon is generally available.
+   * 
+   * This function will generally be used with pixbufs loaded
+   * via gdk_pixbuf_new_from_inline().
+   * 
+   * Since: 2.4
+   * @param icon_name The name of the icon to register.
+   * @param size The size at which to register the icon (different
+   * images can be registered for the same icon name
+   * at different sizes.).
+   * @param pixbuf Gdk::Pixbuf that contains the image to use
+   * for @a icon_name .
+   */
+  static void add_builtin_icon(const Glib::ustring& icon_name, int size, const Glib::RefPtr<Gdk::Pixbuf>& pixbuf);
+
+  
+  Glib::SignalProxy0< void > signal_changed();
+
+
+public:
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+  virtual void on_changed();
+
+
+};
+
+} // namespace Gtk
+
+
+namespace Glib
+{
+  /** @relates Gtk::IconTheme
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Glib::RefPtr<Gtk::IconTheme> wrap(GtkIconTheme* object, bool take_copy = false);
+}
+
+
+#endif /* _GTKMM_ICONTHEME_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/iconview.cc b/libs/gtkmm2/gtk/gtkmm/iconview.cc
new file mode 100644
index 0000000000..a053eae250
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/iconview.cc
@@ -0,0 +1,695 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/iconview.h>
+#include <gtkmm/private/iconview_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* Copyright 1998-2004 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/adjustment.h> 
+#include <gtk/gtkiconview.h>
+
+namespace //anonymous namespace
+{
+
+void proxy_foreach_callback(GtkIconView* /* icon_view */, GtkTreePath* path, void* data)
+{
+  typedef Gtk::IconView::SlotForeach SlotType;
+  SlotType& slot = *static_cast<SlotType*>(data);
+
+  try
+  {
+    slot(Gtk::TreeModel::Path(path, true));
+  }
+  catch(...)
+  {
+    Glib::exception_handlers_invoke();
+  }
+}
+
+} //anonymous namespace
+
+
+namespace Gtk
+{
+
+//Allow the generated code to work without the prefix:
+typedef IconView::ArrayHandle_TreePaths ArrayHandle_TreePaths;
+
+void IconView::selected_foreach(const SlotForeach& slot)
+{
+  SlotForeach slot_copy(slot);
+  gtk_icon_view_selected_foreach(const_cast<GtkIconView*>(gobj()), &proxy_foreach_callback, &slot_copy);
+}
+  
+
+} // namespace Gtk
+
+
+namespace
+{
+
+void IconView_signal_set_scroll_adjustments_callback(GtkIconView* self, GtkAdjustment* p0,GtkAdjustment* p1,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,Adjustment*,Adjustment* > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(Glib::wrap(p0)
+, Glib::wrap(p1)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+}
+
+const Glib::SignalProxyInfo IconView_signal_set_scroll_adjustments_info =
+{
+  "set_scroll_adjustments",
+  (GCallback) &IconView_signal_set_scroll_adjustments_callback,
+  (GCallback) &IconView_signal_set_scroll_adjustments_callback
+};
+
+
+void IconView_signal_item_activated_callback(GtkIconView* self, GtkTreePath* p0,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,const TreeModel::Path& > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(Gtk::TreePath(p0, true)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+}
+
+const Glib::SignalProxyInfo IconView_signal_item_activated_info =
+{
+  "item_activated",
+  (GCallback) &IconView_signal_item_activated_callback,
+  (GCallback) &IconView_signal_item_activated_callback
+};
+
+
+const Glib::SignalProxyInfo IconView_signal_selection_changed_info =
+{
+  "selection_changed",
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
+};
+
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Gtk::IconView* wrap(GtkIconView* object, bool take_copy)
+{
+  return dynamic_cast<Gtk::IconView *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& IconView_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &IconView_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_icon_view_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void IconView_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+  klass->set_scroll_adjustments = &set_scroll_adjustments_callback;
+  klass->item_activated = &item_activated_callback;
+  klass->selection_changed = &selection_changed_callback;
+}
+
+
+void IconView_Class::set_scroll_adjustments_callback(GtkIconView* self, GtkAdjustment* p0, GtkAdjustment* p1)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_set_scroll_adjustments(Glib::wrap(p0)
+, Glib::wrap(p1)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->set_scroll_adjustments)
+      (*base->set_scroll_adjustments)(self, p0, p1);
+  }
+}
+
+void IconView_Class::item_activated_callback(GtkIconView* self, GtkTreePath* p0)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_item_activated(Gtk::TreePath(p0, true)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->item_activated)
+      (*base->item_activated)(self, p0);
+  }
+}
+
+void IconView_Class::selection_changed_callback(GtkIconView* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_selection_changed();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->selection_changed)
+      (*base->selection_changed)(self);
+  }
+}
+
+
+Glib::ObjectBase* IconView_Class::wrap_new(GObject* o)
+{
+  return manage(new IconView((GtkIconView*)(o)));
+
+}
+
+
+/* The implementation: */
+
+IconView::IconView(const Glib::ConstructParams& construct_params)
+:
+  Gtk::Container(construct_params)
+{
+  }
+
+IconView::IconView(GtkIconView* castitem)
+:
+  Gtk::Container((GtkContainer*)(castitem))
+{
+  }
+
+IconView::~IconView()
+{
+  destroy_();
+}
+
+IconView::CppClassType IconView::iconview_class_; // initialize static member
+
+GType IconView::get_type()
+{
+  return iconview_class_.init().get_type();
+}
+
+GType IconView::get_base_type()
+{
+  return gtk_icon_view_get_type();
+}
+
+
+IconView::IconView()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Container(Glib::ConstructParams(iconview_class_.init()))
+{
+  }
+
+IconView::IconView(const Glib::RefPtr<TreeModel>& model)
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Container(Glib::ConstructParams(iconview_class_.init(), "model", Glib::unwrap(model), (char*) 0))
+{
+  }
+
+void IconView::set_model(const Glib::RefPtr<TreeModel>& model)
+{
+  gtk_icon_view_set_model(gobj(), Glib::unwrap(model));
+}
+
+Glib::RefPtr<TreeModel> IconView::get_model()
+{
+  return Glib::wrap(gtk_icon_view_get_model(gobj()));
+}
+
+Glib::RefPtr<const TreeModel> IconView::get_model() const
+{
+  return Glib::wrap(gtk_icon_view_get_model(const_cast<GtkIconView*>(gobj())));
+}
+
+void IconView::set_text_column(int column)
+{
+  gtk_icon_view_set_text_column(gobj(), column);
+}
+
+void IconView::set_text_column(const TreeModelColumnBase& model_column)
+{
+  gtk_icon_view_set_text_column(gobj(), (model_column).index());
+}
+
+int IconView::get_text_column() const
+{
+  return gtk_icon_view_get_text_column(const_cast<GtkIconView*>(gobj()));
+}
+
+void IconView::set_markup_column(int column)
+{
+  gtk_icon_view_set_markup_column(gobj(), column);
+}
+
+void IconView::set_markup_column(const TreeModelColumnBase& column)
+{
+  gtk_icon_view_set_markup_column(gobj(), (column).index());
+}
+
+int IconView::get_markup_column() const
+{
+  return gtk_icon_view_get_markup_column(const_cast<GtkIconView*>(gobj()));
+}
+
+void IconView::set_pixbuf_column(int column)
+{
+  gtk_icon_view_set_pixbuf_column(gobj(), column);
+}
+
+void IconView::set_pixbuf_column(const TreeModelColumnBase& column)
+{
+  gtk_icon_view_set_pixbuf_column(gobj(), (column).index());
+}
+
+int IconView::get_pixbuf_column() const
+{
+  return gtk_icon_view_get_pixbuf_column(const_cast<GtkIconView*>(gobj()));
+}
+
+void IconView::set_orientation(Orientation orientation)
+{
+  gtk_icon_view_set_orientation(gobj(), ((GtkOrientation)(orientation)));
+}
+
+Orientation IconView::get_orientation() const
+{
+  return ((Orientation)(gtk_icon_view_get_orientation(const_cast<GtkIconView*>(gobj()))));
+}
+
+void IconView::set_columns(int columns)
+{
+  gtk_icon_view_set_columns(gobj(), columns);
+}
+
+int IconView::get_columns() const
+{
+  return gtk_icon_view_get_columns(const_cast<GtkIconView*>(gobj()));
+}
+
+void IconView::set_item_width(int item_width)
+{
+  gtk_icon_view_set_item_width(gobj(), item_width);
+}
+
+int IconView::get_icon_width() const
+{
+  return gtk_icon_view_get_item_width(const_cast<GtkIconView*>(gobj()));
+}
+
+void IconView::set_spacing(int spacing)
+{
+  gtk_icon_view_set_spacing(gobj(), spacing);
+}
+
+int IconView::get_spacing() const
+{
+  return gtk_icon_view_get_spacing(const_cast<GtkIconView*>(gobj()));
+}
+
+void IconView::set_row_spacing(int row_spacing)
+{
+  gtk_icon_view_set_row_spacing(gobj(), row_spacing);
+}
+
+gint IconView::get_row_spacing() const
+{
+  return gtk_icon_view_get_row_spacing(const_cast<GtkIconView*>(gobj()));
+}
+
+void IconView::set_column_spacing(int column_spacing)
+{
+  gtk_icon_view_set_column_spacing(gobj(), column_spacing);
+}
+
+int IconView::get_column_spacing() const
+{
+  return gtk_icon_view_get_column_spacing(const_cast<GtkIconView*>(gobj()));
+}
+
+void IconView::set_margin(int margin)
+{
+  gtk_icon_view_set_margin(gobj(), margin);
+}
+
+int IconView::get_margin() const
+{
+  return gtk_icon_view_get_margin(const_cast<GtkIconView*>(gobj()));
+}
+
+TreeModel::Path IconView::get_path_at_pos(int x, int y) const
+{
+  return Gtk::TreePath(gtk_icon_view_get_path_at_pos(const_cast<GtkIconView*>(gobj()), x, y), false);
+}
+
+void IconView::set_selection_mode(SelectionMode mode)
+{
+  gtk_icon_view_set_selection_mode(gobj(), ((GtkSelectionMode)(mode)));
+}
+
+SelectionMode IconView::get_selection_mode() const
+{
+  return ((SelectionMode)(gtk_icon_view_get_selection_mode(const_cast<GtkIconView*>(gobj()))));
+}
+
+void IconView::select_path(const TreeModel::Path& path)
+{
+  gtk_icon_view_select_path(gobj(), const_cast<GtkTreePath*>((path).gobj()));
+}
+
+void IconView::unselect_path(const TreeModel::Path& path)
+{
+  gtk_icon_view_unselect_path(gobj(), const_cast<GtkTreePath*>((path).gobj()));
+}
+
+bool IconView::path_is_selected(const TreeModel::Path& path) const
+{
+  return gtk_icon_view_path_is_selected(const_cast<GtkIconView*>(gobj()), const_cast<GtkTreePath*>((path).gobj()));
+}
+
+ArrayHandle_TreePaths IconView::get_selected_items() const
+{
+  return ArrayHandle_TreePaths(gtk_icon_view_get_selected_items(const_cast<GtkIconView*>(gobj())), Glib::OWNERSHIP_SHALLOW);
+}
+
+void IconView::select_all()
+{
+  gtk_icon_view_select_all(gobj());
+}
+
+void IconView::unselect_all()
+{
+  gtk_icon_view_unselect_all(gobj());
+}
+
+void IconView::item_activated(const TreeModel::Path& path)
+{
+  gtk_icon_view_item_activated(gobj(), const_cast<GtkTreePath*>((path).gobj()));
+}
+
+
+Glib::SignalProxy2< void,Adjustment*,Adjustment* > IconView::signal_set_scroll_adjustments()
+{
+  return Glib::SignalProxy2< void,Adjustment*,Adjustment* >(this, &IconView_signal_set_scroll_adjustments_info);
+}
+
+Glib::SignalProxy1< void,const TreeModel::Path& > IconView::signal_item_activated()
+{
+  return Glib::SignalProxy1< void,const TreeModel::Path& >(this, &IconView_signal_item_activated_info);
+}
+
+Glib::SignalProxy0< void > IconView::signal_selection_changed()
+{
+  return Glib::SignalProxy0< void >(this, &IconView_signal_selection_changed_info);
+}
+
+
+Glib::PropertyProxy<int> IconView::property_pixbuf_column() 
+{
+  return Glib::PropertyProxy<int>(this, "pixbuf-column");
+}
+
+Glib::PropertyProxy_ReadOnly<int> IconView::property_pixbuf_column() const
+{
+  return Glib::PropertyProxy_ReadOnly<int>(this, "pixbuf-column");
+}
+
+Glib::PropertyProxy<int> IconView::property_text_column() 
+{
+  return Glib::PropertyProxy<int>(this, "text-column");
+}
+
+Glib::PropertyProxy_ReadOnly<int> IconView::property_text_column() const
+{
+  return Glib::PropertyProxy_ReadOnly<int>(this, "text-column");
+}
+
+Glib::PropertyProxy<int> IconView::property_markup_column() 
+{
+  return Glib::PropertyProxy<int>(this, "markup-column");
+}
+
+Glib::PropertyProxy_ReadOnly<int> IconView::property_markup_column() const
+{
+  return Glib::PropertyProxy_ReadOnly<int>(this, "markup-column");
+}
+
+Glib::PropertyProxy<SelectionMode> IconView::property_selection_mode() 
+{
+  return Glib::PropertyProxy<SelectionMode>(this, "selection-mode");
+}
+
+Glib::PropertyProxy_ReadOnly<SelectionMode> IconView::property_selection_mode() const
+{
+  return Glib::PropertyProxy_ReadOnly<SelectionMode>(this, "selection-mode");
+}
+
+Glib::PropertyProxy<Orientation> IconView::property_orientation() 
+{
+  return Glib::PropertyProxy<Orientation>(this, "orientation");
+}
+
+Glib::PropertyProxy_ReadOnly<Orientation> IconView::property_orientation() const
+{
+  return Glib::PropertyProxy_ReadOnly<Orientation>(this, "orientation");
+}
+
+Glib::PropertyProxy< Glib::RefPtr<TreeModel> > IconView::property_model() 
+{
+  return Glib::PropertyProxy< Glib::RefPtr<TreeModel> >(this, "model");
+}
+
+Glib::PropertyProxy_ReadOnly< Glib::RefPtr<TreeModel> > IconView::property_model() const
+{
+  return Glib::PropertyProxy_ReadOnly< Glib::RefPtr<TreeModel> >(this, "model");
+}
+
+Glib::PropertyProxy<int> IconView::property_columns() 
+{
+  return Glib::PropertyProxy<int>(this, "columns");
+}
+
+Glib::PropertyProxy_ReadOnly<int> IconView::property_columns() const
+{
+  return Glib::PropertyProxy_ReadOnly<int>(this, "columns");
+}
+
+Glib::PropertyProxy<int> IconView::property_item_width() 
+{
+  return Glib::PropertyProxy<int>(this, "item-width");
+}
+
+Glib::PropertyProxy_ReadOnly<int> IconView::property_item_width() const
+{
+  return Glib::PropertyProxy_ReadOnly<int>(this, "item-width");
+}
+
+Glib::PropertyProxy<int> IconView::property_spacing() 
+{
+  return Glib::PropertyProxy<int>(this, "spacing");
+}
+
+Glib::PropertyProxy_ReadOnly<int> IconView::property_spacing() const
+{
+  return Glib::PropertyProxy_ReadOnly<int>(this, "spacing");
+}
+
+Glib::PropertyProxy<int> IconView::property_row_spacing() 
+{
+  return Glib::PropertyProxy<int>(this, "row-spacing");
+}
+
+Glib::PropertyProxy_ReadOnly<int> IconView::property_row_spacing() const
+{
+  return Glib::PropertyProxy_ReadOnly<int>(this, "row-spacing");
+}
+
+Glib::PropertyProxy<int> IconView::property_column_spacing() 
+{
+  return Glib::PropertyProxy<int>(this, "column-spacing");
+}
+
+Glib::PropertyProxy_ReadOnly<int> IconView::property_column_spacing() const
+{
+  return Glib::PropertyProxy_ReadOnly<int>(this, "column-spacing");
+}
+
+Glib::PropertyProxy<int> IconView::property_margin() 
+{
+  return Glib::PropertyProxy<int>(this, "margin");
+}
+
+Glib::PropertyProxy_ReadOnly<int> IconView::property_margin() const
+{
+  return Glib::PropertyProxy_ReadOnly<int>(this, "margin");
+}
+
+
+void Gtk::IconView::on_set_scroll_adjustments(Adjustment* hadjustment, Adjustment* vadjustment)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->set_scroll_adjustments)
+    (*base->set_scroll_adjustments)(gobj(),(GtkAdjustment*)Glib::unwrap(hadjustment),(GtkAdjustment*)Glib::unwrap(vadjustment));
+}
+
+void Gtk::IconView::on_item_activated(const TreeModel::Path& path)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->item_activated)
+    (*base->item_activated)(gobj(),const_cast<GtkTreePath*>((path).gobj()));
+}
+
+void Gtk::IconView::on_selection_changed()
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->selection_changed)
+    (*base->selection_changed)(gobj());
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/iconview.h b/libs/gtkmm2/gtk/gtkmm/iconview.h
new file mode 100644
index 0000000000..26fc442662
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/iconview.h
@@ -0,0 +1,596 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_ICONVIEW_H
+#define _GTKMM_ICONVIEW_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* iconview.h
+ * 
+ * Copyright (C) 1998-2004 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+
+#include <gtkmm/container.h>
+#include <gtkmm/treemodel.h>
+#include <gtkmm/treepath.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkIconView GtkIconView;
+typedef struct _GtkIconViewClass GtkIconViewClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class IconView_Class; } // namespace Gtk
+namespace Gtk
+{
+
+/** TODO
+ *
+ * @ingroup Widgets
+ * @ingroup Containers
+ */
+
+class IconView : public Container
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef IconView CppObjectType;
+  typedef IconView_Class CppClassType;
+  typedef GtkIconView BaseObjectType;
+  typedef GtkIconViewClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~IconView();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class IconView_Class;
+  static CppClassType iconview_class_;
+
+  // noncopyable
+  IconView(const IconView&);
+  IconView& operator=(const IconView&);
+
+protected:
+  explicit IconView(const Glib::ConstructParams& construct_params);
+  explicit IconView(GtkIconView* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GtkIconView*       gobj()       { return reinterpret_cast<GtkIconView*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GtkIconView* gobj() const { return reinterpret_cast<GtkIconView*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+  virtual void on_set_scroll_adjustments(Adjustment* hadjustment, Adjustment* vadjustment);
+  virtual void on_item_activated(const TreeModel::Path& path);
+  virtual void on_selection_changed();
+
+
+private:
+
+public:
+
+  IconView();
+  explicit IconView(const Glib::RefPtr<TreeModel>& model);
+
+
+  /** Sets the model for a Gtk::IconView.  
+   * If the @a icon_view  already has a model set, it will remove 
+   * it before setting the new model.  If @a model  is <tt>0</tt>, then
+   * it will unset the old model.
+   * 
+   * Since: 2.6
+   * @param model The model.
+   */
+  void set_model(const Glib::RefPtr<TreeModel>& model);
+  
+  /** Returns the model the Gtk::IconView is based on.  Returns <tt>0</tt> if the
+   * model is unset.
+   * @return A Gtk::TreeModel, or <tt>0</tt> if none is currently being used.
+   * 
+   * Since: 2.6.
+   */
+  Glib::RefPtr<TreeModel> get_model();
+  
+  /** Returns the model the Gtk::IconView is based on.  Returns <tt>0</tt> if the
+   * model is unset.
+   * @return A Gtk::TreeModel, or <tt>0</tt> if none is currently being used.
+   * 
+   * Since: 2.6.
+   */
+  Glib::RefPtr<const TreeModel> get_model() const;
+
+  
+  /** Sets the column with text for @a icon_view  to be @a column . The text
+   * column must be of type G::TYPE_STRING.
+   * 
+   * Since: 2.6
+   * @param column A column in the currently used model.
+   */
+  void set_text_column(int column);
+  
+  /** Sets the column with text for @a icon_view  to be @a column . The text
+   * column must be of type G::TYPE_STRING.
+   * 
+   * Since: 2.6
+   * @param column A column in the currently used model.
+   */
+  void set_text_column(const TreeModelColumnBase& model_column);
+  
+  /** Returns the column with text for @a icon_view .
+   * @return The text column, or -1 if it's unset.
+   * 
+   * Since: 2.6.
+   */
+  int get_text_column() const;
+  
+  /** Sets the column with markup information for @a icon_view  to be
+   *  @a column . The markup column must be of type G::TYPE_STRING.
+   * If the markup column is set to something, it overrides
+   * the text column set by set_text_column().
+   * 
+   * Since: 2.6
+   * @param column A column in the currently used model.
+   */
+  void set_markup_column(int column);
+  
+  /** Sets the column with markup information for @a icon_view  to be
+   *  @a column . The markup column must be of type G::TYPE_STRING.
+   * If the markup column is set to something, it overrides
+   * the text column set by set_text_column().
+   * 
+   * Since: 2.6
+   * @param column A column in the currently used model.
+   */
+  void set_markup_column(const TreeModelColumnBase& column); 
+  
+  /** Returns the column with markup text for @a icon_view .
+   * @return The markup column, or -1 if it's unset.
+   * 
+   * Since: 2.6.
+   */
+  int get_markup_column() const;
+  
+  /** Sets the column with pixbufs for @a icon_view  to be @a column . The pixbuf
+   * column must be of type Gdk::TYPE_PIXBUF
+   * 
+   * Since: 2.6
+   * @param column A column in the currently used model.
+   */
+  void set_pixbuf_column(int column);
+  
+  /** Sets the column with pixbufs for @a icon_view  to be @a column . The pixbuf
+   * column must be of type Gdk::TYPE_PIXBUF
+   * 
+   * Since: 2.6
+   * @param column A column in the currently used model.
+   */
+  void set_pixbuf_column(const TreeModelColumnBase& column);  
+  
+  /** Returns the column with pixbufs for @a icon_view .
+   * @return The pixbuf column, or -1 if it's unset.
+   * 
+   * Since: 2.6.
+   */
+  int get_pixbuf_column() const;
+
+  
+  /** Sets the ::orientation property which determines whether the labels 
+   * are drawn beside the icons instead of below.
+   * 
+   * Since: 2.6
+   * @param orientation The relative position of texts and icons.
+   */
+  void set_orientation(Orientation orientation);
+  
+  /** Returns the value of the ::orientation property which determines 
+   * whether the labels are drawn beside the icons instead of below.
+   * @return The relative position of texts and icons 
+   * 
+   * Since: 2.6.
+   */
+  Orientation get_orientation() const;
+
+  
+  void set_columns(int columns);
+  
+  int get_columns() const;
+  
+  void set_item_width(int item_width);
+  
+  int get_icon_width() const;
+  
+  void set_spacing(int spacing);
+  
+  int get_spacing() const;
+  
+  void set_row_spacing(int row_spacing);
+  
+  gint get_row_spacing() const;
+  
+  void set_column_spacing(int column_spacing);
+  
+  int get_column_spacing() const;
+
+  
+  void set_margin(int margin);
+  
+  int get_margin() const;
+
+  
+  /** Finds the path at the point ( @a x , @a y ), relative to widget coordinates.
+   * @param x The x position to be identified.
+   * @param y The y position to be identified.
+   * @return The Gtk::TreePath corresponding to the icon or <tt>0</tt>
+   * if no icon exists at that position.
+   * 
+   * Since: 2.6.
+   */
+  TreeModel::Path get_path_at_pos(int x, int y) const;
+
+  /** For instance, 
+   * void on_foreach(const Gtk::TreeModel::Path& path);
+   */
+  typedef sigc::slot<void, const TreeModel::Path&> SlotForeach;
+
+  /** Calls a function for each selected icon. Note that the model or
+  * selection cannot be modified from within this function.
+  *
+  * @param slot The callback to call for each selected icon.
+  */
+  void selected_foreach(const SlotForeach& slot);
+  
+
+//Default value?:
+  
+  /** Sets the selection mode of the @a icon_view .
+   * 
+   * Since: 2.6
+   * @param mode The selection mode.
+   */
+  void set_selection_mode(SelectionMode mode);
+  
+  /** Gets the selection mode of the @a icon_view .
+   * @return The current selection mode
+   * 
+   * Since: 2.6.
+   */
+  SelectionMode get_selection_mode() const;
+  
+  /** Selects the row at @a path .
+   * 
+   * Since: 2.6
+   * @param path The Gtk::TreePath to be selected.
+   */
+  void select_path(const TreeModel::Path& path);
+  
+  /** Unselects the row at @a path .
+   * 
+   * Since: 2.6
+   * @param path The Gtk::TreePath to be unselected.
+   */
+  void unselect_path(const TreeModel::Path& path);
+  
+  /** Returns <tt>true</tt> if the icon pointed to by @a path  is currently
+   * selected. If @a icon  does not point to a valid location, <tt>false</tt> is returned.
+   * @param path A Gtk::TreePath to check selection on.
+   * @return <tt>true</tt> if @a path  is selected.
+   * 
+   * Since: 2.6.
+   */
+  bool path_is_selected(const TreeModel::Path& path) const;
+  
+  
+  #ifndef DOXYGEN_SHOULD_SKIP_THIS
+  //TODO: I'm not sure about these to_*() functions. murrayc.
+  struct TreePathTraits
+  {
+    typedef TreePath  CppType;
+    typedef const GtkTreePath* CType;
+    typedef GtkTreePath*    CTypeNonConst;
+
+    static CType   to_c_type      (const CppType& obj) { return obj.gobj(); }
+    static CType   to_c_type      (const CType&   obj) { return obj; }
+    static CppType to_cpp_type    (const CType&   obj) { return CppType(const_cast<CTypeNonConst>(obj), true); }
+    static void    release_c_type (const CType&)       {}
+  };
+  #endif //DOXYGEN_SHOULD_SKIP_THIS
+
+  typedef Glib::ListHandle<TreePath, TreePathTraits> ArrayHandle_TreePaths;
+
+  
+  /** Creates a list of paths of all selected items. Additionally, if you are
+   * planning on modifying the model after calling this function, you may
+   * want to convert the returned list into a list of Gtk::TreeRowReference&lt;!-- --&gt;s.
+   * To do this, you can use Gtk::Tree::row_reference_new().
+   * 
+   * To free the return value, use:
+   * @code
+   * g_list_foreach (list, gtk_tree_path_free, <tt>0</tt>);
+   * g_list_free (list);
+   * @endcode
+   * @return A G::List containing a Gtk::TreePath for each selected row.
+   * 
+   * Since: 2.6.
+   */
+  ArrayHandle_TreePaths get_selected_items() const;
+  
+  
+  /** Selects all the icons. @a icon_view  must has its selection mode set
+   * to Gtk::SELECTION_MULTIPLE.
+   * 
+   * Since: 2.6
+   */
+  void select_all();
+  
+  /** Unselects all the icons.
+   * 
+   * Since: 2.6
+   */
+  void unselect_all();
+  
+  /** Activates the item determined by @a path .
+   * 
+   * Since: 2.6
+   * @param path The Gtk::TreePath to be activated.
+   */
+  void item_activated(const TreeModel::Path& path);
+
+  
+  Glib::SignalProxy2< void,Adjustment*,Adjustment* > signal_set_scroll_adjustments();
+ 
+  
+  Glib::SignalProxy1< void,const TreeModel::Path& > signal_item_activated();
+
+  
+  Glib::SignalProxy0< void > signal_selection_changed();
+
+
+  /* Key binding signals */
+  
+  
+  /** Model column used to retrieve the icon pixbuf from.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<int> property_pixbuf_column() ;
+
+/** Model column used to retrieve the icon pixbuf from.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<int> property_pixbuf_column() const;
+
+  /** Model column used to retrieve the text from.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<int> property_text_column() ;
+
+/** Model column used to retrieve the text from.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<int> property_text_column() const;
+
+  /** Model column used to retrieve the text if using Pango markup.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<int> property_markup_column() ;
+
+/** Model column used to retrieve the text if using Pango markup.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<int> property_markup_column() const;
+
+  /** The selection mode.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<SelectionMode> property_selection_mode() ;
+
+/** The selection mode.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<SelectionMode> property_selection_mode() const;
+
+  /** How the text and icon of each item are positioned relative to each other.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Orientation> property_orientation() ;
+
+/** How the text and icon of each item are positioned relative to each other.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Orientation> property_orientation() const;
+
+  /** The model for the icon view.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy< Glib::RefPtr<TreeModel> > property_model() ;
+
+/** The model for the icon view.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly< Glib::RefPtr<TreeModel> > property_model() const;
+
+  /** Number of columns to display.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<int> property_columns() ;
+
+/** Number of columns to display.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<int> property_columns() const;
+
+  /** The width used for each item.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<int> property_item_width() ;
+
+/** The width used for each item.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<int> property_item_width() const;
+
+  /** Space which is inserted between cells of an item.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<int> property_spacing() ;
+
+/** Space which is inserted between cells of an item.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<int> property_spacing() const;
+
+  /** Space which is inserted between grid rows.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<int> property_row_spacing() ;
+
+/** Space which is inserted between grid rows.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<int> property_row_spacing() const;
+
+  /** Space which is inserted between grid column.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<int> property_column_spacing() ;
+
+/** Space which is inserted between grid column.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<int> property_column_spacing() const;
+
+  /** Space which is inserted at the edges of the icon view.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<int> property_margin() ;
+
+/** Space which is inserted at the edges of the icon view.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<int> property_margin() const;
+
+
+};
+
+} // namespace Gtk
+
+
+namespace Glib
+{
+  /** @relates Gtk::IconView
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gtk::IconView* wrap(GtkIconView* object, bool take_copy = false);
+}
+#endif /* _GTKMM_ICONVIEW_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/image.cc b/libs/gtkmm2/gtk/gtkmm/image.cc
new file mode 100644
index 0000000000..8152af1f7e
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/image.cc
@@ -0,0 +1,446 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/image.h>
+#include <gtkmm/private/image_p.h>
+
+#include <gtk/gtktypebuiltins.h>
+// -*- c++ -*-
+/* $Id$ */
+
+/* 
+ *
+ * Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtk/gtkimage.h>
+#include <gdkmm/image.h>
+#include <gdkmm/bitmap.h>
+#include <gdkmm/pixmap.h>
+
+namespace Gtk
+{
+
+Image::Image(const Gtk::StockID& stock_id, IconSize size)
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Misc(Glib::ConstructParams(image_class_.init(), "stock",stock_id.get_c_str(),"icon-size",(GtkIconSize) int(size), (char*) 0))
+{}
+
+Image::Image(IconSet& icon_set, IconSize size)
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Misc(Glib::ConstructParams(image_class_.init(), "icon-set",icon_set.gobj(),"icon-size",(GtkIconSize) int(size), (char*) 0))
+{}
+
+Image::Image(const Glib::RefPtr<Gdk::PixbufAnimation>& animation)
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Misc(Glib::ConstructParams(image_class_.init(), "pixbuf-animation",Glib::unwrap(animation), (char*) 0))
+{}
+
+void Image::get_pixmap(Glib::RefPtr<Gdk::Pixmap>& pixmap, Glib::RefPtr<Gdk::Bitmap>& mask) const
+{
+  GdkPixmap* pPixmap = 0;
+  GdkBitmap* pBitmap = 0;
+
+  gtk_image_get_pixmap(const_cast<GtkImage*>(gobj()), &pPixmap, &pBitmap);
+
+  pixmap = Glib::wrap((GdkPixmapObject*) pPixmap, true);
+  mask   = Glib::RefPtr<Gdk::Bitmap>::cast_dynamic(Glib::wrap((GdkPixmapObject*) pBitmap, true));
+}
+
+void Image::get_image(Glib::RefPtr<Gdk::Image>& gdk_image, Glib::RefPtr<Gdk::Bitmap>& mask) const
+{
+  GdkImage* pImage = 0;
+  GdkBitmap* pBitmap = 0;
+
+  gtk_image_get_image(const_cast<GtkImage*>(gobj()), &pImage, &pBitmap);
+
+  gdk_image = Glib::wrap(pImage, true);
+  mask = Glib::RefPtr<Gdk::Bitmap>::cast_dynamic(Glib::wrap((GdkPixmapObject*) pBitmap, true));
+}
+
+void Image::get_stock(Gtk::StockID& stock_id, IconSize& size) const
+{
+  char* pStockID = 0; // GTK+ iconsistency: although not const, it should not be freed.
+  GtkIconSize icon_size = GTK_ICON_SIZE_INVALID;
+
+  gtk_image_get_stock(const_cast<GtkImage*>(gobj()), &pStockID, &icon_size);
+
+  size = IconSize(static_cast<int>(icon_size));
+  stock_id = Gtk::StockID(pStockID); // the StockID ctor checks for 0
+}
+
+void Image::get_icon_set(IconSet& icon_set, IconSize& size) const
+{
+  GtkIconSet* pIconSet = 0;
+  GtkIconSize icon_size = GTK_ICON_SIZE_INVALID;
+
+  gtk_image_get_icon_set(const_cast<GtkImage*>(gobj()), &pIconSet, &icon_size);
+
+  size = IconSize(static_cast<int>(icon_size));
+  icon_set = Glib::wrap(pIconSet, true); //true = take_copy.
+}
+
+void Image::clear()
+{
+  gtk_image_set_from_pixbuf(gobj(), 0);
+}
+
+Glib::ustring Image::get_icon_name() const
+{
+  const gchar* pchIconName = 0;
+  gtk_image_get_icon_name(const_cast<GtkImage*>(gobj()), &pchIconName, 0);
+  return Glib::convert_const_gchar_ptr_to_ustring(pchIconName);
+}
+
+Glib::ustring Image::get_icon_name(IconSize& size)
+{
+  const gchar* pchIconName = 0;
+  GtkIconSize cIconSize = GTK_ICON_SIZE_INVALID;
+  gtk_image_get_icon_name(const_cast<GtkImage*>(gobj()), &pchIconName, &cIconSize);
+  size = (IconSize)cIconSize;
+  return Glib::convert_const_gchar_ptr_to_ustring(pchIconName);
+}
+
+} // namespace Gtk
+
+
+namespace
+{
+} // anonymous namespace
+
+// static
+GType Glib::Value<Gtk::ImageType>::value_type()
+{
+  return gtk_image_type_get_type();
+}
+
+
+namespace Glib
+{
+
+Gtk::Image* wrap(GtkImage* object, bool take_copy)
+{
+  return dynamic_cast<Gtk::Image *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& Image_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &Image_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_image_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void Image_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+}
+
+
+Glib::ObjectBase* Image_Class::wrap_new(GObject* o)
+{
+  return manage(new Image((GtkImage*)(o)));
+
+}
+
+
+/* The implementation: */
+
+Image::Image(const Glib::ConstructParams& construct_params)
+:
+  Gtk::Misc(construct_params)
+{
+  }
+
+Image::Image(GtkImage* castitem)
+:
+  Gtk::Misc((GtkMisc*)(castitem))
+{
+  }
+
+Image::~Image()
+{
+  destroy_();
+}
+
+Image::CppClassType Image::image_class_; // initialize static member
+
+GType Image::get_type()
+{
+  return image_class_.init().get_type();
+}
+
+GType Image::get_base_type()
+{
+  return gtk_image_get_type();
+}
+
+
+Image::Image()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Misc(Glib::ConstructParams(image_class_.init()))
+{
+  }
+
+Image::Image(const Glib::RefPtr<Gdk::Pixmap>& pixmap, const Glib::RefPtr<Gdk::Bitmap>& mask)
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Misc(Glib::ConstructParams(image_class_.init(), "pixmap", Glib::unwrap(pixmap), "mask", Glib::unwrap(mask), (char*) 0))
+{
+  }
+
+Image::Image(const Glib::RefPtr<Gdk::Image>& image, const Glib::RefPtr<Gdk::Bitmap>& mask)
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Misc(Glib::ConstructParams(image_class_.init(), "image", Glib::unwrap(image), "mask", Glib::unwrap(mask), (char*) 0))
+{
+  }
+
+Image::Image(const std::string& file)
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Misc(Glib::ConstructParams(image_class_.init(), "file", file.c_str(), (char*) 0))
+{
+  }
+
+Image::Image(const Glib::RefPtr<Gdk::Pixbuf>& pixbuf)
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Misc(Glib::ConstructParams(image_class_.init(), "pixbuf", Glib::unwrap(pixbuf), (char*) 0))
+{
+  }
+
+void Image::set(const Glib::RefPtr<Gdk::Pixmap>& pixmap, const Glib::RefPtr<Gdk::Bitmap>& mask)
+{
+  gtk_image_set_from_pixmap(gobj(), Glib::unwrap(pixmap), Glib::unwrap(mask));
+}
+
+void Image::set(const Glib::RefPtr<Gdk::Image>& gdk_image, const Glib::RefPtr<Gdk::Bitmap>& mask)
+{
+  gtk_image_set_from_image(gobj(), Glib::unwrap(gdk_image), Glib::unwrap(mask));
+}
+
+void Image::set(const std::string& filename)
+{
+  gtk_image_set_from_file(gobj(), filename.c_str());
+}
+
+void Image::set(const Glib::RefPtr<Gdk::Pixbuf>& pixbuf)
+{
+  gtk_image_set_from_pixbuf(gobj(), Glib::unwrap(pixbuf));
+}
+
+void Image::set(const Gtk::StockID& stock_id, IconSize size)
+{
+  gtk_image_set_from_stock(gobj(), (stock_id).get_c_str(), static_cast<GtkIconSize>(int(size)));
+}
+
+void Image::set(IconSet& icon_set, IconSize size)
+{
+  gtk_image_set_from_icon_set(gobj(), (icon_set).gobj(), static_cast<GtkIconSize>(int(size)));
+}
+
+void Image::set(const Glib::RefPtr<Gdk::PixbufAnimation>& animation)
+{
+  gtk_image_set_from_animation(gobj(), Glib::unwrap(animation));
+}
+
+void Image::set_from_icon_name(const Glib::ustring& icon_name, IconSize size)
+{
+  gtk_image_set_from_icon_name(gobj(), icon_name.c_str(), static_cast<GtkIconSize>(int(size)));
+}
+
+ImageType Image::get_storage_type() const
+{
+  return ((ImageType)(gtk_image_get_storage_type(const_cast<GtkImage*>(gobj()))));
+}
+
+Glib::RefPtr<Gdk::Pixbuf> Image::get_pixbuf()
+{
+
+  Glib::RefPtr<Gdk::Pixbuf> retvalue = Glib::wrap(gtk_image_get_pixbuf(gobj()));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::RefPtr<const Gdk::Pixbuf> Image::get_pixbuf() const
+{
+
+  Glib::RefPtr<const Gdk::Pixbuf> retvalue = Glib::wrap(gtk_image_get_pixbuf(const_cast<GtkImage*>(gobj())));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::RefPtr<Gdk::PixbufAnimation> Image::get_animation()
+{
+
+  Glib::RefPtr<Gdk::PixbufAnimation> retvalue = Glib::wrap(gtk_image_get_animation(gobj()));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::RefPtr<const Gdk::PixbufAnimation> Image::get_animation() const
+{
+
+  Glib::RefPtr<const Gdk::PixbufAnimation> retvalue = Glib::wrap(gtk_image_get_animation(const_cast<GtkImage*>(gobj())));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+int Image::get_pixel_size() const
+{
+  return gtk_image_get_pixel_size(const_cast<GtkImage*>(gobj()));
+}
+
+void Image::set_pixel_size(int pixel_size)
+{
+  gtk_image_set_pixel_size(gobj(), pixel_size);
+}
+
+
+Glib::PropertyProxy< Glib::RefPtr<Gdk::Pixbuf> > Image::property_pixbuf() 
+{
+  return Glib::PropertyProxy< Glib::RefPtr<Gdk::Pixbuf> >(this, "pixbuf");
+}
+
+Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::Pixbuf> > Image::property_pixbuf() const
+{
+  return Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::Pixbuf> >(this, "pixbuf");
+}
+
+Glib::PropertyProxy< Glib::RefPtr<Gdk::Pixmap> > Image::property_pixmap() 
+{
+  return Glib::PropertyProxy< Glib::RefPtr<Gdk::Pixmap> >(this, "pixmap");
+}
+
+Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::Pixmap> > Image::property_pixmap() const
+{
+  return Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::Pixmap> >(this, "pixmap");
+}
+
+Glib::PropertyProxy< Glib::RefPtr<Gdk::Image> > Image::property_image() 
+{
+  return Glib::PropertyProxy< Glib::RefPtr<Gdk::Image> >(this, "image");
+}
+
+Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::Image> > Image::property_image() const
+{
+  return Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::Image> >(this, "image");
+}
+
+Glib::PropertyProxy< Glib::RefPtr<Gdk::Pixmap> > Image::property_mask() 
+{
+  return Glib::PropertyProxy< Glib::RefPtr<Gdk::Pixmap> >(this, "mask");
+}
+
+Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::Pixmap> > Image::property_mask() const
+{
+  return Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::Pixmap> >(this, "mask");
+}
+
+Glib::PropertyProxy_WriteOnly<Glib::ustring> Image::property_file() 
+{
+  return Glib::PropertyProxy_WriteOnly<Glib::ustring>(this, "file");
+}
+
+Glib::PropertyProxy_ReadOnly<Glib::ustring> Image::property_file() const
+{
+  return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "file");
+}
+
+Glib::PropertyProxy<Glib::ustring> Image::property_stock() 
+{
+  return Glib::PropertyProxy<Glib::ustring>(this, "stock");
+}
+
+Glib::PropertyProxy_ReadOnly<Glib::ustring> Image::property_stock() const
+{
+  return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "stock");
+}
+
+Glib::PropertyProxy<Gtk::IconSet> Image::property_icon_set() 
+{
+  return Glib::PropertyProxy<Gtk::IconSet>(this, "icon-set");
+}
+
+Glib::PropertyProxy_ReadOnly<Gtk::IconSet> Image::property_icon_set() const
+{
+  return Glib::PropertyProxy_ReadOnly<Gtk::IconSet>(this, "icon-set");
+}
+
+Glib::PropertyProxy<int> Image::property_icon_size() 
+{
+  return Glib::PropertyProxy<int>(this, "icon-size");
+}
+
+Glib::PropertyProxy_ReadOnly<int> Image::property_icon_size() const
+{
+  return Glib::PropertyProxy_ReadOnly<int>(this, "icon-size");
+}
+
+Glib::PropertyProxy< Glib::RefPtr<Gdk::PixbufAnimation> > Image::property_pixbuf_animation() 
+{
+  return Glib::PropertyProxy< Glib::RefPtr<Gdk::PixbufAnimation> >(this, "pixbuf-animation");
+}
+
+Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::PixbufAnimation> > Image::property_pixbuf_animation() const
+{
+  return Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::PixbufAnimation> >(this, "pixbuf-animation");
+}
+
+Glib::PropertyProxy_ReadOnly<ImageType> Image::property_storage_type() const
+{
+  return Glib::PropertyProxy_ReadOnly<ImageType>(this, "storage-type");
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/image.h b/libs/gtkmm2/gtk/gtkmm/image.h
new file mode 100644
index 0000000000..13775a2c92
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/image.h
@@ -0,0 +1,454 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_IMAGE_H
+#define _GTKMM_IMAGE_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* image.h
+ * 
+ * Copyright (C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/misc.h>
+#include <gtkmm/iconset.h>
+#include <gdkmm/pixbufanimation.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkImage GtkImage;
+typedef struct _GtkImageClass GtkImageClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class Image_Class; } // namespace Gtk
+namespace Gtk
+{
+
+
+/** @addtogroup gtkmmEnums Enums and Flags */
+
+/**
+ * @ingroup gtkmmEnums
+ */
+enum ImageType
+{
+  IMAGE_EMPTY,
+  IMAGE_PIXMAP,
+  IMAGE_IMAGE,
+  IMAGE_PIXBUF,
+  IMAGE_STOCK,
+  IMAGE_ICON_SET,
+  IMAGE_ANIMATION,
+  IMAGE_ICON_NAME
+};
+
+} // namespace Gtk
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Gtk::ImageType> : public Glib::Value_Enum<Gtk::ImageType>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{
+
+
+/** A widget displaying an image.
+ *
+ * The Gtk::Image widget displays an image. Various kinds of object can be
+ * displayed as an image; most typically, you would load a Gdk::Pixbuf ("pixel
+ * buffer") from a file, and then display that. 
+ *
+ * Gtk::Image is a subclass of Gtk::Misc, which implies that you can align it
+ * (center, left, right) and add padding to it, using Gtk::Misc methods.
+ *
+ * Gtk::Image is a "no window" widget (has no Gdk::Window of its own), so by
+ * default does not receive events. If you want to receive events on the
+ * image, such as button clicks, place the image inside a Gtk::EventBox, then
+ * connect to the event signals on the event box. 
+ *
+ * @ingroup Widgets
+ */
+
+class Image : public Misc
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Image CppObjectType;
+  typedef Image_Class CppClassType;
+  typedef GtkImage BaseObjectType;
+  typedef GtkImageClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~Image();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class Image_Class;
+  static CppClassType image_class_;
+
+  // noncopyable
+  Image(const Image&);
+  Image& operator=(const Image&);
+
+protected:
+  explicit Image(const Glib::ConstructParams& construct_params);
+  explicit Image(GtkImage* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GtkImage*       gobj()       { return reinterpret_cast<GtkImage*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GtkImage* gobj() const { return reinterpret_cast<GtkImage*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+private:
+
+  
+public:
+
+  Image();
+  explicit Image(const Glib::RefPtr<Gdk::Pixmap>& pixmap, const Glib::RefPtr<Gdk::Bitmap>& mask);
+  explicit Image(const Glib::RefPtr<Gdk::Image>& image, const Glib::RefPtr<Gdk::Bitmap>& mask);
+  explicit Image(const std::string& file);
+  explicit Image(const Glib::RefPtr<Gdk::Pixbuf>& pixbuf);
+  Image(const Gtk::StockID& stock_id, IconSize size);
+  Image(IconSet& icon_set, IconSize size);
+  Image(const Glib::RefPtr<Gdk::PixbufAnimation>& animation);
+  
+
+  /** See new_from_pixmap() for details.
+   * @param pixmap A Gdk::Pixmap or <tt>0</tt>.
+   * @param mask A Gdk::Bitmap or <tt>0</tt>.
+   */
+  void set(const Glib::RefPtr<Gdk::Pixmap>& pixmap, const Glib::RefPtr<Gdk::Bitmap>& mask);
+  
+  /** See new_from_image() for details.
+   * @param gdk_image A Gdk::Image or <tt>0</tt>.
+   * @param mask A Gdk::Bitmap or <tt>0</tt>.
+   */
+  void set(const Glib::RefPtr<Gdk::Image>& gdk_image, const Glib::RefPtr<Gdk::Bitmap>& mask);
+  
+  /** See new_from_file() for details.
+   * @param filename A filename or <tt>0</tt>.
+   */
+  void set(const std::string& filename);
+  
+  /** See new_from_pixbuf() for details.
+   * @param pixbuf A Gdk::Pixbuf or <tt>0</tt>.
+   */
+  void set(const Glib::RefPtr<Gdk::Pixbuf>& pixbuf);
+  
+  /** See new_from_stock() for details.
+   * @param stock_id A stock icon name.
+   * @param size A stock icon size.
+   */
+  void set(const Gtk::StockID& stock_id, IconSize size);
+  
+  /** See new_from_icon_set() for details.
+   * @param icon_set A Gtk::IconSet.
+   * @param size A stock icon size.
+   */
+  void set(IconSet& icon_set, IconSize size);
+  
+  /** Causes the Gtk::Image to display the given animation (or display
+   * nothing, if you set the animation to <tt>0</tt>).
+   * @param animation The Gdk::PixbufAnimation.
+   */
+  void set(const Glib::RefPtr<Gdk::PixbufAnimation>& animation);
+  
+  /** See new_from_icon_name() for details.
+   * 
+   * Since: 2.6
+   * @param icon_name An icon name.
+   * @param size An icon size.
+   */
+  void set_from_icon_name(const Glib::ustring& icon_name, IconSize size);
+
+  void clear();
+
+  
+  /** Gets the type of representation being used by the Gtk::Image
+   * to store image data. If the Gtk::Image has no image data,
+   * the return value will be Gtk::IMAGE_EMPTY.
+   * @return Image representation being used.
+   */
+  ImageType get_storage_type() const;
+
+  void get_pixmap(Glib::RefPtr<Gdk::Pixmap>& pixmap, Glib::RefPtr<Gdk::Bitmap>& mask) const;
+  void get_image(Glib::RefPtr<Gdk::Image>& gdk_image, Glib::RefPtr<Gdk::Bitmap>& mask) const;
+  
+  /** Gets the Gdk::Pixbuf being displayed by the Gtk::Image.
+   * The storage type of the image must be Gtk::IMAGE_EMPTY or
+   * Gtk::IMAGE_PIXBUF (see get_storage_type()).
+   * The caller of this function does not own a reference to the
+   * returned pixbuf.
+   * @return The displayed pixbuf, or <tt>0</tt> if the image is empty.
+   */
+  Glib::RefPtr<Gdk::Pixbuf> get_pixbuf();
+  
+  /** Gets the Gdk::Pixbuf being displayed by the Gtk::Image.
+   * The storage type of the image must be Gtk::IMAGE_EMPTY or
+   * Gtk::IMAGE_PIXBUF (see get_storage_type()).
+   * The caller of this function does not own a reference to the
+   * returned pixbuf.
+   * @return The displayed pixbuf, or <tt>0</tt> if the image is empty.
+   */
+  Glib::RefPtr<const Gdk::Pixbuf> get_pixbuf() const;
+  void get_stock(Gtk::StockID& stock_id, IconSize& size) const;
+  void get_icon_set(IconSet& icon_set, IconSize& size) const;
+  
+  /** Gets the Gdk::PixbufAnimation being displayed by the Gtk::Image.
+   * The storage type of the image must be Gtk::IMAGE_EMPTY or
+   * Gtk::IMAGE_ANIMATION (see get_storage_type()).
+   * The caller of this function does not own a reference to the
+   * returned animation.
+   * @return The displayed animation, or <tt>0</tt> if the image is empty.
+   */
+  Glib::RefPtr<Gdk::PixbufAnimation> get_animation();
+  
+  /** Gets the Gdk::PixbufAnimation being displayed by the Gtk::Image.
+   * The storage type of the image must be Gtk::IMAGE_EMPTY or
+   * Gtk::IMAGE_ANIMATION (see get_storage_type()).
+   * The caller of this function does not own a reference to the
+   * returned animation.
+   * @return The displayed animation, or <tt>0</tt> if the image is empty.
+   */
+  Glib::RefPtr<const Gdk::PixbufAnimation> get_animation() const;
+  
+  Glib::ustring get_icon_name() const;
+  Glib::ustring get_icon_name(IconSize& size);
+  
+
+  /** Gets the pixel size used for named icons.
+   * @return The pixel size used for named icons.
+   * 
+   * Since: 2.6.
+   */
+  int get_pixel_size() const;
+ 
+  /** Sets the pixel size to use for named icons. If the pixel size is set
+   * to a value != -1, it is used instead of the icon size set by
+   * set_from_icon_name().
+   * 
+   * Since: 2.6
+   * @param pixel_size The new pixel size.
+   */
+  void set_pixel_size(int pixel_size);
+ 
+  /** A GdkPixbuf to display.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy< Glib::RefPtr<Gdk::Pixbuf> > property_pixbuf() ;
+
+/** A GdkPixbuf to display.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::Pixbuf> > property_pixbuf() const;
+
+  /** A GdkPixmap to display.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy< Glib::RefPtr<Gdk::Pixmap> > property_pixmap() ;
+
+/** A GdkPixmap to display.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::Pixmap> > property_pixmap() const;
+
+  /** A GdkImage to display.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy< Glib::RefPtr<Gdk::Image> > property_image() ;
+
+/** A GdkImage to display.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::Image> > property_image() const;
+
+  /** Mask bitmap to use with GdkImage or GdkPixmap.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy< Glib::RefPtr<Gdk::Pixmap> > property_mask() ;
+
+/** Mask bitmap to use with GdkImage or GdkPixmap.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::Pixmap> > property_mask() const;
+
+  /** Filename to load and display.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_WriteOnly<Glib::ustring> property_file() ;
+
+/** Filename to load and display.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Glib::ustring> property_file() const;
+
+  /** Stock ID for a stock image to display.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Glib::ustring> property_stock() ;
+
+/** Stock ID for a stock image to display.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Glib::ustring> property_stock() const;
+
+  /** Icon set to display.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Gtk::IconSet> property_icon_set() ;
+
+/** Icon set to display.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Gtk::IconSet> property_icon_set() const;
+
+  /** Symbolic size to use for stock icon
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<int> property_icon_size() ;
+
+/** Symbolic size to use for stock icon
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<int> property_icon_size() const;
+
+  /** GdkPixbufAnimation to display.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy< Glib::RefPtr<Gdk::PixbufAnimation> > property_pixbuf_animation() ;
+
+/** GdkPixbufAnimation to display.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::PixbufAnimation> > property_pixbuf_animation() const;
+
+  /** The representation being used for image data.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<ImageType> property_storage_type() const;
+
+
+};
+
+} /* namespace Gtk */
+
+
+namespace Glib
+{
+  /** @relates Gtk::Image
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gtk::Image* wrap(GtkImage* object, bool take_copy = false);
+}
+#endif /* _GTKMM_IMAGE_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/imagemenuitem.cc b/libs/gtkmm2/gtk/gtkmm/imagemenuitem.cc
new file mode 100644
index 0000000000..61abd691cd
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/imagemenuitem.cc
@@ -0,0 +1,192 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/imagemenuitem.h>
+#include <gtkmm/private/imagemenuitem_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* 
+ *
+ * Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtk/gtkimagemenuitem.h>
+
+#include <gtkmm/image.h>
+#include <gtkmm/stock.h>
+#include <gtkmm/accellabel.h>
+
+namespace Gtk
+{
+
+ImageMenuItem::ImageMenuItem(Widget& image, 
+                             const Glib::ustring& label, bool mnemonic)
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::MenuItem(Glib::ConstructParams(imagemenuitem_class_.init(), (char*) 0))
+{
+  set_image(image);
+  add_accel_label(label, mnemonic);
+}
+
+ImageMenuItem::ImageMenuItem(const Glib::ustring& label, bool mnemonic)
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::MenuItem(Glib::ConstructParams(imagemenuitem_class_.init(), (char*) 0))
+{
+  add_accel_label(label, mnemonic);
+}
+
+ImageMenuItem::ImageMenuItem(const Gtk::StockID& stock_id)
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::MenuItem(Glib::ConstructParams(imagemenuitem_class_.init(), (char*) 0))
+{
+  Gtk::Image* image = new Gtk::Image(stock_id, ICON_SIZE_MENU);
+  image->show();
+  set_image( *(Gtk::manage(image)) );
+
+  Gtk::StockItem item;
+  if(Gtk::Stock::lookup(stock_id, item))
+  {
+    add_accel_label(item.get_label(), true); //true = use mnemonic.
+    set_accel_key( AccelKey(item.get_keyval(), item.get_modifier()) );
+  }
+  else
+  {
+    add_accel_label(stock_id.get_string(), false);
+  }
+}
+
+} // namespace Gtk
+
+
+namespace
+{
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Gtk::ImageMenuItem* wrap(GtkImageMenuItem* object, bool take_copy)
+{
+  return dynamic_cast<Gtk::ImageMenuItem *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& ImageMenuItem_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &ImageMenuItem_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_image_menu_item_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void ImageMenuItem_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+}
+
+
+Glib::ObjectBase* ImageMenuItem_Class::wrap_new(GObject* o)
+{
+  return manage(new ImageMenuItem((GtkImageMenuItem*)(o)));
+
+}
+
+
+/* The implementation: */
+
+ImageMenuItem::ImageMenuItem(const Glib::ConstructParams& construct_params)
+:
+  Gtk::MenuItem(construct_params)
+{
+  }
+
+ImageMenuItem::ImageMenuItem(GtkImageMenuItem* castitem)
+:
+  Gtk::MenuItem((GtkMenuItem*)(castitem))
+{
+  }
+
+ImageMenuItem::~ImageMenuItem()
+{
+  destroy_();
+}
+
+ImageMenuItem::CppClassType ImageMenuItem::imagemenuitem_class_; // initialize static member
+
+GType ImageMenuItem::get_type()
+{
+  return imagemenuitem_class_.init().get_type();
+}
+
+GType ImageMenuItem::get_base_type()
+{
+  return gtk_image_menu_item_get_type();
+}
+
+
+ImageMenuItem::ImageMenuItem()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::MenuItem(Glib::ConstructParams(imagemenuitem_class_.init()))
+{
+  }
+
+void ImageMenuItem::set_image(Widget& image)
+{
+  gtk_image_menu_item_set_image(gobj(), (image).gobj());
+}
+
+Widget* ImageMenuItem::get_image()
+{
+  return Glib::wrap(gtk_image_menu_item_get_image(gobj()));
+}
+
+const Widget* ImageMenuItem::get_image() const
+{
+  return Glib::wrap(gtk_image_menu_item_get_image(const_cast<GtkImageMenuItem*>(gobj())));
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/imagemenuitem.h b/libs/gtkmm2/gtk/gtkmm/imagemenuitem.h
new file mode 100644
index 0000000000..f9f21f8002
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/imagemenuitem.h
@@ -0,0 +1,149 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_IMAGEMENUITEM_H
+#define _GTKMM_IMAGEMENUITEM_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* checkmenuitem.h
+ * 
+ * Copyright (C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/menuitem.h>
+#include <gtkmm/stockid.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkImageMenuItem GtkImageMenuItem;
+typedef struct _GtkImageMenuItemClass GtkImageMenuItemClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class ImageMenuItem_Class; } // namespace Gtk
+namespace Gtk
+{
+
+/** A menu item with an icon.
+ * 
+ * A GtkImageMenuItem is a menu item which has an icon next to the text label. Note that the
+ * user can disable display of menu icons, so make sure to still fill in the text label.
+ *
+ * @ingroup Menus
+ * @ingroup Widgets                                                                                                                                                S
+ */
+
+class ImageMenuItem : public MenuItem
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef ImageMenuItem CppObjectType;
+  typedef ImageMenuItem_Class CppClassType;
+  typedef GtkImageMenuItem BaseObjectType;
+  typedef GtkImageMenuItemClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~ImageMenuItem();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class ImageMenuItem_Class;
+  static CppClassType imagemenuitem_class_;
+
+  // noncopyable
+  ImageMenuItem(const ImageMenuItem&);
+  ImageMenuItem& operator=(const ImageMenuItem&);
+
+protected:
+  explicit ImageMenuItem(const Glib::ConstructParams& construct_params);
+  explicit ImageMenuItem(GtkImageMenuItem* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GtkImageMenuItem*       gobj()       { return reinterpret_cast<GtkImageMenuItem*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GtkImageMenuItem* gobj() const { return reinterpret_cast<GtkImageMenuItem*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+private:
+
+public:
+
+  ImageMenuItem();
+  explicit ImageMenuItem(Widget& image, 
+                         const Glib::ustring& label, bool mnemonic = false);
+  explicit ImageMenuItem(const Glib::ustring& label, bool mnemonic = false);
+  explicit ImageMenuItem(const StockID& id);  
+  
+  
+  /** Sets the image of @a image_menu_item  to the given widget.
+   * Note that it depends on the show-menu-images setting whether
+   * the image will be displayed or not.
+   * @param image A widget to set as the image for the menu item.
+   */
+  void set_image(Widget& image);
+  
+  /** Gets the widget that is currently set as the image of @a image_menu_item .
+   * See set_image().
+   * @return The widget set as image of @a image_menu_item .
+   */
+  Widget* get_image();
+  
+  /** Gets the widget that is currently set as the image of @a image_menu_item .
+   * See set_image().
+   * @return The widget set as image of @a image_menu_item .
+   */
+  const Widget* get_image() const;
+
+
+};
+
+} /* namespace Gtk */
+
+
+namespace Glib
+{
+  /** @relates Gtk::ImageMenuItem
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gtk::ImageMenuItem* wrap(GtkImageMenuItem* object, bool take_copy = false);
+}
+#endif /* _GTKMM_IMAGEMENUITEM_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/inputdialog.cc b/libs/gtkmm2/gtk/gtkmm/inputdialog.cc
new file mode 100644
index 0000000000..9ccbf28a10
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/inputdialog.cc
@@ -0,0 +1,386 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/inputdialog.h>
+#include <gtkmm/private/inputdialog_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* 
+ *
+ * Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtk/gtkinputdialog.h>
+#include <gtkmm/button.h>
+#include <gtkmm/optionmenu.h>
+#include <gtkmm/scrolledwindow.h>
+#include <gtkmm/table.h>
+
+
+namespace
+{
+
+void InputDialog_signal_enable_device_callback(GtkInputDialog* self, GdkDevice* p0,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,const Glib::RefPtr<Gdk::Device>& > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(Glib::wrap(p0, true)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+}
+
+const Glib::SignalProxyInfo InputDialog_signal_enable_device_info =
+{
+  "enable_device",
+  (GCallback) &InputDialog_signal_enable_device_callback,
+  (GCallback) &InputDialog_signal_enable_device_callback
+};
+
+
+void InputDialog_signal_disable_device_callback(GtkInputDialog* self, GdkDevice* p0,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,const Glib::RefPtr<Gdk::Device>& > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(Glib::wrap(p0, true)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+}
+
+const Glib::SignalProxyInfo InputDialog_signal_disable_device_info =
+{
+  "disable_device",
+  (GCallback) &InputDialog_signal_disable_device_callback,
+  (GCallback) &InputDialog_signal_disable_device_callback
+};
+
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Gtk::InputDialog* wrap(GtkInputDialog* object, bool take_copy)
+{
+  return dynamic_cast<Gtk::InputDialog *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& InputDialog_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &InputDialog_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_input_dialog_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void InputDialog_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+  klass->enable_device = &enable_device_callback;
+  klass->disable_device = &disable_device_callback;
+}
+
+
+void InputDialog_Class::enable_device_callback(GtkInputDialog* self, GdkDevice* p0)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_enable_device(Glib::wrap(p0, true)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->enable_device)
+      (*base->enable_device)(self, p0);
+  }
+}
+
+void InputDialog_Class::disable_device_callback(GtkInputDialog* self, GdkDevice* p0)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_disable_device(Glib::wrap(p0, true)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->disable_device)
+      (*base->disable_device)(self, p0);
+  }
+}
+
+
+Glib::ObjectBase* InputDialog_Class::wrap_new(GObject* o)
+{
+  return new InputDialog((GtkInputDialog*)(o)); //top-level windows can not be manage()ed.
+
+}
+
+
+/* The implementation: */
+
+InputDialog::InputDialog(const Glib::ConstructParams& construct_params)
+:
+  Gtk::Dialog(construct_params)
+{
+  }
+
+InputDialog::InputDialog(GtkInputDialog* castitem)
+:
+  Gtk::Dialog((GtkDialog*)(castitem))
+{
+  }
+
+InputDialog::~InputDialog()
+{
+  destroy_();
+}
+
+InputDialog::CppClassType InputDialog::inputdialog_class_; // initialize static member
+
+GType InputDialog::get_type()
+{
+  return inputdialog_class_.init().get_type();
+}
+
+GType InputDialog::get_base_type()
+{
+  return gtk_input_dialog_get_type();
+}
+
+
+InputDialog::InputDialog()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Dialog(Glib::ConstructParams(inputdialog_class_.init()))
+{
+  }
+
+Table* InputDialog::get_axis_list()
+{
+  return Glib::wrap((GtkTable*)(gobj()->axis_list));
+}
+
+const Table* InputDialog::get_axis_list() const
+{
+  return Glib::wrap((GtkTable*)(gobj()->axis_list));
+}
+
+ScrolledWindow* InputDialog::get_axis_box()
+{
+  return Glib::wrap((GtkScrolledWindow*)(gobj()->axis_listbox));
+}
+
+const ScrolledWindow* InputDialog::get_axis_box() const
+{
+  return Glib::wrap((GtkScrolledWindow*)(gobj()->axis_listbox));
+}
+
+OptionMenu* InputDialog::get_mode_optionmenu()
+{
+  return Glib::wrap((GtkOptionMenu*)(gobj()->mode_optionmenu));
+}
+
+const OptionMenu* InputDialog::get_mode_optionmenu() const
+{
+  return Glib::wrap((GtkOptionMenu*)(gobj()->mode_optionmenu));
+}
+
+Button* InputDialog::get_close_button()
+{
+  return Glib::wrap((GtkButton*)(gobj()->close_button));
+}
+
+const Button* InputDialog::get_close_button() const
+{
+  return Glib::wrap((GtkButton*)(gobj()->close_button));
+}
+
+Button* InputDialog::get_save_button()
+{
+  return Glib::wrap((GtkButton*)(gobj()->save_button));
+}
+
+const Button* InputDialog::get_save_button() const
+{
+  return Glib::wrap((GtkButton*)(gobj()->save_button));
+}
+
+Glib::RefPtr<Gdk::Device> InputDialog::get_current_device()
+{
+  Glib::RefPtr<Gdk::Device> ref_ptr(Glib::wrap(gobj()->current_device));
+
+  if(ref_ptr)
+    ref_ptr->reference();
+
+  return ref_ptr;
+}
+
+Glib::RefPtr<const Gdk::Device> InputDialog::get_current_device() const
+{
+  Glib::RefPtr<const Gdk::Device> ref_ptr(Glib::wrap(gobj()->current_device));
+
+  if(ref_ptr)
+    ref_ptr->reference();
+
+  return ref_ptr;
+}
+
+Table* InputDialog::get_keys_list()
+{
+  return Glib::wrap((GtkTable*)(gobj()->keys_list));
+}
+
+const Table* InputDialog::get_keys_list() const
+{
+  return Glib::wrap((GtkTable*)(gobj()->keys_list));
+}
+
+ScrolledWindow* InputDialog::get_keys_box()
+{
+  return Glib::wrap((GtkScrolledWindow*)(gobj()->keys_listbox));
+}
+
+const ScrolledWindow* InputDialog::get_keys_box() const
+{
+  return Glib::wrap((GtkScrolledWindow*)(gobj()->keys_listbox));
+}
+
+
+Glib::SignalProxy1< void,const Glib::RefPtr<Gdk::Device>& > InputDialog::signal_enable_device()
+{
+  return Glib::SignalProxy1< void,const Glib::RefPtr<Gdk::Device>& >(this, &InputDialog_signal_enable_device_info);
+}
+
+Glib::SignalProxy1< void,const Glib::RefPtr<Gdk::Device>& > InputDialog::signal_disable_device()
+{
+  return Glib::SignalProxy1< void,const Glib::RefPtr<Gdk::Device>& >(this, &InputDialog_signal_disable_device_info);
+}
+
+
+void Gtk::InputDialog::on_enable_device(const Glib::RefPtr<Gdk::Device>& device)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->enable_device)
+    (*base->enable_device)(gobj(),Glib::unwrap(device));
+}
+
+void Gtk::InputDialog::on_disable_device(const Glib::RefPtr<Gdk::Device>& device)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->disable_device)
+    (*base->disable_device)(gobj(),Glib::unwrap(device));
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/inputdialog.h b/libs/gtkmm2/gtk/gtkmm/inputdialog.h
new file mode 100644
index 0000000000..d5306cb778
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/inputdialog.h
@@ -0,0 +1,155 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_INPUTDIALOG_H
+#define _GTKMM_INPUTDIALOG_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* inputdialog.h
+ * 
+ * Copyright (C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/dialog.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkInputDialog GtkInputDialog;
+typedef struct _GtkInputDialogClass GtkInputDialogClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class InputDialog_Class; } // namespace Gtk
+namespace Gtk
+{
+
+class Button;
+class Table;
+class OptionMenu;
+class ScrolledWindow;
+
+// Don't list this in the documentation's Dialogs group because it isn't really useful
+// - see the GTK+ docs.
+
+class InputDialog : public Dialog
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef InputDialog CppObjectType;
+  typedef InputDialog_Class CppClassType;
+  typedef GtkInputDialog BaseObjectType;
+  typedef GtkInputDialogClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~InputDialog();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class InputDialog_Class;
+  static CppClassType inputdialog_class_;
+
+  // noncopyable
+  InputDialog(const InputDialog&);
+  InputDialog& operator=(const InputDialog&);
+
+protected:
+  explicit InputDialog(const Glib::ConstructParams& construct_params);
+  explicit InputDialog(GtkInputDialog* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GtkInputDialog*       gobj()       { return reinterpret_cast<GtkInputDialog*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GtkInputDialog* gobj() const { return reinterpret_cast<GtkInputDialog*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+  virtual void on_enable_device(const Glib::RefPtr<Gdk::Device>& device);
+  virtual void on_disable_device(const Glib::RefPtr<Gdk::Device>& device);
+
+
+private:
+
+  
+public:
+
+  InputDialog();
+  
+
+  Table* get_axis_list();
+  const Table* get_axis_list() const;
+  ScrolledWindow* get_axis_box();
+  const ScrolledWindow* get_axis_box() const;
+  OptionMenu* get_mode_optionmenu();
+  const OptionMenu* get_mode_optionmenu() const;
+
+  Button* get_close_button();
+  const Button* get_close_button() const;
+  Button* get_save_button();
+  const Button* get_save_button() const;
+
+  //GtkWidget *axis_items[GDK_AXIS_LAST];
+
+  Glib::RefPtr<Gdk::Device> get_current_device();
+  Glib::RefPtr<const Gdk::Device> get_current_device() const;
+
+  Table* get_keys_list();
+  const Table* get_keys_list() const;
+  ScrolledWindow* get_keys_box();
+  const ScrolledWindow* get_keys_box() const;
+
+  
+  Glib::SignalProxy1< void,const Glib::RefPtr<Gdk::Device>& > signal_enable_device();
+
+  
+  Glib::SignalProxy1< void,const Glib::RefPtr<Gdk::Device>& > signal_disable_device();
+
+
+};
+
+} /* namespace Gtk */
+
+
+namespace Glib
+{
+  /** @relates Gtk::InputDialog
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gtk::InputDialog* wrap(GtkInputDialog* object, bool take_copy = false);
+}
+#endif /* _GTKMM_INPUTDIALOG_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/invisible.cc b/libs/gtkmm2/gtk/gtkmm/invisible.cc
new file mode 100644
index 0000000000..3c54f190da
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/invisible.cc
@@ -0,0 +1,167 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/invisible.h>
+#include <gtkmm/private/invisible_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* 
+ *
+ * Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtk/gtkinvisible.h>
+
+namespace Gtk
+{
+
+
+}
+
+
+namespace
+{
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Gtk::Invisible* wrap(GtkInvisible* object, bool take_copy)
+{
+  return dynamic_cast<Gtk::Invisible *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& Invisible_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &Invisible_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_invisible_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void Invisible_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+}
+
+
+Glib::ObjectBase* Invisible_Class::wrap_new(GObject* o)
+{
+  return manage(new Invisible((GtkInvisible*)(o)));
+
+}
+
+
+/* The implementation: */
+
+Invisible::Invisible(const Glib::ConstructParams& construct_params)
+:
+  Gtk::Widget(construct_params)
+{
+  }
+
+Invisible::Invisible(GtkInvisible* castitem)
+:
+  Gtk::Widget((GtkWidget*)(castitem))
+{
+  }
+
+Invisible::~Invisible()
+{
+  destroy_();
+}
+
+Invisible::CppClassType Invisible::invisible_class_; // initialize static member
+
+GType Invisible::get_type()
+{
+  return invisible_class_.init().get_type();
+}
+
+GType Invisible::get_base_type()
+{
+  return gtk_invisible_get_type();
+}
+
+
+Invisible::Invisible()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Widget(Glib::ConstructParams(invisible_class_.init()))
+{
+  }
+
+Invisible::Invisible(const Glib::RefPtr<Gdk::Screen>& screen)
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Widget(Glib::ConstructParams(invisible_class_.init(), "screen", Glib::unwrap(screen), (char*) 0))
+{
+  }
+
+Glib::RefPtr<Gdk::Screen> Invisible::get_screen()
+{
+
+  Glib::RefPtr<Gdk::Screen> retvalue = Glib::wrap(gtk_invisible_get_screen(gobj()));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::RefPtr<const Gdk::Screen> Invisible::get_screen() const
+{
+
+  Glib::RefPtr<const Gdk::Screen> retvalue = Glib::wrap(gtk_invisible_get_screen(const_cast<GtkInvisible*>(gobj())));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+void Invisible::set_screen(const Glib::RefPtr<Gdk::Screen>& screen)
+{
+  gtk_invisible_set_screen(gobj(), Glib::unwrap(screen));
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/invisible.h b/libs/gtkmm2/gtk/gtkmm/invisible.h
new file mode 100644
index 0000000000..7e22cba573
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/invisible.h
@@ -0,0 +1,142 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_INVISIBLE_H
+#define _GTKMM_INVISIBLE_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* invisible.h
+ * 
+ * Copyright (C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/widget.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkInvisible GtkInvisible;
+typedef struct _GtkInvisibleClass GtkInvisibleClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class Invisible_Class; } // namespace Gtk
+namespace Gtk
+{
+
+/** This widget is used internally in GTK+, and is probably not useful for application developers.
+ * It is used for reliable pointer grabs and selection handling in the code for drag-and-drop.
+ * @ingroup Widgets
+ */
+
+class Invisible : public Widget
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Invisible CppObjectType;
+  typedef Invisible_Class CppClassType;
+  typedef GtkInvisible BaseObjectType;
+  typedef GtkInvisibleClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~Invisible();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class Invisible_Class;
+  static CppClassType invisible_class_;
+
+  // noncopyable
+  Invisible(const Invisible&);
+  Invisible& operator=(const Invisible&);
+
+protected:
+  explicit Invisible(const Glib::ConstructParams& construct_params);
+  explicit Invisible(GtkInvisible* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GtkInvisible*       gobj()       { return reinterpret_cast<GtkInvisible*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GtkInvisible* gobj() const { return reinterpret_cast<GtkInvisible*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+private:
+
+public:
+  Invisible();
+  explicit Invisible(const Glib::RefPtr<Gdk::Screen>& screen);
+ 
+  
+  /** Returns the Gdk::Screen object associated with @a invisible 
+   * @return The associated Gdk::Screen.
+   * 
+   * Since: 2.2.
+   */
+  Glib::RefPtr<Gdk::Screen> get_screen();
+  
+  /** Returns the Gdk::Screen object associated with @a invisible 
+   * @return The associated Gdk::Screen.
+   * 
+   * Since: 2.2.
+   */
+  Glib::RefPtr<const Gdk::Screen> get_screen() const;
+  
+  /** Sets the Gdk::Screen where the Gtk::Invisible object will be displayed.
+   * 
+   * Since: 2.2
+   * @param screen A Gdk::Screen.
+   */
+  void set_screen(const Glib::RefPtr<Gdk::Screen>& screen);
+
+
+};
+
+} /* namespace Gtk */
+
+
+namespace Glib
+{
+  /** @relates Gtk::Invisible
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gtk::Invisible* wrap(GtkInvisible* object, bool take_copy = false);
+}
+#endif /* _GTKMM_INVISIBLE_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/item.cc b/libs/gtkmm2/gtk/gtkmm/item.cc
new file mode 100644
index 0000000000..45e28f6fbc
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/item.cc
@@ -0,0 +1,321 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/item.h>
+#include <gtkmm/private/item_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* 
+ *
+ * Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtk/gtkitem.h>
+
+
+namespace
+{
+
+const Glib::SignalProxyInfo Item_signal_select_info =
+{
+  "select",
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
+};
+
+
+const Glib::SignalProxyInfo Item_signal_deselect_info =
+{
+  "deselect",
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
+};
+
+
+const Glib::SignalProxyInfo Item_signal_toggle_info =
+{
+  "toggle",
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
+};
+
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Gtk::Item* wrap(GtkItem* object, bool take_copy)
+{
+  return dynamic_cast<Gtk::Item *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& Item_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &Item_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_item_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void Item_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+  klass->select = &select_callback;
+  klass->deselect = &deselect_callback;
+  klass->toggle = &toggle_callback;
+}
+
+
+void Item_Class::select_callback(GtkItem* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_select();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->select)
+      (*base->select)(self);
+  }
+}
+
+void Item_Class::deselect_callback(GtkItem* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_deselect();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->deselect)
+      (*base->deselect)(self);
+  }
+}
+
+void Item_Class::toggle_callback(GtkItem* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_toggle();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->toggle)
+      (*base->toggle)(self);
+  }
+}
+
+
+Glib::ObjectBase* Item_Class::wrap_new(GObject* o)
+{
+  return manage(new Item((GtkItem*)(o)));
+
+}
+
+
+/* The implementation: */
+
+Item::Item(const Glib::ConstructParams& construct_params)
+:
+  Gtk::Bin(construct_params)
+{
+  }
+
+Item::Item(GtkItem* castitem)
+:
+  Gtk::Bin((GtkBin*)(castitem))
+{
+  }
+
+Item::~Item()
+{
+  destroy_();
+}
+
+Item::CppClassType Item::item_class_; // initialize static member
+
+GType Item::get_type()
+{
+  return item_class_.init().get_type();
+}
+
+GType Item::get_base_type()
+{
+  return gtk_item_get_type();
+}
+
+
+void Item::select()
+{
+  gtk_item_select(gobj());
+}
+
+void Item::deselect()
+{
+  gtk_item_deselect(gobj());
+}
+
+void Item::toggle()
+{
+  gtk_item_toggle(gobj());
+}
+
+Item::Item()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Bin(Glib::ConstructParams(item_class_.init()))
+{
+  }
+
+
+Glib::SignalProxy0< void > Item::signal_select()
+{
+  return Glib::SignalProxy0< void >(this, &Item_signal_select_info);
+}
+
+Glib::SignalProxy0< void > Item::signal_deselect()
+{
+  return Glib::SignalProxy0< void >(this, &Item_signal_deselect_info);
+}
+
+Glib::SignalProxy0< void > Item::signal_toggle()
+{
+  return Glib::SignalProxy0< void >(this, &Item_signal_toggle_info);
+}
+
+
+void Gtk::Item::on_select()
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->select)
+    (*base->select)(gobj());
+}
+
+void Gtk::Item::on_deselect()
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->deselect)
+    (*base->deselect)(gobj());
+}
+
+void Gtk::Item::on_toggle()
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->toggle)
+    (*base->toggle)(gobj());
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/item.h b/libs/gtkmm2/gtk/gtkmm/item.h
new file mode 100644
index 0000000000..08405b5dd0
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/item.h
@@ -0,0 +1,145 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_ITEM_H
+#define _GTKMM_ITEM_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* item.h
+ * 
+ * Copyright (C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/bin.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkItem GtkItem;
+typedef struct _GtkItemClass GtkItemClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class Item_Class; } // namespace Gtk
+namespace Gtk
+{
+
+/** This class should be considered as a virtual base class.
+ * Only the signals and methods it provides are of any interest.
+ * You don't want to instantiate any objects of that class.
+ *
+ * @ingroup Widgets
+ */
+
+class Item : public Bin
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Item CppObjectType;
+  typedef Item_Class CppClassType;
+  typedef GtkItem BaseObjectType;
+  typedef GtkItemClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~Item();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class Item_Class;
+  static CppClassType item_class_;
+
+  // noncopyable
+  Item(const Item&);
+  Item& operator=(const Item&);
+
+protected:
+  explicit Item(const Glib::ConstructParams& construct_params);
+  explicit Item(GtkItem* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GtkItem*       gobj()       { return reinterpret_cast<GtkItem*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GtkItem* gobj() const { return reinterpret_cast<GtkItem*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+  virtual void on_select();
+  virtual void on_deselect();
+  virtual void on_toggle();
+
+
+private:
+
+public:
+
+  
+  void select();
+  
+
+  Glib::SignalProxy0< void > signal_select();
+
+
+  void deselect();
+  
+
+  Glib::SignalProxy0< void > signal_deselect();
+
+
+  void toggle();
+  
+
+  Glib::SignalProxy0< void > signal_toggle();
+
+
+protected:
+  Item();
+
+
+};
+
+} /* namespace Gtk */
+
+
+namespace Glib
+{
+  /** @relates Gtk::Item
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gtk::Item* wrap(GtkItem* object, bool take_copy = false);
+}
+#endif /* _GTKMM_ITEM_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/label.cc b/libs/gtkmm2/gtk/gtkmm/label.cc
new file mode 100644
index 0000000000..0de70b9b64
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/label.cc
@@ -0,0 +1,603 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/label.h>
+#include <gtkmm/private/label_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtk/gtklabel.h>
+#include <gtkmm/menu.h>
+
+namespace Gtk
+{
+
+Label::Label()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Misc(Glib::ConstructParams(label_class_.init(), (char*) 0))
+{}
+
+Label::Label(const Glib::ustring& label, bool mnemonic)
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Misc(Glib::ConstructParams(label_class_.init(), "label",label.c_str(),"use_underline",gboolean(mnemonic), (char*) 0))
+{}
+
+Label::Label(const Glib::ustring& label, float xalign, float yalign, bool mnemonic)
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Misc(Glib::ConstructParams(label_class_.init(), "label",label.c_str(),"use_underline",gboolean(mnemonic), (char*) 0))
+{
+  set_alignment(xalign, yalign);
+}
+
+Label::Label(const Glib::ustring& label, AlignmentEnum xalign, AlignmentEnum yalign, bool mnemonic)
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Misc(Glib::ConstructParams(label_class_.init(), "label",label.c_str(),"use_underline",gboolean(mnemonic), (char*) 0))
+{
+  set_alignment(xalign, yalign);
+}
+
+void Label::select_region(int start_offset)
+{
+  gtk_label_select_region(gobj(), start_offset, -1 /* See C docs */);
+}
+
+} // namespace Gtk
+
+
+namespace
+{
+
+void Label_signal_populate_popup_callback(GtkLabel* self, GtkMenu* p0,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,Menu* > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(Glib::wrap(p0)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+}
+
+const Glib::SignalProxyInfo Label_signal_populate_popup_info =
+{
+  "populate_popup",
+  (GCallback) &Label_signal_populate_popup_callback,
+  (GCallback) &Label_signal_populate_popup_callback
+};
+
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Gtk::Label* wrap(GtkLabel* object, bool take_copy)
+{
+  return dynamic_cast<Gtk::Label *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& Label_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &Label_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_label_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void Label_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+  klass->populate_popup = &populate_popup_callback;
+}
+
+
+void Label_Class::populate_popup_callback(GtkLabel* self, GtkMenu* p0)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_populate_popup(Glib::wrap(p0)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->populate_popup)
+      (*base->populate_popup)(self, p0);
+  }
+}
+
+
+Glib::ObjectBase* Label_Class::wrap_new(GObject* o)
+{
+  return manage(new Label((GtkLabel*)(o)));
+
+}
+
+
+/* The implementation: */
+
+Label::Label(const Glib::ConstructParams& construct_params)
+:
+  Gtk::Misc(construct_params)
+{
+  }
+
+Label::Label(GtkLabel* castitem)
+:
+  Gtk::Misc((GtkMisc*)(castitem))
+{
+  }
+
+Label::~Label()
+{
+  destroy_();
+}
+
+Label::CppClassType Label::label_class_; // initialize static member
+
+GType Label::get_type()
+{
+  return label_class_.init().get_type();
+}
+
+GType Label::get_base_type()
+{
+  return gtk_label_get_type();
+}
+
+
+void Label::set_text(const Glib::ustring & str)
+{
+  gtk_label_set_text(gobj(), str.c_str());
+}
+
+Glib::ustring Label::get_text() const
+{
+  return Glib::convert_const_gchar_ptr_to_ustring(gtk_label_get_text(const_cast<GtkLabel*>(gobj())));
+}
+
+void Label::set_attributes(Pango::AttrList& attrs)
+{
+  gtk_label_set_attributes(gobj(), (attrs).gobj());
+}
+
+Pango::AttrList Label::get_attributes() const
+{
+  return Pango::AttrList((gtk_label_get_attributes(const_cast<GtkLabel*>(gobj()))));
+}
+
+void Label::set_label(const Glib::ustring& str)
+{
+  gtk_label_set_label(gobj(), str.c_str());
+}
+
+Glib::ustring Label::get_label() const
+{
+  return Glib::convert_const_gchar_ptr_to_ustring(gtk_label_get_label(const_cast<GtkLabel*>(gobj())));
+}
+
+void Label::set_markup(const Glib::ustring& str)
+{
+  gtk_label_set_markup(gobj(), str.c_str());
+}
+
+void Label::set_use_markup(bool setting)
+{
+  gtk_label_set_use_markup(gobj(), static_cast<int>(setting));
+}
+
+bool Label::get_use_markup() const
+{
+  return gtk_label_get_use_markup(const_cast<GtkLabel*>(gobj()));
+}
+
+void Label::set_use_underline(bool setting)
+{
+  gtk_label_set_use_underline(gobj(), static_cast<int>(setting));
+}
+
+bool Label::get_use_underline() const
+{
+  return gtk_label_get_use_underline(const_cast<GtkLabel*>(gobj()));
+}
+
+void Label::set_markup_with_mnemonic(const Glib::ustring& str)
+{
+  gtk_label_set_markup_with_mnemonic(gobj(), str.c_str());
+}
+
+guint Label::get_mnemonic_keyval() const
+{
+  return gtk_label_get_mnemonic_keyval(const_cast<GtkLabel*>(gobj()));
+}
+
+void Label::set_mnemonic_widget(Widget& widget)
+{
+  gtk_label_set_mnemonic_widget(gobj(), (widget).gobj());
+}
+
+Widget* Label::get_mnemonic_widget()
+{
+  return Glib::wrap(gtk_label_get_mnemonic_widget(gobj()));
+}
+
+const Widget* Label::get_mnemonic_widget() const
+{
+  return Glib::wrap(gtk_label_get_mnemonic_widget(const_cast<GtkLabel*>(gobj())));
+}
+
+void Label::set_text_with_mnemonic(const Glib::ustring& str)
+{
+  gtk_label_set_text_with_mnemonic(gobj(), str.c_str());
+}
+
+void Label::set_justify(Justification jtype)
+{
+  gtk_label_set_justify(gobj(), ((GtkJustification)(jtype)));
+}
+
+Justification Label::get_justify() const
+{
+  return ((Justification)(gtk_label_get_justify(const_cast<GtkLabel*>(gobj()))));
+}
+
+void Label::set_ellipsize(Pango::EllipsizeMode mode)
+{
+  gtk_label_set_ellipsize(gobj(), ((PangoEllipsizeMode)(mode)));
+}
+
+Pango::EllipsizeMode Label::get_ellipsize() const
+{
+  return ((Pango::EllipsizeMode)(gtk_label_get_ellipsize(const_cast<GtkLabel*>(gobj()))));
+}
+
+void Label::set_width_chars(int n_chars)
+{
+  gtk_label_set_width_chars(gobj(), n_chars);
+}
+
+int Label::get_width_chars() const
+{
+  return gtk_label_get_width_chars(const_cast<GtkLabel*>(gobj()));
+}
+
+void Label::set_max_width_chars(int n_chars)
+{
+  gtk_label_set_max_width_chars(gobj(), n_chars);
+}
+
+int Label::get_max_width_chars() const
+{
+  return gtk_label_get_max_width_chars(const_cast<GtkLabel*>(gobj()));
+}
+
+void Label::set_pattern(const Glib::ustring& pattern)
+{
+  gtk_label_set_pattern(gobj(), pattern.c_str());
+}
+
+void Label::set_line_wrap(bool wrap)
+{
+  gtk_label_set_line_wrap(gobj(), static_cast<int>(wrap));
+}
+
+bool Label::get_line_wrap() const
+{
+  return gtk_label_get_line_wrap(const_cast<GtkLabel*>(gobj()));
+}
+
+void Label::set_selectable(bool setting)
+{
+  gtk_label_set_selectable(gobj(), static_cast<int>(setting));
+}
+
+bool Label::get_selectable() const
+{
+  return gtk_label_get_selectable(const_cast<GtkLabel*>(gobj()));
+}
+
+void Label::set_angle(double angle)
+{
+  gtk_label_set_angle(gobj(), angle);
+}
+
+double Label::get_angle() const
+{
+  return gtk_label_get_angle(const_cast<GtkLabel*>(gobj()));
+}
+
+void Label::select_region(int start_offset, int end_offset)
+{
+  gtk_label_select_region(gobj(), start_offset, end_offset);
+}
+
+bool Label::get_selection_bounds(int& start, int& end) const
+{
+  return gtk_label_get_selection_bounds(const_cast<GtkLabel*>(gobj()), &start, &end);
+}
+
+Glib::RefPtr<Pango::Layout> Label::get_layout()
+{
+
+  Glib::RefPtr<Pango::Layout> retvalue = Glib::wrap(gtk_label_get_layout(gobj()));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::RefPtr<const Pango::Layout> Label::get_layout() const
+{
+
+  Glib::RefPtr<const Pango::Layout> retvalue = Glib::wrap(gtk_label_get_layout(const_cast<GtkLabel*>(gobj())));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+void Label::get_layout_offsets(int& x, int& y) const
+{
+  gtk_label_get_layout_offsets(const_cast<GtkLabel*>(gobj()), &x, &y);
+}
+
+void Label::set_single_line_mode(bool single_line_mode)
+{
+  gtk_label_set_single_line_mode(gobj(), static_cast<int>(single_line_mode));
+}
+
+bool Label::get_single_line_mode() const
+{
+  return gtk_label_get_single_line_mode(const_cast<GtkLabel*>(gobj()));
+}
+
+
+Glib::SignalProxy1< void,Menu* > Label::signal_populate_popup()
+{
+  return Glib::SignalProxy1< void,Menu* >(this, &Label_signal_populate_popup_info);
+}
+
+
+Glib::PropertyProxy<Glib::ustring> Label::property_label() 
+{
+  return Glib::PropertyProxy<Glib::ustring>(this, "label");
+}
+
+Glib::PropertyProxy_ReadOnly<Glib::ustring> Label::property_label() const
+{
+  return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "label");
+}
+
+Glib::PropertyProxy<Pango::AttrList> Label::property_attributes() 
+{
+  return Glib::PropertyProxy<Pango::AttrList>(this, "attributes");
+}
+
+Glib::PropertyProxy_ReadOnly<Pango::AttrList> Label::property_attributes() const
+{
+  return Glib::PropertyProxy_ReadOnly<Pango::AttrList>(this, "attributes");
+}
+
+Glib::PropertyProxy<bool> Label::property_use_markup() 
+{
+  return Glib::PropertyProxy<bool>(this, "use-markup");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> Label::property_use_markup() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "use-markup");
+}
+
+Glib::PropertyProxy<bool> Label::property_use_underline() 
+{
+  return Glib::PropertyProxy<bool>(this, "use-underline");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> Label::property_use_underline() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "use-underline");
+}
+
+Glib::PropertyProxy<Justification> Label::property_justify() 
+{
+  return Glib::PropertyProxy<Justification>(this, "justify");
+}
+
+Glib::PropertyProxy_ReadOnly<Justification> Label::property_justify() const
+{
+  return Glib::PropertyProxy_ReadOnly<Justification>(this, "justify");
+}
+
+Glib::PropertyProxy_WriteOnly<Glib::ustring> Label::property_pattern() 
+{
+  return Glib::PropertyProxy_WriteOnly<Glib::ustring>(this, "pattern");
+}
+
+Glib::PropertyProxy_ReadOnly<Glib::ustring> Label::property_pattern() const
+{
+  return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "pattern");
+}
+
+Glib::PropertyProxy<bool> Label::property_wrap() 
+{
+  return Glib::PropertyProxy<bool>(this, "wrap");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> Label::property_wrap() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "wrap");
+}
+
+Glib::PropertyProxy<bool> Label::property_selectable() 
+{
+  return Glib::PropertyProxy<bool>(this, "selectable");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> Label::property_selectable() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "selectable");
+}
+
+Glib::PropertyProxy_ReadOnly<guint> Label::property_mnemonic_keyval() const
+{
+  return Glib::PropertyProxy_ReadOnly<guint>(this, "mnemonic-keyval");
+}
+
+Glib::PropertyProxy<Widget*> Label::property_mnemonic_widget() 
+{
+  return Glib::PropertyProxy<Widget*>(this, "mnemonic-widget");
+}
+
+Glib::PropertyProxy_ReadOnly<Widget*> Label::property_mnemonic_widget() const
+{
+  return Glib::PropertyProxy_ReadOnly<Widget*>(this, "mnemonic-widget");
+}
+
+Glib::PropertyProxy_ReadOnly<int> Label::property_cursor_position() const
+{
+  return Glib::PropertyProxy_ReadOnly<int>(this, "cursor-position");
+}
+
+Glib::PropertyProxy_ReadOnly<int> Label::property_selection_bound() const
+{
+  return Glib::PropertyProxy_ReadOnly<int>(this, "selection-bound");
+}
+
+Glib::PropertyProxy<Pango::EllipsizeMode> Label::property_ellipsize() 
+{
+  return Glib::PropertyProxy<Pango::EllipsizeMode>(this, "ellipsize");
+}
+
+Glib::PropertyProxy_ReadOnly<Pango::EllipsizeMode> Label::property_ellipsize() const
+{
+  return Glib::PropertyProxy_ReadOnly<Pango::EllipsizeMode>(this, "ellipsize");
+}
+
+Glib::PropertyProxy<int> Label::property_width_chars() 
+{
+  return Glib::PropertyProxy<int>(this, "width-chars");
+}
+
+Glib::PropertyProxy_ReadOnly<int> Label::property_width_chars() const
+{
+  return Glib::PropertyProxy_ReadOnly<int>(this, "width-chars");
+}
+
+Glib::PropertyProxy<bool> Label::property_single_line_mode() 
+{
+  return Glib::PropertyProxy<bool>(this, "single-line-mode");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> Label::property_single_line_mode() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "single-line-mode");
+}
+
+Glib::PropertyProxy<double> Label::property_angle() 
+{
+  return Glib::PropertyProxy<double>(this, "angle");
+}
+
+Glib::PropertyProxy_ReadOnly<double> Label::property_angle() const
+{
+  return Glib::PropertyProxy_ReadOnly<double>(this, "angle");
+}
+
+Glib::PropertyProxy<int> Label::property_max_width_chars() 
+{
+  return Glib::PropertyProxy<int>(this, "max-width-chars");
+}
+
+Glib::PropertyProxy_ReadOnly<int> Label::property_max_width_chars() const
+{
+  return Glib::PropertyProxy_ReadOnly<int>(this, "max-width-chars");
+}
+
+
+void Gtk::Label::on_populate_popup(Menu* menu)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->populate_popup)
+    (*base->populate_popup)(gobj(),(GtkMenu*)Glib::unwrap(menu));
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/label.h b/libs/gtkmm2/gtk/gtkmm/label.h
new file mode 100644
index 0000000000..83d3b68bf0
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/label.h
@@ -0,0 +1,742 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_LABEL_H
+#define _GTKMM_LABEL_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* Copyright(C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+
+#include <gtkmm/misc.h>
+#include <pangomm/attrlist.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkLabel GtkLabel;
+typedef struct _GtkLabelClass GtkLabelClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class Label_Class; } // namespace Gtk
+namespace Gtk
+{
+
+class Menu;
+
+/** A widget that displays a small to medium amount of text.
+ *
+ * A simple setable widget for holding a Glib::ustring.
+ * @ingroup Widgets
+ */
+
+class Label : public Misc
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Label CppObjectType;
+  typedef Label_Class CppClassType;
+  typedef GtkLabel BaseObjectType;
+  typedef GtkLabelClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~Label();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class Label_Class;
+  static CppClassType label_class_;
+
+  // noncopyable
+  Label(const Label&);
+  Label& operator=(const Label&);
+
+protected:
+  explicit Label(const Glib::ConstructParams& construct_params);
+  explicit Label(GtkLabel* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GtkLabel*       gobj()       { return reinterpret_cast<GtkLabel*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GtkLabel* gobj() const { return reinterpret_cast<GtkLabel*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+  virtual void on_populate_popup(Menu* menu);
+
+
+private:
+
+  
+public:
+  Label();
+  explicit Label(const Glib::ustring& label, bool mnemonic = false);
+
+  /** This constructor is a shortcut for often used code
+   * when you want to create a label with alignment different
+   * than default one.
+   * @code
+   * Gtk::Label label(text, x, y, mnemonic);
+   * @endcode
+   * is equivalent to:
+   * @code
+   * Gtk::Label label(text, mnemonic);
+   * label.set_alignment(x, y);
+   * @endcode
+   */
+  Label(const Glib::ustring& label, float xalign, float yalign, bool mnemonic = false);
+
+  /** This constructor is a shortcut for often used code
+   * when you want to create a label with alignment different
+   * than default one.
+   * @code
+   * Gtk::Label label(text, x, y, mnemonic);
+   * @endcode
+   * is equivalent to:
+   * @code
+   * Gtk::Label label(text, mnemonic);
+   * label.set_alignment(x, y);
+   * @endcode
+   */
+  Label(const Glib::ustring& label, AlignmentEnum xalign, AlignmentEnum yalign = ALIGN_CENTER, bool mnemonic = false);
+
+
+  /// Doesn't use markup.
+  
+  /** Sets the text within the Gtk::Label widget.  It overwrites any text that
+   * was there before.  
+   * 
+   * This will also clear any previously set mnemonic accelerators.
+   * @param str The text you want to set.
+   */
+  void set_text(const Glib::ustring &str);
+  
+  /** Fetches the text from a label widget, as displayed on the
+   * screen. This does not include any embedded underlines
+   * indicating mnemonics or Pango markup. (See get_label())
+   * @return The text in the label widget.
+   */
+  Glib::ustring get_text() const;
+
+  
+  /** Sets a Pango::AttrList; the attributes in the list are applied to the
+   * label text. The attributes set with this function will be ignored
+   * if the "use_underline" property or the "use_markup" property
+   * is <tt>true</tt>.
+   * @param attrs A Pango::AttrList.
+   */
+  void set_attributes(Pango::AttrList& attrs);
+  
+  /** Gets the attribute list that was set on the label using
+   * set_attributes(), if any. This function does
+   * not reflect attributes that come from the labels markup
+   * (see set_markup()). If you want to get the
+   * effective attributes for the label, use
+   * pango_layout_get_attribute (gtk_label_get_layout (label)).
+   * @return The attribute list, or <tt>0</tt> if none was set.
+   */
+  Pango::AttrList get_attributes() const;
+
+  
+  /** Sets the text of the label. The label is interpreted as
+   * including embedded underlines and/or Pango markup depending
+   * on the values of label->use_underline and label->use_markup.
+   * @param str The new text to set for the label.
+   */
+  void set_label(const Glib::ustring& str);
+  
+  /** Fetches the text from a label widget including any embedded
+   * underlines indicating mnemonics and Pango markup. (See
+   * get_text()).
+   * @return The text of the label widget..
+   */
+  Glib::ustring get_label() const;
+  
+  /** Parses @a str  which is marked up with the Pango text markup language, setting the
+   * label's text and attribute list based on the parse results.  If the @a str  is
+   * external data, you may need to escape it with Glib::markup_escape_text() or
+   * Glib::markup_printf_escaped()&lt;!-- --&gt;:
+   * @code
+   * char *markup;
+   * &lt;!-- --&gt;
+   * markup = g_markup_printf_escaped ("&lt;span style=\"italic\"&gt;%s&lt;/span&gt;", str);
+   * gtk_label_set_markup (GTK_LABEL (label), markup);
+   * g_free (markup);
+   * @endcode
+   * @param str A markup string (see Pango markup format).
+   */
+  void set_markup(const Glib::ustring& str);
+  
+  /** Sets whether the text of the label contains markup in Pango's text markup
+   * language. See set_markup().
+   * @param setting <tt>true</tt> if the label's text should be parsed for markup.
+   */
+  void set_use_markup(bool setting = true);
+  
+  /** Returns whether the label's text is interpreted as marked up with
+   * the Pango text markup
+   * language. See set_use_markup().
+   * @return <tt>true</tt> if the label's text will be parsed for markup.
+   */
+  bool get_use_markup() const;
+  
+  /** If true, an underline in the text indicates the next character should be
+   * used for the mnemonic accelerator key.
+   * @param setting <tt>true</tt> if underlines in the text indicate mnemonics.
+   */
+  void set_use_underline(bool setting = true);
+  
+  /** Returns whether an embedded underline in the label indicates a
+   * mnemonic. See set_use_underline().
+   * @return <tt>true</tt> whether an embedded underline in the label indicates
+   * the mnemonic accelerator keys.
+   */
+  bool get_use_underline() const;
+
+  
+  /** Parses @a str  which is marked up with the Pango text markup language,
+   * setting the label's text and attribute list based on the parse results.
+   * If characters in @a str  are preceded by an underscore, they are underlined
+   * indicating that they represent a keyboard accelerator called a mnemonic.
+   * 
+   * The mnemonic key can be used to activate another widget, chosen automatically,
+   * or explicitly using set_mnemonic_widget().
+   * @param str A markup string (see Pango markup format).
+   */
+  void set_markup_with_mnemonic(const Glib::ustring& str);
+  
+  /** If the label has been set so that it has an mnemonic key this function
+   * returns the keyval used for the mnemonic accelerator. If there is no
+   * mnemonic set up it returns #GDK_VoidSymbol.
+   * @return GDK keyval usable for accelerators, or #GDK_VoidSymbol.
+   */
+  guint get_mnemonic_keyval() const;
+  
+  /** If the label has been set so that it has an mnemonic key (using
+   * i.e.\  set_markup_with_mnemonic(),
+   * set_text_with_mnemonic(), new_with_mnemonic()
+   * or the "use_underline" property) the label can be associated with a
+   * widget that is the target of the mnemonic. When the label is inside
+   * a widget (like a Gtk::Button or a Gtk::Notebook tab) it is
+   * automatically associated with the correct widget, but sometimes
+   * (i.e. when the target is a Gtk::Entry next to the label) you need to
+   * set it explicitly using this function.
+   * 
+   * The target widget will be accelerated by emitting "mnemonic_activate" on it.
+   * The default handler for this signal will activate the widget if there are no
+   * mnemonic collisions and toggle focus between the colliding widgets otherwise.
+   * @param widget The target Gtk::Widget.
+   */
+  void set_mnemonic_widget(Widget& widget);
+  
+  /** Retrieves the target of the mnemonic (keyboard shortcut) of this
+   * label. See set_mnemonic_widget().
+   * @return The target of the label's mnemonic, or <tt>0</tt> if none
+   * has been set and the default algorithm will be used.
+   */
+  Widget* get_mnemonic_widget();
+  
+  /** Retrieves the target of the mnemonic (keyboard shortcut) of this
+   * label. See set_mnemonic_widget().
+   * @return The target of the label's mnemonic, or <tt>0</tt> if none
+   * has been set and the default algorithm will be used.
+   */
+  const Widget* get_mnemonic_widget() const;
+  
+  /** Sets the label's text from the string @a str .
+   * If characters in @a str  are preceded by an underscore, they are underlined
+   * indicating that they represent a keyboard accelerator called a mnemonic.
+   * The mnemonic key can be used to activate another widget, chosen automatically,
+   * or explicitly using set_mnemonic_widget().
+   * @param str A string.
+   */
+  void set_text_with_mnemonic(const Glib::ustring& str);
+  
+  /** Sets the alignment of the lines in the text of the label relative to
+   * each other.  Gtk::JUSTIFY_LEFT is the default value when the
+   * widget is first created with new(). If you instead want
+   * to set the alignment of the label as a whole, use
+   * Gtk::Misc::set_alignment() instead. set_justify() has no
+   * effect on labels containing only a single line.
+   * @param jtype A Gtk::Justification.
+   */
+  void set_justify(Justification jtype);
+  
+  /** Returns the justification of the label. See set_justify().
+   * @return Gtk::Justification.
+   */
+  Justification get_justify() const;
+
+//TODO: Default value?:
+  
+  /** Sets the mode used to ellipsize (add an ellipsis: "...") to the text if there
+   * is not enough space to render the entire string.
+   * 
+   * Since: 2.6
+   * @param mode A Pango::EllipsizeMode.
+   */
+  void set_ellipsize(Pango::EllipsizeMode mode);
+  
+  /** Returns the ellipsizing position of the label. See set_ellipsize().
+   * @return Pango::EllipsizeMode
+   * 
+   * Since: 2.6.
+   */
+  Pango::EllipsizeMode get_ellipsize() const;
+
+  
+  /** Sets the desired width in characters of @a label  to @a n_chars .
+   * 
+   * Since: 2.6
+   * @param n_chars The new desired width, in characters.
+   */
+  void set_width_chars(int n_chars);
+  
+  /** Retrieves the desired width of @a label , in characters. See
+   * set_width_chars().
+   * @return The width of the label in characters.
+   * 
+   * Since: 2.6.
+   */
+  int get_width_chars() const;
+
+  
+  /** Sets the desired maximum width in characters of @a label  to @a n_chars .
+   * 
+   * Since: 2.6
+   * @param n_chars The new desired maximum width, in characters.
+   */
+  void set_max_width_chars(int n_chars);
+  
+  /** Retrieves the desired maximum width of @a label , in characters. See
+   * set_width_chars().
+   * @return The maximum width of the label in characters.
+   * 
+   * Since: 2.6.
+   */
+  int get_max_width_chars() const;
+
+  
+  void set_pattern(const Glib::ustring& pattern);
+  
+  /** Toggles line wrapping within the Gtk::Label widget.  <tt>true</tt> makes it break
+   * lines if text exceeds the widget's size.  <tt>false</tt> lets the text get cut off
+   * by the edge of the widget if it exceeds the widget size.
+   * @param wrap The setting.
+   */
+  void set_line_wrap(bool wrap = true);
+  
+  /** Returns whether lines in the label are automatically wrapped. See set_line_wrap().
+   * @return <tt>true</tt> if the lines of the label are automatically wrapped.
+   */
+  bool get_line_wrap() const;
+  
+  /** Selectable labels allow the user to select text from the label, for
+   * copy-and-paste.
+   * @param setting <tt>true</tt> to allow selecting text in the label.
+   */
+  void set_selectable(bool setting = true);
+  
+  /** Gets the value set by set_selectable().
+   * @return <tt>true</tt> if the user can copy text from the label.
+   */
+  bool get_selectable() const;
+  
+  /** Sets the angle of rotation for the label. An angle of 90 reads from
+   * from bottom to top, an angle of 270, from top to bottom. The angle
+   * setting for the label is ignored if the label is selectable,
+   * wrapped, or ellipsized.
+   * 
+   * Since: 2.6
+   * @param angle The angle that the baseline of the label makes with
+   * the horizontal, in degrees, measured counterclockwise.
+   */
+  void set_angle(double angle);
+  
+  /** Gets the angle of rotation for the label. See
+   * gtk_label_set_angle.
+   * @return The angle of rotation for the label
+   * 
+   * Since: 2.6.
+   */
+  double get_angle() const;
+  
+  /** Selects a range of characters in the label, if the label is selectable.
+   * See set_selectable(). If the label is not selectable,
+   * this function has no effect. If @a start_offset  or
+   *  @a end_offset  are -1, then the end of the label will be substituted.
+   * @param start_offset Start offset (in characters not bytes).
+   * @param end_offset End offset (in characters not bytes).
+   */
+  void select_region(int start_offset, int end_offset);
+
+  /** Selects a range of characters in the label, from @a start_offset to the end,
+   * if the label is selectable.
+   * See gtk_label_set_selectable(). If the label is not selectable,
+   * this function has no effect.
+   *
+   * @param start_offset Start offset (in characters not bytes)
+   */
+  void select_region(int start_offset);
+  
+  
+  /** Gets the selected range of characters in the label, returning <tt>true</tt>
+   * if there's a selection.
+   * @param start Return location for start of selection, as a character offset.
+   * @param end Return location for end of selection, as a character offset.
+   * @return <tt>true</tt> if selection is non-empty.
+   */
+  bool get_selection_bounds(int& start, int& end) const;
+
+  
+  /** Gets the Pango::Layout used to display the label.
+   * The layout is useful to e.g. convert text positions to
+   * pixel positions, in combination with get_layout_offsets().
+   * @return The Pango::Layout for this label.
+   */
+  Glib::RefPtr<Pango::Layout> get_layout();
+  
+  /** Gets the Pango::Layout used to display the label.
+   * The layout is useful to e.g. convert text positions to
+   * pixel positions, in combination with get_layout_offsets().
+   * @return The Pango::Layout for this label.
+   */
+  Glib::RefPtr<const Pango::Layout> get_layout() const;
+  
+  /** Obtains the coordinates where the label will draw the Pango::Layout
+   * representing the text in the label; useful to convert mouse events
+   * into coordinates inside the Pango::Layout, e.g.\ to take some action
+   * if some part of the label is clicked. Of course you will need to
+   * create a Gtk::EventBox to receive the events, and pack the label
+   * inside it, since labels are a Gtk::NO_WINDOW widget. Remember
+   * when using the Pango::Layout functions you need to convert to
+   * and from pixels using PANGO_PIXELS() or Pango::SCALE.
+   * @param x Location to store X offset of layout, or <tt>0</tt>.
+   * @param y Location to store Y offset of layout, or <tt>0</tt>.
+   */
+  void get_layout_offsets(int& x, int& y) const;
+  
+  
+  /** Sets whether the label is in single line mode.
+   * 
+   * Since: 2.6
+   * @param single_line_mode <tt>true</tt> if the label should be in single line mode.
+   */
+  void set_single_line_mode(bool single_line_mode = true);
+  
+  /** Returns whether the label is in single line mode.
+   * @return <tt>true</tt> when the label is in single line mode.
+   * 
+   * Since: 2.6.
+   */
+  bool get_single_line_mode() const;
+
+  
+  Glib::SignalProxy1< void,Menu* > signal_populate_popup();
+
+
+  //Keybinding signals:
+  
+  
+  /** The text of the label.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Glib::ustring> property_label() ;
+
+/** The text of the label.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Glib::ustring> property_label() const;
+
+  /** A list of style attributes to apply to the text of the label.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Pango::AttrList> property_attributes() ;
+
+/** A list of style attributes to apply to the text of the label.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Pango::AttrList> property_attributes() const;
+
+  /** The text of the label includes XML markup. See pango_parse_markup.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_use_markup() ;
+
+/** The text of the label includes XML markup. See pango_parse_markup.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_use_markup() const;
+
+  /** If set
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_use_underline() ;
+
+/** If set
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_use_underline() const;
+
+  /** The alignment of the lines in the text of the label relative to each other. This does NOT affect the alignment of the label within its allocation. See GtkMisc::xalign for that.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Justification> property_justify() ;
+
+/** The alignment of the lines in the text of the label relative to each other. This does NOT affect the alignment of the label within its allocation. See GtkMisc::xalign for that.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Justification> property_justify() const;
+
+  /** A string with _ characters in positions correspond to characters in the text to underline.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_WriteOnly<Glib::ustring> property_pattern() ;
+
+/** A string with _ characters in positions correspond to characters in the text to underline.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Glib::ustring> property_pattern() const;
+
+  /** If set
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_wrap() ;
+
+/** If set
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_wrap() const;
+
+  /** Whether the label text can be selected with the mouse.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_selectable() ;
+
+/** Whether the label text can be selected with the mouse.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_selectable() const;
+
+  /** The mnemonic accelerator key for this label.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<guint> property_mnemonic_keyval() const;
+
+
+  /** The widget to be activated when the label's mnemonic key is pressed.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Widget*> property_mnemonic_widget() ;
+
+/** The widget to be activated when the label's mnemonic key is pressed.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Widget*> property_mnemonic_widget() const;
+
+  /** The current position of the insertion cursor in chars.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<int> property_cursor_position() const;
+
+
+  /** The position of the opposite end of the selection from the cursor in chars.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<int> property_selection_bound() const;
+
+
+  /** The preferred place to ellipsize the string
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Pango::EllipsizeMode> property_ellipsize() ;
+
+/** The preferred place to ellipsize the string
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Pango::EllipsizeMode> property_ellipsize() const;
+
+  /** The desired width of the label
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<int> property_width_chars() ;
+
+/** The desired width of the label
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<int> property_width_chars() const;
+    
+  /** Whether the label is in single line mode.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_single_line_mode() ;
+
+/** Whether the label is in single line mode.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_single_line_mode() const;
+
+  /** Angle at which the label is rotated.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<double> property_angle() ;
+
+/** Angle at which the label is rotated.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<double> property_angle() const;
+
+  /** The desired maximum width of the label
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<int> property_max_width_chars() ;
+
+/** The desired maximum width of the label
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<int> property_max_width_chars() const;
+
+
+};
+
+}  // namespace Gtk
+
+
+namespace Glib
+{
+  /** @relates Gtk::Label
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gtk::Label* wrap(GtkLabel* object, bool take_copy = false);
+}
+#endif /* _GTKMM_LABEL_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/layout.cc b/libs/gtkmm2/gtk/gtkmm/layout.cc
new file mode 100644
index 0000000000..366df0ea6f
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/layout.cc
@@ -0,0 +1,371 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/layout.h>
+#include <gtkmm/private/layout_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* 
+ *
+ * Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtk/gtklayout.h>
+
+namespace Gtk
+{
+
+/* layout.cc
+ * 
+ * Copyright (C) 1998 EMC Capital Management Inc.
+ * Developed by Havoc Pennington <hp@pobox.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+Layout::Layout()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Container(Glib::ConstructParams(layout_class_.init(), (char*) 0))
+{
+  set_hadjustment();
+  set_vadjustment();
+}
+
+Layout::Layout(Adjustment& hadjustment, Adjustment& vadjustment)
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Container(Glib::ConstructParams(layout_class_.init(), (char*) 0))
+{
+  set_hadjustment(hadjustment);
+  set_vadjustment(vadjustment);
+}
+
+void Layout::set_hadjustment()
+{
+  gtk_layout_set_hadjustment(gobj(), 0);
+}
+
+void Layout::set_vadjustment()
+{
+  gtk_layout_set_vadjustment(gobj(), 0);
+}
+
+} // namespace Gtk
+
+
+namespace
+{
+
+void Layout_signal_set_scroll_adjustments_callback(GtkLayout* self, GtkAdjustment* p0,GtkAdjustment* p1,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,Adjustment*,Adjustment* > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(Glib::wrap(p0)
+, Glib::wrap(p1)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+}
+
+const Glib::SignalProxyInfo Layout_signal_set_scroll_adjustments_info =
+{
+  "set_scroll_adjustments",
+  (GCallback) &Layout_signal_set_scroll_adjustments_callback,
+  (GCallback) &Layout_signal_set_scroll_adjustments_callback
+};
+
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Gtk::Layout* wrap(GtkLayout* object, bool take_copy)
+{
+  return dynamic_cast<Gtk::Layout *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& Layout_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &Layout_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_layout_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void Layout_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+  klass->set_scroll_adjustments = &set_scroll_adjustments_callback;
+}
+
+
+void Layout_Class::set_scroll_adjustments_callback(GtkLayout* self, GtkAdjustment* p0, GtkAdjustment* p1)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_set_scroll_adjustments(Glib::wrap(p0)
+, Glib::wrap(p1)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->set_scroll_adjustments)
+      (*base->set_scroll_adjustments)(self, p0, p1);
+  }
+}
+
+
+Glib::ObjectBase* Layout_Class::wrap_new(GObject* o)
+{
+  return manage(new Layout((GtkLayout*)(o)));
+
+}
+
+
+/* The implementation: */
+
+Layout::Layout(const Glib::ConstructParams& construct_params)
+:
+  Gtk::Container(construct_params)
+{
+  }
+
+Layout::Layout(GtkLayout* castitem)
+:
+  Gtk::Container((GtkContainer*)(castitem))
+{
+  }
+
+Layout::~Layout()
+{
+  destroy_();
+}
+
+Layout::CppClassType Layout::layout_class_; // initialize static member
+
+GType Layout::get_type()
+{
+  return layout_class_.init().get_type();
+}
+
+GType Layout::get_base_type()
+{
+  return gtk_layout_get_type();
+}
+
+
+void Layout::put(Widget& child_widget, int x, int y)
+{
+  gtk_layout_put(gobj(), (child_widget).gobj(), x, y);
+}
+
+void Layout::move(Widget& child_widget, int x, int y)
+{
+  gtk_layout_move(gobj(), (child_widget).gobj(), x, y);
+}
+
+void Layout::set_size(guint width, guint height)
+{
+  gtk_layout_set_size(gobj(), width, height);
+}
+
+void Layout::get_size(guint& width, guint& height) const
+{
+  gtk_layout_get_size(const_cast<GtkLayout*>(gobj()), &(width), &(height));
+}
+
+void Layout::set_hadjustment(Adjustment& adjustment)
+{
+  gtk_layout_set_hadjustment(gobj(), (adjustment).gobj());
+}
+
+Adjustment* Layout::get_hadjustment()
+{
+  return Glib::wrap(gtk_layout_get_hadjustment(gobj()));
+}
+
+const Adjustment* Layout::get_hadjustment() const
+{
+  return Glib::wrap(gtk_layout_get_hadjustment(const_cast<GtkLayout*>(gobj())));
+}
+
+void Layout::set_vadjustment(Adjustment& adjustment)
+{
+  gtk_layout_set_vadjustment(gobj(), (adjustment).gobj());
+}
+
+Adjustment* Layout::get_vadjustment()
+{
+  return Glib::wrap(gtk_layout_get_vadjustment(gobj()));
+}
+
+const Adjustment* Layout::get_vadjustment() const
+{
+  return Glib::wrap(gtk_layout_get_vadjustment(const_cast<GtkLayout*>(gobj())));
+}
+
+Glib::RefPtr<Gdk::Window> Layout::get_bin_window()
+{
+  Glib::RefPtr<Gdk::Window> ref_ptr(Glib::wrap((GdkWindowObject*)(gobj()->bin_window)));
+
+  if(ref_ptr)
+    ref_ptr->reference();
+
+  return ref_ptr;
+}
+
+Glib::RefPtr<const Gdk::Window> Layout::get_bin_window() const
+{
+  Glib::RefPtr<const Gdk::Window> ref_ptr(Glib::wrap((GdkWindowObject*)(gobj()->bin_window)));
+
+  if(ref_ptr)
+    ref_ptr->reference();
+
+  return ref_ptr;
+}
+
+
+Glib::SignalProxy2< void,Adjustment*,Adjustment* > Layout::signal_set_scroll_adjustments()
+{
+  return Glib::SignalProxy2< void,Adjustment*,Adjustment* >(this, &Layout_signal_set_scroll_adjustments_info);
+}
+
+
+Glib::PropertyProxy<Adjustment*> Layout::property_hadjustment() 
+{
+  return Glib::PropertyProxy<Adjustment*>(this, "hadjustment");
+}
+
+Glib::PropertyProxy_ReadOnly<Adjustment*> Layout::property_hadjustment() const
+{
+  return Glib::PropertyProxy_ReadOnly<Adjustment*>(this, "hadjustment");
+}
+
+Glib::PropertyProxy<Adjustment*> Layout::property_vadjustment() 
+{
+  return Glib::PropertyProxy<Adjustment*>(this, "vadjustment");
+}
+
+Glib::PropertyProxy_ReadOnly<Adjustment*> Layout::property_vadjustment() const
+{
+  return Glib::PropertyProxy_ReadOnly<Adjustment*>(this, "vadjustment");
+}
+
+Glib::PropertyProxy<guint> Layout::property_width() 
+{
+  return Glib::PropertyProxy<guint>(this, "width");
+}
+
+Glib::PropertyProxy_ReadOnly<guint> Layout::property_width() const
+{
+  return Glib::PropertyProxy_ReadOnly<guint>(this, "width");
+}
+
+Glib::PropertyProxy<guint> Layout::property_height() 
+{
+  return Glib::PropertyProxy<guint>(this, "height");
+}
+
+Glib::PropertyProxy_ReadOnly<guint> Layout::property_height() const
+{
+  return Glib::PropertyProxy_ReadOnly<guint>(this, "height");
+}
+
+
+void Gtk::Layout::on_set_scroll_adjustments(Adjustment* hadj, Adjustment* vadj)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->set_scroll_adjustments)
+    (*base->set_scroll_adjustments)(gobj(),(GtkAdjustment*)Glib::unwrap(hadj),(GtkAdjustment*)Glib::unwrap(vadj));
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/layout.h b/libs/gtkmm2/gtk/gtkmm/layout.h
new file mode 100644
index 0000000000..107cf725ff
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/layout.h
@@ -0,0 +1,300 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_LAYOUT_H
+#define _GTKMM_LAYOUT_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* layout.h
+ * 
+ * Copyright (C) 2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/container.h>
+#include <gtkmm/adjustment.h>
+#include <gdkmm/window.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkLayout GtkLayout;
+typedef struct _GtkLayoutClass GtkLayoutClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class Layout_Class; } // namespace Gtk
+namespace Gtk
+{
+
+/** Infinite scrollable area containing child widgets and/or custom drawing.
+ *
+ * Gtk::Layout is similar to Gtk::DrawingArea in that it's a "blank slate"
+ * and doesn't do anything but paint a blank background by default. It's
+ * different in that it supports scrolling natively (You can add it directly
+ * to a Gtk::ScrolledWindow), and it can contain child widgets, since it's a
+ * Gtk::Container.  However if you're just going to draw, a Gtk::DrawingArea
+ * is a better choice since it has lower overhead.
+ *
+ * When handling expose_event signals, you must draw to the bin_window
+ * Gdk::Window - see get_bin_window() - rather than the normal Gdk::Window -
+ * see get_window() - as you would for a drawing area.
+ *
+ * @ingroup Widgets
+ * @ingroup Containers
+ */
+
+class Layout : public Container
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Layout CppObjectType;
+  typedef Layout_Class CppClassType;
+  typedef GtkLayout BaseObjectType;
+  typedef GtkLayoutClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~Layout();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class Layout_Class;
+  static CppClassType layout_class_;
+
+  // noncopyable
+  Layout(const Layout&);
+  Layout& operator=(const Layout&);
+
+protected:
+  explicit Layout(const Glib::ConstructParams& construct_params);
+  explicit Layout(GtkLayout* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GtkLayout*       gobj()       { return reinterpret_cast<GtkLayout*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GtkLayout* gobj() const { return reinterpret_cast<GtkLayout*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+  virtual void on_set_scroll_adjustments(Adjustment* hadj, Adjustment* vadj);
+
+
+private:
+
+  
+public:
+  Layout();
+  Layout(Adjustment& hadjustment, Adjustment& vadjustment);
+
+  
+  /** Adds @a child_widget  to @a layout , at position ( @a x , @a y ).
+   *  @a layout  becomes the new parent container of @a child_widget .
+   * @param child_widget Child widget.
+   * @param x X position of child widget.
+   * @param y Y position of child widget.
+   */
+  void put(Widget& child_widget, int x, int y);
+  
+  /** Moves a current child of @a layout  to a new position.
+   * @param child_widget A current child of @a layout .
+   * @param x X position to move to.
+   * @param y Y position to move to.
+   */
+  void move(Widget& child_widget, int x, int y);
+  
+  /** Sets the size of the scrollable area of the layout.
+   * @param width Width of entire scrollable area.
+   * @param height Height of entire scrollable area.
+   */
+  void set_size(guint width, guint height);
+  
+  /** Gets the size that has been set on the layout, and that determines
+   * the total extents of the layout's scrollbar area. See
+   * set_size().
+   * @param width Location to store the width set on @a layout , or <tt>0</tt>.
+   * @param height Location to store the height set on @a layout , or <tt>0</tt>.
+   */
+  void get_size(guint& width, guint& height) const;
+
+  
+  /** Sets the horizontal scroll adjustment for the layout.
+   * 
+   * See Gtk::ScrolledWindow, Gtk::Scrollbar, Gtk::Adjustment for details.
+   * @param adjustment New scroll adjustment.
+   */
+  void set_hadjustment(Adjustment& adjustment);
+
+  /// Creates the Adjustment.
+  void set_hadjustment();
+  
+  /** This function should only be called after the layout has been
+   * placed in a Gtk::ScrolledWindow or otherwise configured for
+   * scrolling. It returns the Gtk::Adjustment used for communication
+   * between the horizontal scrollbar and @a layout .
+   * 
+   * See Gtk::ScrolledWindow, Gtk::Scrollbar, Gtk::Adjustment for details.
+   * @return Horizontal scroll adjustment.
+   */
+  Adjustment* get_hadjustment();
+  
+  /** This function should only be called after the layout has been
+   * placed in a Gtk::ScrolledWindow or otherwise configured for
+   * scrolling. It returns the Gtk::Adjustment used for communication
+   * between the horizontal scrollbar and @a layout .
+   * 
+   * See Gtk::ScrolledWindow, Gtk::Scrollbar, Gtk::Adjustment for details.
+   * @return Horizontal scroll adjustment.
+   */
+  const Adjustment* get_hadjustment() const;
+  
+  /** Sets the vertical scroll adjustment for the layout.
+   * 
+   * See Gtk::ScrolledWindow, Gtk::Scrollbar, Gtk::Adjustment for details.
+   * @param adjustment New scroll adjustment.
+   */
+  void set_vadjustment(Adjustment& adjustment);
+
+  /// Creates the Adjustment.
+  void set_vadjustment();
+  
+  /** This function should only be called after the layout has been
+   * placed in a Gtk::ScrolledWindow or otherwise configured for
+   * scrolling. It returns the Gtk::Adjustment used for communication
+   * between the vertical scrollbar and @a layout .
+   * 
+   * See Gtk::ScrolledWindow, Gtk::Scrollbar, Gtk::Adjustment for details.
+   * @return Vertical scroll adjustment.
+   */
+  Adjustment* get_vadjustment();
+  
+  /** This function should only be called after the layout has been
+   * placed in a Gtk::ScrolledWindow or otherwise configured for
+   * scrolling. It returns the Gtk::Adjustment used for communication
+   * between the vertical scrollbar and @a layout .
+   * 
+   * See Gtk::ScrolledWindow, Gtk::Scrollbar, Gtk::Adjustment for details.
+   * @return Vertical scroll adjustment.
+   */
+  const Adjustment* get_vadjustment() const;
+
+  Glib::RefPtr<Gdk::Window> get_bin_window();
+  Glib::RefPtr<const Gdk::Window> get_bin_window() const;
+
+  // See Gtk::Widget::set_scroll_adjustments()
+  
+
+  Glib::SignalProxy2< void,Adjustment*,Adjustment* > signal_set_scroll_adjustments();
+
+
+  /** The GtkAdjustment for the horizontal position.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Adjustment*> property_hadjustment() ;
+
+/** The GtkAdjustment for the horizontal position.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Adjustment*> property_hadjustment() const;
+
+  /** The GtkAdjustment for the vertical position.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Adjustment*> property_vadjustment() ;
+
+/** The GtkAdjustment for the vertical position.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Adjustment*> property_vadjustment() const;
+
+  /** The width of the layout.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<guint> property_width() ;
+
+/** The width of the layout.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<guint> property_width() const;
+
+  /** The height of the layout.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<guint> property_height() ;
+
+/** The height of the layout.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<guint> property_height() const;
+
+
+};
+
+} /* namespace Gtk */
+
+
+namespace Glib
+{
+  /** @relates Gtk::Layout
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gtk::Layout* wrap(GtkLayout* object, bool take_copy = false);
+}
+#endif /* _GTKMM_LAYOUT_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/liststore.cc b/libs/gtkmm2/gtk/gtkmm/liststore.cc
new file mode 100644
index 0000000000..dadeb5f4f5
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/liststore.cc
@@ -0,0 +1,264 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/liststore.h>
+#include <gtkmm/private/liststore_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtk/gtkliststore.h>
+
+
+namespace Gtk
+{
+
+ListStore::ListStore(const TreeModelColumnRecord& columns)
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Glib::Object(Glib::ConstructParams(liststore_class_.init(), (char*) 0))
+{
+  gtk_list_store_set_column_types(gobj(), columns.size(), const_cast<GType*>(columns.types()));
+}
+
+void ListStore::set_column_types(const TreeModelColumnRecord& columns)
+{
+   gtk_list_store_set_column_types(gobj(), columns.size(), const_cast<GType*>(columns.types()));
+}
+  
+
+TreeModel::iterator ListStore::erase(const iterator& iter)
+{
+  g_assert(iter.get_gobject_if_not_end() != 0);
+
+  iterator next(iter);
+  ++next;
+
+  GtkTreeIter tmp = *iter.gobj();
+  gtk_list_store_remove(gobj(), &tmp);
+
+  return next;
+}
+
+TreeModel::iterator ListStore::insert(const iterator& iter)
+{
+  iterator new_pos(this);
+
+  // get_gobject_if_not_end() returns 0 if iter is an end iterator, which
+  // is in turn interpreted by gtk_list_store_insert_before() as a request to
+  // insert at the end of the list.
+
+  gtk_list_store_insert_before(
+      gobj(), new_pos.gobj(),
+      const_cast<GtkTreeIter*>(iter.get_gobject_if_not_end()));
+
+  // GtkTreeIter::stamp should always have a value if it's valid.
+  // For end iterators, we need to remember the iter's parent, and
+  // this is what setup_end_iterator() does.
+
+  if(new_pos.gobj()->stamp == 0)
+    new_pos.setup_end_iterator(iter);
+
+  return new_pos;
+}
+
+TreeModel::iterator ListStore::insert_after(const iterator& iter)
+{
+  iterator new_pos(this);
+
+  // get_gobject_if_not_end() returns 0 if iter is an end iterator, which
+  // is in turn interpreted by gtk_list_store_insert_after() as a request to
+  // insert at the beginning of the list.
+
+  gtk_list_store_insert_after(
+      gobj(), new_pos.gobj(),
+      const_cast<GtkTreeIter*>(iter.get_gobject_if_not_end()));
+
+  // GtkTreeIter::stamp should always have a value if it's valid.
+  // For end iterators, we need to remember the iter's parent, and
+  // this is what setup_end_iterator() does.
+
+  if(new_pos.gobj()->stamp == 0)
+    new_pos.setup_end_iterator(iter);
+
+  return new_pos;
+}
+
+TreeModel::iterator ListStore::prepend()
+{
+  iterator new_pos(this);
+  gtk_list_store_prepend(gobj(), new_pos.gobj());
+  return new_pos;
+}
+
+TreeModel::iterator ListStore::append()
+{
+  iterator new_pos(this);
+  gtk_list_store_append(gobj(), new_pos.gobj());
+  return new_pos;
+}
+
+void ListStore::move(const iterator& source, const iterator& destination)
+{
+  gtk_list_store_move_before(gobj(),
+      const_cast<GtkTreeIter*>(source.get_gobject_if_not_end()),
+      const_cast<GtkTreeIter*>(destination.get_gobject_if_not_end()));
+}
+
+void ListStore::reorder(const Glib::ArrayHandle<int>& new_order)
+{
+  gtk_list_store_reorder(gobj(), const_cast<int*>(new_order.data()));
+}
+
+void ListStore::set_value_impl(const iterator& row, int column, const Glib::ValueBase& value)
+{
+  gtk_list_store_set_value(
+      gobj(), const_cast<GtkTreeIter*>(row.gobj()),
+      column, const_cast<GValue*>(value.gobj()));
+}
+
+} // namespace Gtk
+
+
+namespace
+{
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Glib::RefPtr<Gtk::ListStore> wrap(GtkListStore* object, bool take_copy)
+{
+  return Glib::RefPtr<Gtk::ListStore>( dynamic_cast<Gtk::ListStore*> (Glib::wrap_auto ((GObject*)(object), take_copy)) );
+  //We use dynamic_cast<> in case of multiple inheritance.
+}
+
+} /* namespace Glib */
+
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& ListStore_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &ListStore_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_list_store_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  TreeModel::add_interface(get_type());
+  TreeSortable::add_interface(get_type());
+  TreeDragSource::add_interface(get_type());
+  TreeDragDest::add_interface(get_type());
+  }
+
+  return *this;
+}
+
+void ListStore_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+}
+
+
+Glib::ObjectBase* ListStore_Class::wrap_new(GObject* object)
+{
+  return new ListStore((GtkListStore*)object);
+}
+
+
+/* The implementation: */
+
+GtkListStore* ListStore::gobj_copy()
+{
+  reference();
+  return gobj();
+}
+
+ListStore::ListStore(const Glib::ConstructParams& construct_params)
+:
+  Glib::Object(construct_params)
+{}
+
+ListStore::ListStore(GtkListStore* castitem)
+:
+  Glib::Object((GObject*)(castitem))
+{}
+
+ListStore::~ListStore()
+{}
+
+
+ListStore::CppClassType ListStore::liststore_class_; // initialize static member
+
+GType ListStore::get_type()
+{
+  return liststore_class_.init().get_type();
+}
+
+GType ListStore::get_base_type()
+{
+  return gtk_list_store_get_type();
+}
+
+
+ListStore::ListStore()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Glib::Object(Glib::ConstructParams(liststore_class_.init()))
+{
+  }
+
+Glib::RefPtr<ListStore> ListStore::create(const TreeModelColumnRecord& columns)
+{
+  return Glib::RefPtr<ListStore>( new ListStore(columns) );
+}
+void ListStore::iter_swap(const iterator& a, const iterator& b)
+{
+  gtk_list_store_swap(gobj(), const_cast<GtkTreeIter*>((a).gobj()), const_cast<GtkTreeIter*>((b).gobj()));
+}
+
+void ListStore::clear()
+{
+  gtk_list_store_clear(gobj());
+}
+
+bool ListStore::iter_is_valid(const iterator& iter) const
+{
+  return gtk_list_store_iter_is_valid(const_cast<GtkListStore*>(gobj()), const_cast<GtkTreeIter*>((iter).gobj()));
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/liststore.h b/libs/gtkmm2/gtk/gtkmm/liststore.h
new file mode 100644
index 0000000000..9d2fe355e2
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/liststore.h
@@ -0,0 +1,246 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_LISTSTORE_H
+#define _GTKMM_LISTSTORE_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* Copyright(C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/treeiter.h>
+#include <gtkmm/treemodel.h>
+#include <gtkmm/treesortable.h>
+#include <gtkmm/treedragdest.h>
+#include <gtkmm/treedragsource.h>
+// We couldn't include it in treemodel.h, but doing it here makes it easier for people.
+#include <gtkmm/treepath.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkListStore GtkListStore;
+typedef struct _GtkListStoreClass GtkListStoreClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class ListStore_Class; } // namespace Gtk
+namespace Gtk
+{
+
+/** Thist is a list model for use with a Gtk::TreeView widget.
+ * @ingroup TreeView
+ * It implements the Gtk::TreeModel interface, and also implements the
+ * Gtk::TreeSortable interface so you can sort the list using the view.
+ * Finally, it also implements the tree drag and drop interfaces.
+ */
+
+class ListStore :
+  public Glib::Object,
+  public TreeModel,
+  public TreeSortable,
+  public TreeDragSource,
+  public TreeDragDest
+{
+  
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+public:
+  typedef ListStore CppObjectType;
+  typedef ListStore_Class CppClassType;
+  typedef GtkListStore BaseObjectType;
+  typedef GtkListStoreClass BaseClassType;
+
+private:  friend class ListStore_Class;
+  static CppClassType liststore_class_;
+
+private:
+  // noncopyable
+  ListStore(const ListStore&);
+  ListStore& operator=(const ListStore&);
+
+protected:
+  explicit ListStore(const Glib::ConstructParams& construct_params);
+  explicit ListStore(GtkListStore* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+  virtual ~ListStore();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GObject.
+  GtkListStore*       gobj()       { return reinterpret_cast<GtkListStore*>(gobject_); }
+
+  ///Provides access to the underlying C GObject.
+  const GtkListStore* gobj() const { return reinterpret_cast<GtkListStore*>(gobject_); }
+
+  ///Provides access to the underlying C instance. The caller is responsible for unrefing it. Use when directly setting fields in structs.
+  GtkListStore* gobj_copy();
+
+private:
+
+  
+protected:
+  /** When using this constructor, you must use set_column_types() immediately afterwards.
+   * This can be useful when deriving from this class, with a fixed TreeModelColumnRecord
+   * that is a member of the class.
+   * There is no create() method that corresponds to this constructor, because this
+   * constructor should only be used by derived classes.
+   */
+  ListStore();
+  
+  explicit ListStore(const TreeModelColumnRecord& columns);
+
+public:
+
+  /** Instantiate a new ListStore.
+   * @param columns The column types for this tree model.
+   * @result The new ListStore.
+   */
+  
+  static Glib::RefPtr<ListStore> create(const TreeModelColumnRecord& columns);
+
+
+  void set_column_types(const TreeModelColumnRecord& columns);
+  
+  
+  /** Removes the given row from the list store.
+   * @param iter The iterator to the row to be removed.
+   * @result An iterator to the next row, or end() if there is none.
+   */
+  iterator erase(const iterator& iter);
+  
+
+  //TODO: Make this documentation similar to documentation for Standard C++ insert methods.
+  /** Creates a new row before the position.
+   * If iter is end() then a new row will be appended to the list.
+   * The row will be empty - to fill in values, you need to dereference the returned iterator and use Row::operator[] or Row::set_value().
+   * See also prepend() and append().
+   *
+   * @param iter An iterator to the row before which the new row will be inserted.
+   * @result An iterator to the new row. 
+   */
+  iterator insert(const iterator& iter);
+  
+
+  //TODO: Docs. This one is apparently faster.
+  /** Creates a new row after the position.
+   * If iter is end() then a new row will be prepended to the list.
+   * The row will be empty - to fill in values, you need to dereference the returned iterator and use Row::operator[] or Row::set_value().
+   * See also insert(), prepend() and append().
+   *
+   * @param iter An iterator to the row after which the new row will be inserted.
+   * @result An iterator to the new row.
+   */
+  iterator insert_after(const iterator& iter);
+  
+  
+  /** Creates a new row at the start.
+   * The row will be empty - to fill in values, you need to dereference the returned iterator and use Row::operator[] or Row::set_value().
+   * See also insert() and append().
+   *
+   * @result An iterator to the new row.
+   */
+  iterator prepend();
+
+  /** Creates a new row at the end.
+   * The row will be empty - to fill in values, you need to dereference the returned iterator and use Row::operator[] or Row::set_value().
+   * See also insert() and prepend().
+   *
+   * @result An iterator to the new row.
+   */
+  iterator append();
+
+  
+  /** Swaps @a a  and @a b  in @a store . Note that this function only works with
+   * unsorted stores.
+   * 
+   * Since: 2.2
+   * @param a A Gtk::TreeIter.
+   * @param b Another Gtk::TreeIter.
+   */
+  void iter_swap(const iterator& a, const iterator& b);
+
+  /** Moves @a source to the position at @a destination.
+   * Note that this function only works with unsorted stores.
+   * @param source The row that should be moved.
+   * @param destination The position to move to.
+   */
+  void move(const iterator& source, const iterator& destination);
+
+  /** Reorders the list store to follow the order indicated by @a new_order.
+   * Note that this function only works with unsorted stores.
+   */
+  void reorder(const Glib::ArrayHandle<int>& new_order);
+
+  
+  /** Removes all rows from the list store.
+   */
+  void clear();
+
+  
+  /** &lt;warning&gt;This function is slow. Only use it for debugging and/or testing
+   * purposes.&lt;/warning&gt;
+   * 
+   * Checks if the given iter is a valid iter for this Gtk::ListStore.
+   * @param iter A Gtk::TreeIter.
+   * @return <tt>true</tt> if the iter is valid, <tt>false</tt> if the iter is invalid.
+   * 
+   * Since: 2.2.
+   */
+  bool iter_is_valid(const iterator& iter) const;
+
+protected:
+  virtual void set_value_impl(const iterator& row, int column, const Glib::ValueBase& value);
+
+
+public:
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+};
+
+} // namespace Gtk
+
+
+namespace Glib
+{
+  /** @relates Gtk::ListStore
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Glib::RefPtr<Gtk::ListStore> wrap(GtkListStore* object, bool take_copy = false);
+}
+
+
+#endif /* _GTKMM_LISTSTORE_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/main.cc b/libs/gtkmm2/gtk/gtkmm/main.cc
new file mode 100644
index 0000000000..9ff2be9aa7
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/main.cc
@@ -0,0 +1,538 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/main.h>
+#include <gtkmm/private/main_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* 
+ *
+ * Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <glib.h>
+#include <gtkmmconfig.h>
+#include <gtkmm/main.h>
+#include <gtkmm/window.h>
+#include <glibmm/init.h>
+#include <pangomm/wrap_init.h>
+#include <atkmm/wrap_init.h>
+#include <gdkmm/wrap_init.h>
+#include <gtkmm/wrap_init.h>
+
+namespace
+{
+
+/* This class tells sigc++ how to break GTK+ main signal connections.  Since
+ * the gtk_*_remove() functions have the same signature, all main signals can
+ * be handled by a single class.  Special handling is needed for signals that
+ * don't support destroy notification; see the comment on connection_list_.
+ */
+class GtkMainConnectionNode
+{
+public:
+  // A function taking a connection id, e.g. gtk_timeout_remove().
+  typedef void (*RemoveFunc) (guint);
+
+  explicit GtkMainConnectionNode(const sigc::slot_base& slot);
+
+  static void* notify(void* data);
+  static void destroy_notify_handler(void* data);
+
+  // Call this after installing the GTK+ callback.
+  void install(guint conn_id, RemoveFunc remove_func, bool has_destroy_notify);
+
+  inline sigc::slot_base* get_slot();
+
+  static bool list_remove(GtkMainConnectionNode* conn_node);
+  static void list_notify_all();
+
+private:
+  sigc::slot_base slot_;
+  static GSList*  connection_list_;
+
+  guint           conn_id_;
+  RemoveFunc      remove_func_;
+  bool            has_destroy_notify_;
+  bool            destroyed_;
+};
+
+
+/* The global connection_list_ is needed to deal with GTK+ main signals
+ * that don't support destroy notification.  This applies only to
+ * gtk_key_snooper_install() and gtk_init_add().
+ *
+ * The list is static and not a member of Gtk::Main, in order to support
+ * connection to Gtk::Main::signal_run() before Gtk::Main is instantiated.
+ * Thus, it's possible to install initialization hooks in global constructors,
+ * for instance.
+ */
+// static
+GSList* GtkMainConnectionNode::connection_list_ = 0;
+
+GtkMainConnectionNode::GtkMainConnectionNode(const sigc::slot_base& slot)
+:
+  slot_(slot),
+  conn_id_             (0),
+  remove_func_         (0),
+  has_destroy_notify_          (false),
+  destroyed_           (false)
+{
+  slot_.set_parent(this, &GtkMainConnectionNode::notify);
+}
+
+//static:
+void* GtkMainConnectionNode::notify(void* data)
+{
+  // notification from the sigc++ side ...
+
+  GtkMainConnectionNode *const self = static_cast<GtkMainConnectionNode*>(data);
+
+  // this call might be triggered from destroy_notify_handler().
+  if(!self->destroyed_)
+  {
+    // during (*remove_func_)() destroy_notify_handler() might get called.
+    // This must not lead to the destruction of the object!
+    self->destroyed_ = true;
+
+    // disconnect from the gtk+ side.
+    (*(self->remove_func_))(self->conn_id_);
+
+    // remove self from global list.
+    if (!self->has_destroy_notify_)
+      list_remove(self);
+
+    // destruction of slot_ notifies all objects referring to it.
+    delete self;
+  }
+
+  return 0;
+}
+
+// static
+void GtkMainConnectionNode::destroy_notify_handler(void* data)
+{
+  // notification from the gtk+ side ...
+
+  GtkMainConnectionNode *const self = static_cast<GtkMainConnectionNode*>(data);
+
+  // this call might be triggered from notify().
+  if(!self->destroyed_)
+  {
+    self->destroyed_ = true;
+
+    // The GTK+ side is disconnected now, thus the ID is no longer valid.
+    self->conn_id_ = 0;
+
+    // remove self from global list.
+    if (!self->has_destroy_notify_)
+      list_remove(self);
+
+    // destruction of slot_ notifies all objects referring to it.
+    delete self;
+  }
+}
+
+void GtkMainConnectionNode::install(
+    guint conn_id, GtkMainConnectionNode::RemoveFunc remove_func, bool has_destroy_notify)
+{
+  conn_id_     = conn_id;
+  remove_func_ = remove_func;
+  has_destroy_notify_  = has_destroy_notify;
+
+  if (!has_destroy_notify_)
+    connection_list_ = g_slist_prepend(connection_list_, this);
+}
+
+inline
+sigc::slot_base* GtkMainConnectionNode::get_slot()
+{
+  return &slot_;
+}
+
+// static
+bool GtkMainConnectionNode::list_remove(GtkMainConnectionNode* conn_node)
+{
+  // The conn_node pointer is only valid if we still hold
+  // a reference of the ConnectionNode in our global list.
+  //
+  if(GSList *const link = g_slist_find(connection_list_, conn_node))
+  {
+    connection_list_ = g_slist_delete_link(connection_list_, link);
+    return true;
+  }
+
+  return false;
+}
+
+/* Cleanup function to be called by the Gtk::Main destructor.  The elements
+ * are removed prior to notification, in order to avoid invalid elements in
+ * the container.
+ */
+// static
+void GtkMainConnectionNode::list_notify_all()
+{
+  while(connection_list_ != 0)
+  {
+    GtkMainConnectionNode *const conn_node =
+        static_cast<GtkMainConnectionNode*>(connection_list_->data);
+
+    connection_list_ = g_slist_delete_link(connection_list_, connection_list_);
+
+    // no need to search the list in notify().
+    conn_node->has_destroy_notify_ = true;
+
+    // conn_node gets destroyed from notify().
+    notify(conn_node);
+  }
+}
+
+} // anonymous namespace
+
+
+namespace Gtk
+{
+
+/**** Gtk::RunSig **********************************************************/
+
+sigc::connection RunSig::connect(const RunSig::SlotType& slot)
+{
+  GtkMainConnectionNode *const conn_node = new GtkMainConnectionNode(slot);
+  const sigc::connection connection(*conn_node->get_slot());
+
+  // The callback will be invoked the next time gtk_main() is called.
+  gtk_init_add(&RunSig::gtk_callback, conn_node);
+
+  conn_node->install(0, 0, false); // there's no gtk_init_remove()
+  return connection;
+}
+
+// static
+gboolean RunSig::gtk_callback(gpointer data)
+{
+  GtkMainConnectionNode *const conn_node =
+      static_cast<GtkMainConnectionNode*>(data);
+
+  if(GtkMainConnectionNode::list_remove(conn_node))
+  {
+    try
+    {
+      // Recreate the specific SlotType from the generic slot_base.
+      SlotType* pSlot = static_cast<SlotType*>(conn_node->get_slot());
+      (*pSlot)();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+
+    // We don't need it anymore, since RunSig is a one-shot signal.
+    GtkMainConnectionNode::destroy_notify_handler(conn_node);
+  }
+
+  return 0;
+}
+
+
+/**** Gtk::QuitSig *********************************************************/
+
+sigc::connection QuitSig::connect(const QuitSig::SlotType& slot, guint main_level)
+{
+  GtkMainConnectionNode *const conn_node = new GtkMainConnectionNode(slot);
+  const sigc::connection connection(*conn_node->get_slot());
+
+  const guint conn_id = gtk_quit_add_full(
+      main_level, &QuitSig::gtk_callback, 0 /* marshaller */,
+      conn_node, &GtkMainConnectionNode::destroy_notify_handler);
+
+  conn_node->install(conn_id, &gtk_quit_remove, true);
+  return connection;
+}
+
+// static
+gboolean QuitSig::gtk_callback(gpointer data)
+{
+  try
+  {
+    // Call the slot:
+    GtkMainConnectionNode* node = static_cast<GtkMainConnectionNode*>(data);
+    SlotType* pSlot = static_cast<SlotType*>(node->get_slot());
+    (*pSlot)();
+  }
+  catch(...)
+  {
+    Glib::exception_handlers_invoke();
+  }
+  return 0;
+}
+
+
+/**** Gtk::KeySnooperSig ***************************************************/
+
+sigc::connection KeySnooperSig::connect(const KeySnooperSig::SlotType& slot)
+{
+  GtkMainConnectionNode *const conn_node = new GtkMainConnectionNode(slot);
+  const sigc::connection connection(*conn_node->get_slot());
+
+  const guint conn_id = gtk_key_snooper_install(&KeySnooperSig::gtk_callback, conn_node);
+
+  conn_node->install(conn_id, &gtk_key_snooper_remove, false);
+  return connection;
+}
+
+// static
+gint KeySnooperSig::gtk_callback(GtkWidget* widget, GdkEventKey* event, gpointer data)
+{
+  try
+  {
+    // Recreate the specific SlotType from the generic slot node.
+    GtkMainConnectionNode* conn_node = static_cast<GtkMainConnectionNode*>(data);
+    SlotType* pSlot = static_cast<SlotType*>(conn_node->get_slot());
+    return (*pSlot)(Glib::wrap(widget), event);
+  }
+  catch(...)
+  {
+    Glib::exception_handlers_invoke();
+  }
+  return 0;
+}
+
+
+/**** Gtk::Main -- static data *********************************************/
+
+RunSig        Main::signal_run_;
+QuitSig       Main::signal_quit_;
+KeySnooperSig Main::signal_key_snooper_;
+Main*         Main::instance_ = 0;
+
+
+/**** Gtk::Main -- construction/destruction ********************************/
+
+Main::Main(int& argc, char**& argv, bool set_locale)
+{
+  init(&argc, &argv, set_locale);
+}
+
+Main::Main(int* argc, char*** argv, bool set_locale)
+{
+  init(argc, argv, set_locale);
+}
+
+/*Main::Main(int* argc, char*** argv, const std::string& parameter_string, const Glib::ArrayHandle<const Glib::OptionEntry&>& entries, const std::string& translation_domain)
+{
+  init(argc, argv, parameter_string, entries, translation_domain);
+}*/
+
+// Default ctor only used by subclasses:
+Main::Main()
+{
+  if(instance_ == 0)
+  {
+    init_gtkmm_internals();
+    instance_ = this;
+  }
+  else
+  {
+    g_warning("Gtk::Main instantiated twice");
+  }
+}
+
+Main::~Main()
+{
+  // A second Gtk::Main will produce a warning, but
+  // Main::~Main would still run. So this prevents the crash.
+  if(instance_ == this)
+  {
+    instance_ = 0;
+    GtkMainConnectionNode::list_notify_all();
+
+    Glib::init();
+  }
+}
+
+// protected
+void Main::init(int* argc, char*** argv, bool set_locale)
+{
+  if(instance_)
+  {
+    g_warning("Gtk::Main::init() called twice");
+  }
+  else
+  {
+    if(!set_locale)
+      gtk_disable_setlocale();
+
+    //TODO: Add support for gtk_init_check().
+    gtk_init(argc, argv);
+
+    init_gtkmm_internals();
+    instance_ = this;
+  }
+}
+
+Main::Main(int& argc, char**& argv, Glib::OptionContext& option_context)
+{
+  if(instance_)
+  {
+    g_warning("Gtk::Main::init() called twice");
+  }
+  else
+  {
+    init_gtkmm_internals();
+    instance_ = this;
+
+    //This reimplements some stuff from gtk_init_with_options(),
+    //without calling check_setugid(), because that is not public API.
+
+    add_gtk_option_group(option_context);
+    option_context.parse(argc, argv);
+  }
+}
+
+// This is a static method so that it can be used before Main is instantiated,
+// for instance in Gnome::canvas_init().  But if you use this method, you
+// _must_ have a Gtk::Main, so that Main::~Main() is called to clean this up
+// later.  Of course I can't imagine any situation in which you wouldn't have
+// a Gtk::Main.
+//
+void Main::init_gtkmm_internals()
+{
+  static bool init_done = false;
+
+  if(!init_done)
+  {
+    Glib::init();
+
+    // Populate the map of GTypes to C++ wrap_new() functions.
+    Pango::wrap_init();
+    Atk::wrap_init();
+    Gdk::wrap_init();
+    Gtk::wrap_init();
+
+    init_done = true;
+  }
+}
+
+void Main::add_gtk_option_group(Glib::OptionContext& option_context, bool open_default_display)
+{
+  //Get the option group:
+  Glib::OptionGroup gtkgroup( gtk_get_option_group(open_default_display) ); //Takes ownership of the GOptionGroup.
+
+  //Give it to the option_context, which will also then own the underlying GOptionGroup, deleting it when necessary:
+  option_context.add_group(gtkgroup);
+}
+
+
+/**** Gtk::Main -- static forwarder methods ********************************/
+
+Main* Main::instance()
+{
+  return instance_;
+}
+
+void Main::run()
+{
+  instance_->run_impl();
+}
+
+void Main::run(Gtk::Window& window)
+{
+  window.show();
+  window.signal_hide().connect(sigc::mem_fun(*instance_, &Main::on_window_hide));
+  instance_->run_impl();
+}
+
+void Main::quit()
+{
+  instance_->quit_impl();
+}
+
+guint Main::level()
+{
+  return instance_->level_impl();
+}
+
+bool Main::iteration(bool blocking)
+{
+  return instance_->iteration_impl(blocking);
+}
+
+bool Main::events_pending()
+{
+  return instance_->events_pending_impl();
+}
+
+
+/**** Gtk::Main -- static signal accessors *********************************/
+
+RunSig& Main::signal_run()
+{
+  return signal_run_;
+}
+
+QuitSig& Main::signal_quit()
+{
+  return signal_quit_;
+}
+
+KeySnooperSig& Main::signal_key_snooper()
+{
+  return signal_key_snooper_;
+}
+
+
+/**** Gtk::Main -- protected virtuals **************************************/
+
+void Main::run_impl()
+{
+  gtk_main();
+}
+
+void Main::quit_impl()
+{
+  gtk_main_quit();
+}
+
+guint Main::level_impl()
+{
+  return gtk_main_level();
+}
+
+bool Main::iteration_impl(bool blocking)
+{
+  return gtk_main_iteration_do(blocking);
+}
+
+bool Main::events_pending_impl()
+{
+  return gtk_events_pending();
+}
+
+void Main::on_window_hide()
+{
+  quit_impl();
+}
+
+} /* namespace Gtk */
+
+
+namespace
+{
+} // anonymous namespace
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/main.h b/libs/gtkmm2/gtk/gtkmm/main.h
new file mode 100644
index 0000000000..027cbeff07
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/main.h
@@ -0,0 +1,284 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_MAIN_H
+#define _GTKMM_MAIN_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* main.h
+ * 
+ * Copyright (C) 1998-2003 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+
+#include <gtk/gtkmain.h>
+
+#include <sigc++/sigc++.h>
+#include <gdkmm/types.h>
+
+
+namespace Gtk
+{
+
+class Widget;
+class Window;
+
+//**********************************************************************
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+//Actually, I'd like to just keep these out of the alphabetical list. murrayc.
+
+/// Run Signal Class (internal)
+class RunSig
+{
+public:
+  typedef sigc::slot<void> SlotType;
+
+  sigc::connection connect(const SlotType& slot);
+
+protected:
+  static gboolean gtk_callback(gpointer data);
+};
+
+
+/// Quit Signal Class (internal)
+class QuitSig
+{
+public:
+  typedef sigc::slot<bool> SlotType;
+
+  sigc::connection connect(const SlotType& slot, guint main_level = 0);
+
+protected:
+  static gboolean gtk_callback(gpointer data); //gtk+ calls this, which then calls our slot.
+};
+
+
+/// KeySnooper Signal Class (internal)
+class KeySnooperSig
+{
+public:
+  typedef sigc::slot<int, Widget*, GdkEventKey*> SlotType;
+
+  sigc::connection connect(const SlotType& slot);
+
+protected:
+  static int gtk_callback(GtkWidget* widget, GdkEventKey* event, gpointer data);
+};
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+//**********************************************************************
+
+/** Main application class
+ * Every application must have one of these objects.
+ * It may not be global and must be the first Gtk object created.
+ * It is a singleton so declaring more than one will simply access the first
+ * created.
+ *
+ * Normal use of this class is in the main() function to give argc and argv
+ * to the gtk initialization. Widgets can use Gtk::Main::quit()
+ * to exit from the application.
+ *
+ * The internals of the widget have been disguised as signals
+ * so that the user can easily connect using the same methods
+ * used throughout the widget interface.
+ *
+ * Minimal gtkmm application is something like this:
+ * @code
+ * int main(int argc, char *argv[]) {
+ *     Gtk::Main kit(argc, argv);
+ *     ... create some widgets ...
+ *     kit.run();
+ * }
+ * @endcode
+ */
+class Main : public sigc::trackable
+{
+public:
+
+  //This offers the same functionality as gtk_init_with_args():
+  /** Scans the argument vector, and strips off all parameters parsed by GTK+ or your @a option_context.
+   * Add a Glib::OptionGroup to the Glib::OptionContext to parse your own command-line arguments.  
+   *
+   * Note:  The argument strings themselves won't be modified, although the
+   * pointers to them might change.  This makes it possible to create your
+   * own argv of string literals, which have the type 'const char[]' in
+   * standard C++.  (You might need to use const_cast<>, though.)
+   *
+   * This function automatically generates nicely formatted 
+   * <option>--help</option> output. Note that your program will
+   * be terminated after writing out the help output.
+   *
+   * @param argc a reference to the number of command line arguments.
+   * @param argv a reference to the array of command line arguments.
+   * @parameter_string a string which is displayed in the first line of <option>--help</option> output, 
+   * after <literal><replaceable>programname</replaceable> [OPTION...]</literal>
+   * @param option_context A Glib::OptionContext containing Glib::OptionGroups which described the command-line arguments taken by your program. 
+   *
+   * @throw Glib::OptionError
+   */
+  Main(int& argc, char**& argv, Glib::OptionContext& option_context);
+
+  /** Scans the argument vector, and strips off all parameters known to GTK+.
+   * Your application may then handle the remaining arguments.
+   *
+   * Note:  The argument strings themself won't be modified, although the
+   * pointers to them might change.  This makes it possible to create your
+   * own argv of string literals, which have the type 'const char[]' in
+   * standard C++.  (You might need to use const_cast<>, though.)
+   */
+  Main(int* argc, char*** argv, bool set_locale = true);
+
+  /// See Main(int* argc, char*** argv, bool set_locale).
+  Main(int& argc, char**& argv, bool set_locale = true);
+
+ 
+  virtual ~Main();
+
+  /// Access to the one global instance of Gtk::Main.
+  static Gtk::Main* instance();
+
+  /** Start the event loop.
+   * This begins the event loop which handles events.  No
+   * events propagate until this has been called.  It may be
+   * called recursively to popup dialogs
+   */
+  static void run();
+
+  /** Returns from the main loop when the window is closed.
+   * When using this override, you should not use Gtk::Main::quit() to close
+   * the application, but just call hide() on your Window class.
+   *
+   * @param window The window to show. This method will return when the window is hidden.
+   */
+  static void run(Window& window);
+
+  /** Makes the innermost invocation of the main loop return when it regains control.
+   */
+  static void quit();
+
+  static guint level();
+
+  //This attempts to provide the same functionality as gtk_get_option_group():
+  /** Add a Glib::OptionGroup, for the commandline arguments recognized
+   * by GTK+ and GDK, to a Glib::OptionContext, so that these commandline arguments will 
+   * be processed in addition to the existing commandline arguments specified by the Glib::OptionContext.
+   *
+   * You do not need to use this method if you pass your Glib::OptionContext to the Main constructor, because 
+   * it adds the gtk option group automatically.
+   *
+   * @param option_context Option Context to which the group will be added.
+   * @param open_default_display Whether to open the default display when parsing the commandline arguments.
+   */
+  static void add_gtk_option_group(Glib::OptionContext& option_context, bool open_default_display = true);
+
+  /** Runs a single iteration of the main loop.
+   * If no events are waiting to be processed GTK+ will block until the next event is noticed.
+   * If you don't want to block then pass false for @a blocking or check if any events are pending with
+   * pending() first.
+   *
+   * @param blocking Whether the caller must wait until the next event is noticed, or return immediately if there are no events.
+   * @result true if quit() has been called for the innermost main loop.
+   */
+  static bool iteration(bool blocking = true);
+
+  /** Checks if any events are pending. This can be used to update the GUI and invoke timeouts etc. while doing some time intensive computation.
+   *
+   * Example: Updating the GUI during a long computation.
+   * @code
+   * // computation going on
+   * while( Gtk::Main::events_pending() )
+   *   Gtk::Main::iteration();
+   *
+   * // computation continued
+   * @endcode
+   *
+   * @result true if any events are pending, false otherwise.
+   */
+  static bool events_pending();
+
+  /** Run signal
+   * @return void
+   */
+  static RunSig& signal_run();
+
+  /** Quit signal
+   * You can connect signal handlers to invoke actions when Gtk::Main::quit()
+   * has been called.  Note that main loops can be nested by calling
+   * Gtk::Main::run() recursively, therefore receiving this signal doesn't
+   * necessarily mean the application is about to be terminated.  If you want
+   * to receive a signal only when the last main loop quits, call connect()
+   * with <tt>main_level&nbsp;=&nbsp;1</tt>.
+   * @code
+   * bool thisclass::mymethod() { return false; }
+   * Gtk::Main::signal_quit().connect(sigc::mem_fun(this, &thisclass::mymethod));
+   * @endcode
+   * @return bool - @c false means callback is removed, @c true means
+   * it'll be called again the next the main loop quits.
+   */
+  static QuitSig& signal_quit();
+
+  /** KeySnooper signal
+   * Allows you to channel keypresses to a signal handler
+   * without registering with the widget.
+   *
+   * @return KeySnooperSig A Signal to which you can connect a sigc::slot< int, Widget *, GdkEventKey * >
+   *
+   * It is the responsibility of the snooper to pass the keypress
+   * to the widget, however, care must be taken that the keypress is
+   * not passed twice.
+   */
+  static KeySnooperSig& signal_key_snooper();
+
+  // Initialize table of wrap_new functions.
+  // Doesn't need an instance of Gtk::Main.
+  static void init_gtkmm_internals();
+
+protected:
+  Main();
+
+  void init(int* argc, char*** argv, bool set_locale);
+  // TODO: implement this to use the new Glib::OptionEntry argument parsing classes.
+  //void init(int* argc, char*** argv, const std::string& parameter_string, const Glib::ArrayHandle<const Glib::OptionEntry&>& entries, const std::string& translation_domain);
+
+  virtual void run_impl();
+  virtual void quit_impl();
+  virtual guint level_impl();
+  virtual bool iteration_impl(bool blocking);
+  virtual bool events_pending_impl();
+
+  // Signal handlers:
+  virtual void on_window_hide();
+
+  // Signal proxies:
+  static RunSig         signal_run_;
+  static QuitSig        signal_quit_;
+  static KeySnooperSig  signal_key_snooper_;
+
+private:
+  static Main* instance_;
+};
+
+} // namespace Gtk
+
+
+#endif /* _GTKMM_MAIN_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/menu.cc b/libs/gtkmm2/gtk/gtkmm/menu.cc
new file mode 100644
index 0000000000..9fdc254a21
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/menu.cc
@@ -0,0 +1,348 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/menu.h>
+#include <gtkmm/private/menu_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtk/gtkdnd.h>
+#include <gtk/gtkmenu.h>
+#include <gtkmm/accelgroup.h>
+
+
+namespace
+{
+
+// This Signal Proxy allows the C++ coder to specify a sigc::slot instead of a static function.
+class SignalProxy_PopupPosition
+{
+public:
+  typedef Gtk::Menu::SlotPositionCalc SlotType;
+
+  SignalProxy_PopupPosition(const SlotType& slot);
+  ~SignalProxy_PopupPosition();
+
+  static void gtk_callback(GtkMenu* menu, int* x, int* y, gboolean* push_in, void* data);
+
+protected:
+  SlotType slot_;
+};
+
+SignalProxy_PopupPosition::SignalProxy_PopupPosition(const SlotType& slot)
+:
+  slot_ (slot)
+{}
+
+SignalProxy_PopupPosition::~SignalProxy_PopupPosition()
+{}
+
+void SignalProxy_PopupPosition::gtk_callback(GtkMenu*, int* x, int* y, gboolean* push_in, void* data)
+{
+  SignalProxy_PopupPosition *const self = static_cast<SignalProxy_PopupPosition*>(data);
+
+  int  temp_x = (x) ? *x : 0;
+  int  temp_y = (y) ? *y : 0;
+  bool temp_push_in = (push_in) ? bool(*push_in) : false;
+
+  try
+  {
+    (self->slot_)(temp_x, temp_y, temp_push_in);
+  }
+  catch(...)
+  {
+    Glib::exception_handlers_invoke();
+  }
+
+  if(x) *x = temp_x;
+  if(y) *y = temp_y;
+  if(push_in) *push_in = temp_push_in;
+}
+
+} // anonymous namespace
+
+
+namespace Gtk
+{
+
+void Menu::popup(const SlotPositionCalc& position_calc_slot, guint button, guint32 activate_time)
+{
+  SignalProxy_PopupPosition proxy(position_calc_slot);
+
+  // Tell GTK+ to call the static function with Proxy's address as the extra
+  // data, so that the static function can then call the sigc::slot:
+  gtk_menu_popup(gobj(), 0, 0, &SignalProxy_PopupPosition::gtk_callback, &proxy, button, activate_time);
+}
+
+void Menu::popup(MenuShell& parent_menu_shell, MenuItem& parent_menu_item, const SlotPositionCalc& position_calc_slot, guint button, guint32 activate_time)
+{
+  SignalProxy_PopupPosition proxy(position_calc_slot);
+
+  // Tell GTK+ to call the static function with Proxy's address as the extra
+  // data, so that the static function can then call the sigc::slot:
+  gtk_menu_popup(gobj(), parent_menu_shell.Gtk::Widget::gobj(), parent_menu_item.Gtk::Widget::gobj(), &SignalProxy_PopupPosition::gtk_callback, &proxy, button, activate_time);
+}
+
+void Menu::popup(guint button, guint32 activate_time)
+{
+  gtk_menu_popup(gobj(), 0, 0, 0, 0, button, activate_time);
+}
+
+void Menu::reorder_child(const MenuItem& child, int position)
+{
+  gtk_menu_reorder_child(
+      gobj(),
+      const_cast<GtkWidget*>(child.Gtk::Widget::gobj()),
+      position);
+}
+
+void Menu::unset_accel_group()
+{
+  gtk_menu_set_accel_group(gobj(), 0);
+}
+
+void Menu::unset_title()
+{
+  gtk_menu_set_title(gobj(), 0);
+}
+
+} // namespace Gtk
+
+
+namespace
+{
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Gtk::Menu* wrap(GtkMenu* object, bool take_copy)
+{
+  return dynamic_cast<Gtk::Menu *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& Menu_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &Menu_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_menu_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void Menu_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+}
+
+
+Glib::ObjectBase* Menu_Class::wrap_new(GObject* o)
+{
+  return manage(new Menu((GtkMenu*)(o)));
+
+}
+
+
+/* The implementation: */
+
+Menu::Menu(const Glib::ConstructParams& construct_params)
+:
+  Gtk::MenuShell(construct_params)
+{
+  }
+
+Menu::Menu(GtkMenu* castitem)
+:
+  Gtk::MenuShell((GtkMenuShell*)(castitem))
+{
+  }
+
+Menu::~Menu()
+{
+  destroy_();
+}
+
+Menu::CppClassType Menu::menu_class_; // initialize static member
+
+GType Menu::get_type()
+{
+  return menu_class_.init().get_type();
+}
+
+GType Menu::get_base_type()
+{
+  return gtk_menu_get_type();
+}
+
+
+Menu::Menu()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::MenuShell(Glib::ConstructParams(menu_class_.init()))
+{
+  }
+
+void Menu::reposition()
+{
+  gtk_menu_reposition(gobj());
+}
+
+void Menu::popdown()
+{
+  gtk_menu_popdown(gobj());
+}
+
+MenuItem* Menu::get_active()
+{
+  return Glib::wrap((GtkMenuItem*)(gtk_menu_get_active(gobj())));
+}
+
+const MenuItem* Menu::get_active() const
+{
+  return Glib::wrap((GtkMenuItem*)(gtk_menu_get_active(const_cast<GtkMenu*>(gobj()))));
+}
+
+void Menu::set_active(guint index)
+{
+  gtk_menu_set_active(gobj(), index);
+}
+
+void Menu::set_accel_group(const Glib::RefPtr<AccelGroup>& accel_group)
+{
+  gtk_menu_set_accel_group(gobj(), Glib::unwrap(accel_group));
+}
+
+Glib::RefPtr<AccelGroup> Menu::get_accel_group()
+{
+
+  Glib::RefPtr<AccelGroup> retvalue = Glib::wrap(gtk_menu_get_accel_group(gobj()));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::RefPtr<const AccelGroup> Menu::get_accel_group() const
+{
+
+  Glib::RefPtr<const AccelGroup> retvalue = Glib::wrap(gtk_menu_get_accel_group(const_cast<GtkMenu*>(gobj())));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+void Menu::set_accel_path(const Glib::ustring& accel_path)
+{
+  gtk_menu_set_accel_path(gobj(), accel_path.c_str());
+}
+
+void Menu::detach()
+{
+  gtk_menu_detach(gobj());
+}
+
+Widget* Menu::get_attach_widget()
+{
+  return Glib::wrap(gtk_menu_get_attach_widget(gobj()));
+}
+
+const Widget* Menu::get_attach_widget() const
+{
+  return Glib::wrap(gtk_menu_get_attach_widget(const_cast<GtkMenu*>(gobj())));
+}
+
+void Menu::set_tearoff_state(bool torn_off)
+{
+  gtk_menu_set_tearoff_state(gobj(), static_cast<int>(torn_off));
+}
+
+bool Menu::get_tearoff_state() const
+{
+  return gtk_menu_get_tearoff_state(const_cast<GtkMenu*>(gobj()));
+}
+
+void Menu::set_title(const Glib::ustring& title)
+{
+  gtk_menu_set_title(gobj(), title.c_str());
+}
+
+Glib::ustring Menu::get_title() const
+{
+  return Glib::convert_const_gchar_ptr_to_ustring(gtk_menu_get_title(const_cast<GtkMenu*>(gobj())));
+}
+
+void Menu::set_screen(const Glib::RefPtr<Gdk::Screen>& screen)
+{
+  gtk_menu_set_screen(gobj(), Glib::unwrap(screen));
+}
+
+void Menu::attach(Gtk::Widget& child, guint left_attach, guint right_attach, guint top_attach, guint bottom_attach)
+{
+  gtk_menu_attach(gobj(), (child).gobj(), left_attach, right_attach, top_attach, bottom_attach);
+}
+
+void Menu::set_monitor(int monitor_num)
+{
+  gtk_menu_set_monitor(gobj(), monitor_num);
+}
+
+void Menu::attach_to_widget(Widget& widget, GtkMenuDetachFunc detacher)
+{
+  gtk_menu_attach_to_widget(gobj(), (widget).gobj(), detacher);
+}
+
+
+Glib::PropertyProxy<Glib::ustring> Menu::property_tearoff_title() 
+{
+  return Glib::PropertyProxy<Glib::ustring>(this, "tearoff-title");
+}
+
+Glib::PropertyProxy_ReadOnly<Glib::ustring> Menu::property_tearoff_title() const
+{
+  return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "tearoff-title");
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/menu.h b/libs/gtkmm2/gtk/gtkmm/menu.h
new file mode 100644
index 0000000000..26e78721be
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/menu.h
@@ -0,0 +1,304 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_MENU_H
+#define _GTKMM_MENU_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* Copyright (C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+
+//#include <gtk/gtkmenu.h>
+#include <gtkmm/menushell.h>
+#include <gtkmm/menuitem.h>
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkMenu GtkMenu;
+typedef struct _GtkMenuClass GtkMenuClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class Menu_Class; } // namespace Gtk
+namespace Gtk
+{
+
+class AccelGroup;
+
+/** @defgroup Menus Menu classes
+ */
+
+/** A drop-down menu consisting of Gtk::MenuItem objects which can be navigated and activated by the user to perform application functions.
+ * Menus are normally placed inside a Gtk::MenuBar or another MenuItem as a sub menu.
+ * A Menu can also be popped up, for instance as a right-click context menu, by calling the popup() method.
+ * See also Gtk::OptionMenu.
+ * @ingroup Widgets
+ * @ingroup Menus
+ */
+
+class Menu : public MenuShell
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Menu CppObjectType;
+  typedef Menu_Class CppClassType;
+  typedef GtkMenu BaseObjectType;
+  typedef GtkMenuClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~Menu();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class Menu_Class;
+  static CppClassType menu_class_;
+
+  // noncopyable
+  Menu(const Menu&);
+  Menu& operator=(const Menu&);
+
+protected:
+  explicit Menu(const Glib::ConstructParams& construct_params);
+  explicit Menu(GtkMenu* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GtkMenu*       gobj()       { return reinterpret_cast<GtkMenu*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GtkMenu* gobj() const { return reinterpret_cast<GtkMenu*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+private:
+
+  
+   //deprecated.
+public:
+  Menu();
+
+/* append, prepend, and insert are defined in MenuShell */
+
+  /** For instance,
+   * void on_popup_menu_position(int& x, int& y, bool& push_in);
+   */
+  typedef sigc::slot<void, int&, int&, bool&> SlotPositionCalc;
+             
+  void popup(MenuShell& parent_menu_shell, MenuItem& parent_menu_item, const SlotPositionCalc& slot, guint button, guint32 activate_time);
+  
+
+  /** Displays a menu and makes it available for selection.  Applications can use
+   * this function to display context-sensitive menus.
+   *
+   * The @a button  parameter should be the mouse button pressed to initiate
+   * the menu popup. If the menu popup was initiated by something other than
+   * a mouse button press, such as a mouse button release or a keypress,
+   *  @a button  should be 0.
+   *
+   * The @a activate_time  parameter should be the time stamp of the event that
+   * initiated the popup. If such an event is not available, use
+   * gtk_get_current_event_time() instead.
+   * @param func A position_calc_slot supplied function used to position the menu, or <tt>0</tt>.
+   * @param button The mouse button which was pressed to initiate the event.
+   * @param activate_time The time at which the activation event occurred.
+   */
+  void popup(const SlotPositionCalc& position_calc_slot, guint button, guint32 activate_time);
+
+  /** Displays a menu and makes it available for selection.
+   * Applications can use this function to display context-sensitive menus, at the current pointer position.
+   * @param button The button which was pressed to initiate the event.
+   * @param activate_time The time at which the activation event occurred.
+   */
+  void popup(guint button, guint32 activate_time);
+
+  
+  void reposition();
+
+  
+  void popdown();
+
+  
+  MenuItem* get_active();
+  
+  const MenuItem* get_active() const;
+  
+  void set_active(guint index);
+
+  
+  void set_accel_group(const Glib::RefPtr<AccelGroup>& accel_group);
+  void unset_accel_group();
+  
+  Glib::RefPtr<AccelGroup> get_accel_group();
+  
+  Glib::RefPtr<const AccelGroup> get_accel_group() const;
+  
+  
+  /** Sets an accelerator path for this menu from which accelerator paths
+   * for its immediate children, its menu items, can be constructed.
+   * The main purpose of this function is to spare the programmer the
+   * inconvenience of having to call Gtk::MenuItem::set_accel_path() on
+   * each menu item that should support runtime user changable accelerators.
+   * Instead, by just calling set_accel_path() on their parent,
+   * each menu item of this menu, that contains a label describing its purpose,
+   * automatically gets an accel path assigned. For example, a menu containing
+   * menu items "New" and "Exit", will, after 
+   * <tt>gtk_menu_set_accel_path (menu, "&lt;Gnumeric-Sheet&gt;/File");</tt>
+   * has been called, assign its items the accel paths:
+   * <tt>"&lt;Gnumeric-Sheet&gt;/File/New"</tt> and <tt>"&lt;Gnumeric-Sheet&gt;/File/Exit"</tt>.
+   * Assigning accel paths to menu items then enables the user to change
+   * their accelerators at runtime. More details about accelerator paths
+   * and their default setups can be found at gtk_accel_map_add_entry().
+   * @param accel_path A valid accelerator path.
+   */
+  void set_accel_path(const Glib::ustring& accel_path);
+
+  
+  void detach();
+  
+  Widget* get_attach_widget();
+  
+  const Widget* get_attach_widget() const;
+
+  
+  void set_tearoff_state(bool torn_off = true);
+  
+  /** Returns whether the menu is torn off. See
+   * set_tearoff_state().
+   * @return <tt>true</tt> if the menu is currently torn off.
+   */
+  bool get_tearoff_state() const;
+
+  
+  /** Sets the title string for the menu.  The title is displayed when the menu
+   * is shown as a tearoff menu.
+   * @param title A string containing the title for the menu.
+   */
+  void set_title(const Glib::ustring& title);
+  void unset_title();
+  
+  /** Returns the title of the menu. See set_title().
+   * @return The title of the menu, or <tt>0</tt> if the menu has no
+   * title set on it. This string is owned by the widget and should
+   * not be modified or freed.
+   */
+  Glib::ustring get_title() const;
+  
+  /** Sets the Gdk::Screen on which the menu will be displayed.
+   * 
+   * Since: 2.2
+   * @param screen A Gdk::Screen, or <tt>0</tt> if the screen should be
+   * determined by the widget the menu is attached to.
+   */
+  void set_screen(const Glib::RefPtr<Gdk::Screen>& screen);
+
+  
+  /** Adds a new Gtk::MenuItem to a (table) menu. The number of 'cells' that
+   * an item will occupy is specified by @a left_attach , @a right_attach ,
+   *  @a top_attach  and @a bottom_attach . These each represent the leftmost,
+   * rightmost, uppermost and lower column and row numbers of the table.
+   * (Columns and rows are indexed from zero).
+   * 
+   * Note that this function is not related to detach().
+   * 
+   * Since: 2.4
+   * @param child A Gtk::MenuItem.
+   * @param left_attach The column number to attach the left side of the item to.
+   * @param right_attach The column number to attach the right side of the item to.
+   * @param top_attach The row number to attach the top of the item to.
+   * @param bottom_attach The row number to attach the bottom of the item to.
+   */
+  void attach(Gtk::Widget& child, guint left_attach, guint right_attach, guint top_attach, guint bottom_attach);
+
+  
+  /** Informs GTK+ on which monitor a menu should be popped up. 
+   * See gdk_screen_get_monitor_geometry().
+   * 
+   * This function should be called from a Gtk::MenuPositionFunc if the
+   * menu should not appear on the same monitor as the pointer. This 
+   * information can't be reliably inferred from the coordinates returned
+   * by a Gtk::MenuPositionFunc, since, for very long menus, these coordinates 
+   * may extend beyond the monitor boundaries or even the screen boundaries. 
+   * 
+   * Since: 2.4
+   * @param monitor_num The number of the monitor on which the menu should
+   * be popped up.
+   */
+  void set_monitor(int monitor_num);
+  
+  void reorder_child(const MenuItem& child, int position);
+  
+
+  /** A title that may be displayed by the window manager when this menu is torn-off.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Glib::ustring> property_tearoff_title() ;
+
+/** A title that may be displayed by the window manager when this menu is torn-off.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Glib::ustring> property_tearoff_title() const;
+
+
+protected:
+
+  //We can not wrap this as a slot because there is no data parameter, and no destroy callback to destroy that data.
+  typedef void (*GtkMenuDetachFunc)   (GtkWidget *attach_widget, GtkMenu   *menu);
+  
+  void attach_to_widget(Widget& widget, GtkMenuDetachFunc detacher);
+
+
+};
+
+} // namespace Gtk
+
+
+namespace Glib
+{
+  /** @relates Gtk::Menu
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gtk::Menu* wrap(GtkMenu* object, bool take_copy = false);
+}
+#endif /* _GTKMM_MENU_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/menu_elems.cc b/libs/gtkmm2/gtk/gtkmm/menu_elems.cc
new file mode 100644
index 0000000000..251113ffcf
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/menu_elems.cc
@@ -0,0 +1,286 @@
+// -*- c++ -*-
+/* $Id$ */
+
+/* 
+ *
+ * Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtk/gtkimagemenuitem.h>
+
+#include <gtkmm/menu_elems.h>
+#include <gtkmm/label.h>
+
+#ifndef GLIBMM_WIN32
+#include <strings.h>
+#endif // GLIBMM_WIN32
+
+namespace Gtk
+{
+
+namespace Menu_Helpers
+{
+
+Element::Element()
+{
+}
+
+Element::Element(MenuItem& child)
+{
+  //TODO: Can't we avoid using RefPtr<> with a widget. It's not what it's meant for, and apparently it doesn't work well. murrayc.
+  child_ = Glib::RefPtr<MenuItem>(&child);
+  child_->reference(); //It's normally used with a create(), which starts with a refcount of 1.
+}
+
+Element::~Element()
+{}
+
+void Element::set_child(MenuItem* pChild)
+{
+  child_ = Glib::RefPtr<MenuItem>(pChild);
+  child_->reference(); //TODO. We used to use the old RefPtr::operator=(), and this is what it did.
+}
+
+void Element::set_accel_key(const AccelKey& accel_key)
+{
+  if(child_)
+    child_->set_accel_key(accel_key);
+}
+
+const Glib::RefPtr<MenuItem>& Element::get_child() const
+{
+  return child_;
+}
+
+MenuElem::MenuElem(MenuItem& child)
+: Element(child)
+{}
+
+MenuElem::MenuElem(const Glib::ustring& label, 
+                   const CallSlot& slot)
+{
+  set_child( manage(new MenuItem(label, true)) );
+  if(slot)
+    child_->signal_activate().connect(slot);
+  child_->show();
+}
+
+MenuElem::MenuElem(const Glib::ustring& label,
+                   const AccelKey& accel_key,
+                   const CallSlot& slot)
+{
+  set_child( manage(new MenuItem(label, true)) );
+  if(slot)
+    child_->signal_activate().connect(slot);
+  set_accel_key(accel_key);
+  child_->show();
+}
+
+MenuElem::MenuElem(const Glib::ustring& label, Menu& submenu)
+{
+  set_child( manage(new MenuItem(label, true)) );
+  child_->set_submenu(submenu);
+  child_->show();
+}
+
+MenuElem::MenuElem(const Glib::ustring& label, 
+                   const AccelKey& accel_key,
+                   Gtk::Menu& submenu)
+{
+  set_child( manage(new MenuItem(label, true)) );
+  child_->set_submenu(submenu);
+  set_accel_key(accel_key);
+  child_->show();
+}
+
+SeparatorElem::SeparatorElem()
+{
+  set_child( manage(new SeparatorMenuItem()) );
+  child_->show();
+}
+
+ImageMenuElem::ImageMenuElem(ImageMenuItem& child)
+: Element(child)
+{}
+
+ImageMenuElem::ImageMenuElem(const Glib::ustring& label,
+                             Gtk::Widget& image_widget,
+                             const CallSlot& slot)
+{
+  image_widget.show(); //We assume that the coder wants to actually show the widget.
+  set_child( manage(new ImageMenuItem(image_widget, label, true)) );
+  if(slot)
+    child_->signal_activate().connect(slot);
+  child_->show();
+}
+
+ImageMenuElem::ImageMenuElem(const Glib::ustring& label,
+                             const AccelKey& accel_key,
+                             Gtk::Widget& image_widget,
+                             const CallSlot& slot)
+{
+  image_widget.show(); //We assume that the coder wants to actually show the widget.
+  set_child( manage(new ImageMenuItem(image_widget, label, true)) );
+  if(slot)
+    child_->signal_activate().connect(slot);
+  set_accel_key(accel_key);
+  child_->show();
+}
+
+ImageMenuElem::ImageMenuElem(const Glib::ustring& label,
+                             Gtk::Widget& image_widget,
+                             Gtk::Menu& submenu)
+{
+  image_widget.show(); //We assume that the coder wants to actually show the widget.
+  set_child( manage(new ImageMenuItem(image_widget, label, true)) );
+  child_->set_submenu(submenu);
+  child_->show();
+}
+
+ImageMenuElem::ImageMenuElem(const Glib::ustring& label,
+                             const AccelKey& accel_key,
+                             Gtk::Widget& image_widget,
+                             Gtk::Menu& submenu)
+{
+  image_widget.show(); //We assume that the coder wants to actually show the widget.
+  set_child( manage(new ImageMenuItem(image_widget, label, true)) );
+  set_accel_key(accel_key);
+  child_->set_submenu(submenu);
+  child_->show();
+}
+
+StockMenuElem::StockMenuElem(const Gtk::StockID& stock_id,
+                             const CallSlot& slot)
+{
+  set_child( manage(new ImageMenuItem(stock_id)) );
+  if(slot)
+    child_->signal_activate().connect(slot);
+  child_->show();
+}
+
+StockMenuElem::StockMenuElem(const Gtk::StockID& stock_id,
+                             const AccelKey& accel_key,
+                             const CallSlot& slot)
+{
+  set_child( manage(new ImageMenuItem(stock_id)) );
+  if(slot)
+    child_->signal_activate().connect(slot);
+  set_accel_key(accel_key);
+  child_->show();
+}
+
+StockMenuElem::StockMenuElem(const Gtk::StockID& stock_id,
+                             Gtk::Menu& submenu)
+{
+  set_child( manage(new ImageMenuItem(stock_id)) );
+  child_->set_submenu(submenu);
+  child_->show();
+}
+
+StockMenuElem::StockMenuElem(const Gtk::StockID& stock_id,
+                             const AccelKey& accel_key,
+                             Gtk::Menu& submenu)
+{
+  set_child( manage(new ImageMenuItem(stock_id)) );
+  set_accel_key(accel_key);
+  child_->set_submenu(submenu);
+  child_->show();
+}
+
+CheckMenuElem::CheckMenuElem(CheckMenuItem& child)
+: Element(child)
+{}
+
+CheckMenuElem::CheckMenuElem(const Glib::ustring& label,
+                             const CallSlot& slot)
+{
+  CheckMenuItem* item = manage(new CheckMenuItem(label, true));
+  set_child( item );
+  if(slot)
+    item->signal_toggled().connect(slot);
+  child_->show();
+}
+
+CheckMenuElem::CheckMenuElem(const Glib::ustring& label,
+                             const AccelKey& accel_key,
+                             const CallSlot& slot)
+{
+  CheckMenuItem* item = manage(new CheckMenuItem(label, true));
+  set_child( item );
+  set_accel_key(accel_key);
+  if(slot)
+    item->signal_toggled().connect(slot);
+  child_->show();
+}
+
+
+RadioMenuElem::RadioMenuElem(RadioMenuItem& child)
+: Element(child), gr_(0)
+{}
+
+RadioMenuElem::RadioMenuElem(RadioMenuItem::Group& group,
+                             const Glib::ustring& label,
+                             const CallSlot& slot)
+  : gr_(&group)
+{
+  CheckMenuItem* item = manage(new RadioMenuItem(*gr_, label, true));
+  set_child( item );
+  if(slot)
+    item->signal_toggled().connect(slot);
+  child_->show();
+}
+
+RadioMenuElem::RadioMenuElem(RadioMenuItem::Group& gr,
+                             const Glib::ustring& label,
+                             const AccelKey& accel_key,
+                             const CallSlot& slot)
+  : gr_(&gr)
+{
+  CheckMenuItem* item = manage(new RadioMenuItem(*gr_, label, true));
+  set_child( item );
+  set_accel_key(accel_key);
+  if(slot)
+    item->signal_toggled().connect(slot);
+  child_->show();
+}
+
+TearoffMenuElem::TearoffMenuElem(TearoffMenuItem& child)
+: Element(child)
+{}
+
+TearoffMenuElem::TearoffMenuElem(const CallSlot& slot)
+{
+  set_child( manage(new TearoffMenuItem()) );
+  if(slot)
+    child_->signal_activate().connect(slot);
+  child_->show();
+}
+
+TearoffMenuElem::TearoffMenuElem(const AccelKey& accel_key,
+                                 const CallSlot& slot)
+{
+  set_child( manage(new TearoffMenuItem()) );
+  set_accel_key(accel_key);
+  if(slot)
+    child_->signal_activate().connect(slot);
+  child_->show();
+}
+
+} /* namespace Menu_Helpers */
+
+} /* namespace Gtk */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/menu_elems.h b/libs/gtkmm2/gtk/gtkmm/menu_elems.h
new file mode 100644
index 0000000000..b443e94bbd
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/menu_elems.h
@@ -0,0 +1,266 @@
+/* $Id$ */
+#ifndef _GTKMM_MENU_ELEMS_H
+#define _GTKMM_MENU_ELEMS_H
+/* menu_elems.h
+ * 
+ * Copyright (C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gdk/gdkkeysyms.h>
+
+#include <gtkmm/container.h>
+#include <gtkmm/menuitem.h>
+#include <gtkmm/imagemenuitem.h>
+#include <gtkmm/radiomenuitem.h>
+#include <gtkmm/checkmenuitem.h>
+#include <gtkmm/tearoffmenuitem.h>
+#include <gtkmm/separatormenuitem.h>
+#include <gtkmm/accelgroup.h>
+#include <gtkmm/accelkey.h>
+
+namespace Gtk
+{
+
+class Menu;
+
+namespace Menu_Helpers
+{
+
+// input class (MenuItem-Factory)
+
+class Element
+{
+public:
+  typedef sigc::slot<void> CallSlot;
+
+  Element();
+  Element(MenuItem& child);
+  ~Element();
+
+  const Glib::RefPtr<MenuItem>& get_child() const;
+
+protected:
+
+  void set_child(MenuItem* pChild);
+  void set_accel_key(const AccelKey& accel_key);
+
+  //We use a RefPtr to avoid leaks when the manage()d widget never gets added to a container.
+  //TODO: RefPtr is probably meant only for use with a create() method - see the extra reference() in set_child().
+  Glib::RefPtr<MenuItem> child_;
+};
+
+/** Use this class and its subclasses to build menu items.
+ * For example,
+ * @code
+ * m_Menu_File.items().push_back( Gtk::Menu_Helpers::MenuElem("_New",
+ *   sigc::mem_fun(*this, &ExampleWindow::on_menu_file_new) ) );
+ * @endcode
+ *
+ * @ingroup Menus
+ */
+class MenuElem : public Element
+{
+public:
+
+  MenuElem(MenuItem& child);
+
+  /** Create a labeled, non-accelerated MenuItem with a sigc::slot
+   * @param label The menu item's name
+   * @param slot Use sigc::mem_fun() to specify a signal handler
+   */
+  MenuElem(const Glib::ustring& label, const CallSlot& slot = CallSlot());
+
+  /** Create a labeled, accelerated MenuItem with a sigc::slot
+   * @param label The menu item's name
+   * @param key The accelerator key combination
+   * @param slot Use sigc::mem_fun() to specify a signal handler
+   */
+  MenuElem(const Glib::ustring& label, const AccelKey& key,
+           const CallSlot& slot = CallSlot());
+
+  /** Create a labeled, non-accelerated MenuItem with a submenu
+   * @param label The menu item's name
+   * @param submenu The sub menu
+   */
+  MenuElem(const Glib::ustring& label, Gtk::Menu& submenu);
+
+  /** Create a labeled, accelerated MenuItem with a submenu
+   * @param label The menu item's name
+   * @param key The accelerator key combination
+   * @param submenu The sub menu
+   */
+  MenuElem(const Glib::ustring& label,
+           const AccelKey& key,
+           Gtk::Menu& submenu);
+};
+
+class SeparatorElem : public Element
+{
+public:
+  SeparatorElem();
+};
+
+class ImageMenuElem : public Element
+{
+public:
+  ImageMenuElem(ImageMenuItem& child);
+
+  /** Create a labeled, non-accelerated MenuItem with a sigc::slot
+   * @param label The menu item's name
+   * @param image_widget The image
+   * @param slot Use sigc::mem_fun() to specify a signal handler
+   */
+  ImageMenuElem(const Glib::ustring& label,
+                Gtk::Widget& image_widget,
+                const CallSlot& slot = CallSlot());
+
+  /** Create a labeled, accelerated MenuItem with a sigc::slot
+   * @param label The menu item's name
+   * @param key The accelerator key combination
+   * @param image_widget The image
+   * @param slot Use sigc::mem_fun() to specify a signal handler
+   */
+  ImageMenuElem(const Glib::ustring& label, const AccelKey& key,
+                Gtk::Widget& image_widget,
+                const CallSlot& slot = CallSlot());
+
+  /** Create a labeled, non-accelerated MenuItem with a submenu
+   * @param label The menu item's name
+   * @param image_widget The image
+   * @param submenu The sub menu
+   */
+  ImageMenuElem(const Glib::ustring& label,
+                Gtk::Widget& image_widget,
+                Gtk::Menu& submenu);
+
+  /** Create a labeled, accelerated MenuItem with a submenu
+   * @param label The menu item's name
+   * @param key The accelerator key combination
+   * @param image_widget The image
+   * @param submenu The sub menu
+   */
+  ImageMenuElem(const Glib::ustring& label, const AccelKey& key,
+                Gtk::Widget& image_widget,
+                Gtk::Menu& submenu);
+};
+
+class StockMenuElem : public Element
+{
+public:
+  /** Create a non-accelerated MenuItem from a stock item
+   * @param stock_id The ID of the stock item
+   * @param slot Use sigc::mem_fun() to specify a signal handler
+   */
+  StockMenuElem(const Gtk::StockID& stock_id,
+                const CallSlot& slot = CallSlot());
+
+  /** Create an accelerated MenuItem from a stock item
+   * @param stock_id The ID of the stock item
+   * @param key The accelerator key combination
+   * @param slot Use sigc::mem_fun() to specify a signal handler
+   */
+  StockMenuElem(const Gtk::StockID& stock_id,
+                const AccelKey& key,
+                const CallSlot& slot = CallSlot());
+
+  /** Create a non-accelerated MenuItem from a stock item with a submenu
+   * @param stock_id The ID of the stock item
+   * @param submenu The sub menu
+   */
+  StockMenuElem(const Gtk::StockID& stock_id,
+                Gtk::Menu& submenu);
+
+  /** Create an accelerated MenuItem from a stock item with a submenu
+   * @param stock_id The ID of the stock item
+   * @param key The accelerator key combination
+   * @param submenu The sub menu
+   */
+  StockMenuElem(const Gtk::StockID& stock_id,
+                const AccelKey& key,
+                Gtk::Menu& submenu);
+};
+
+class CheckMenuElem : public Element
+{
+public:
+  CheckMenuElem(CheckMenuItem& child);
+
+  /** Create a labeled, non-accelerated MenuItem with a sigc::slot
+   * @param label The menu item's name
+   * @param slot Use sigc::mem_fun() to specify a signal handler
+   */
+  CheckMenuElem(const Glib::ustring& label, const CallSlot& slot = CallSlot());
+
+  /** Create a labeled, accelerated CheckMenuItem with a sigc::slot
+   * @param label The menu item's name
+   * @param key The accelerator key combination
+   * @param slot Use sigc::mem_fun() to specify a signal handler
+   */
+  CheckMenuElem(const Glib::ustring& label, const AccelKey& key,
+                const CallSlot& slot = CallSlot());
+};
+
+
+class RadioMenuElem : public Element
+{
+public:
+  RadioMenuElem(RadioMenuItem& child);
+
+  /** Create a labeled, non-accelerated MenuItem with a sigc::slot
+   * @param label The menu item's name
+   * @param slot Use sigc::mem_fun() to specify a signal handler
+   */
+  RadioMenuElem(RadioMenuItem::Group&, const Glib::ustring& label,
+                const CallSlot& slot = CallSlot());
+
+  /** Create a labeled, accelerated CheckMenuItem with a sigc::slot
+   * @param group The RadioMenuItem group in which to put this.
+   * @param label The menu item's name
+   * @param key The accelerator key combination
+   * @param slot Use sigc::mem_fun() to specify a signal handler
+   */
+  RadioMenuElem(RadioMenuItem::Group& group, const Glib::ustring& label,
+                const AccelKey& key,
+                const CallSlot& slot = CallSlot());
+
+protected:
+  RadioMenuItem::Group* gr_;
+};
+
+class TearoffMenuElem : public Element
+{
+public:
+  TearoffMenuElem(TearoffMenuItem& child);
+
+  /** Create a non-accelerated TearoffMenuItem with a sigc::slot
+   * @param slot Use sigc::mem_fun() to specify a signal handler
+   */
+  TearoffMenuElem(const CallSlot& slot = CallSlot());
+
+  /** Create accelerated TearoffMenuItem with a sigc::slot
+   * @param key The accelerator key combination
+   * @param slot Use sigc::mem_fun() to specify a signal handler
+   */
+  TearoffMenuElem(const AccelKey& key,
+                  const CallSlot& slot = CallSlot());
+};
+
+} /* namespace Menu_Helpers */
+
+} /* namespace Gtk */
+
+#endif //_GTKMM_MENU_ELEMS_H
diff --git a/libs/gtkmm2/gtk/gtkmm/menubar.cc b/libs/gtkmm2/gtk/gtkmm/menubar.cc
new file mode 100644
index 0000000000..8b5ef04bbc
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/menubar.cc
@@ -0,0 +1,147 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/menubar.h>
+#include <gtkmm/private/menubar_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtk/gtkmenubar.h>
+
+namespace Gtk
+{
+
+MenuBar::MenuBar()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::MenuShell(Glib::ConstructParams(menubar_class_.init(), (char*) 0))
+{
+  // Connect to the signal instead of overriding the on_hierarchy_changed()
+  // method because invocation of C++ default signal handlers is skipped
+  // for gtkmmproc-generated classes (a gtkmm-wide optimization).
+
+  signal_realize().connect(sigc::mem_fun(*this, &MenuBar::init_accels_handler_));
+}
+
+void MenuBar::init_accels_handler_()
+{
+  if(gobj())
+  {
+    if(Window *const toplevel = dynamic_cast<Window*>(get_toplevel()))
+    {
+      accelerate(*toplevel);
+    }
+  }
+}
+
+} // namespace Gtk
+
+
+namespace
+{
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Gtk::MenuBar* wrap(GtkMenuBar* object, bool take_copy)
+{
+  return dynamic_cast<Gtk::MenuBar *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& MenuBar_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &MenuBar_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_menu_bar_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void MenuBar_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+}
+
+
+Glib::ObjectBase* MenuBar_Class::wrap_new(GObject* o)
+{
+  return manage(new MenuBar((GtkMenuBar*)(o)));
+
+}
+
+
+/* The implementation: */
+
+MenuBar::MenuBar(const Glib::ConstructParams& construct_params)
+:
+  Gtk::MenuShell(construct_params)
+{
+  }
+
+MenuBar::MenuBar(GtkMenuBar* castitem)
+:
+  Gtk::MenuShell((GtkMenuShell*)(castitem))
+{
+  }
+
+MenuBar::~MenuBar()
+{
+  destroy_();
+}
+
+MenuBar::CppClassType MenuBar::menubar_class_; // initialize static member
+
+GType MenuBar::get_type()
+{
+  return menubar_class_.init().get_type();
+}
+
+GType MenuBar::get_base_type()
+{
+  return gtk_menu_bar_get_type();
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/menubar.h b/libs/gtkmm2/gtk/gtkmm/menubar.h
new file mode 100644
index 0000000000..f7d8dea03e
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/menubar.h
@@ -0,0 +1,128 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_MENUBAR_H
+#define _GTKMM_MENUBAR_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+
+/* menubar.h
+ * 
+ * Copyright (C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+ 
+#include <gtkmm/menushell.h>
+#include <gtkmm/menuitem.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkMenuBar GtkMenuBar;
+typedef struct _GtkMenuBarClass GtkMenuBarClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class MenuBar_Class; } // namespace Gtk
+namespace Gtk
+{
+
+/** A standard menu bar which usually holds Gtk::Menu submenu items.
+ * The useful methods are in the base class - Gtk::MenuShell.
+ * @ingroup Widgets
+ * @ingroup Menus
+ */
+
+class MenuBar : public MenuShell
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef MenuBar CppObjectType;
+  typedef MenuBar_Class CppClassType;
+  typedef GtkMenuBar BaseObjectType;
+  typedef GtkMenuBarClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~MenuBar();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class MenuBar_Class;
+  static CppClassType menubar_class_;
+
+  // noncopyable
+  MenuBar(const MenuBar&);
+  MenuBar& operator=(const MenuBar&);
+
+protected:
+  explicit MenuBar(const Glib::ConstructParams& construct_params);
+  explicit MenuBar(GtkMenuBar* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GtkMenuBar*       gobj()       { return reinterpret_cast<GtkMenuBar*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GtkMenuBar* gobj() const { return reinterpret_cast<GtkMenuBar*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+private:
+
+
+public:
+  MenuBar();
+
+  // append, prepend and insert are defined in menushell
+
+private:
+  void init_accels_handler_(void);
+
+
+};
+
+} // namespace Gtk
+
+
+namespace Glib
+{
+  /** @relates Gtk::MenuBar
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gtk::MenuBar* wrap(GtkMenuBar* object, bool take_copy = false);
+}
+#endif /* _GTKMM_MENUBAR_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/menuitem.cc b/libs/gtkmm2/gtk/gtkmm/menuitem.cc
new file mode 100644
index 0000000000..44f86a9204
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/menuitem.cc
@@ -0,0 +1,552 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/menuitem.h>
+#include <gtkmm/private/menuitem_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* 
+ *
+ * Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtk/gtkmenuitem.h>
+#include <gtk/gtkaccelmap.h>
+#include <gtkmm/label.h>
+#include <gtkmm/misc.h>
+#include <gtkmm/menu.h>
+#include <gtkmm/box.h>
+#include <gtkmm/window.h>
+#include <gtkmm/menubar.h>
+#include <gtkmm/accelmap.h>
+
+// gtk_menu_item_(de)select are just a wrapper for gtk_item_(de)select
+// and defined in Gtk_Item, so they do not be redefined here
+
+namespace Gtk
+{
+
+
+MenuItem::MenuItem(Widget& widget)
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Item(Glib::ConstructParams(menuitem_class_.init(), (char*) 0))
+{
+  add(widget);
+}
+
+MenuItem::MenuItem(const Glib::ustring& label, bool mnemonic)
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Item(Glib::ConstructParams(menuitem_class_.init(), (char*) 0))
+{
+  add_accel_label(label, mnemonic); /* Left-aligned label */
+}
+
+void MenuItem::add_accel_label(const Glib::ustring& label, bool mnemonic)
+{
+  AccelLabel* pLabel = manage(new AccelLabel(label, mnemonic));
+  //Labels are centered by default, but in menus they should be left-aligned.
+  pLabel->property_xalign() = 0.0; 
+
+  add(*pLabel);
+
+  //Note that we have to unset the accel_widget in  MenuList::remove() to avoid
+  //a memory leak due to the extra reference:
+  pLabel->set_accel_widget(*this);
+  pLabel->show();
+}
+
+void MenuItem::set_accel_key(const AccelKey& accel_key)
+{
+  accel_key_ = accel_key;
+}
+
+bool MenuItem::has_submenu() const
+{
+  return get_submenu() != 0;
+}
+
+void MenuItem::accelerate(Window& window)
+{
+  if(!accel_key_.is_null())
+  {
+    if(accel_key_.get_path().empty())
+    {
+      add_accelerator("activate", window.get_accel_group(), 
+                      accel_key_.get_key(), accel_key_.get_mod(), ACCEL_VISIBLE);
+    }
+    else
+    {
+      AccelMap::add_entry(accel_key_.get_path(),
+                          accel_key_.get_key(),
+                          accel_key_.get_mod());
+
+      Item::set_accel_path(accel_key_.get_path(), window.get_accel_group());
+    }
+  }
+
+  if(has_submenu())
+    get_submenu()->accelerate(window);
+}
+
+void MenuItem::unset_accel_path()
+{
+  gtk_menu_item_set_accel_path(gobj(), 0);
+}
+
+
+} // namespace Gtk
+
+
+namespace
+{
+
+const Glib::SignalProxyInfo MenuItem_signal_activate_info =
+{
+  "activate",
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
+};
+
+
+const Glib::SignalProxyInfo MenuItem_signal_activate_item_info =
+{
+  "activate_item",
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
+};
+
+
+void MenuItem_signal_toggle_size_request_callback(GtkMenuItem* self, int* p0,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,int* > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(p0);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+}
+
+const Glib::SignalProxyInfo MenuItem_signal_toggle_size_request_info =
+{
+  "toggle_size_request",
+  (GCallback) &MenuItem_signal_toggle_size_request_callback,
+  (GCallback) &MenuItem_signal_toggle_size_request_callback
+};
+
+
+void MenuItem_signal_toggle_size_allocate_callback(GtkMenuItem* self, gint p0,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,int > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(p0
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+}
+
+const Glib::SignalProxyInfo MenuItem_signal_toggle_size_allocate_info =
+{
+  "toggle_size_allocate",
+  (GCallback) &MenuItem_signal_toggle_size_allocate_callback,
+  (GCallback) &MenuItem_signal_toggle_size_allocate_callback
+};
+
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Gtk::MenuItem* wrap(GtkMenuItem* object, bool take_copy)
+{
+  return dynamic_cast<Gtk::MenuItem *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& MenuItem_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &MenuItem_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_menu_item_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void MenuItem_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+  klass->activate = &activate_callback;
+  klass->activate_item = &activate_item_callback;
+  klass->toggle_size_request = &toggle_size_request_callback;
+  klass->toggle_size_allocate = &toggle_size_allocate_callback;
+}
+
+
+void MenuItem_Class::activate_callback(GtkMenuItem* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_activate();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->activate)
+      (*base->activate)(self);
+  }
+}
+
+void MenuItem_Class::activate_item_callback(GtkMenuItem* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_activate_item();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->activate_item)
+      (*base->activate_item)(self);
+  }
+}
+
+void MenuItem_Class::toggle_size_request_callback(GtkMenuItem* self, int* p0)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_toggle_size_request(p0);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->toggle_size_request)
+      (*base->toggle_size_request)(self, p0);
+  }
+}
+
+void MenuItem_Class::toggle_size_allocate_callback(GtkMenuItem* self, gint p0)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_toggle_size_allocate(p0
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->toggle_size_allocate)
+      (*base->toggle_size_allocate)(self, p0);
+  }
+}
+
+
+Glib::ObjectBase* MenuItem_Class::wrap_new(GObject* o)
+{
+  return manage(new MenuItem((GtkMenuItem*)(o)));
+
+}
+
+
+/* The implementation: */
+
+MenuItem::MenuItem(const Glib::ConstructParams& construct_params)
+:
+  Gtk::Item(construct_params)
+{
+  }
+
+MenuItem::MenuItem(GtkMenuItem* castitem)
+:
+  Gtk::Item((GtkItem*)(castitem))
+{
+  }
+
+MenuItem::~MenuItem()
+{
+  destroy_();
+}
+
+MenuItem::CppClassType MenuItem::menuitem_class_; // initialize static member
+
+GType MenuItem::get_type()
+{
+  return menuitem_class_.init().get_type();
+}
+
+GType MenuItem::get_base_type()
+{
+  return gtk_menu_item_get_type();
+}
+
+
+MenuItem::MenuItem()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Item(Glib::ConstructParams(menuitem_class_.init()))
+{
+  }
+
+void MenuItem::set_submenu(Menu& submenu)
+{
+  gtk_menu_item_set_submenu(gobj(), (submenu).Gtk::Widget::gobj());
+}
+
+Menu* MenuItem::get_submenu()
+{
+  return Glib::wrap((GtkMenu*)(gtk_menu_item_get_submenu(gobj())));
+}
+
+const Menu* MenuItem::get_submenu() const
+{
+  return Glib::wrap((GtkMenu*)(gtk_menu_item_get_submenu(const_cast<GtkMenuItem*>(gobj()))));
+}
+
+void MenuItem::remove_submenu()
+{
+  gtk_menu_item_remove_submenu(gobj());
+}
+
+void MenuItem::select()
+{
+  gtk_menu_item_select(gobj());
+}
+
+void MenuItem::deselect()
+{
+  gtk_menu_item_deselect(gobj());
+}
+
+void MenuItem::activate()
+{
+  gtk_menu_item_activate(gobj());
+}
+
+void MenuItem::toggle_size_request(int& requisition)
+{
+  gtk_menu_item_toggle_size_request(gobj(), &requisition);
+}
+
+void MenuItem::toggle_size_allocate(int allocation)
+{
+  gtk_menu_item_toggle_size_allocate(gobj(), allocation);
+}
+
+void MenuItem::set_right_justified(bool right_justified)
+{
+  gtk_menu_item_set_right_justified(gobj(), static_cast<int>(right_justified));
+}
+
+bool MenuItem::get_right_justified() const
+{
+  return gtk_menu_item_get_right_justified(const_cast<GtkMenuItem*>(gobj()));
+}
+
+void MenuItem::set_accel_path(const Glib::ustring& accel_path)
+{
+  gtk_menu_item_set_accel_path(gobj(), accel_path.c_str());
+}
+
+
+Glib::SignalProxy0< void > MenuItem::signal_activate()
+{
+  return Glib::SignalProxy0< void >(this, &MenuItem_signal_activate_info);
+}
+
+Glib::SignalProxy0< void > MenuItem::signal_activate_item()
+{
+  return Glib::SignalProxy0< void >(this, &MenuItem_signal_activate_item_info);
+}
+
+Glib::SignalProxy1< void,int* > MenuItem::signal_toggle_size_request()
+{
+  return Glib::SignalProxy1< void,int* >(this, &MenuItem_signal_toggle_size_request_info);
+}
+
+Glib::SignalProxy1< void,int > MenuItem::signal_toggle_size_allocate()
+{
+  return Glib::SignalProxy1< void,int >(this, &MenuItem_signal_toggle_size_allocate_info);
+}
+
+
+void Gtk::MenuItem::on_activate()
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->activate)
+    (*base->activate)(gobj());
+}
+
+void Gtk::MenuItem::on_activate_item()
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->activate_item)
+    (*base->activate_item)(gobj());
+}
+
+void Gtk::MenuItem::on_toggle_size_request(int* requisition)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->toggle_size_request)
+    (*base->toggle_size_request)(gobj(),requisition);
+}
+
+void Gtk::MenuItem::on_toggle_size_allocate(int allocation)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->toggle_size_allocate)
+    (*base->toggle_size_allocate)(gobj(),allocation);
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/menuitem.h b/libs/gtkmm2/gtk/gtkmm/menuitem.h
new file mode 100644
index 0000000000..50e2ccc610
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/menuitem.h
@@ -0,0 +1,233 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_MENUITEM_H
+#define _GTKMM_MENUITEM_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+
+/* menuitem.h
+ * 
+ * Copyright (C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+ 
+#include <gtkmm/item.h>
+#include <gtkmm/accelkey.h>
+#include <gtkmm/accellabel.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkMenuItem GtkMenuItem;
+typedef struct _GtkMenuItemClass GtkMenuItemClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class MenuItem_Class; } // namespace Gtk
+namespace Gtk
+{
+
+class Menu;
+namespace Menu_Helpers { class Element; }
+
+/** Child item for menus.
+ * Handle highlighting, alignment, events and submenus.
+ * As it derives from Gtk::Bin it can hold any valid child widget, altough only a few are really useful.
+ * @ingroup Widgets
+ * @ingroup Menus
+ */
+
+class MenuItem : public Item
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef MenuItem CppObjectType;
+  typedef MenuItem_Class CppClassType;
+  typedef GtkMenuItem BaseObjectType;
+  typedef GtkMenuItemClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~MenuItem();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class MenuItem_Class;
+  static CppClassType menuitem_class_;
+
+  // noncopyable
+  MenuItem(const MenuItem&);
+  MenuItem& operator=(const MenuItem&);
+
+protected:
+  explicit MenuItem(const Glib::ConstructParams& construct_params);
+  explicit MenuItem(GtkMenuItem* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GtkMenuItem*       gobj()       { return reinterpret_cast<GtkMenuItem*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GtkMenuItem* gobj() const { return reinterpret_cast<GtkMenuItem*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+  virtual void on_activate();
+  virtual void on_activate_item();
+  virtual void on_toggle_size_request(int* requisition);
+  virtual void on_toggle_size_allocate(int allocation);
+
+
+private:
+
+public:
+
+  /// Create an empty menu item
+  MenuItem();
+
+  /// Create a menu item with widget
+  explicit MenuItem(Widget& widget);
+
+  /// Create a menu item with label
+  explicit MenuItem(const Glib::ustring& label, bool mnemonic = false);
+
+  
+  void set_submenu(Menu& submenu);
+  
+  /** Gets the submenu underneath this menu item, if any. See
+   * set_submenu().
+   * @return Submenu for this menu item, or <tt>0</tt> if none.
+   */
+  Menu* get_submenu();
+  
+  /** Gets the submenu underneath this menu item, if any. See
+   * set_submenu().
+   * @return Submenu for this menu item, or <tt>0</tt> if none.
+   */
+  const Menu* get_submenu() const;
+  bool has_submenu() const;
+
+  
+  void remove_submenu();
+  
+  void select();
+  
+  void deselect();
+  
+  void activate();
+  
+  void toggle_size_request(int& requisition);
+  
+  void toggle_size_allocate(int allocation);
+  
+  /** Sets whether the menu item appears justified at the right
+   * side of a menu bar. This was traditionally done for "Help" menu
+   * items, but is now considered a bad idea. (If the widget
+   * layout is reversed for a right-to-left language like Hebrew
+   * or Arabic, right-justified-menu-items appear at the left.)
+   * @param right_justified If <tt>true</tt> the menu item will appear at the 
+   * far right if added to a menu bar.
+   */
+  void set_right_justified(bool right_justified = true);
+  
+  /** Gets whether the menu item appears justified at the right
+   * side of the menu bar.
+   * @return <tt>true</tt> if the menu item will appear at the
+   * far right if added to a menu bar.
+   */
+  bool get_right_justified() const;
+  
+  /** Set the accelerator path on @a menu_item , through which runtime changes of the
+   * menu item's accelerator caused by the user can be identified and saved to
+   * persistant storage (see gtk_accel_map_save() on this).
+   * To setup a default accelerator for this menu item, call
+   * gtk_accel_map_add_entry() with the same @a accel_path .
+   * See also gtk_accel_map_add_entry() on the specifics of accelerator paths,
+   * and set_accel_path() for a more convenient variant of this function.
+   * 
+   * This function is basically a convenience wrapper that handles calling
+   * Gtk::Widget::set_accel_path() with the appropriate accelerator group for
+   * the menu item.
+   * 
+   * Note that you do need to set an accelerator on the parent menu with
+   * set_accel_group() for this to work.
+   * @param accel_path Accelerator path, corresponding to this menu item's
+   * functionality.
+   */
+  void set_accel_path(const Glib::ustring& accel_path);
+  void unset_accel_path();
+
+  
+  Glib::SignalProxy0< void > signal_activate();
+
+  
+  Glib::SignalProxy0< void > signal_activate_item();
+
+  
+  Glib::SignalProxy1< void,int* > signal_toggle_size_request();
+
+  
+  Glib::SignalProxy1< void,int > signal_toggle_size_allocate();
+
+
+  void accelerate(Window& window);
+
+protected:
+
+  void add_accel_label(const Glib::ustring& label, bool mnemonic = true);
+
+  void set_accel_key(const AccelKey& accel_key);
+
+private:
+
+  friend class Menu_Helpers::Element;
+
+  //This data is set by MenuElem, and will be used in on_realize(), in the call to add_accelerator().
+  AccelKey accel_key_;
+
+
+};
+
+} /* namespace Gtk */
+
+
+namespace Glib
+{
+  /** @relates Gtk::MenuItem
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gtk::MenuItem* wrap(GtkMenuItem* object, bool take_copy = false);
+}
+#endif /* _GTKMM_MENUITEM_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/menushell.cc b/libs/gtkmm2/gtk/gtkmm/menushell.cc
new file mode 100644
index 0000000000..60cc879572
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/menushell.cc
@@ -0,0 +1,492 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/menushell.h>
+#include <gtkmm/private/menushell_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtk/gtkmenuitem.h>
+#include <gtk/gtkaccellabel.h>
+
+
+namespace Gtk
+{
+
+// All ctors are manually implemented just to initialize accel_window_.
+
+MenuShell::MenuShell()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Container(Glib::ConstructParams(menushell_class_.init(), (char*) 0)),
+  items_proxy_  (gobj()),
+  accel_window_ (0)
+{}
+
+MenuShell::MenuShell(const Glib::ConstructParams& construct_params)
+:
+  Glib::ObjectBase(0),
+  Gtk::Container  (construct_params),
+  items_proxy_    (gobj()),
+  accel_window_   (0)
+{}
+
+MenuShell::MenuShell(GtkMenuShell* castitem)
+:
+  Gtk::Container((GtkContainer*) castitem),
+  items_proxy_  (gobj()),
+  accel_window_ (0)
+{}
+
+// TODO: Why do we need a custom dtor?
+MenuShell::~MenuShell()
+{}
+
+void MenuShell::accelerate(Window& window)
+{
+  // accel_window_ is used by menuitems that are added to the menushell
+  // after it has been accelerated.
+  accel_window_ = &window;
+
+  const MenuList::iterator items_end = items().end();
+
+  for(MenuList::iterator iter = items().begin(); iter != items_end; ++iter)
+    iter->accelerate(window);
+}
+
+void MenuShell::accelerate(Widget& parent)
+{
+  Gtk::Window* toplevel_window 
+      = dynamic_cast<Gtk::Window*>(parent.get_toplevel());
+  if(toplevel_window)
+    accelerate(*toplevel_window);
+}
+
+MenuShell::MenuList& MenuShell::items()
+{
+  return items_proxy_;
+}
+
+const MenuShell::MenuList& MenuShell::items() const
+{
+  return items_proxy_;
+}
+
+void MenuShell_Class::insert_vfunc_callback(GtkMenuShell* self, GtkWidget* child, int position)
+{
+  try
+  {
+    MenuShell *const obj = dynamic_cast<MenuShell*>(
+        Glib::ObjectBase::_get_current_wrapper((GObject*) self));
+
+    // If MenuShell is accelerated initialize accelerators of new MenuItem.
+    if(obj && obj->accel_window_ && GTK_IS_MENU_ITEM(child))
+    {
+      Glib::wrap((GtkMenuItem*) child)->accelerate(*obj->accel_window_);
+    }
+  }
+  catch(...)
+  {
+    Glib::exception_handlers_invoke();
+  }
+
+  GtkMenuShellClass *const base = static_cast<GtkMenuShellClass*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)));
+
+  if(base && base->insert)
+    (*base->insert)(self, child, position);
+}
+
+
+namespace Menu_Helpers
+{
+
+// List implementation:
+
+
+MenuList::iterator MenuList::insert(MenuList::iterator position, const Element& element)
+{
+  const Glib::RefPtr<Gtk::MenuItem> item = element.get_child();
+
+  g_return_val_if_fail(item != 0, position);
+  g_return_val_if_fail(gparent() != 0, position);
+
+  int pos = -1;
+
+  if(position.node_)
+    pos = g_list_position(glist(), position.node_);
+
+  gtk_menu_shell_insert(gparent(), item->Widget::gobj(), pos);
+
+  return --position;
+}
+
+void MenuList::remove(const_reference child)
+{
+  const Widget& widget = child;
+  remove(const_cast<Widget&>(widget));
+}
+
+void MenuList::remove(Widget& widget)
+{
+  //This is the same as the standard implementation,
+  //but we also unset the accel_label to avoid leaking its reference.
+
+  //If it is a Bin, (actually we're looking for a MenuItem):
+  if(GTK_IS_BIN(widget.gobj()))
+  {
+    //TODO: There is duplication here, with erase().
+    //If the child's child is an AccelLabel then unset its accel widget:
+    //This can't catch every possible AccelLabel in the hierarchy, but it
+    //will catch the ones that we create in MenuItem::MenuItem() without
+    //people being aware of it. People can take care of their own ones themselves.
+    Gtk::AccelLabel* pAccelLabel = dynamic_cast<Gtk::AccelLabel*>(dynamic_cast<Gtk::Bin&>(widget).get_child());
+    if(pAccelLabel) //If the child is an AccelLabel.
+    {
+      //The unset_accel_widget() method is not implemented in gtkmm until 2.4:
+      gtk_accel_label_set_accel_widget(pAccelLabel->gobj(), 0);
+    }
+  }
+
+  gtk_container_remove(GTK_CONTAINER(gparent_),
+                       (GtkWidget*)(widget.gobj()));
+}
+
+MenuList::iterator MenuList::erase(iterator position)
+{
+  //Check that it is a valid iterator, to a real item:
+  if ( !position.node_|| (position == end()) )
+    return end();
+
+  //Get an iterator the the next item, to return:
+  iterator next = position;
+  next++;
+
+  GtkWidget* pChild = (GtkWidget*)(position->gobj());
+  if(GTK_IS_BIN(pChild)) //A MenuItem is a Bin.
+  {  
+    //If the child's child is an AccelLabel then unset it's accel widget:
+    //This can't catch every possible AccelLabel in the hierarchy, but it
+    //will catch the ones that we create in MenuItem::MenuItem() without
+    //people being aware of it. People can take care of their own ones themselves.
+    GtkWidget* pChildOfChild = (GtkWidget*)gtk_bin_get_child(GTK_BIN(pChild));
+    if(GTK_IS_ACCEL_LABEL(pChildOfChild))
+       gtk_accel_label_set_accel_widget(GTK_ACCEL_LABEL(pChildOfChild), 0);
+  }
+  
+  //Use GTK+ C function to remove it, by providing the GtkWidget*:
+  gtk_container_remove( GTK_CONTAINER(gparent_), pChild );
+  
+  return next;
+}
+
+} // namespace Menu_Helpers
+
+} // namespace Gtk
+
+
+namespace
+{
+
+const Glib::SignalProxyInfo MenuShell_signal_deactivate_info =
+{
+  "deactivate",
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
+};
+
+
+const Glib::SignalProxyInfo MenuShell_signal_selection_done_info =
+{
+  "selection_done",
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
+};
+
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Gtk::MenuShell* wrap(GtkMenuShell* object, bool take_copy)
+{
+  return dynamic_cast<Gtk::MenuShell *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& MenuShell_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &MenuShell_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_menu_shell_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void MenuShell_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+    klass->insert = &insert_vfunc_callback;
+    klass->deactivate = &deactivate_callback;
+  klass->selection_done = &selection_done_callback;
+}
+
+
+void MenuShell_Class::deactivate_callback(GtkMenuShell* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_deactivate();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->deactivate)
+      (*base->deactivate)(self);
+  }
+}
+
+void MenuShell_Class::selection_done_callback(GtkMenuShell* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_selection_done();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->selection_done)
+      (*base->selection_done)(self);
+  }
+}
+
+
+Glib::ObjectBase* MenuShell_Class::wrap_new(GObject* o)
+{
+  return manage(new MenuShell((GtkMenuShell*)(o)));
+
+}
+
+
+/* The implementation: */
+
+MenuShell::CppClassType MenuShell::menushell_class_; // initialize static member
+
+GType MenuShell::get_type()
+{
+  return menushell_class_.init().get_type();
+}
+
+GType MenuShell::get_base_type()
+{
+  return gtk_menu_shell_get_type();
+}
+
+
+namespace Menu_Helpers
+{
+
+MenuList::MenuList()
+{}
+
+MenuList::MenuList(GtkMenuShell* gparent)
+: type_base((GObject*)gparent)
+{}
+
+MenuList::MenuList(const MenuList& src)
+:
+  type_base(src)
+{}
+
+MenuList& MenuList::operator=(const MenuList& src)
+{
+  type_base::operator=(src);
+  return *this;
+}
+
+GList*& MenuList::glist() const
+{
+  return ((GtkMenuShell*)gparent_)->children;
+}
+
+void MenuList::erase(iterator start, iterator stop)
+{
+  type_base::erase(start, stop);
+}
+
+GtkMenuShell* MenuList::gparent()
+{
+  return (GtkMenuShell*)type_base::gparent();
+}
+
+const GtkMenuShell* MenuList::gparent() const
+{
+  return (GtkMenuShell*)type_base::gparent();
+}
+
+MenuList::reference MenuList::operator[](size_type l) const
+{
+  return type_base::operator[](l);
+}
+
+} /* namespace Menu_Helpers */
+
+void MenuShell::append(MenuItem& menu_item)
+{
+  gtk_menu_shell_append(gobj(), (menu_item).Gtk::Widget::gobj());
+}
+
+void MenuShell::prepend(MenuItem& menu_item)
+{
+  gtk_menu_shell_prepend(gobj(), (menu_item).Gtk::Widget::gobj());
+}
+
+void MenuShell::insert(MenuItem& menu_item, int position)
+{
+  gtk_menu_shell_insert(gobj(), (menu_item).Gtk::Widget::gobj(), position);
+}
+
+void MenuShell::select_item(MenuItem& menu_item)
+{
+  gtk_menu_shell_select_item(gobj(), (menu_item).Gtk::Widget::gobj());
+}
+
+void MenuShell::deselect()
+{
+  gtk_menu_shell_deselect(gobj());
+}
+
+void MenuShell::activate_item(MenuItem& menu_item, bool force_deactivate)
+{
+  gtk_menu_shell_activate_item(gobj(), (menu_item).Gtk::Widget::gobj(), static_cast<int>(force_deactivate));
+}
+
+void MenuShell::select_first(bool search_sensitive)
+{
+  gtk_menu_shell_select_first(gobj(), static_cast<int>(search_sensitive));
+}
+
+void MenuShell::deactivate()
+{
+  gtk_menu_shell_deactivate(gobj());
+}
+
+void MenuShell::cancel()
+{
+  gtk_menu_shell_cancel(gobj());
+}
+
+
+Glib::SignalProxy0< void > MenuShell::signal_deactivate()
+{
+  return Glib::SignalProxy0< void >(this, &MenuShell_signal_deactivate_info);
+}
+
+Glib::SignalProxy0< void > MenuShell::signal_selection_done()
+{
+  return Glib::SignalProxy0< void >(this, &MenuShell_signal_selection_done_info);
+}
+
+
+void Gtk::MenuShell::on_deactivate()
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->deactivate)
+    (*base->deactivate)(gobj());
+}
+
+void Gtk::MenuShell::on_selection_done()
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->selection_done)
+    (*base->selection_done)(gobj());
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/menushell.h b/libs/gtkmm2/gtk/gtkmm/menushell.h
new file mode 100644
index 0000000000..c5ad744828
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/menushell.h
@@ -0,0 +1,288 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_MENUSHELL_H
+#define _GTKMM_MENUSHELL_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* Copyright (C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+ 
+#include <gdk/gdkkeysyms.h>
+
+
+#include <gtkmm/container.h>
+#include <gtkmm/menu_elems.h>
+#include <glibmm/helperlist.h>
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkMenuShell GtkMenuShell;
+typedef struct _GtkMenuShellClass GtkMenuShellClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class MenuShell_Class; } // namespace Gtk
+namespace Gtk
+{
+
+class Menu;
+class MenuShell;
+class Window;
+
+namespace Menu_Helpers
+{
+
+/*********************************************************************
+***** List properties
+*********************************************************************/
+
+ 
+class MenuList : public Glib::HelperList< MenuItem, const Element, Glib::List_Cpp_Iterator<GtkMenuItem,MenuItem> >
+{
+public:
+  MenuList();
+  explicit MenuList(GtkMenuShell* gparent);
+  MenuList(const MenuList& src);
+  virtual ~MenuList() {}
+
+  MenuList& operator=(const MenuList& src);
+
+  typedef Glib::HelperList< MenuItem, const Element,  Glib::List_Cpp_Iterator<GtkMenuItem,MenuItem> > type_base;
+
+  GtkMenuShell* gparent();
+  const GtkMenuShell* gparent() const;
+
+  virtual GList*& glist() const;      // front of list
+
+  virtual void erase(iterator start, iterator stop);
+  virtual iterator erase(iterator);  //Implented as custom or by LIST_CONTAINER_REMOVE
+  virtual void remove(const_reference); //Implented as custom or by LIST_CONTAINER_REMOVE
+
+  /// This is order n. (use at own risk)
+  reference operator[](size_type l) const;
+
+public:
+  iterator insert(iterator position, element_type& e); //custom-implemented.
+
+  template <class InputIterator>
+  inline void insert(iterator position, InputIterator first, InputIterator last)
+  {
+    for(;first != last; ++first)
+      position = insert(position, *first);
+  }
+
+ inline void push_front(element_type& e)
+    { insert(begin(), e); }
+  inline void push_back(element_type& e)
+    { insert(end(), e); }
+
+
+  virtual void remove(Widget& widget); //custom
+  };
+
+
+} // namespace Menu_Helpers
+
+
+/** The abstract base class for Gtk::Menu and Gtk::MenuBar.
+ * It is a container of Gtk::MenuItem objects arranged in a list which can be navigated, selected, and activated by the user to perform application functions.
+ * It can have a submenu associated with it, allowing for nested hierarchical menus.
+ * You can use append(), prepend() and insert() to add Gtk::MenuItem widgets,
+ * but you will probably find it more convenient to use the STL-style items() interface with the Gtk::Menu_Helpers::MenuElem() class.
+ * @ingroup Widgets
+ * @ingroup Containers
+ * @ingroup Menus
+ */
+
+class MenuShell : public Container 
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef MenuShell CppObjectType;
+  typedef MenuShell_Class CppClassType;
+  typedef GtkMenuShell BaseObjectType;
+  typedef GtkMenuShellClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~MenuShell();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class MenuShell_Class;
+  static CppClassType menushell_class_;
+
+  // noncopyable
+  MenuShell(const MenuShell&);
+  MenuShell& operator=(const MenuShell&);
+
+protected:
+  explicit MenuShell(const Glib::ConstructParams& construct_params);
+  explicit MenuShell(GtkMenuShell* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GtkMenuShell*       gobj()       { return reinterpret_cast<GtkMenuShell*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GtkMenuShell* gobj() const { return reinterpret_cast<GtkMenuShell*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+  virtual void on_deactivate();
+  virtual void on_selection_done();
+
+
+private:
+
+
+public:
+  
+
+  typedef Menu_Helpers::MenuList MenuList;
+  friend class Menu_Helpers::MenuList;
+
+  
+  void append(MenuItem& menu_item);
+  
+  void prepend(MenuItem& menu_item);
+  
+  void insert(MenuItem& menu_item, int position);
+
+  
+  void select_item(MenuItem& menu_item);
+  
+  void deselect();
+
+  //TODO: Is force_deactivate = false a good default?
+  
+  void activate_item(MenuItem& menu_item, bool force_deactivate = false);
+  
+  /** Select the first visible or selectable child of the menu shell;
+   * don't select tearoff items unless the only item is a tearoff
+   * item.
+   * 
+   * Since: 2.2
+   * @param search_sensitive If <tt>true</tt>, search for the first selectable
+   * menu item, otherwise select nothing if
+   * the first item isn't sensitive. This
+   * should be <tt>false</tt> if the menu is being
+   * popped up initially.
+   */
+  void select_first(bool search_sensitive = true);
+  
+  void deactivate();
+  
+  /** Cancels the selection within the menu shell.  
+   * 
+   * Since: 2.4
+   */
+  void cancel();
+
+  
+  Glib::SignalProxy0< void > signal_deactivate();
+
+  
+  Glib::SignalProxy0< void > signal_selection_done();
+
+
+  //Keybinding signals:
+  
+  
+  MenuList& items();
+  const MenuList& items() const;
+
+  /**
+   * Initializes menu accelerators.
+   * This method initializes the menu accelerators. Therefore an
+   * AccelGroup object is needed which is stored in each Window object
+   * in the Gtkmm library implementation.
+   *
+   * When using MenuBar and OptionMenu objects this method is called
+   * automatically when the menus are realized. Because most likely the
+   * MenuBar and OptionMenu is attached to a window at this time and
+   * the window object can be found automatically.
+   *
+   * Important note when using popup menus: 
+   * If you are using accelerated menu entries inside a popup
+   * menu you have to call the accelerate() method manually. This is
+   * because the popup menu is not connected to any window and the
+   * accelerators should be initialized even before the popup menu is
+   * shown. The right place to call the accelerate() method is right
+   * after the popup menu has been build.
+   *
+   * @param window Window where the menu is shown. Inside this window
+   *   the AccelGroup object is stored that will be used to initialize
+   *   the accelerators.
+   */
+  void accelerate(Window& window);
+
+  /**
+   * Initializes menu accelerators.
+   * Does the same as the accelerate(Window& window) method. But you can
+   * use any parent widget where the menu is used. This method then gets
+   * the toplevel window using Widget::get_toplevel() and uses this
+   * window for registering the menu accelerators.
+   *
+   * @param parent Parent widget used as starting point for searching
+   *   the toplevel window.
+   */
+  void accelerate(Widget& parent);
+
+protected:
+  MenuShell();
+  
+
+private:
+
+
+  MenuList      items_proxy_;
+  Gtk::Window*  accel_window_;
+
+
+};
+
+} // namespace Gtk
+
+
+namespace Glib
+{
+  /** @relates Gtk::MenuShell
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gtk::MenuShell* wrap(GtkMenuShell* object, bool take_copy = false);
+}
+#endif /* _GTKMM_MENUSHELL_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/menutoolbutton.cc b/libs/gtkmm2/gtk/gtkmm/menutoolbutton.cc
new file mode 100644
index 0000000000..8cb38dca61
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/menutoolbutton.cc
@@ -0,0 +1,247 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/menutoolbutton.h>
+#include <gtkmm/private/menutoolbutton_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* 
+ *
+ * Copyright 2003 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtk/gtkmenutoolbutton.h>
+
+namespace Gtk
+{
+
+MenuToolButton::MenuToolButton(const Glib::ustring& label)
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::ToolButton(Glib::ConstructParams(menutoolbutton_class_.init(), "label", label.c_str(), (char*) 0))
+{
+}
+
+MenuToolButton::MenuToolButton(Widget& icon_widget, const Glib::ustring& label)
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::ToolButton(Glib::ConstructParams(menutoolbutton_class_.init(), "icon_widget", (icon_widget).gobj(), "label", label.c_str(), (char*) 0))
+{
+}
+
+} // namespace Gtk
+
+
+namespace
+{
+
+const Glib::SignalProxyInfo MenuToolButton_signal_show_menu_info =
+{
+  "show_menu",
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
+};
+
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Gtk::MenuToolButton* wrap(GtkMenuToolButton* object, bool take_copy)
+{
+  return dynamic_cast<Gtk::MenuToolButton *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& MenuToolButton_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &MenuToolButton_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_menu_tool_button_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void MenuToolButton_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+  klass->show_menu = &show_menu_callback;
+}
+
+
+void MenuToolButton_Class::show_menu_callback(GtkMenuToolButton* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_show_menu();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->show_menu)
+      (*base->show_menu)(self);
+  }
+}
+
+
+Glib::ObjectBase* MenuToolButton_Class::wrap_new(GObject* o)
+{
+  return manage(new MenuToolButton((GtkMenuToolButton*)(o)));
+
+}
+
+
+/* The implementation: */
+
+MenuToolButton::MenuToolButton(const Glib::ConstructParams& construct_params)
+:
+  Gtk::ToolButton(construct_params)
+{
+  }
+
+MenuToolButton::MenuToolButton(GtkMenuToolButton* castitem)
+:
+  Gtk::ToolButton((GtkToolButton*)(castitem))
+{
+  }
+
+MenuToolButton::~MenuToolButton()
+{
+  destroy_();
+}
+
+MenuToolButton::CppClassType MenuToolButton::menutoolbutton_class_; // initialize static member
+
+GType MenuToolButton::get_type()
+{
+  return menutoolbutton_class_.init().get_type();
+}
+
+GType MenuToolButton::get_base_type()
+{
+  return gtk_menu_tool_button_get_type();
+}
+
+
+MenuToolButton::MenuToolButton()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::ToolButton(Glib::ConstructParams(menutoolbutton_class_.init()))
+{
+  }
+
+MenuToolButton::MenuToolButton(const Gtk::StockID& stock_id)
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::ToolButton(Glib::ConstructParams(menutoolbutton_class_.init(), "stock_id", (stock_id).get_c_str(), (char*) 0))
+{
+  }
+
+void MenuToolButton::set_menu(Menu& menu)
+{
+  gtk_menu_tool_button_set_menu(gobj(), (menu).Gtk::Widget::gobj());
+}
+
+Menu* MenuToolButton::get_menu()
+{
+  return Glib::wrap((GtkMenu*)(gtk_menu_tool_button_get_menu(gobj())));
+}
+
+const Menu* MenuToolButton::get_menu() const
+{
+  return Glib::wrap((GtkMenu*)(gtk_menu_tool_button_get_menu(const_cast<GtkMenuToolButton*>(gobj()))));
+}
+
+void MenuToolButton::set_arrow_tooltip(Tooltips& tooltips, const Glib::ustring& tip_text, const Glib::ustring& tip_private)
+{
+  gtk_menu_tool_button_set_arrow_tooltip(gobj(), (tooltips).gobj(), tip_text.c_str(), tip_private.c_str());
+}
+
+
+Glib::SignalProxy0< void > MenuToolButton::signal_show_menu()
+{
+  return Glib::SignalProxy0< void >(this, &MenuToolButton_signal_show_menu_info);
+}
+
+
+Glib::PropertyProxy<Menu*> MenuToolButton::property_menu() 
+{
+  return Glib::PropertyProxy<Menu*>(this, "menu");
+}
+
+Glib::PropertyProxy_ReadOnly<Menu*> MenuToolButton::property_menu() const
+{
+  return Glib::PropertyProxy_ReadOnly<Menu*>(this, "menu");
+}
+
+
+void Gtk::MenuToolButton::on_show_menu()
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->show_menu)
+    (*base->show_menu)(gobj());
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/menutoolbutton.h b/libs/gtkmm2/gtk/gtkmm/menutoolbutton.h
new file mode 100644
index 0000000000..a8d6be8055
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/menutoolbutton.h
@@ -0,0 +1,196 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_MENUTOOLBUTTON_H
+#define _GTKMM_MENUTOOLBUTTON_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* box.h
+ *
+ * Copyright (C) 2003 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/toolbutton.h>
+#include <gtkmm/menu.h>
+#include <gtkmm/tooltips.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkMenuToolButton GtkMenuToolButton;
+typedef struct _GtkMenuToolButtonClass GtkMenuToolButtonClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class MenuToolButton_Class; } // namespace Gtk
+namespace Gtk
+{
+
+/** A Gtk::ToolItem containing a toggle button.
+ *
+ * A MenuToolButton is a Gtk::ToolItem that contains a menu.
+ * @ingroup Widgets
+ */
+
+class MenuToolButton : public ToolButton
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef MenuToolButton CppObjectType;
+  typedef MenuToolButton_Class CppClassType;
+  typedef GtkMenuToolButton BaseObjectType;
+  typedef GtkMenuToolButtonClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~MenuToolButton();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class MenuToolButton_Class;
+  static CppClassType menutoolbutton_class_;
+
+  // noncopyable
+  MenuToolButton(const MenuToolButton&);
+  MenuToolButton& operator=(const MenuToolButton&);
+
+protected:
+  explicit MenuToolButton(const Glib::ConstructParams& construct_params);
+  explicit MenuToolButton(GtkMenuToolButton* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GtkMenuToolButton*       gobj()       { return reinterpret_cast<GtkMenuToolButton*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GtkMenuToolButton* gobj() const { return reinterpret_cast<GtkMenuToolButton*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+  virtual void on_show_menu();
+
+
+private:
+
+public:
+
+  /** Creates a new MenuToolButton.
+   */
+  MenuToolButton();
+  
+  /** Creates a new MenuToolButton from a StockID.
+   *
+   * The MenuToolButton will be created according to the @a stock_id properties.
+   * 
+   * @param stock_id The StockID which determines the look of the MenuToolButton.
+   */
+  explicit MenuToolButton(const Gtk::StockID& stock_id);
+  
+  /** Creates a new MenuToolButton with a label.
+   *
+   * The MenuToolButton will have the label @a label.
+   *
+   * @param label The string used to display the label for this MenuToolButton.
+   */
+  explicit MenuToolButton(const Glib::ustring& label);
+  
+  /** Creates a new MenuToolButton with an image.
+   *
+   * The MenuToolButton will have the label @a label and an image widget @a icon_widget.
+   *
+   * @param icon_widget The widget placed as the MenuToolButton's icon.
+   * @param label The string used to display the label for this MenuToolButton.
+   */
+  explicit MenuToolButton(Widget& icon_widget, const Glib::ustring& label = Glib::ustring());
+
+  
+  /** Sets the Gtk::Menu that is popped up when the user clicks on the arrow.
+   * If @a menu  is <tt>0</tt>, the arrow button becomes insensitive.
+   * 
+   * Since: 2.6
+   * @param menu The Gtk::Menu associated with Gtk::MenuToolButton.
+   */
+  void set_menu(Menu& menu);
+  
+  /** Gets the Gtk::Menu associated with Gtk::MenuToolButton.
+   * @return The Gtk::Menu associated with Gtk::MenuToolButton
+   * 
+   * Since: 2.6.
+   */
+  Menu* get_menu();
+  
+  /** Gets the Gtk::Menu associated with Gtk::MenuToolButton.
+   * @return The Gtk::Menu associated with Gtk::MenuToolButton
+   * 
+   * Since: 2.6.
+   */
+  const Menu* get_menu() const;
+
+  
+  void set_arrow_tooltip(Tooltips& tooltips, const Glib::ustring& tip_text, const Glib::ustring& tip_private);
+
+  
+  Glib::SignalProxy0< void > signal_show_menu();
+
+  /** The dropdown menu.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Menu*> property_menu() ;
+
+/** The dropdown menu.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Menu*> property_menu() const;
+
+
+};
+
+} // namespace Gtk
+
+
+namespace Glib
+{
+  /** @relates Gtk::MenuToolButton
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gtk::MenuToolButton* wrap(GtkMenuToolButton* object, bool take_copy = false);
+}
+#endif /* _GTKMM_MENUTOOLBUTTON_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/messagedialog.cc b/libs/gtkmm2/gtk/gtkmm/messagedialog.cc
new file mode 100644
index 0000000000..4a86cc5f1f
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/messagedialog.cc
@@ -0,0 +1,189 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/messagedialog.h>
+#include <gtkmm/private/messagedialog_p.h>
+
+#include <gtk/gtktypebuiltins.h>
+// -*- c++ -*-
+/* $Id$ */
+
+/* 
+ *
+ * Copyright 2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtk/gtkmessagedialog.h>
+#include <gtk/gtklabel.h>
+
+
+namespace Gtk
+{
+
+MessageDialog::MessageDialog(const Glib::ustring& message, bool use_markup,
+                             MessageType type, ButtonsType buttons,
+                             bool modal)
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Dialog(Glib::ConstructParams(messagedialog_class_.init(), "message_type",(GtkMessageType)type,"buttons",(GtkButtonsType)buttons, (char*) 0))
+{
+  set_modal(modal);
+  set_message(message, use_markup);
+}
+
+MessageDialog::MessageDialog(Gtk::Window& parent, const Glib::ustring& message, bool use_markup,
+                             MessageType type, ButtonsType buttons,
+                             bool modal)
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Dialog(Glib::ConstructParams(messagedialog_class_.init(), "message_type",(GtkMessageType)type,"buttons",(GtkButtonsType)buttons, (char*) 0))
+{
+  set_modal(modal);
+  set_transient_for(parent);
+  set_message(message, use_markup);
+}
+
+void MessageDialog::set_message(const Glib::ustring& message, bool use_markup)
+{
+  // TODO: GTK+ bug: The label widget is really a <private> struct field.
+  // There should really be a message property.
+
+  if(use_markup)
+    gtk_message_dialog_set_markup(gobj(), message.c_str()); 
+  else
+    gtk_label_set_text(GTK_LABEL(gobj()->label), message.c_str());
+}
+
+void MessageDialog::set_secondary_text(const Glib::ustring& text, bool use_markup)
+{
+  if(use_markup)
+    gtk_message_dialog_format_secondary_markup(gobj(), text.c_str());
+  else
+    gtk_message_dialog_format_secondary_text(gobj(), text.c_str());
+}
+
+} // namespace Gtk
+
+
+namespace
+{
+} // anonymous namespace
+
+// static
+GType Glib::Value<Gtk::MessageType>::value_type()
+{
+  return gtk_message_type_get_type();
+}
+
+// static
+GType Glib::Value<Gtk::ButtonsType>::value_type()
+{
+  return gtk_buttons_type_get_type();
+}
+
+
+namespace Glib
+{
+
+Gtk::MessageDialog* wrap(GtkMessageDialog* object, bool take_copy)
+{
+  return dynamic_cast<Gtk::MessageDialog *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& MessageDialog_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &MessageDialog_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_message_dialog_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void MessageDialog_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+}
+
+
+Glib::ObjectBase* MessageDialog_Class::wrap_new(GObject* o)
+{
+  return new MessageDialog((GtkMessageDialog*)(o)); //top-level windows can not be manage()ed.
+
+}
+
+
+/* The implementation: */
+
+MessageDialog::MessageDialog(const Glib::ConstructParams& construct_params)
+:
+  Gtk::Dialog(construct_params)
+{
+  }
+
+MessageDialog::MessageDialog(GtkMessageDialog* castitem)
+:
+  Gtk::Dialog((GtkDialog*)(castitem))
+{
+  }
+
+MessageDialog::~MessageDialog()
+{
+  destroy_();
+}
+
+MessageDialog::CppClassType MessageDialog::messagedialog_class_; // initialize static member
+
+GType MessageDialog::get_type()
+{
+  return messagedialog_class_.init().get_type();
+}
+
+GType MessageDialog::get_base_type()
+{
+  return gtk_message_dialog_get_type();
+}
+
+
+void MessageDialog::set_markup(const Glib::ustring& str)
+{
+  gtk_message_dialog_set_markup(gobj(), str.c_str());
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/messagedialog.h b/libs/gtkmm2/gtk/gtkmm/messagedialog.h
new file mode 100644
index 0000000000..68519df606
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/messagedialog.h
@@ -0,0 +1,228 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_MESSAGEDIALOG_H
+#define _GTKMM_MESSAGEDIALOG_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* messagedialog.h
+ *
+ * Copyright (C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/dialog.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkMessageDialog GtkMessageDialog;
+typedef struct _GtkMessageDialogClass GtkMessageDialogClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class MessageDialog_Class; } // namespace Gtk
+namespace Gtk
+{
+
+
+/** @addtogroup gtkmmEnums Enums and Flags */
+
+/**
+ * @ingroup gtkmmEnums
+ */
+enum MessageType
+{
+  MESSAGE_INFO,
+  MESSAGE_WARNING,
+  MESSAGE_QUESTION,
+  MESSAGE_ERROR
+};
+
+} // namespace Gtk
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Gtk::MessageType> : public Glib::Value_Enum<Gtk::MessageType>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{
+
+/**
+ * @ingroup gtkmmEnums
+ */
+enum ButtonsType
+{
+  BUTTONS_NONE,
+  BUTTONS_OK,
+  BUTTONS_CLOSE,
+  BUTTONS_CANCEL,
+  BUTTONS_YES_NO,
+  BUTTONS_OK_CANCEL
+};
+
+} // namespace Gtk
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Gtk::ButtonsType> : public Glib::Value_Enum<Gtk::ButtonsType>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{
+
+
+/** Convenient message window.
+ *
+ * Gtk::MessageDialog presents a dialog with an image representing the type
+ * of message (Error, Question, etc.) alongside some message text. It's
+ * simply a convenience widget; you could construct the equivalent of
+ * Gtk::MessageDialog from Gtk::Dialog without too much effort, but
+ * Gtk::MessageDialog saves typing. 
+ *
+ * @ingroup Dialogs
+ */
+
+class MessageDialog : public Dialog
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef MessageDialog CppObjectType;
+  typedef MessageDialog_Class CppClassType;
+  typedef GtkMessageDialog BaseObjectType;
+  typedef GtkMessageDialogClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~MessageDialog();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class MessageDialog_Class;
+  static CppClassType messagedialog_class_;
+
+  // noncopyable
+  MessageDialog(const MessageDialog&);
+  MessageDialog& operator=(const MessageDialog&);
+
+protected:
+  explicit MessageDialog(const Glib::ConstructParams& construct_params);
+  explicit MessageDialog(GtkMessageDialog* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GtkMessageDialog*       gobj()       { return reinterpret_cast<GtkMessageDialog*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GtkMessageDialog* gobj() const { return reinterpret_cast<GtkMessageDialog*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+private:
+
+  
+public:
+  explicit MessageDialog(const Glib::ustring& message, bool use_markup = false, MessageType type = MESSAGE_INFO, ButtonsType buttons = BUTTONS_OK, bool modal = false);
+  MessageDialog(Gtk::Window& parent, const Glib::ustring& message, bool use_markup = false, MessageType type = MESSAGE_INFO, ButtonsType buttons = BUTTONS_OK, bool modal = false);
+  
+
+  /** @deprecated Use set_message(string, true);
+   */
+  
+  /** Sets the text of the message dialog to be @a str , which is marked
+   * up with the Pango text markup
+   * language.
+   * 
+   * Since: 2.4
+   * @param str Markup string (see Pango markup format).
+   */
+  void set_markup(const Glib::ustring& str);
+
+  /** Sets the primary text of the message dialog.
+   *
+   * @param text The message.
+   * @param use_markup Whether @a message contains pango markup.
+   */
+  void set_message(const Glib::ustring& message, bool use_markup = false);
+  
+  
+  /** Sets the secondary text of the message dialog.
+   * Note that setting a secondary text makes the primary text become bold, unless you have provided explicit markup.
+   *
+   * Since 2.6.
+   *
+   * @param text The message.
+   * @param use_markup Whether @a message contains pango markup.
+   */
+  void set_secondary_text(const Glib::ustring& text, bool use_markup = false);
+  
+
+};
+
+} // namespace Gtk
+
+
+namespace Glib
+{
+  /** @relates Gtk::MessageDialog
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gtk::MessageDialog* wrap(GtkMessageDialog* object, bool take_copy = false);
+}
+#endif /* _GTKMM_MESSAGEDIALOG_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/misc.cc b/libs/gtkmm2/gtk/gtkmm/misc.cc
new file mode 100644
index 0000000000..e3b73f70c9
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/misc.cc
@@ -0,0 +1,200 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/misc.h>
+#include <gtkmm/private/misc_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* 
+ *
+ * Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtk/gtkmisc.h>
+
+namespace Gtk
+{
+
+} //namespace Gtk
+
+
+namespace
+{
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Gtk::Misc* wrap(GtkMisc* object, bool take_copy)
+{
+  return dynamic_cast<Gtk::Misc *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& Misc_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &Misc_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_misc_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void Misc_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+}
+
+
+Glib::ObjectBase* Misc_Class::wrap_new(GObject* o)
+{
+  return manage(new Misc((GtkMisc*)(o)));
+
+}
+
+
+/* The implementation: */
+
+Misc::Misc(const Glib::ConstructParams& construct_params)
+:
+  Gtk::Widget(construct_params)
+{
+  }
+
+Misc::Misc(GtkMisc* castitem)
+:
+  Gtk::Widget((GtkWidget*)(castitem))
+{
+  }
+
+Misc::~Misc()
+{
+  destroy_();
+}
+
+Misc::CppClassType Misc::misc_class_; // initialize static member
+
+GType Misc::get_type()
+{
+  return misc_class_.init().get_type();
+}
+
+GType Misc::get_base_type()
+{
+  return gtk_misc_get_type();
+}
+
+
+Misc::Misc()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Widget(Glib::ConstructParams(misc_class_.init()))
+{
+  }
+
+void Misc::set_alignment(float xalign, float yalign)
+{
+  gtk_misc_set_alignment(gobj(), xalign, yalign);
+}
+
+void Misc::set_alignment(AlignmentEnum xalign, AlignmentEnum yalign)
+{
+  gtk_misc_set_alignment(gobj(), _gtkmm_align_float_from_enum(xalign), _gtkmm_align_float_from_enum(yalign));
+}
+
+void Misc::get_alignment(float& xalign, float& yalign) const
+{
+  gtk_misc_get_alignment(const_cast<GtkMisc*>(gobj()), &(xalign), &(yalign));
+}
+
+void Misc::set_padding(int xpad, int ypad)
+{
+  gtk_misc_set_padding(gobj(), xpad, ypad);
+}
+
+void Misc::get_padding(int& xpad, int& ypad) const
+{
+  gtk_misc_get_padding(const_cast<GtkMisc*>(gobj()), &xpad, &ypad);
+}
+
+
+Glib::PropertyProxy<float> Misc::property_xalign() 
+{
+  return Glib::PropertyProxy<float>(this, "xalign");
+}
+
+Glib::PropertyProxy_ReadOnly<float> Misc::property_xalign() const
+{
+  return Glib::PropertyProxy_ReadOnly<float>(this, "xalign");
+}
+
+Glib::PropertyProxy<float> Misc::property_yalign() 
+{
+  return Glib::PropertyProxy<float>(this, "yalign");
+}
+
+Glib::PropertyProxy_ReadOnly<float> Misc::property_yalign() const
+{
+  return Glib::PropertyProxy_ReadOnly<float>(this, "yalign");
+}
+
+Glib::PropertyProxy<int> Misc::property_xpad() 
+{
+  return Glib::PropertyProxy<int>(this, "xpad");
+}
+
+Glib::PropertyProxy_ReadOnly<int> Misc::property_xpad() const
+{
+  return Glib::PropertyProxy_ReadOnly<int>(this, "xpad");
+}
+
+Glib::PropertyProxy<int> Misc::property_ypad() 
+{
+  return Glib::PropertyProxy<int>(this, "ypad");
+}
+
+Glib::PropertyProxy_ReadOnly<int> Misc::property_ypad() const
+{
+  return Glib::PropertyProxy_ReadOnly<int>(this, "ypad");
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/misc.h b/libs/gtkmm2/gtk/gtkmm/misc.h
new file mode 100644
index 0000000000..1d1a32d794
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/misc.h
@@ -0,0 +1,212 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_MISC_H
+#define _GTKMM_MISC_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* misc.h
+ * 
+ * Copyright (C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/widget.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkMisc GtkMisc;
+typedef struct _GtkMiscClass GtkMiscClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class Misc_Class; } // namespace Gtk
+namespace Gtk
+{
+
+/** A base class for widgets with alignments and padding.
+ *
+ * This is an abstract for a set of utility widgets
+ * that lack a physical window.  They do have
+ * alignment and padding within their defined space.
+ *
+ * Without a window, widgets of this type cannot capture events.
+ * To capture events place in Gtk::EventBox.
+ *
+ */
+
+class Misc : public Widget
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Misc CppObjectType;
+  typedef Misc_Class CppClassType;
+  typedef GtkMisc BaseObjectType;
+  typedef GtkMiscClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~Misc();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class Misc_Class;
+  static CppClassType misc_class_;
+
+  // noncopyable
+  Misc(const Misc&);
+  Misc& operator=(const Misc&);
+
+protected:
+  explicit Misc(const Glib::ConstructParams& construct_params);
+  explicit Misc(GtkMisc* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GtkMisc*       gobj()       { return reinterpret_cast<GtkMisc*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GtkMisc* gobj() const { return reinterpret_cast<GtkMisc*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+private:
+
+protected:
+  Misc();
+public:
+
+  
+  void set_alignment(float xalign = 0.0, float yalign = 0.5);
+  
+  void set_alignment(AlignmentEnum xalign = Gtk::ALIGN_LEFT, AlignmentEnum yalign = Gtk::ALIGN_CENTER);
+
+  
+  /** Gets the X and Y alignment of the widget within its allocation. See
+   * set_alignment().
+   * @param xalign Location to store X alignment of @a misc , or <tt>0</tt>.
+   * @param yalign Location to store Y alignment of @a misc , or <tt>0</tt>.
+   */
+  void get_alignment(float& xalign, float& yalign) const;
+
+  
+  void set_padding(int xpad, int ypad);
+  
+  /** Gets the padding in the X and Y directions of the widget. See set_padding().
+   * @param xpad Location to store padding in the X direction, or <tt>0</tt>.
+   * @param ypad Location to store padding in the Y direction, or <tt>0</tt>.
+   */
+  void get_padding(int& xpad, int& ypad) const;
+
+  /** The horizontal alignment
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<float> property_xalign() ;
+
+/** The horizontal alignment
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<float> property_xalign() const;
+
+  /** The vertical alignment
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<float> property_yalign() ;
+
+/** The vertical alignment
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<float> property_yalign() const;
+
+  /** The amount of space to add on the left and right of the widget
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<int> property_xpad() ;
+
+/** The amount of space to add on the left and right of the widget
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<int> property_xpad() const;
+
+  /** The amount of space to add on the top and bottom of the widget
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<int> property_ypad() ;
+
+/** The amount of space to add on the top and bottom of the widget
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<int> property_ypad() const;
+
+
+};
+
+} /* namespace Gtk */
+
+
+namespace Glib
+{
+  /** @relates Gtk::Misc
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gtk::Misc* wrap(GtkMisc* object, bool take_copy = false);
+}
+#endif /* _GTKMM_MISC_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/notebook.cc b/libs/gtkmm2/gtk/gtkmm/notebook.cc
new file mode 100644
index 0000000000..7ff83da6d1
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/notebook.cc
@@ -0,0 +1,910 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/notebook.h>
+#include <gtkmm/private/notebook_p.h>
+
+#include <gtk/gtktypebuiltins.h>
+// -*- c++ -*-
+/* $Id$ */
+
+/* Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtk/gtknotebook.h>
+#include <gtkmm/label.h>
+
+
+namespace Gtk
+{
+
+namespace Notebook_Helpers
+{
+
+/**** Gtk::Notebook_Helpers::PageIterator **********************************/
+
+bool PageIterator::equal(const PageIterator& other) const
+{
+  return (node_ == other.node_);
+}
+
+PageIterator::operator bool() const
+{
+  return (node_ != 0);
+}
+
+PageIterator& PageIterator::operator++()
+{
+  g_return_val_if_fail(node_ != 0, *this);
+
+  node_ = node_->next;
+  return *this;
+}
+
+const PageIterator PageIterator::operator++(int)
+{
+  const PageIterator tmp (*this);
+  this->operator++();
+  return tmp;
+}
+
+PageIterator& PageIterator::operator--()
+{
+  if(node_)
+    node_ = node_->prev;
+  else
+    node_ = g_list_last(parent_->gobj()->children);
+
+  return *this;
+}
+
+const PageIterator PageIterator::operator--(int)
+{
+  const PageIterator tmp (*this);
+  this->operator--();
+  return tmp;
+}
+
+
+/*********************************************************************
+***** Page Properties
+*********************************************************************/
+
+int Page::get_page_num() const
+{
+  return g_list_position(parent_->gobj()->children, node_);
+}
+
+Widget* Page::get_child() const
+{
+  return parent_->get_nth_page(get_page_num());
+}
+
+Widget* Page::get_tab_label() const
+{
+  return parent_->get_tab_label(*get_child());
+}
+
+void Page::set_tab_label(Widget& tab_label)
+{
+  parent_->set_tab_label(*get_child(), tab_label);
+}
+
+void Page::set_tab_label_text(const Glib::ustring& tab_text)
+{
+  parent_->set_tab_label_text(*get_child(), tab_text);
+}
+
+Glib::ustring Page::get_tab_label_text() const
+{
+  return parent_->get_tab_label_text(*get_child());
+}
+
+Widget* Page::get_menu_label() const
+{
+  return parent_->get_menu_label(*get_child());
+}
+
+void Page::set_menu_label(Widget& menu_label)
+{
+  parent_->set_menu_label(*get_child(), menu_label);
+}
+
+void Page::set_menu_label_text(const Glib::ustring& menu_text)
+{
+  parent_->set_menu_label_text(*get_child(), menu_text);
+}
+
+Glib::ustring Page::get_menu_label_text() const
+{
+  return parent_->get_menu_label_text(*get_child());
+}
+
+void Page::query_tab_label_packing(bool& expand, bool& fill, PackType& pack_type)
+{
+  parent_->query_tab_label_packing(*get_child(), expand, fill, pack_type);
+}
+
+void Page::set_tab_label_packing(bool expand, bool fill, PackType pack_type)
+{
+  parent_->set_tab_label_packing(*get_child(), expand, fill, pack_type);
+}
+
+/*********************************************************************
+***** List properties
+*********************************************************************/
+PageList::PageList()
+:
+  gparent_ (0)
+{}
+
+PageList::PageList(GtkNotebook* gparent)
+:
+  gparent_ (gparent)
+{}
+
+PageList::PageList(const PageList& src)
+{
+  operator=(src);
+}
+
+PageList& PageList::operator=(const PageList& src)
+{
+  gparent_ = src.gparent_;
+  return *this;
+}
+
+PageList::size_type PageList::max_size() const
+{
+  return G_MAXINT;
+}
+
+bool PageList::empty() const
+{
+  return (gparent_->children == 0);
+}
+
+PageList::size_type PageList::size() const
+{
+  return g_list_length(gparent_->children);
+}
+
+PageList::value_type PageList::front() const
+{
+  return *begin();
+}
+
+PageList::value_type PageList::back() const
+{
+  iterator pend (end());
+  return *--pend;
+}
+
+PageList::value_type PageList::operator[](size_type index) const
+{
+  GList *const node = g_list_nth(gparent_->children, index);
+  g_assert(node != 0);
+
+  return *iterator(Glib::wrap(gparent_), node);
+}
+
+PageList::iterator PageList::insert(PageList::iterator position, const Element& elem)
+{
+  // Get the iterator index, or -1 for end().
+  const int index = (position) ? position->get_page_num() : -1;
+
+  // Give item to GTK+.
+  gtk_notebook_insert_page_menu(gparent_,
+                                Glib::unwrap(elem.child_),
+                                Glib::unwrap(elem.tab_),
+                                Glib::unwrap(elem.menu_),
+                                index);
+
+  // Return an iterator pointing to the inserted element.
+  return --position;
+}
+
+void PageList::erase(PageList::iterator start, PageList::iterator stop)
+{
+  while(start != stop)
+    start = erase(start);
+}
+
+PageList::iterator PageList::erase(PageList::iterator position)
+{
+  iterator next (position);
+
+  if(position)
+  {
+    ++next;
+    gtk_container_remove(GTK_CONTAINER(gparent_), position->get_child()->gobj());
+  }
+
+  return next;
+}
+
+void PageList::remove(const_reference child)
+{
+//  g_return_if_fail(child.parent_ != 0);
+  gtk_container_remove(GTK_CONTAINER(gparent_), child.get_child()->gobj());
+}
+
+void PageList::remove(Widget& widget)
+{
+  gtk_container_remove(GTK_CONTAINER(gparent_), widget.gobj());
+}
+
+void PageList::reorder(PageList::iterator position, PageList::iterator page)
+{
+  gtk_notebook_reorder_child(gparent(), page->get_child()->gobj(), position->get_page_num());
+}
+
+PageList::iterator PageList::find(int num)
+{
+  if(num < 0) return end();
+  int j = 0;
+  iterator i;
+  for(i = begin(), j = 0; i != end(), j < num; ++i, ++j);
+  return i;
+}
+
+PageList::iterator PageList::find(const_reference c)
+{
+  iterator i = begin();
+  for(i = begin(); i != end() && ((*i).get_child() != c.get_child()); i++);
+  return i;
+}
+
+PageList::iterator PageList::find(Widget& widget)
+{
+  iterator i;
+  for(i = begin(); i != end() && ((*i).get_child() != &widget); i++);
+  return i;
+}
+
+PageList::iterator PageList::find(GtkNotebookPage* page)
+{
+  GList* node = gparent_->children;
+
+  while(node && node->data != page)
+    node = node->next;
+
+  return (node) ? iterator(Glib::wrap(gparent_), node) : end();
+}
+
+void PageList::clear()
+{
+  erase(begin(), end());
+}
+
+PageList::iterator PageList::begin_() const
+{
+  return iterator(Glib::wrap(gparent_), gparent_->children);
+}
+
+PageList::iterator PageList::end_() const
+{
+  return iterator(Glib::wrap(gparent_), 0);
+}
+
+Element::Element(Widget* child, Widget* tab, Widget* menu)
+:
+  child_  (child),
+  tab_    (tab),
+  menu_   (menu)
+{}
+
+Element::Element(Widget& child, Widget& tab, Widget& menu)
+:
+  child_  (&child),
+  tab_    (&tab),
+  menu_   (&menu)
+{}
+
+Element::Element(Widget& child)
+:
+  child_  (&child),
+  tab_    (0),
+  menu_   (0)
+{}
+
+TabElem::TabElem(Widget& child, Widget& tab)
+:
+  Element(&child, &tab, 0)
+{}
+
+TabElem::TabElem(Widget& child, const Glib::ustring& label, bool mnemonic)
+:
+  Element(&child, manage(new Label(label, mnemonic)), 0)
+{}
+
+MenuElem::MenuElem(Widget& child, Widget& menu)
+:
+  Element(&child, 0, &menu)
+{}
+
+} /* namespace Notebook_Helpers */
+
+
+Notebook::PageList::iterator Notebook::get_current()
+{
+  return pages().find(get_current_page());
+}
+
+Notebook::PageList& Notebook::pages()
+{
+  pages_proxy_ = PageList(gobj());
+  return pages_proxy_;
+}
+
+const Notebook::PageList& Notebook::pages() const
+{
+  pages_proxy_ = PageList(const_cast<GtkNotebook*>(gobj()));
+  return pages_proxy_;
+}
+
+/*Widget* Notebook::get_current_page()
+{
+  return get_nth_page(get_current_page_num());
+}*/
+
+int Notebook::prepend_page(Widget& child, const Glib::ustring& tab_label, bool use_mnemonic)
+{
+  Label* pLabel = Gtk::manage( new Label(tab_label, use_mnemonic) );
+  return prepend_page(child, *pLabel);
+}
+
+int Notebook::prepend_page(Widget& child, const Glib::ustring& tab_label, const Glib::ustring& menu_label, bool use_mnemonic)
+{
+  Label* pLabel = Gtk::manage( new Label(tab_label, use_mnemonic) );
+  Label* pLabelMenu = Gtk::manage( new Label(menu_label, use_mnemonic) );
+  return prepend_page(child, *pLabel, *pLabelMenu);
+}
+
+int Notebook::append_page(Widget& child, const Glib::ustring& tab_label, bool use_mnemonic)
+{
+  Label* pLabel = Gtk::manage( new Label(tab_label, use_mnemonic) );
+  return append_page(child, *pLabel);
+}
+
+int Notebook::append_page(Widget& child, const Glib::ustring& tab_label, const Glib::ustring& menu_label, bool use_mnemonic)
+{
+  Label* pLabel = Gtk::manage( new Label(tab_label, use_mnemonic) );
+  Label* pLabelMenu = Gtk::manage( new Label(menu_label, use_mnemonic) );
+  return append_page(child, *pLabel, *pLabelMenu);
+}
+
+int Notebook::insert_page(Widget& child, const Glib::ustring& tab_label, int position, bool use_mnemonic)
+{
+  Label* pLabel = Gtk::manage( new Label(tab_label, use_mnemonic) );
+  return insert_page(child, *pLabel, position);
+}
+
+int Notebook::insert_page(Widget& child, const Glib::ustring& tab_label, const Glib::ustring& menu_label, int position, bool use_mnemonic)
+{
+  Label* pLabel = Gtk::manage( new Label(tab_label, use_mnemonic) );
+  Label* pLabelMenu = Gtk::manage( new Label(menu_label, use_mnemonic) );
+  return insert_page(child, *pLabel, *pLabelMenu, position);
+}
+
+void Notebook::remove_page(Widget& child)
+{
+  int pos = page_num(child);
+  if(pos != -1)
+    remove_page(pos);
+}
+
+void Notebook::query_tab_label_packing(Widget& child, bool& expand, bool& fill, PackType& pack_type)
+{
+  gboolean gexpand = false;
+  gboolean gfill = false;
+  GtkPackType gpack_type = GTK_PACK_START;
+  gtk_notebook_query_tab_label_packing(gobj(), child.gobj(), &gexpand, &gfill, &gpack_type);
+  expand = gexpand;
+  fill = gfill;
+  pack_type = (PackType)gpack_type;
+}
+
+int Notebook::prepend_page(Widget& child)
+{
+  return gtk_notebook_prepend_page(gobj(), child.gobj(), 0 /* see GTK+ docs */);
+}
+
+int Notebook::append_page(Widget& child)
+{
+  return gtk_notebook_append_page(gobj(), child.gobj(), 0 /* see GTK+ docs */);
+}
+
+int Notebook::insert_page(Widget& child, int position)
+{
+  return gtk_notebook_insert_page(gobj(), child.gobj(), 0 /* see GTK+ docs */, position);
+}
+
+} //namespace Gtk
+
+
+namespace
+{
+
+void Notebook_signal_switch_page_callback(GtkNotebook* self, GtkNotebookPage* p0,guint p1,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,GtkNotebookPage*,guint > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(p0, p1);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+}
+
+const Glib::SignalProxyInfo Notebook_signal_switch_page_info =
+{
+  "switch_page",
+  (GCallback) &Notebook_signal_switch_page_callback,
+  (GCallback) &Notebook_signal_switch_page_callback
+};
+
+} // anonymous namespace
+
+// static
+GType Glib::Value<Gtk::NotebookTab>::value_type()
+{
+  return gtk_notebook_tab_get_type();
+}
+
+
+namespace Glib
+{
+
+Gtk::Notebook* wrap(GtkNotebook* object, bool take_copy)
+{
+  return dynamic_cast<Gtk::Notebook *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& Notebook_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &Notebook_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_notebook_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void Notebook_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+  klass->switch_page = &switch_page_callback;
+}
+
+
+void Notebook_Class::switch_page_callback(GtkNotebook* self, GtkNotebookPage* p0, guint p1)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_switch_page(p0, p1);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->switch_page)
+      (*base->switch_page)(self, p0, p1);
+  }
+}
+
+
+Glib::ObjectBase* Notebook_Class::wrap_new(GObject* o)
+{
+  return manage(new Notebook((GtkNotebook*)(o)));
+
+}
+
+
+/* The implementation: */
+
+Notebook::Notebook(const Glib::ConstructParams& construct_params)
+:
+  Gtk::Container(construct_params)
+{
+  }
+
+Notebook::Notebook(GtkNotebook* castitem)
+:
+  Gtk::Container((GtkContainer*)(castitem))
+{
+  }
+
+Notebook::~Notebook()
+{
+  destroy_();
+}
+
+Notebook::CppClassType Notebook::notebook_class_; // initialize static member
+
+GType Notebook::get_type()
+{
+  return notebook_class_.init().get_type();
+}
+
+GType Notebook::get_base_type()
+{
+  return gtk_notebook_get_type();
+}
+
+
+Notebook::Notebook()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Container(Glib::ConstructParams(notebook_class_.init()))
+{
+  }
+
+int Notebook::prepend_page(Widget& child, Widget& tab_label)
+{
+  return gtk_notebook_prepend_page(gobj(), (child).gobj(), (tab_label).gobj());
+}
+
+int Notebook::prepend_page(Widget& child, Widget& tab_label, Widget& menu_label)
+{
+  return gtk_notebook_prepend_page_menu(gobj(), (child).gobj(), (tab_label).gobj(), (menu_label).gobj());
+}
+
+int Notebook::append_page(Widget& child, Widget& tab_label)
+{
+  return gtk_notebook_append_page(gobj(), (child).gobj(), (tab_label).gobj());
+}
+
+int Notebook::append_page(Widget& child, Widget& tab_label, Widget& menu_label)
+{
+  return gtk_notebook_append_page_menu(gobj(), (child).gobj(), (tab_label).gobj(), (menu_label).gobj());
+}
+
+int Notebook::insert_page(Widget& child, Widget& tab_label, int position)
+{
+  return gtk_notebook_insert_page(gobj(), (child).gobj(), (tab_label).gobj(), position);
+}
+
+int Notebook::insert_page(Widget& child, Widget& tab_label, Widget& menu_label, int position)
+{
+  return gtk_notebook_insert_page_menu(gobj(), (child).gobj(), (tab_label).gobj(), (menu_label).gobj(), position);
+}
+
+void Notebook::remove_page(int page_num)
+{
+  gtk_notebook_remove_page(gobj(), page_num);
+}
+
+int Notebook::get_current_page() const
+{
+  return gtk_notebook_get_current_page(const_cast<GtkNotebook*>(gobj()));
+}
+
+Widget* Notebook::get_nth_page(int page_num)
+{
+  return Glib::wrap(gtk_notebook_get_nth_page(gobj(), page_num));
+}
+
+const Widget* Notebook::get_nth_page(int page_num) const
+{
+  return Glib::wrap(gtk_notebook_get_nth_page(const_cast<GtkNotebook*>(gobj()), page_num));
+}
+
+int Notebook::get_n_pages()
+{
+  return gtk_notebook_get_n_pages(gobj());
+}
+
+int Notebook::page_num(const Widget& child)
+{
+  return gtk_notebook_page_num(gobj(), const_cast<GtkWidget*>((child).gobj()));
+}
+
+void Notebook::set_current_page(int page_num)
+{
+  gtk_notebook_set_current_page(gobj(), page_num);
+}
+
+void Notebook::next_page()
+{
+  gtk_notebook_next_page(gobj());
+}
+
+void Notebook::prev_page()
+{
+  gtk_notebook_prev_page(gobj());
+}
+
+void Notebook::set_show_border(bool show_border)
+{
+  gtk_notebook_set_show_border(gobj(), static_cast<int>(show_border));
+}
+
+bool Notebook::get_show_border() const
+{
+  return gtk_notebook_get_show_border(const_cast<GtkNotebook*>(gobj()));
+}
+
+void Notebook::set_show_tabs(bool show_tabs)
+{
+  gtk_notebook_set_show_tabs(gobj(), static_cast<int>(show_tabs));
+}
+
+bool Notebook::get_show_tabs() const
+{
+  return gtk_notebook_get_show_tabs(const_cast<GtkNotebook*>(gobj()));
+}
+
+void Notebook::set_tab_pos(PositionType pos)
+{
+  gtk_notebook_set_tab_pos(gobj(), ((GtkPositionType)(pos)));
+}
+
+PositionType Notebook::get_tab_pos() const
+{
+  return ((PositionType)(gtk_notebook_get_tab_pos(const_cast<GtkNotebook*>(gobj()))));
+}
+
+void Notebook::set_scrollable(bool scrollable)
+{
+  gtk_notebook_set_scrollable(gobj(), static_cast<int>(scrollable));
+}
+
+bool Notebook::get_scrollable() const
+{
+  return gtk_notebook_get_scrollable(const_cast<GtkNotebook*>(gobj()));
+}
+
+void Notebook::popup_enable()
+{
+  gtk_notebook_popup_enable(gobj());
+}
+
+void Notebook::popup_disable()
+{
+  gtk_notebook_popup_disable(gobj());
+}
+
+Widget* Notebook::get_tab_label(Widget& child)
+{
+  return Glib::wrap(gtk_notebook_get_tab_label(gobj(), (child).gobj()));
+}
+
+const Widget* Notebook::get_tab_label(Widget& child) const
+{
+  return Glib::wrap(gtk_notebook_get_tab_label(const_cast<GtkNotebook*>(gobj()), (child).gobj()));
+}
+
+void Notebook::set_tab_label(Widget& child, Widget& tab_label)
+{
+  gtk_notebook_set_tab_label(gobj(), (child).gobj(), (tab_label).gobj());
+}
+
+void Notebook::set_tab_label_text(Widget& child, const Glib::ustring& tab_text)
+{
+  gtk_notebook_set_tab_label_text(gobj(), (child).gobj(), tab_text.c_str());
+}
+
+Glib::ustring Notebook::get_tab_label_text(Widget& child) const
+{
+  return Glib::convert_const_gchar_ptr_to_ustring(gtk_notebook_get_tab_label_text(const_cast<GtkNotebook*>(gobj()), (child).gobj()));
+}
+
+Widget* Notebook::get_menu_label(Widget& child)
+{
+  return Glib::wrap(gtk_notebook_get_menu_label(gobj(), (child).gobj()));
+}
+
+const Widget* Notebook::get_menu_label(Widget& child) const
+{
+  return Glib::wrap(gtk_notebook_get_menu_label(const_cast<GtkNotebook*>(gobj()), (child).gobj()));
+}
+
+void Notebook::set_menu_label(Widget& child, Widget& menu_label)
+{
+  gtk_notebook_set_menu_label(gobj(), (child).gobj(), (menu_label).gobj());
+}
+
+void Notebook::set_menu_label_text(Widget& child, const Glib::ustring& menu_text)
+{
+  gtk_notebook_set_menu_label_text(gobj(), (child).gobj(), menu_text.c_str());
+}
+
+Glib::ustring Notebook::get_menu_label_text(Widget& child) const
+{
+  return Glib::convert_const_gchar_ptr_to_ustring(gtk_notebook_get_menu_label_text(const_cast<GtkNotebook*>(gobj()), (child).gobj()));
+}
+
+void Notebook::set_tab_label_packing(Widget& child, bool expand, bool fill, PackType pack_type)
+{
+  gtk_notebook_set_tab_label_packing(gobj(), (child).gobj(), static_cast<int>(expand), static_cast<int>(fill), ((GtkPackType)(pack_type)));
+}
+
+void Notebook::reorder_child(Widget& child, int position)
+{
+  gtk_notebook_reorder_child(gobj(), (child).gobj(), position);
+}
+
+
+Glib::SignalProxy2< void,GtkNotebookPage*,guint > Notebook::signal_switch_page()
+{
+  return Glib::SignalProxy2< void,GtkNotebookPage*,guint >(this, &Notebook_signal_switch_page_info);
+}
+
+
+Glib::PropertyProxy<PositionType> Notebook::property_tab_pos() 
+{
+  return Glib::PropertyProxy<PositionType>(this, "tab-pos");
+}
+
+Glib::PropertyProxy_ReadOnly<PositionType> Notebook::property_tab_pos() const
+{
+  return Glib::PropertyProxy_ReadOnly<PositionType>(this, "tab-pos");
+}
+
+Glib::PropertyProxy<bool> Notebook::property_show_tabs() 
+{
+  return Glib::PropertyProxy<bool>(this, "show-tabs");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> Notebook::property_show_tabs() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "show-tabs");
+}
+
+Glib::PropertyProxy<bool> Notebook::property_show_border() 
+{
+  return Glib::PropertyProxy<bool>(this, "show-border");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> Notebook::property_show_border() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "show-border");
+}
+
+Glib::PropertyProxy<bool> Notebook::property_scrollable() 
+{
+  return Glib::PropertyProxy<bool>(this, "scrollable");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> Notebook::property_scrollable() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "scrollable");
+}
+
+Glib::PropertyProxy_WriteOnly<guint> Notebook::property_tab_border() 
+{
+  return Glib::PropertyProxy_WriteOnly<guint>(this, "tab-border");
+}
+
+Glib::PropertyProxy_ReadOnly<guint> Notebook::property_tab_border() const
+{
+  return Glib::PropertyProxy_ReadOnly<guint>(this, "tab-border");
+}
+
+Glib::PropertyProxy<guint> Notebook::property_tab_hborder() 
+{
+  return Glib::PropertyProxy<guint>(this, "tab-hborder");
+}
+
+Glib::PropertyProxy_ReadOnly<guint> Notebook::property_tab_hborder() const
+{
+  return Glib::PropertyProxy_ReadOnly<guint>(this, "tab-hborder");
+}
+
+Glib::PropertyProxy<guint> Notebook::property_tab_vborder() 
+{
+  return Glib::PropertyProxy<guint>(this, "tab-vborder");
+}
+
+Glib::PropertyProxy_ReadOnly<guint> Notebook::property_tab_vborder() const
+{
+  return Glib::PropertyProxy_ReadOnly<guint>(this, "tab-vborder");
+}
+
+Glib::PropertyProxy<int> Notebook::property_page() 
+{
+  return Glib::PropertyProxy<int>(this, "page");
+}
+
+Glib::PropertyProxy_ReadOnly<int> Notebook::property_page() const
+{
+  return Glib::PropertyProxy_ReadOnly<int>(this, "page");
+}
+
+Glib::PropertyProxy<bool> Notebook::property_enable_popup() 
+{
+  return Glib::PropertyProxy<bool>(this, "enable-popup");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> Notebook::property_enable_popup() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "enable-popup");
+}
+
+Glib::PropertyProxy<bool> Notebook::property_homogeneous() 
+{
+  return Glib::PropertyProxy<bool>(this, "homogeneous");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> Notebook::property_homogeneous() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "homogeneous");
+}
+
+
+void Gtk::Notebook::on_switch_page(GtkNotebookPage* page, guint page_num)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->switch_page)
+    (*base->switch_page)(gobj(),page,page_num);
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/notebook.h b/libs/gtkmm2/gtk/gtkmm/notebook.h
new file mode 100644
index 0000000000..47378df9ed
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/notebook.h
@@ -0,0 +1,903 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_NOTEBOOK_H
+#define _GTKMM_NOTEBOOK_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* notebook.h
+ * 
+ * Copyright (C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/container.h>
+#include <gtkmm/label.h>
+//#include <gtk/gtknotebook.h>
+#include <glibmm/helperlist.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+extern "C"
+{
+  typedef struct _GtkNotebookPage GtkNotebookPage;
+}
+#endif //DOXYGEN_SHOULD_SKIP_THIS
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkNotebook GtkNotebook;
+typedef struct _GtkNotebookClass GtkNotebookClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class Notebook_Class; } // namespace Gtk
+namespace Gtk
+{
+
+
+/** @addtogroup gtkmmEnums Enums and Flags */
+
+/**
+ * @ingroup gtkmmEnums
+ */
+enum NotebookTab
+{
+  NOTEBOOK_TAB_FIRST,
+  NOTEBOOK_TAB_LAST
+};
+
+} // namespace Gtk
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Gtk::NotebookTab> : public Glib::Value_Enum<Gtk::NotebookTab>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{
+
+
+class Notebook;
+
+namespace Notebook_Helpers
+{
+/*********************************************************************
+***** Elem classes
+*********************************************************************/
+
+class Page;
+
+/* Since the data stored in GtkNotebook's GList is inaccessible
+ * the iterator "PageIterator" has to hold a pointer to the Notebook
+ * that owns the list. "Page" (the value_type of "PageList")
+ * inherits "PageIterator" privately and uses Notebook-API-functions
+ * to retrieve and manipulate data.
+ *
+ * Note that PageIterator uses g_list_* functions just to step through
+ * the children and test for iterator equality instead of simply using
+ * the child index number. This is done because even if you use a
+ * child index number, you would still have to use g_list_length() to
+ * retrieve the number of elements.  And using an element index results
+ * in iterators not staying valid on insertion/removal. This would only
+ * lead to fragile and unexpected behaviour.
+ * (Thanks for this explanation, Daniel!)
+ */
+class PageIterator
+{
+public:
+  typedef std::bidirectional_iterator_tag iterator_category;
+  typedef size_t size_type;
+  typedef ptrdiff_t difference_type;
+
+  typedef Page        value_type;
+  typedef const Page* pointer;
+  typedef const Page& reference;
+
+  PageIterator(Gtk::Notebook* parent, GList* node) : node_(node), parent_(parent) {}
+  PageIterator()                                   : node_(0),    parent_(0)      {}
+
+  bool equal(const PageIterator& other) const;
+  operator bool() const;
+
+  PageIterator&      operator++();
+  const PageIterator operator++(int);
+
+  PageIterator&      operator--();
+  const PageIterator operator--(int);
+
+  inline reference operator*()  const;
+  inline pointer   operator->() const;
+
+protected:
+  GList*         node_;
+  Gtk::Notebook* parent_;
+
+  friend class Gtk::Notebook_Helpers::Page;
+};
+
+/** @relates Gtk::Notebook_Helpers::PageIterator */
+inline bool operator==(const PageIterator& lhs, const PageIterator& rhs)
+  { return lhs.equal(rhs); }
+
+/** @relates Gtk::Notebook_Helpers::PageIterator */
+inline bool operator!=(const PageIterator& lhs, const PageIterator& rhs)
+  { return !lhs.equal(rhs); }
+
+
+// Page is the output class
+class Page : public PageIterator
+{
+protected:
+  Page();
+private:
+  Page& operator=(const Page&);
+
+public:
+  int get_page_num() const;
+  Widget* get_child() const;
+  Widget* get_tab_label() const;
+  void set_tab_label(Widget& tab_label);
+  void set_tab_label_text(const Glib::ustring& tab_text);
+  Glib::ustring get_tab_label_text() const;
+  Widget* get_menu_label() const;
+  void set_menu_label(Widget& menu_label);
+  void set_menu_label_text(const Glib::ustring& menu_text);
+  Glib::ustring get_menu_label_text() const;
+  void query_tab_label_packing(bool& expand, bool& fill, PackType& pack_type);
+  void set_tab_label_packing(bool expand, bool fill, PackType pack_type);
+};
+
+
+// Element is the input class
+class PageList;
+
+class Element
+{
+public:
+  Element(Widget* child, Widget* tab, Widget* menu);
+  Element(Widget& child, Widget& tab, Widget& menu);
+  explicit Element(Widget& child);
+
+protected:
+  friend class PageList;
+  Widget* child_;
+  Widget* tab_;
+  Widget* menu_;
+};
+
+// Just a widget without a tab
+typedef Element WidgetElem;
+
+struct TabElem : public Element
+{
+  TabElem(Widget& child, Widget& tab);
+  TabElem(Widget& child, const Glib::ustring& label, bool mnemonic = false);
+};
+
+struct MenuElem : public Element
+{
+  MenuElem(Widget& child, Widget& menu);
+};
+
+/*********************************************************************
+***** List properties
+*********************************************************************/
+
+/** An STL-style container for pages in a Gtk::Notebook.
+ *
+ */
+class PageList
+{
+public:
+  PageList();
+  explicit PageList(GtkNotebook* gparent);
+  PageList(const PageList& src);
+
+  PageList& operator=(const PageList& src);
+
+  typedef Page  value_type;
+  typedef Page& reference;
+  typedef const Page& const_reference;
+
+  typedef PageIterator iterator;
+  typedef Glib::List_ConstIterator<iterator> const_iterator;
+  typedef Glib::List_ReverseIterator<iterator> reverse_iterator;
+  typedef Glib::List_ConstIterator<reverse_iterator> const_reverse_iterator;
+
+  typedef const Element element_type;
+
+  typedef size_t difference_type;
+  typedef size_t size_type;
+
+  inline GtkNotebook* gparent()
+    { return gparent_; }
+  inline const GtkNotebook* gparent() const
+    { return gparent_; }
+
+  size_type size() const;
+
+  size_type max_size() const;
+  bool empty() const;
+
+  inline iterator begin()
+    { return begin_(); }
+  inline iterator end()
+    { return end_(); }
+
+  inline const_iterator begin() const
+    { return const_iterator(begin_()); }
+  inline const_iterator end() const
+    { return const_iterator(end_()); }
+
+  inline reverse_iterator rbegin()
+    { return reverse_iterator(end_()); }
+  inline reverse_iterator rend()
+    { return reverse_iterator(begin_()); }
+
+  inline const_reverse_iterator rbegin() const
+    { return const_reverse_iterator(reverse_iterator(end_())); }
+  inline const_reverse_iterator rend() const
+    { return const_reverse_iterator(reverse_iterator(begin_())); }
+
+  value_type front() const;
+  value_type back() const;
+
+  value_type operator[](size_type l) const;
+
+  iterator insert(iterator position, element_type& e); //custom-implemented.
+
+  template <class InputIterator>
+  inline void insert(iterator position, InputIterator first, InputIterator last)
+  {
+    for(;first != last; ++first)
+      position = insert(position, *first);
+  }
+
+  inline void push_front(element_type& e)
+    { insert(begin(), e); }
+  inline void push_back(element_type& e)
+    { insert(end(), e); }
+
+  void erase(iterator start, iterator stop);
+  iterator erase(iterator);
+  void remove(const_reference child);
+  void remove(Widget& w);
+
+  void reorder(iterator loc, iterator page); // Non-standard
+
+  iterator find(int num);
+  iterator find(const_reference c);
+  iterator find(Widget& w);
+  iterator find(GtkNotebookPage* t);
+
+  inline void pop_front()
+    { erase(begin()); }
+  inline void pop_back()
+    { erase(--end()); }
+
+  void clear();
+
+protected:
+  iterator begin_() const;
+  iterator end_() const;
+
+  GtkNotebook* gparent_;
+};
+
+} /* Notebook_Helpers */
+
+/** Container which shows one of its children at a time, in tabbed windows.
+ *
+ * The Gtk::Notebook widget is a Gtk::Container whose children are pages that
+ * can be switched between using tab labels along one edge. 
+ *
+ * You can use the PageList returned by pages() as any normal STL container
+ * to manipulate the pages.
+ *
+ * @ingroup Widgets
+ * @ingroup Containers
+ */
+
+class Notebook : public Container
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Notebook CppObjectType;
+  typedef Notebook_Class CppClassType;
+  typedef GtkNotebook BaseObjectType;
+  typedef GtkNotebookClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~Notebook();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class Notebook_Class;
+  static CppClassType notebook_class_;
+
+  // noncopyable
+  Notebook(const Notebook&);
+  Notebook& operator=(const Notebook&);
+
+protected:
+  explicit Notebook(const Glib::ConstructParams& construct_params);
+  explicit Notebook(GtkNotebook* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GtkNotebook*       gobj()       { return reinterpret_cast<GtkNotebook*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GtkNotebook* gobj() const { return reinterpret_cast<GtkNotebook*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+  virtual void on_switch_page(GtkNotebookPage* page, guint page_num);
+
+
+private:
+
+  
+public:
+  typedef Notebook_Helpers::PageList PageList;
+
+  Notebook();
+
+  
+  /** Prepends a page to @a notebook .
+   * @param child The Gtk::Widget to use as the contents of the page.
+   * @param tab_label The Gtk::Widget to be used as the label for the page.
+   */
+  int prepend_page(Widget& child, Widget& tab_label);
+  int prepend_page(Widget& child);
+
+  int prepend_page(Widget& child, const Glib::ustring& tab_label, bool use_mnemonic = false);
+  
+  /** Prepends a page to @a notebook , specifying the widget to use as the
+   * label in the popup menu.
+   * @param child The Gtk::Widget to use as the contents of the page.
+   * @param tab_label The Gtk::Widget to be used as the label for the page.
+   * @param menu_label The widget to use as a label for the page-switch
+   * menu.
+   */
+  int prepend_page(Widget& child, Widget& tab_label, Widget& menu_label);
+  //Ignore the possible-0 menu_label version of this method. It would have the same signature as another method.
+ 
+  int prepend_page(Widget& child, const Glib::ustring& tab_label, const Glib::ustring& menu_label, bool use_mnemonic);
+
+  
+  /** Appends a page to @a notebook .
+   * @param child The Gtk::Widget to use as the contents of the page.
+   * @param tab_label The Gtk::Widget to be used as the label for the page.
+   */
+  int append_page(Widget& child, Widget& tab_label);
+  int append_page(Widget& child);
+  int append_page(Widget& child, const Glib::ustring& tab_label, bool use_mnemonic = false);
+
+  
+  /** Appends a page to @a notebook , specifying the widget to use as the
+   * label in the popup menu.
+   * @param child The Gtk::Widget to use as the contents of the page.
+   * @param tab_label The Gtk::Widget to be used as the label for the page.
+   * @param menu_label The widget to use as a label for the page-switch
+   * menu.
+   */
+  int append_page(Widget& child, Widget& tab_label, Widget& menu_label);
+  //Ignore the possible-0 menu_label version of this method. It would have the same signature as another method.
+  
+  int append_page(Widget& child, const Glib::ustring& tab_label, const Glib::ustring& menu_label, bool use_mnemonic = false);
+
+  
+  /** Insert a page into @a notebook  at the given position
+   * @param child The Gtk::Widget to use as the contents of the page.
+   * @param tab_label The Gtk::Widget to be used as the label for the page.
+   * @param position The index (starting at 0) at which to insert the page,
+   * or -1 to append the page after all other pages.
+   */
+  int insert_page(Widget& child, Widget& tab_label, int position);
+  int insert_page(Widget& child, int position);
+ 
+  int insert_page(Widget& child, const Glib::ustring& tab_label, int position, bool use_mnemonic = false);
+  
+  /** Insert a page into @a notebook  at the given position, specifying
+   * the widget to use as the label in the popup menu.
+   * @param child The Gtk::Widget to use as the contents of the page.
+   * @param tab_label The Gtk::Widget to be used as the label for the page..
+   * @param menu_label The widget to use as a label for the page-switch
+   * menu.
+   * @param position The index (starting at 0) at which to insert the page,
+   * or -1 to append the page after all other pages.
+   */
+  int insert_page(Widget& child, Widget& tab_label, Widget& menu_label, int position);
+  //Ignore the possible-0 menu_label version of this method. It would have the same signature as another method.
+ 
+  int insert_page(Widget& child, const Glib::ustring& tab_label, const Glib::ustring& menu_label, int position, bool use_mnemonic = false);
+
+  
+  /** Removes a page from the notebook given its index
+   * in the notebook.
+   * @param page_num The index of a notebook page, starting
+   * from 0. If -1, the last page will
+   * be removed.
+   */
+  void remove_page(int page_num = 0);
+  void remove_page(Widget& child);
+
+  
+  /** Returns the page number of the current page.
+   * @return The index (starting from 0) of the current
+   * page in the notebook. If the notebook has no pages, then
+   * -1 will be returned.
+   */
+  int get_current_page() const;
+  
+  /** Returns the child widget contained in page number @a page_num .
+   * @param page_num The index of a page in the noteobok, or -1
+   * to get the last page.
+   * @return The child widget, or <tt>0</tt> if @a page_num  is
+   * out of bounds.
+   */
+  Widget* get_nth_page(int page_num);
+  
+  /** Returns the child widget contained in page number @a page_num .
+   * @param page_num The index of a page in the noteobok, or -1
+   * to get the last page.
+   * @return The child widget, or <tt>0</tt> if @a page_num  is
+   * out of bounds.
+   */
+  const Widget* get_nth_page(int page_num) const;
+  
+  /** Gets the number of pages in a notebook.
+   * @return The number of pages in the notebook.
+   * 
+   * Since: 2.2.
+   */
+  int get_n_pages();
+  /*Widget* get_current_page();*/ /*inconsistency with set_current_page*/
+  
+  /** Finds the index of the page which contains the given child
+   * widget.
+   * @param child A Gtk::Widget.
+   * @return The index of the page containing @a child , or
+   * -1 if @a child  is not in the notebook.
+   */
+  int page_num(const Widget& child);
+
+  
+  /** Switches to the page number @a page_num .
+   * @param page_num Index of the page to switch to, starting from 0.
+   * If negative, the last page will be used. If greater
+   * than the number of pages in the notebook, nothing
+   * will be done.
+   */
+  void set_current_page(int page_num);
+  
+  /** Switches to the next page. Nothing happens if the current page is
+   * the last page.
+   */
+  void next_page();
+  
+  /** Switches to the previous page. Nothing happens if the current page
+   * is the first page.
+   */
+  void prev_page();
+
+  
+  /** Sets whether a bevel will be drawn around the notebook pages.
+   * This only has a visual effect when the tabs are not shown.
+   * See set_show_tabs().
+   * @param show_border <tt>true</tt> if a bevel should be drawn around the notebook.
+   */
+  void set_show_border(bool show_border = true);
+
+  
+  /** Returns whether a bevel will be drawn around the notebook pages. See
+   * set_show_border().
+   * @return <tt>true</tt> if the bevel is drawn.
+   */
+  bool get_show_border() const;
+  
+  /** Sets whether to show the tabs for the notebook or not.
+   * @param show_tabs <tt>true</tt> if the tabs should be shown.
+   */
+  void set_show_tabs(bool show_tabs = true);
+  
+  /** Returns whether the tabs of the notebook are shown. See
+   * set_show_tabs().
+   * @return <tt>true</tt> if the tabs are shown.
+   */
+  bool get_show_tabs() const;
+
+
+  /** Sets the edge at which the tabs for switching pages in the
+   * notebook are drawn.
+   * @param pos The edge to draw the tabs at.
+   */
+  void set_tab_pos(PositionType pos);
+  
+  /** Gets the edge at which the tabs for switching pages in the
+   * notebook are drawn.
+   * @return The edge at which the tabs are drawn.
+   */
+  PositionType get_tab_pos() const;
+
+  
+  /** Sets whether the tab label area will have arrows for scrolling if
+   * there are too many tabs to fit in the area.
+   * @param scrollable <tt>true</tt> if scroll arrows should be added.
+   */
+  void set_scrollable(bool scrollable = true);
+  
+  /** Returns whether the tab label area has arrows for scrolling. See
+   * set_scrollable().
+   * @return <tt>true</tt> if arrows for scrolling are present.
+   */
+  bool get_scrollable() const;
+
+  
+  /** Enables the popup menu: if the user clicks with the right mouse button on
+   * the bookmarks, a menu with all the pages will be popped up.
+   */
+  void popup_enable();
+
+  
+  /** Disables the popup menu.
+   */
+  void popup_disable();
+
+
+  /** Returns the tab label widget for the page @a child . <tt>0</tt> is returned
+   * if @a child  is not in @a notebook  or if no tab label has specifically
+   * been set for @a child .
+   * @param child The page.
+   * @return The tab label.
+   */
+  Widget* get_tab_label(Widget& child);
+  
+  /** Returns the tab label widget for the page @a child . <tt>0</tt> is returned
+   * if @a child  is not in @a notebook  or if no tab label has specifically
+   * been set for @a child .
+   * @param child The page.
+   * @return The tab label.
+   */
+  const Widget* get_tab_label(Widget& child) const;
+  
+  /** Changes the tab label for @a child . If <tt>0</tt> is specified
+   * for @a tab_label , then the page will have the label 'page N'.
+   * @param child The page.
+   * @param tab_label The tab label widget to use, or <tt>0</tt> for default tab
+   * label.
+   */
+  void set_tab_label(Widget& child, Widget& tab_label);
+  
+  /** Creates a new label and sets it as the tab label for the page
+   * containing @a child .
+   * @param child The page.
+   * @param tab_text The label text.
+   */
+  void set_tab_label_text(Widget& child, const Glib::ustring& tab_text);
+  
+  /** Retrieves the text of the tab label for the page containing
+   *  @a child .
+   * @param child A widget contained in a page of @a notebook .
+   * @return Value: the text of the tab label.
+   */
+  Glib::ustring get_tab_label_text(Widget& child) const;
+  
+  /** Retrieves the menu label widget of the page containing @a child .
+   * @param child A widget contained in a page of @a notebook .
+   * @return The menu label, or <tt>0</tt> if the
+   * notebook page does not have a menu label other
+   * than the default (the tab label).
+   */
+  Widget* get_menu_label(Widget& child);
+  
+  /** Retrieves the menu label widget of the page containing @a child .
+   * @param child A widget contained in a page of @a notebook .
+   * @return The menu label, or <tt>0</tt> if the
+   * notebook page does not have a menu label other
+   * than the default (the tab label).
+   */
+  const Widget* get_menu_label(Widget& child) const;
+  
+  /** Changes the menu label for the page containing @a child .
+   * @param child The child widget.
+   * @param menu_label The menu label, or <tt>0</tt> for default.
+   */
+  void set_menu_label(Widget& child, Widget& menu_label);
+  
+  /** Creates a new label and sets it as the menu label of @a child .
+   * @param child The child widget.
+   * @param menu_text The label text.
+   */
+  void set_menu_label_text(Widget& child, const Glib::ustring& menu_text);
+  
+  /** Retrieves the text of the menu label for the page containing
+   *  @a child .
+   * @param child The child widget of a page of the notebook.
+   * @return Value: the text of the tab label.
+   */
+  Glib::ustring get_menu_label_text(Widget& child) const;
+  void query_tab_label_packing(Widget& child, bool& expand, bool& fill, PackType& pack_type);
+  
+  
+  /** Sets the packing parameters for the tab label of the page
+   * containing @a child . See Gtk::Box::pack_start() for the exact meaning
+   * of the parameters.
+   * @param child The child widget.
+   * @param expand Whether to expand the bookmark or not.
+   * @param fill Whether the bookmark should fill the allocated area or not.
+   * @param pack_type The position of the bookmark.
+   */
+  void set_tab_label_packing(Widget& child, bool expand, bool fill, PackType pack_type);
+  
+  /** Reorders the page containing @a child , so that it appears in position
+   *  @a position . If @a position  is greater than or equal to the number of
+   * children in the list or negative, @a child  will be moved to the end
+   * of the list.
+   * @param child The child to move.
+   * @param position The new position, or -1 to move to the end.
+   */
+  void reorder_child(Widget& child, int position);
+
+
+  PageList::iterator get_current();
+
+  PageList& pages();
+  const PageList& pages() const;
+
+  
+  Glib::SignalProxy2< void,GtkNotebookPage*,guint > signal_switch_page();
+
+
+  //Key-binding signals:
+  
+  
+  /** Which side of the notebook holds the tabs.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<PositionType> property_tab_pos() ;
+
+/** Which side of the notebook holds the tabs.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<PositionType> property_tab_pos() const;
+
+  /** Whether tabs should be shown or not.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_show_tabs() ;
+
+/** Whether tabs should be shown or not.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_show_tabs() const;
+
+  /** Whether the border should be shown or not.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_show_border() ;
+
+/** Whether the border should be shown or not.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_show_border() const;
+
+  /** If TRUE
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_scrollable() ;
+
+/** If TRUE
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_scrollable() const;
+
+  /** Width of the border around the tab labels.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_WriteOnly<guint> property_tab_border() ;
+
+/** Width of the border around the tab labels.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<guint> property_tab_border() const;
+
+  /** Width of the horizontal border of tab labels.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<guint> property_tab_hborder() ;
+
+/** Width of the horizontal border of tab labels.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<guint> property_tab_hborder() const;
+
+  /** Width of the vertical border of tab labels.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<guint> property_tab_vborder() ;
+
+/** Width of the vertical border of tab labels.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<guint> property_tab_vborder() const;
+
+  /** The index of the current page.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<int> property_page() ;
+
+/** The index of the current page.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<int> property_page() const;
+
+  /** If TRUE
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_enable_popup() ;
+
+/** If TRUE
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_enable_popup() const;
+
+  /** Whether tabs should have homogeneous sizes.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_homogeneous() ;
+
+/** Whether tabs should have homogeneous sizes.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_homogeneous() const;
+
+
+protected:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  mutable PageList pages_proxy_;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+};
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+namespace Notebook_Helpers
+{
+
+/**** PageIterator **************************************************/
+
+inline
+PageIterator::reference PageIterator::operator*() const 
+{ 
+  return static_cast<const Page&>(*this);
+}
+
+inline
+PageIterator::pointer PageIterator::operator->() const
+{ 
+  return static_cast<const Page*>(this);
+}
+
+} /* Notebook_Helpers */
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+} /* namespace Gtk */
+
+
+namespace Glib
+{
+  /** @relates Gtk::Notebook
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gtk::Notebook* wrap(GtkNotebook* object, bool take_copy = false);
+}
+#endif /* _GTKMM_NOTEBOOK_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/object.cc b/libs/gtkmm2/gtk/gtkmm/object.cc
new file mode 100644
index 0000000000..b61a028949
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/object.cc
@@ -0,0 +1,407 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/object.h>
+#include <gtkmm/private/object_p.h>
+
+/* $Id$ */
+
+/* Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <glibmm/quark.h>
+#include <gtk/gtkobject.h>
+
+
+namespace Gtk
+{
+
+Object::Object(const Glib::ConstructParams& construct_params)
+:
+  Glib::Object(construct_params)
+{
+   gobject_disposed_ = false;
+
+  _init_unmanage(); //We don't like the GTK+ default memory management - we want to be in control._)
+}
+
+Object::Object(GtkObject* castitem)
+:
+  Glib::Object((GObject*) castitem)
+{
+  gobject_disposed_ = false;
+
+   _init_unmanage(); //We don't like the GTK+ default memory management - we want to be in control.
+}
+
+void Object::_init_unmanage(bool /* is_toplevel = false */)
+{
+  //GTKMM_LIFECYCLE
+
+  if(gobject_)
+  {
+    //Glib::Object::Object has already stored a pointer to this C++ instance in the underlying C instance,
+    //and connected a callback which will, in turn, call our destroy_notify_(),
+    //so will will know if GTK+ disposes of the underlying instance.
+
+    // Most GTK+ objects are floating, by default. This means that the container widget controls their lifetime.
+    // We'll change this:
+    if(GTK_OBJECT_FLOATING (gobject_)) //Top-level Windows and Dialogs can not be manag()ed, so there is no need to do this.
+    {
+      GLIBMM_DEBUG_REFERENCE(this, gobject_);
+      g_object_ref(gobject_);  //Increase ref by 1 so that it doesn't get deleted when we sink() it (sink()ing does an unref)
+      gtk_object_sink((GtkObject*)gobject_); //Stops it from being floating - we will make this optional ( see Gtk::manage() ),
+
+      #ifdef GLIBMM_DEBUG_REFCOUNTING
+      g_warning("gtkmm after sink: C++ instance: %p, C instance: %p, refcount=%d\n", (void*)(Glib::ObjectBase*)this, (void*)gobject_, G_OBJECT(gobject_)->ref_count);
+      g_warning("    c instance gtype: %s\n", G_OBJECT_TYPE_NAME(gobject_));
+      #endif
+
+     referenced_ = true; //Not managed.
+    }
+    else
+    {
+       //This widget is already not floating. It's probably already been added to a GTK+ container, and has just had Glib::wrap() called on it.
+       //It's not floating because containers call gtk_object_sink() on child widgets to take control of them.
+       //We just ref() it so that we can unref it later.
+       //GLIBMM_DEBUG_REFERENCE(this, gobject_);
+       //g_object_ref(gobject_);
+    
+       //Alternatively, it might be a top-level window (e.g. a Dialog). We would then be doing one too-many refs(),
+       //We do an extra unref() in Window::_destroy_c_instance() to take care of that.
+
+       referenced_ = false; //Managed. We should not try to unfloat GtkObjects that we did not instantiate.
+    }
+  }
+}
+
+void Object::_destroy_c_instance()
+{
+  #ifdef GLIBMM_DEBUG_REFCOUNTING
+  g_warning("Gtk::Object::_destroy_c_instance() this=%10X, gobject_=%10X\n", this, gobject_);
+    if(gobject_)
+      g_warning("  gtypename: %s\n", G_OBJECT_TYPE_NAME(gobject_));
+  #endif
+
+  cpp_destruction_in_progress_ = true;
+
+  // remove our hook.
+  GtkObject* object = gobj();
+
+  if (object)
+  { 
+    g_assert(GTK_IS_OBJECT(object));
+
+    disconnect_cpp_wrapper();
+    //Unfortunately this means that our dispose callback will not be called, because the qdata has been removed.
+    //So we'll connect the callback again, just so that gobject_disposed_ gets set for use later in this same method.
+    //See below:
+   
+
+    //This probably isn't a problem now:
+    //If we are killing the C++ instance before the C instance, then this might lead to strange behaviour.
+    //If this is a problem, then you'll have to use a managed() object, which will die only upon GTK+'s request.
+
+    //We can't do anything with the gobject_ if it's already been disposed.
+    //This prevents us from unref-ing it again, or destroying it again after GTK+ has told us that it has been disposed.
+    if (!gobject_disposed_)
+    {
+      if(referenced_)
+      {
+        //It's not manage()ed so we just unref to destroy it
+        #ifdef GLIBMM_DEBUG_REFCOUNTING
+        g_warning("final unref: gtypename: %s, refcount: %d\n", G_OBJECT_TYPE_NAME(object), ((GObject*)object)->ref_count);
+        #endif
+
+        //Because we called disconnect_cpp_wrapper() our dispose callback will not be called, because the qdata has been removed.
+        //So we'll connect a callback again, just so that gobject_disposed_ gets set for use later in this same method.
+        gulong connection_id_destroy = g_signal_connect (object, "destroy", G_CALLBACK (&callback_destroy_), this);
+
+        GLIBMM_DEBUG_UNREFERENCE(this, object);
+        g_object_unref(object);
+
+        if(!gobject_disposed_) //or if(g_signal_handler_is_connected(object, connection_id_destroy))
+          g_signal_handler_disconnect(object, connection_id_destroy);
+
+        //destroy_notify() should have been called after the final g_object_unref() or gtk_object_destroy(), so gobject_disposed_ should now be true.
+
+        //If the C instance still isn't dead then insist, by calling gtk_object_destroy().
+        //This is necessary because even a manage()d widget is refed when added to a container.
+        // <danielk> That's simply not true.  But references might be taken elsewhere,
+        // and gtk_object_destroy() just tells everyone "drop your refs, please!".
+        if (!gobject_disposed_)
+        {
+          #ifdef GLIBMM_DEBUG_REFCOUNTING
+          g_warning("Gtk::Object::_destroy_c_instance(): Calling gtk_object_destroy(): gobject_=%10X, gtypename=%s\n", object, G_OBJECT_TYPE_NAME(object));
+          #endif
+
+          g_assert(GTK_IS_OBJECT(object));
+          gtk_object_destroy(object); //Container widgets can respond to this.
+        }
+      }
+      else
+      {
+        //It's manag()ed, but the coder decided to delete it before deleting its parent.
+        //That should be OK because the Container can respond to that.
+        #ifdef GLIBMM_DEBUG_REFCOUNTING
+        g_warning("Gtk::Object::_destroy_c_instance(): Calling gtk_object_destroy(): gobject_=%10X\n", gobject_);
+        #endif
+
+        if (!gobject_disposed_)
+        {
+          g_assert(GTK_IS_OBJECT(object));
+          gtk_object_destroy(object);
+        }
+      }
+    }
+
+    //Glib::Object::~Object() will not g_object_unref() it too. because gobject_ is now 0.
+  }  
+}
+
+Object::~Object()
+{
+  #ifdef GLIBMM_DEBUG_REFCOUNTING
+  g_warning("Gtk::Object::~Object() gobject_=%10X\n", gobject_);
+  #endif
+
+  //This has probably been called already from Gtk::Object::_destroy(), which is called from derived destructors.
+  _destroy_c_instance();
+}
+
+void Object::disconnect_cpp_wrapper()
+{
+  //GTKMM_LIFECYCLE:
+
+  #ifdef GLIBMM_DEBUG_REFCOUNTING
+  g_warning("Gtk::Object::disconnect_cpp_wrapper() this=%10X, gobject_=%10X\n", this, gobject_);
+    if(gobject_)
+      g_warning("  gtypename: %s\n", G_OBJECT_TYPE_NAME(gobject_));
+  #endif
+
+  if(gobj())
+  {
+    //Prevent gtk vfuncs and default signal handlers from calling our instance methods:
+    g_object_steal_qdata((GObject*)gobj(), Glib::quark_); //It will no longer be possible to get the C++ instance from the C instance.
+
+    //Allow us to prevent generation of a new C++ wrapper during destruction:
+    g_object_set_qdata((GObject*)gobj(), Glib::quark_cpp_wrapper_deleted_, (gpointer)true);
+
+    //Prevent C++ instance from using GTK+ object:
+    gobject_ = 0;
+
+    //TODO: Disconnect any signals, using gtk methods.
+    //We'll have to keep a record of all the connections.
+  }
+}
+
+void Object::destroy_notify_()
+{
+  //Overriden.
+  //GTKMM_LIFECYCLE
+
+  #ifdef GLIBMM_DEBUG_REFCOUNTING
+  g_warning("Gtk::Object::destroy_notify_: this=%10X, gobject_=%10X\n", this, gobject_);
+  if(gobject_)
+    g_warning("  gtypename=%s\n", G_OBJECT_TYPE_NAME(gobject_));
+  #endif
+
+  //Remember that it's been disposed (which only happens once):
+  //This also stops us from destroying it again in the destructor when it calls destroy_().
+  gobject_disposed_ = true;
+
+  if(!cpp_destruction_in_progress_) //This function might have been called as a side-effect of destroy() when it called gtk_object_destroy().
+  {
+    if (!referenced_) //If it's manage()ed.
+    {
+      #ifdef GLIBMM_DEBUG_REFCOUNTING
+      g_warning("Gtk::Object::destroy_notify_: before delete this.\n");
+      #endif
+      delete this; //Free the C++ instance.
+    }
+    else  //It's not managed, but the C gobject_ just died before the C++ instance..
+    {
+      #ifdef GLIBMM_DEBUG_REFCOUNTING
+      g_warning("Gtk::Object::destroy_notify_: setting gobject_ to 0\n");
+      #endif
+      gobject_ = 0;
+    }
+  }
+
+}
+
+void Object::destroy_()
+{
+  //Called from destructors.
+  //GTKMM_LIFECYCLE
+
+  #ifdef GLIBMM_DEBUG_REFCOUNTING
+  g_warning("Gtk::Object::destroy_(): gobject_: %10X\n", gobject_);
+  if(gobject_)
+   g_warning("  gtypename: %s\n", G_OBJECT_TYPE_NAME(gobject_));
+  #endif
+
+  if ( !cpp_destruction_in_progress_ ) //see comment below.
+  {
+    //Prevent destroy_notify_() from running as a possible side-effect of gtk_object_destroy.
+    //We can't predict whether destroy_notify_() will really be run, so we'll disconnect the C++ instance here.
+    cpp_destruction_in_progress_ = true;
+
+    //destroy the C instance:
+    _destroy_c_instance();
+  }
+
+  //The C++ destructor will be reached later. This function was called by a destructor.
+}
+
+void Object::set_manage() 
+{
+  //GTKMM_LIFECYCLE
+  //This object will not be unref()ed by gtkmm, though it could be destroyed if the coder deletes the C++ instance early.
+  //This method is overriden in Gtk::Window because they can not be manage()ed.
+
+  if (!referenced_) return; //It's already managed.
+
+  // remove our reference
+  if (gobject_->ref_count >= 1) //This should only happen just after creation. We don't use "==1" because GtkButton starts with a refcount of 2 when using a mnemonic.
+  {
+    //g_warning("Object::set_manage(), making object floating: %s\n", G_OBJECT_TYPE_NAME(gobject_));
+
+    // Cowardly refuse to remove last reference make floating instead. //TODO: What does that comment mean?
+    #ifdef GLIBMM_DEBUG_REFCOUNTING
+      g_warning("Object::set_manage(): setting GTK_FLOATING: gobject_ = %p", (void*) gobj());
+      g_warning("  gtypename=%s\n", G_OBJECT_TYPE_NAME(gobj()));
+    #endif
+    GTK_OBJECT_SET_FLAGS(gobj(), GTK_FLOATING);
+  }
+  else
+  {
+    g_warning("Object::set_manage(). Refcount seems to be 0. %s\n", G_OBJECT_TYPE_NAME(gobject_));
+
+    //DEF_GLIBMM_DEBUG_UNREF(this, gobj())
+    //g_object_unref(gobj());
+  }
+
+  //g_warning("Object::set_manage(): end: %s", G_OBJECT_TYPE_NAME(gobject_));
+  //g_warning("  refcount=%d", G_OBJECT(gobj())->ref_count);
+
+  referenced_ = false;
+}
+
+void Object::callback_destroy_(GObject*, void* data) //static
+{ 
+  //This is only used for a short time, then disconnected.
+
+  Object* cppObject = static_cast<Object*>(data);
+  if(cppObject) //This will be 0 if the C++ destructor has already run.
+  {
+    cppObject->gobject_disposed_ = true;
+  }
+}
+
+bool Object::is_managed_() const
+{
+  return !referenced_;
+}
+
+} // namespace Gtk
+
+
+namespace
+{
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Gtk::Object* wrap(GtkObject* object, bool take_copy)
+{
+  return dynamic_cast<Gtk::Object *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& Object_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &Object_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_object_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void Object_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+}
+
+
+Glib::ObjectBase* Object_Class::wrap_new(GObject* o)
+{
+  return manage(new Object((GtkObject*)(o)));
+
+}
+
+
+/* The implementation: */
+
+Object::CppClassType Object::object_class_; // initialize static member
+
+GType Object::get_type()
+{
+  return object_class_.init().get_type();
+}
+
+GType Object::get_base_type()
+{
+  return gtk_object_get_type();
+}
+
+
+Glib::PropertyProxy<void*> Object::property_user_data() 
+{
+  return Glib::PropertyProxy<void*>(this, "user-data");
+}
+
+Glib::PropertyProxy_ReadOnly<void*> Object::property_user_data() const
+{
+  return Glib::PropertyProxy_ReadOnly<void*>(this, "user-data");
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/object.h b/libs/gtkmm2/gtk/gtkmm/object.h
new file mode 100644
index 0000000000..3ca724d358
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/object.h
@@ -0,0 +1,168 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_OBJECT_H
+#define _GTKMM_OBJECT_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* Copyright (C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <glibmm/object.h>
+#include <gtkmm/base.h>
+#include <gtkmmconfig.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkObject GtkObject;
+typedef struct _GtkObjectClass GtkObjectClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class Object_Class; } // namespace Gtk
+namespace Gtk
+{
+
+class Object;
+
+template<class T>
+T* manage(T* obj)
+{
+  obj->set_manage();
+  return obj;
+}
+
+
+class Object : public Glib::Object
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Object CppObjectType;
+  typedef Object_Class CppClassType;
+  typedef GtkObject BaseObjectType;
+  typedef GtkObjectClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~Object();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class Object_Class;
+  static CppClassType object_class_;
+
+  // noncopyable
+  Object(const Object&);
+  Object& operator=(const Object&);
+
+protected:
+  explicit Object(const Glib::ConstructParams& construct_params);
+  explicit Object(GtkObject* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GtkObject*       gobj()       { return reinterpret_cast<GtkObject*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GtkObject* gobj() const { return reinterpret_cast<GtkObject*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+private:
+
+  
+public:
+  //void shutdown(); //We probably don't need this.
+  //void finalize(); //We probably don't need this.
+
+  //void set_user_data(gpointer data);
+  //gpointer get_user_data();
+
+  virtual void set_manage();
+
+  /** Anonymous User Data Pointer.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<void*> property_user_data() ;
+
+/** Anonymous User Data Pointer.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<void*> property_user_data() const;
+
+
+  bool is_managed_() const;
+
+protected:
+
+  void destroy_();
+
+  // If you need it, give me an example. murrayc. -- Me too. daniel.
+  //_WRAP_SIGNAL(void destroy(), "destroy")
+  
+
+  void _init_unmanage(bool is_toplevel = false);
+  virtual void destroy_notify_(); //override.
+  void disconnect_cpp_wrapper();
+  void _destroy_c_instance();
+  static void callback_destroy_(GObject* gobject, void* data); //only connected for a short time.
+
+  // set if flags used by derived classes.
+  bool referenced_; // = not managed.
+  bool gobject_disposed_;
+
+
+};
+
+} // namespace Gtk
+
+
+namespace Glib
+{
+  /** @relates Gtk::Object
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gtk::Object* wrap(GtkObject* object, bool take_copy = false);
+}
+#endif /* _GTKMM_OBJECT_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/optionmenu.cc b/libs/gtkmm2/gtk/gtkmm/optionmenu.cc
new file mode 100644
index 0000000000..6985768688
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/optionmenu.cc
@@ -0,0 +1,252 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/optionmenu.h>
+#include <gtkmm/private/optionmenu_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* 
+ *
+ * Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/menu.h>
+#include <gtkmm/window.h>
+#include <gtk/gtkoptionmenu.h>
+
+namespace Gtk
+{
+
+
+OptionMenu::OptionMenu()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Button(Glib::ConstructParams(optionmenu_class_.init(), (char*) 0))
+{
+  // Connect to the signal instead of overriding the on_hierarchy_changed()
+  // method because invocation of C++ default signal handlers is skipped
+  // for gtkmmproc-generated classes (a gtkmm-wide optimization).
+
+  signal_realize().connect(sigc::mem_fun(*this, &OptionMenu::init_accels_handler_));
+}
+
+OptionMenu::~OptionMenu()
+{
+  //GTKMM_LIFECYCLE
+  //Remove the menu so that the Menu forgets about this OptionMenu.
+  //Normally the GtkOptionMenu just destroys the Menu (see gtk_option_menu_destroy),
+  //but we prevent premature destruction in general for all widgets,
+  //so the Menu would survive and remember a dead GtkOptionMenu.
+  remove_menu();
+
+  destroy_();
+}
+
+void OptionMenu::init_accels_handler_()
+{
+  if(gobj())
+  {
+    Window *const toplevel = dynamic_cast<Window*>(get_toplevel());
+    if(toplevel && get_menu())
+    {
+      get_menu()->accelerate(*toplevel);
+    }
+  }
+}
+
+} /* namespace Gtk */
+
+
+namespace
+{
+
+const Glib::SignalProxyInfo OptionMenu_signal_changed_info =
+{
+  "changed",
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
+};
+
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Gtk::OptionMenu* wrap(GtkOptionMenu* object, bool take_copy)
+{
+  return dynamic_cast<Gtk::OptionMenu *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& OptionMenu_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &OptionMenu_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_option_menu_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void OptionMenu_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+  klass->changed = &changed_callback;
+}
+
+
+void OptionMenu_Class::changed_callback(GtkOptionMenu* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_changed();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->changed)
+      (*base->changed)(self);
+  }
+}
+
+
+Glib::ObjectBase* OptionMenu_Class::wrap_new(GObject* o)
+{
+  return manage(new OptionMenu((GtkOptionMenu*)(o)));
+
+}
+
+
+/* The implementation: */
+
+OptionMenu::OptionMenu(const Glib::ConstructParams& construct_params)
+:
+  Gtk::Button(construct_params)
+{
+  }
+
+OptionMenu::OptionMenu(GtkOptionMenu* castitem)
+:
+  Gtk::Button((GtkButton*)(castitem))
+{
+  }
+
+OptionMenu::CppClassType OptionMenu::optionmenu_class_; // initialize static member
+
+GType OptionMenu::get_type()
+{
+  return optionmenu_class_.init().get_type();
+}
+
+GType OptionMenu::get_base_type()
+{
+  return gtk_option_menu_get_type();
+}
+
+
+void OptionMenu::set_menu(Menu& menu)
+{
+  gtk_option_menu_set_menu(gobj(), (menu).Gtk::Widget::gobj());
+}
+
+Menu* OptionMenu::get_menu()
+{
+  return Glib::wrap((GtkMenu*)(gtk_option_menu_get_menu(gobj())));
+}
+
+const Menu* OptionMenu::get_menu() const
+{
+  return Glib::wrap((GtkMenu*)(gtk_option_menu_get_menu(const_cast<GtkOptionMenu*>(gobj()))));
+}
+
+void OptionMenu::remove_menu()
+{
+  gtk_option_menu_remove_menu(gobj());
+}
+
+int OptionMenu::get_history() const
+{
+  return gtk_option_menu_get_history(const_cast<GtkOptionMenu*>(gobj()));
+}
+
+void OptionMenu::set_history(guint index)
+{
+  gtk_option_menu_set_history(gobj(), index);
+}
+
+
+Glib::SignalProxy0< void > OptionMenu::signal_changed()
+{
+  return Glib::SignalProxy0< void >(this, &OptionMenu_signal_changed_info);
+}
+
+
+void Gtk::OptionMenu::on_changed()
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->changed)
+    (*base->changed)(gobj());
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/optionmenu.h b/libs/gtkmm2/gtk/gtkmm/optionmenu.h
new file mode 100644
index 0000000000..6f9633a256
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/optionmenu.h
@@ -0,0 +1,153 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_OPTIONMENU_H
+#define _GTKMM_OPTIONMENU_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* optionmenu.h
+ * 
+ * Copyright (C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/button.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkOptionMenu GtkOptionMenu;
+typedef struct _GtkOptionMenuClass GtkOptionMenuClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class OptionMenu_Class; } // namespace Gtk
+namespace Gtk
+{
+
+class Menu;
+
+/** A widget used to choose from a list of valid choices.
+ *
+ * A Gtk::OptionMenu is a widget that allows the user to choose from a list
+ * of valid choices. The Gtk::OptionMenu displays the selected choice. When
+ * activated the GtkOptionMenu displays a popup Gtk::Menu which allows the
+ * user to make a new choice. 
+ *
+ * @deprecated Use the ComboBox widget instead.
+ */
+
+class OptionMenu : public Button
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef OptionMenu CppObjectType;
+  typedef OptionMenu_Class CppClassType;
+  typedef GtkOptionMenu BaseObjectType;
+  typedef GtkOptionMenuClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~OptionMenu();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class OptionMenu_Class;
+  static CppClassType optionmenu_class_;
+
+  // noncopyable
+  OptionMenu(const OptionMenu&);
+  OptionMenu& operator=(const OptionMenu&);
+
+protected:
+  explicit OptionMenu(const Glib::ConstructParams& construct_params);
+  explicit OptionMenu(GtkOptionMenu* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GtkOptionMenu*       gobj()       { return reinterpret_cast<GtkOptionMenu*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GtkOptionMenu* gobj() const { return reinterpret_cast<GtkOptionMenu*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+  virtual void on_changed();
+
+
+private:
+
+public:
+
+  OptionMenu();
+  
+  
+  void set_menu(Menu& menu);
+  
+  Menu* get_menu();
+  
+  const Menu* get_menu() const;
+  
+  void remove_menu();
+  
+  /** Retrieves the index of the currently selected menu item. The menu
+   * items are numbered from top to bottom, starting with 0.
+   * @return Index of the selected menu item, or -1 if there are no menu items
+   * Deprecated: Use Gtk::ComboBox instead.
+   */
+  int get_history() const;
+  
+  void set_history(guint index);
+
+  
+  Glib::SignalProxy0< void > signal_changed();
+	
+
+private:
+  void init_accels_handler_();
+
+
+};
+
+} /* namespace Gtk */
+
+
+namespace Glib
+{
+  /** @relates Gtk::OptionMenu
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gtk::OptionMenu* wrap(GtkOptionMenu* object, bool take_copy = false);
+}
+#endif /* _GTKMM_OPTIONMENU_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/paned.cc b/libs/gtkmm2/gtk/gtkmm/paned.cc
new file mode 100644
index 0000000000..4b160994bc
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/paned.cc
@@ -0,0 +1,419 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/paned.h>
+#include <gtkmm/private/paned_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* 
+ *
+ * Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtk/gtkpaned.h>
+#include <gtk/gtkhpaned.h>
+#include <gtk/gtkvpaned.h>
+
+namespace Gtk
+{
+
+void Paned::pack1(Widget& child, AttachOptions options)
+{
+  const gboolean resize = ((options & EXPAND) != 0);
+  const gboolean shrink = ((options & SHRINK) != 0);
+
+  gtk_paned_pack1(gobj(), child.gobj(), resize, shrink);
+}
+
+void Paned::pack2(Widget& child, AttachOptions options)
+{
+  const gboolean resize = ((options & EXPAND) != 0);
+  const gboolean shrink = ((options & SHRINK) != 0);
+
+  gtk_paned_pack2(gobj(), child.gobj(), resize, shrink);
+}
+
+} // namespace Gtk
+
+
+namespace
+{
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Gtk::Paned* wrap(GtkPaned* object, bool take_copy)
+{
+  return dynamic_cast<Gtk::Paned *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& Paned_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &Paned_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_paned_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void Paned_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+}
+
+
+Glib::ObjectBase* Paned_Class::wrap_new(GObject* o)
+{
+  return manage(new Paned((GtkPaned*)(o)));
+
+}
+
+
+/* The implementation: */
+
+Paned::Paned(const Glib::ConstructParams& construct_params)
+:
+  Gtk::Container(construct_params)
+{
+  }
+
+Paned::Paned(GtkPaned* castitem)
+:
+  Gtk::Container((GtkContainer*)(castitem))
+{
+  }
+
+Paned::~Paned()
+{
+  destroy_();
+}
+
+Paned::CppClassType Paned::paned_class_; // initialize static member
+
+GType Paned::get_type()
+{
+  return paned_class_.init().get_type();
+}
+
+GType Paned::get_base_type()
+{
+  return gtk_paned_get_type();
+}
+
+
+Paned::Paned()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Container(Glib::ConstructParams(paned_class_.init()))
+{
+  }
+
+void Paned::add1(Widget& child)
+{
+  gtk_paned_add1(gobj(), (child).gobj());
+}
+
+void Paned::add2(Widget& child)
+{
+  gtk_paned_add2(gobj(), (child).gobj());
+}
+
+void Paned::pack1(Widget& child, bool resize, bool shrink)
+{
+  gtk_paned_pack1(gobj(), (child).gobj(), static_cast<int>(resize), static_cast<int>(shrink));
+}
+
+void Paned::pack2(Widget& child, bool resize, bool shrink)
+{
+  gtk_paned_pack2(gobj(), (child).gobj(), static_cast<int>(resize), static_cast<int>(shrink));
+}
+
+int Paned::get_position() const
+{
+  return gtk_paned_get_position(const_cast<GtkPaned*>(gobj()));
+}
+
+void Paned::set_position(int position)
+{
+  gtk_paned_set_position(gobj(), position);
+}
+
+Widget* Paned::get_child1()
+{
+  return Glib::wrap(gtk_paned_get_child1(gobj()));
+}
+
+const Widget* Paned::get_child1() const
+{
+  return Glib::wrap(gtk_paned_get_child1(const_cast<GtkPaned*>(gobj())));
+}
+
+Widget* Paned::get_child2()
+{
+  return Glib::wrap(gtk_paned_get_child2(gobj()));
+}
+
+const Widget* Paned::get_child2() const
+{
+  return Glib::wrap(gtk_paned_get_child2(const_cast<GtkPaned*>(gobj())));
+}
+
+
+Glib::PropertyProxy<int> Paned::property_position() 
+{
+  return Glib::PropertyProxy<int>(this, "position");
+}
+
+Glib::PropertyProxy_ReadOnly<int> Paned::property_position() const
+{
+  return Glib::PropertyProxy_ReadOnly<int>(this, "position");
+}
+
+Glib::PropertyProxy<bool> Paned::property_position_set() 
+{
+  return Glib::PropertyProxy<bool>(this, "position-set");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> Paned::property_position_set() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "position-set");
+}
+
+Glib::PropertyProxy_ReadOnly<int> Paned::property_min_position() const
+{
+  return Glib::PropertyProxy_ReadOnly<int>(this, "min-position");
+}
+
+Glib::PropertyProxy_ReadOnly<int> Paned::property_max_position() const
+{
+  return Glib::PropertyProxy_ReadOnly<int>(this, "max-position");
+}
+
+
+} // namespace Gtk
+
+
+namespace Glib
+{
+
+Gtk::HPaned* wrap(GtkHPaned* object, bool take_copy)
+{
+  return dynamic_cast<Gtk::HPaned *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& HPaned_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &HPaned_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_hpaned_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void HPaned_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+}
+
+
+Glib::ObjectBase* HPaned_Class::wrap_new(GObject* o)
+{
+  return manage(new HPaned((GtkHPaned*)(o)));
+
+}
+
+
+/* The implementation: */
+
+HPaned::HPaned(const Glib::ConstructParams& construct_params)
+:
+  Gtk::Paned(construct_params)
+{
+  }
+
+HPaned::HPaned(GtkHPaned* castitem)
+:
+  Gtk::Paned((GtkPaned*)(castitem))
+{
+  }
+
+HPaned::~HPaned()
+{
+  destroy_();
+}
+
+HPaned::CppClassType HPaned::hpaned_class_; // initialize static member
+
+GType HPaned::get_type()
+{
+  return hpaned_class_.init().get_type();
+}
+
+GType HPaned::get_base_type()
+{
+  return gtk_hpaned_get_type();
+}
+
+HPaned::HPaned()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Paned(Glib::ConstructParams(hpaned_class_.init()))
+{
+  }
+
+
+} // namespace Gtk
+
+
+namespace Glib
+{
+
+Gtk::VPaned* wrap(GtkVPaned* object, bool take_copy)
+{
+  return dynamic_cast<Gtk::VPaned *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& VPaned_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &VPaned_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_vpaned_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void VPaned_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+}
+
+
+Glib::ObjectBase* VPaned_Class::wrap_new(GObject* o)
+{
+  return manage(new VPaned((GtkVPaned*)(o)));
+
+}
+
+
+/* The implementation: */
+
+VPaned::VPaned(const Glib::ConstructParams& construct_params)
+:
+  Gtk::Paned(construct_params)
+{
+  }
+
+VPaned::VPaned(GtkVPaned* castitem)
+:
+  Gtk::Paned((GtkPaned*)(castitem))
+{
+  }
+
+VPaned::~VPaned()
+{
+  destroy_();
+}
+
+VPaned::CppClassType VPaned::vpaned_class_; // initialize static member
+
+GType VPaned::get_type()
+{
+  return vpaned_class_.init().get_type();
+}
+
+GType VPaned::get_base_type()
+{
+  return gtk_vpaned_get_type();
+}
+
+VPaned::VPaned()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Paned(Glib::ConstructParams(vpaned_class_.init()))
+{
+  }
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/paned.h b/libs/gtkmm2/gtk/gtkmm/paned.h
new file mode 100644
index 0000000000..5616d261c5
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/paned.h
@@ -0,0 +1,417 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_PANED_H
+#define _GTKMM_PANED_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+
+/* paned.h
+ * 
+ * Copyright (C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/container.h>
+#include <gtkmm/enums.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkPaned GtkPaned;
+typedef struct _GtkPanedClass GtkPanedClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class Paned_Class; } // namespace Gtk
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkHPaned GtkHPaned;
+typedef struct _GtkHPanedClass GtkHPanedClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class HPaned_Class; } // namespace Gtk
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkVPaned GtkVPaned;
+typedef struct _GtkVPanedClass GtkVPanedClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class VPaned_Class; } // namespace Gtk
+namespace Gtk
+{
+
+/** This is the base class for widgets with two panes, arranged either
+ * horizontally (Gtk::HPaned) or vertically (Gtk::VPaned).
+ *
+ * Child widgets are added to the panes of the widget with pack1() and pack2().
+ * The division beween the two children is set by default from the size
+ * requests of the children, but it can be adjusted by the user.
+ *
+ * A paned widget draws a separator between the two child widgets and a small
+ * handle that the user can drag to adjust the division. It does not draw any
+ * relief around the children or around the separator. Often, it is useful to
+ * put each child inside a Gtk::Frame with the shadow type set to Gtk::SHADOW_IN
+ * so that the gutter appears as a ridge.
+ *
+ * Each child has two options that can be set - resize and shrink. If resize is
+ * true, then when the GtkPaned is resized, that child will expand or shrink
+ * along with the paned widget. If shrink is true, then when that child can be
+ * made smaller than it's requisition. Setting shrink to false allows the
+ * application to set a minimum size. If resize is false for both children,
+ * then this is treated as if resize is true for both children.
+ *
+ * The application can set the position of the slider as if it were set by the
+ * user, by calling set_position().
+ *
+ * @ingroup Widgets
+ * @ingroup Containers
+ */
+
+class Paned : public Container
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Paned CppObjectType;
+  typedef Paned_Class CppClassType;
+  typedef GtkPaned BaseObjectType;
+  typedef GtkPanedClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~Paned();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class Paned_Class;
+  static CppClassType paned_class_;
+
+  // noncopyable
+  Paned(const Paned&);
+  Paned& operator=(const Paned&);
+
+protected:
+  explicit Paned(const Glib::ConstructParams& construct_params);
+  explicit Paned(GtkPaned* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GtkPaned*       gobj()       { return reinterpret_cast<GtkPaned*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GtkPaned* gobj() const { return reinterpret_cast<GtkPaned*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+private:
+
+  
+public:
+  Paned();
+
+  
+  void add1(Widget& child);
+  
+  void add2(Widget& child);
+
+  
+  void pack1(Widget& child, bool resize, bool shrink);
+  void pack1(Widget& child, AttachOptions options = Gtk::EXPAND);
+
+  
+  void pack2(Widget& child, bool resize, bool shrink);
+  void pack2(Widget& child, AttachOptions options  = Gtk::EXPAND);
+
+  
+  /** Obtains the position of the divider between the two panes.
+   * @return Position of the divider.
+   */
+  int get_position() const;
+  
+  /** Sets the position of the divider between the two panes.
+   * @param position Pixel position of divider, a negative value means that the position
+   * is unset.
+   */
+  void set_position(int position);
+
+  
+  /** Obtains the first child of the paned widget.
+   * @return First child, or <tt>0</tt> if it is not set.
+   * 
+   * Since: 2.4.
+   */
+  Widget* get_child1();
+  
+  /** Obtains the first child of the paned widget.
+   * @return First child, or <tt>0</tt> if it is not set.
+   * 
+   * Since: 2.4.
+   */
+  const Widget* get_child1() const;
+
+  
+  /** Obtains the second child of the paned widget.
+   * @return Second child, or <tt>0</tt> if it is not set.
+   * 
+   * Since: 2.4.
+   */
+  Widget* get_child2();
+  
+  /** Obtains the second child of the paned widget.
+   * @return Second child, or <tt>0</tt> if it is not set.
+   * 
+   * Since: 2.4.
+   */
+  const Widget* get_child2() const;
+ 
+  //Keybinding signals:
+  
+  
+  /** Position of paned separator in pixels (0 means all the way to the left/top).
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<int> property_position() ;
+
+/** Position of paned separator in pixels (0 means all the way to the left/top).
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<int> property_position() const;
+
+  /** TRUE if the Position property should be used.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_position_set() ;
+
+/** TRUE if the Position property should be used.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_position_set() const;
+
+  /** Smallest possible value for the position property.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<int> property_min_position() const;
+
+
+  /** Largest possible value for the position property.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<int> property_max_position() const;
+
+
+};
+
+/**
+ * The Gtk::HPaned widget is a container widget with two children arranged
+ * horizontally. The division between the two panes is adjustable by the
+ * user by dragging a handle. See Gtk::Paned for details. 
+ *
+ * @ingroup Widgets
+ */
+
+class HPaned : public Paned
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef HPaned CppObjectType;
+  typedef HPaned_Class CppClassType;
+  typedef GtkHPaned BaseObjectType;
+  typedef GtkHPanedClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~HPaned();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class HPaned_Class;
+  static CppClassType hpaned_class_;
+
+  // noncopyable
+  HPaned(const HPaned&);
+  HPaned& operator=(const HPaned&);
+
+protected:
+  explicit HPaned(const Glib::ConstructParams& construct_params);
+  explicit HPaned(GtkHPaned* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GtkHPaned*       gobj()       { return reinterpret_cast<GtkHPaned*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GtkHPaned* gobj() const { return reinterpret_cast<GtkHPaned*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+private:
+
+public:
+  HPaned();
+
+
+};
+
+/**
+ * The Gtk::VPaned widget is a container widget with two children arranged
+ * horizontally. The division between the two panes is adjustable by the
+ * user by dragging a handle. See Gtk::Paned for details. 
+ *
+ * @ingroup Widgets
+ */
+
+class VPaned : public Paned
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef VPaned CppObjectType;
+  typedef VPaned_Class CppClassType;
+  typedef GtkVPaned BaseObjectType;
+  typedef GtkVPanedClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~VPaned();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class VPaned_Class;
+  static CppClassType vpaned_class_;
+
+  // noncopyable
+  VPaned(const VPaned&);
+  VPaned& operator=(const VPaned&);
+
+protected:
+  explicit VPaned(const Glib::ConstructParams& construct_params);
+  explicit VPaned(GtkVPaned* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GtkVPaned*       gobj()       { return reinterpret_cast<GtkVPaned*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GtkVPaned* gobj() const { return reinterpret_cast<GtkVPaned*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+private:
+
+public:
+  VPaned();
+
+
+};
+
+} // namespace Gtk
+
+
+namespace Glib
+{
+  /** @relates Gtk::Paned
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gtk::Paned* wrap(GtkPaned* object, bool take_copy = false);
+}
+namespace Glib
+{
+  /** @relates Gtk::HPaned
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gtk::HPaned* wrap(GtkHPaned* object, bool take_copy = false);
+}
+namespace Glib
+{
+  /** @relates Gtk::VPaned
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gtk::VPaned* wrap(GtkVPaned* object, bool take_copy = false);
+}
+#endif /* _GTKMM_PANED_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/plug.cc b/libs/gtkmm2/gtk/gtkmm/plug.cc
new file mode 100644
index 0000000000..befa8a4307
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/plug.cc
@@ -0,0 +1,217 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/plug.h>
+#include <gtkmm/private/plug_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* 
+ *
+ * Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtk/gtkplug.h>
+
+namespace Gtk
+{
+
+Plug::Plug()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Window(Glib::ConstructParams(plug_class_.init(), (char*) 0))
+{
+  gtk_plug_construct(gobj(), 0);
+}
+
+Plug::Plug(GdkNativeWindow socket_id)
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Window(Glib::ConstructParams(plug_class_.init(), (char*) 0))
+{
+  gtk_plug_construct(gobj(), socket_id);
+}
+
+Plug::Plug(const Glib::RefPtr<Gdk::Display>& display, GdkNativeWindow socket_id)
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Window(Glib::ConstructParams(plug_class_.init(), (char*) 0))
+{
+  gtk_plug_construct_for_display(gobj(), Glib::unwrap(display), socket_id);
+}
+
+} // namespace Gtk
+
+
+namespace
+{
+
+const Glib::SignalProxyInfo Plug_signal_embedded_info =
+{
+  "embedded",
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
+};
+
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Gtk::Plug* wrap(GtkPlug* object, bool take_copy)
+{
+  return dynamic_cast<Gtk::Plug *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& Plug_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &Plug_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_plug_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void Plug_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+  klass->embedded = &embedded_callback;
+}
+
+
+void Plug_Class::embedded_callback(GtkPlug* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_embedded();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->embedded)
+      (*base->embedded)(self);
+  }
+}
+
+
+Glib::ObjectBase* Plug_Class::wrap_new(GObject* o)
+{
+  return manage(new Plug((GtkPlug*)(o)));
+
+}
+
+
+/* The implementation: */
+
+Plug::Plug(const Glib::ConstructParams& construct_params)
+:
+  Gtk::Window(construct_params)
+{
+  }
+
+Plug::Plug(GtkPlug* castitem)
+:
+  Gtk::Window((GtkWindow*)(castitem))
+{
+  }
+
+Plug::~Plug()
+{
+  destroy_();
+}
+
+Plug::CppClassType Plug::plug_class_; // initialize static member
+
+GType Plug::get_type()
+{
+  return plug_class_.init().get_type();
+}
+
+GType Plug::get_base_type()
+{
+  return gtk_plug_get_type();
+}
+
+
+GdkNativeWindow Plug::get_id() const
+{
+  return gtk_plug_get_id(const_cast<GtkPlug*>(gobj()));
+}
+
+
+Glib::SignalProxy0< void > Plug::signal_embedded()
+{
+  return Glib::SignalProxy0< void >(this, &Plug_signal_embedded_info);
+}
+
+
+void Gtk::Plug::on_embedded()
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->embedded)
+    (*base->embedded)(gobj());
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/plug.h b/libs/gtkmm2/gtk/gtkmm/plug.h
new file mode 100644
index 0000000000..030bdc63c5
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/plug.h
@@ -0,0 +1,132 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_PLUG_H
+#define _GTKMM_PLUG_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* Copyright (C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/window.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkPlug GtkPlug;
+typedef struct _GtkPlugClass GtkPlugClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class Plug_Class; } // namespace Gtk
+namespace Gtk
+{
+
+
+class Plug : public Window
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Plug CppObjectType;
+  typedef Plug_Class CppClassType;
+  typedef GtkPlug BaseObjectType;
+  typedef GtkPlugClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~Plug();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class Plug_Class;
+  static CppClassType plug_class_;
+
+  // noncopyable
+  Plug(const Plug&);
+  Plug& operator=(const Plug&);
+
+protected:
+  explicit Plug(const Glib::ConstructParams& construct_params);
+  explicit Plug(GtkPlug* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GtkPlug*       gobj()       { return reinterpret_cast<GtkPlug*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GtkPlug* gobj() const { return reinterpret_cast<GtkPlug*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+  virtual void on_embedded();
+
+
+private:
+
+  
+  //This is not available in on Win32.
+//This source file will not be compiled,
+//and the class will not be registered in wrap_init.h or wrap_init.cc
+
+public:
+  Plug();
+  explicit Plug(GdkNativeWindow socket_id);
+  explicit Plug(const Glib::RefPtr<Gdk::Display>& display, GdkNativeWindow socket_id);
+
+  
+  /** Gets the window ID of a Gtk::Plug widget, which can then
+   * be used to embed this window inside another window, for
+   * instance with Gtk::Socket::add_id().
+   * @return The window ID for the plug.
+   */
+  GdkNativeWindow get_id() const;
+
+  
+  Glib::SignalProxy0< void > signal_embedded();
+
+
+};
+
+} /* namespace Gtk */
+
+
+namespace Glib
+{
+  /** @relates Gtk::Plug
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gtk::Plug* wrap(GtkPlug* object, bool take_copy = false);
+}
+#endif /* _GTKMM_PLUG_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/aboutdialog_p.h b/libs/gtkmm2/gtk/gtkmm/private/aboutdialog_p.h
new file mode 100644
index 0000000000..60a53a69ba
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/aboutdialog_p.h
@@ -0,0 +1,44 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_ABOUTDIALOG_P_H
+#define _GTKMM_ABOUTDIALOG_P_H
+#include <gtkmm/private/dialog_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class AboutDialog_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef AboutDialog CppObjectType;
+  typedef GtkAboutDialog BaseObjectType;
+  typedef GtkAboutDialogClass BaseClassType;
+  typedef Gtk::Dialog_Class CppClassParent;
+  typedef GtkDialogClass BaseClassParent;
+
+  friend class AboutDialog;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_ABOUTDIALOG_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/accelgroup_p.h b/libs/gtkmm2/gtk/gtkmm/private/accelgroup_p.h
new file mode 100644
index 0000000000..6caa6d52e4
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/accelgroup_p.h
@@ -0,0 +1,45 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_ACCELGROUP_P_H
+#define _GTKMM_ACCELGROUP_P_H
+#include <glibmm/private/object_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class AccelGroup_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef AccelGroup CppObjectType;
+  typedef GtkAccelGroup BaseObjectType;
+  typedef GtkAccelGroupClass BaseClassType;
+  typedef Glib::Object_Class CppClassParent;
+  typedef GObjectClass BaseClassParent;
+
+  friend class AccelGroup;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+  static void accel_changed_callback(GtkAccelGroup* self, guint p0, GdkModifierType p1, GClosure* p2);
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_ACCELGROUP_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/accellabel_p.h b/libs/gtkmm2/gtk/gtkmm/private/accellabel_p.h
new file mode 100644
index 0000000000..fea48d72d6
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/accellabel_p.h
@@ -0,0 +1,44 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_ACCELLABEL_P_H
+#define _GTKMM_ACCELLABEL_P_H
+#include <gtkmm/private/label_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class AccelLabel_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef AccelLabel CppObjectType;
+  typedef GtkAccelLabel BaseObjectType;
+  typedef GtkAccelLabelClass BaseClassType;
+  typedef Gtk::Label_Class CppClassParent;
+  typedef GtkLabelClass BaseClassParent;
+
+  friend class AccelLabel;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_ACCELLABEL_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/action_p.h b/libs/gtkmm2/gtk/gtkmm/private/action_p.h
new file mode 100644
index 0000000000..b143a7e57d
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/action_p.h
@@ -0,0 +1,49 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_ACTION_P_H
+#define _GTKMM_ACTION_P_H
+#include <glibmm/private/object_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class Action_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Action CppObjectType;
+  typedef GtkAction BaseObjectType;
+  typedef GtkActionClass BaseClassType;
+  typedef Glib::Object_Class CppClassParent;
+  typedef GObjectClass BaseClassParent;
+
+  friend class Action;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+  static void activate_callback(GtkAction* self);
+
+  //Callbacks (virtual functions):
+  static GtkWidget* create_menu_item_vfunc_callback(GtkAction* self);
+  static GtkWidget* create_tool_item_vfunc_callback(GtkAction* self);
+  static void connect_proxy_vfunc_callback(GtkAction* self, GtkWidget* proxy);
+  static void disconnect_proxy_vfunc_callback(GtkAction* self, GtkWidget* proxy);
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_ACTION_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/actiongroup_p.h b/libs/gtkmm2/gtk/gtkmm/private/actiongroup_p.h
new file mode 100644
index 0000000000..468723aa92
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/actiongroup_p.h
@@ -0,0 +1,44 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_ACTIONGROUP_P_H
+#define _GTKMM_ACTIONGROUP_P_H
+#include <glibmm/private/object_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class ActionGroup_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef ActionGroup CppObjectType;
+  typedef GtkActionGroup BaseObjectType;
+  typedef GtkActionGroupClass BaseClassType;
+  typedef Glib::Object_Class CppClassParent;
+  typedef GObjectClass BaseClassParent;
+
+  friend class ActionGroup;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_ACTIONGROUP_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/adjustment_p.h b/libs/gtkmm2/gtk/gtkmm/private/adjustment_p.h
new file mode 100644
index 0000000000..4a13ed8c2b
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/adjustment_p.h
@@ -0,0 +1,46 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_ADJUSTMENT_P_H
+#define _GTKMM_ADJUSTMENT_P_H
+#include <gtkmm/private/object_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class Adjustment_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Adjustment CppObjectType;
+  typedef GtkAdjustment BaseObjectType;
+  typedef GtkAdjustmentClass BaseClassType;
+  typedef Gtk::Object_Class CppClassParent;
+  typedef GtkObjectClass BaseClassParent;
+
+  friend class Adjustment;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+  static void changed_callback(GtkAdjustment* self);
+  static void value_changed_callback(GtkAdjustment* self);
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_ADJUSTMENT_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/alignment_p.h b/libs/gtkmm2/gtk/gtkmm/private/alignment_p.h
new file mode 100644
index 0000000000..debf6ee966
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/alignment_p.h
@@ -0,0 +1,44 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_ALIGNMENT_P_H
+#define _GTKMM_ALIGNMENT_P_H
+#include <gtkmm/private/bin_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class Alignment_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Alignment CppObjectType;
+  typedef GtkAlignment BaseObjectType;
+  typedef GtkAlignmentClass BaseClassType;
+  typedef Gtk::Bin_Class CppClassParent;
+  typedef GtkBinClass BaseClassParent;
+
+  friend class Alignment;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_ALIGNMENT_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/arrow_p.h b/libs/gtkmm2/gtk/gtkmm/private/arrow_p.h
new file mode 100644
index 0000000000..7e3e5dd4b7
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/arrow_p.h
@@ -0,0 +1,44 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_ARROW_P_H
+#define _GTKMM_ARROW_P_H
+#include <gtkmm/private/misc_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class Arrow_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Arrow CppObjectType;
+  typedef GtkArrow BaseObjectType;
+  typedef GtkArrowClass BaseClassType;
+  typedef Gtk::Misc_Class CppClassParent;
+  typedef GtkMiscClass BaseClassParent;
+
+  friend class Arrow;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_ARROW_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/aspectframe_p.h b/libs/gtkmm2/gtk/gtkmm/private/aspectframe_p.h
new file mode 100644
index 0000000000..6e5e3ec8b9
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/aspectframe_p.h
@@ -0,0 +1,44 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_ASPECTFRAME_P_H
+#define _GTKMM_ASPECTFRAME_P_H
+#include <gtkmm/private/frame_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class AspectFrame_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef AspectFrame CppObjectType;
+  typedef GtkAspectFrame BaseObjectType;
+  typedef GtkAspectFrameClass BaseClassType;
+  typedef Gtk::Frame_Class CppClassParent;
+  typedef GtkFrameClass BaseClassParent;
+
+  friend class AspectFrame;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_ASPECTFRAME_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/bin_p.h b/libs/gtkmm2/gtk/gtkmm/private/bin_p.h
new file mode 100644
index 0000000000..b81931b19e
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/bin_p.h
@@ -0,0 +1,44 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_BIN_P_H
+#define _GTKMM_BIN_P_H
+#include <gtkmm/private/container_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class Bin_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Bin CppObjectType;
+  typedef GtkBin BaseObjectType;
+  typedef GtkBinClass BaseClassType;
+  typedef Gtk::Container_Class CppClassParent;
+  typedef GtkContainerClass BaseClassParent;
+
+  friend class Bin;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_BIN_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/box_p.h b/libs/gtkmm2/gtk/gtkmm/private/box_p.h
new file mode 100644
index 0000000000..bf26cdbf7d
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/box_p.h
@@ -0,0 +1,118 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_BOX_P_H
+#define _GTKMM_BOX_P_H
+#include <gtkmm/private/container_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class Box_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Box CppObjectType;
+  typedef GtkBox BaseObjectType;
+  typedef GtkBoxClass BaseClassType;
+  typedef Gtk::Container_Class CppClassParent;
+  typedef GtkContainerClass BaseClassParent;
+
+  friend class Box;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class VBox_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef VBox CppObjectType;
+  typedef GtkVBox BaseObjectType;
+  typedef GtkVBoxClass BaseClassType;
+  typedef Gtk::Box_Class CppClassParent;
+  typedef GtkBoxClass BaseClassParent;
+
+  friend class VBox;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class HBox_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef HBox CppObjectType;
+  typedef GtkHBox BaseObjectType;
+  typedef GtkHBoxClass BaseClassType;
+  typedef Gtk::Box_Class CppClassParent;
+  typedef GtkBoxClass BaseClassParent;
+
+  friend class HBox;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_BOX_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/button_p.h b/libs/gtkmm2/gtk/gtkmm/private/button_p.h
new file mode 100644
index 0000000000..7fe15f9a48
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/button_p.h
@@ -0,0 +1,50 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_BUTTON_P_H
+#define _GTKMM_BUTTON_P_H
+#include <gtkmm/private/bin_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class Button_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Button CppObjectType;
+  typedef GtkButton BaseObjectType;
+  typedef GtkButtonClass BaseClassType;
+  typedef Gtk::Bin_Class CppClassParent;
+  typedef GtkBinClass BaseClassParent;
+
+  friend class Button;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+  static void pressed_callback(GtkButton* self);
+  static void released_callback(GtkButton* self);
+  static void clicked_callback(GtkButton* self);
+  static void enter_callback(GtkButton* self);
+  static void leave_callback(GtkButton* self);
+  static void activate_callback(GtkButton* self);
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_BUTTON_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/buttonbox_p.h b/libs/gtkmm2/gtk/gtkmm/private/buttonbox_p.h
new file mode 100644
index 0000000000..59a656dbb5
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/buttonbox_p.h
@@ -0,0 +1,118 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_BUTTONBOX_P_H
+#define _GTKMM_BUTTONBOX_P_H
+#include <gtkmm/private/box_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class ButtonBox_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef ButtonBox CppObjectType;
+  typedef GtkButtonBox BaseObjectType;
+  typedef GtkButtonBoxClass BaseClassType;
+  typedef Gtk::Box_Class CppClassParent;
+  typedef GtkBoxClass BaseClassParent;
+
+  friend class ButtonBox;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class VButtonBox_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef VButtonBox CppObjectType;
+  typedef GtkVButtonBox BaseObjectType;
+  typedef GtkVButtonBoxClass BaseClassType;
+  typedef Gtk::ButtonBox_Class CppClassParent;
+  typedef GtkButtonBoxClass BaseClassParent;
+
+  friend class VButtonBox;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class HButtonBox_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef HButtonBox CppObjectType;
+  typedef GtkHButtonBox BaseObjectType;
+  typedef GtkHButtonBoxClass BaseClassType;
+  typedef Gtk::ButtonBox_Class CppClassParent;
+  typedef GtkButtonBoxClass BaseClassParent;
+
+  friend class HButtonBox;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_BUTTONBOX_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/calendar_p.h b/libs/gtkmm2/gtk/gtkmm/private/calendar_p.h
new file mode 100644
index 0000000000..f138739966
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/calendar_p.h
@@ -0,0 +1,51 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_CALENDAR_P_H
+#define _GTKMM_CALENDAR_P_H
+#include <gtkmm/private/widget_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class Calendar_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Calendar CppObjectType;
+  typedef GtkCalendar BaseObjectType;
+  typedef GtkCalendarClass BaseClassType;
+  typedef Gtk::Widget_Class CppClassParent;
+  typedef GtkWidgetClass BaseClassParent;
+
+  friend class Calendar;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+  static void month_changed_callback(GtkCalendar* self);
+  static void day_selected_callback(GtkCalendar* self);
+  static void day_selected_double_click_callback(GtkCalendar* self);
+  static void prev_month_callback(GtkCalendar* self);
+  static void next_month_callback(GtkCalendar* self);
+  static void prev_year_callback(GtkCalendar* self);
+  static void next_year_callback(GtkCalendar* self);
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_CALENDAR_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/celleditable_p.h b/libs/gtkmm2/gtk/gtkmm/private/celleditable_p.h
new file mode 100644
index 0000000000..31250f561b
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/celleditable_p.h
@@ -0,0 +1,44 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_CELLEDITABLE_P_H
+#define _GTKMM_CELLEDITABLE_P_H
+#include <glibmm/private/interface_p.h>
+
+#include <glibmm/private/interface_p.h>
+
+namespace Gtk
+{
+
+class CellEditable_Class : public Glib::Interface_Class
+{
+public:
+  typedef CellEditable CppObjectType;
+  typedef GtkCellEditable BaseObjectType;
+  typedef GtkCellEditableIface BaseClassType;
+  typedef Glib::Interface_Class CppClassParent;
+
+  friend class CellEditable;
+
+  const Glib::Interface_Class& init();
+
+  static void iface_init_function(void* g_iface, void* iface_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+  static void editing_done_callback(GtkCellEditable* self);
+  static void remove_widget_callback(GtkCellEditable* self);
+
+  //Callbacks (virtual functions):
+  static void start_editing_vfunc_callback(GtkCellEditable* self, GdkEvent* event);
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_CELLEDITABLE_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/celllayout_p.h b/libs/gtkmm2/gtk/gtkmm/private/celllayout_p.h
new file mode 100644
index 0000000000..1af5318448
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/celllayout_p.h
@@ -0,0 +1,47 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_CELLLAYOUT_P_H
+#define _GTKMM_CELLLAYOUT_P_H
+#include <glibmm/private/interface_p.h>
+
+#include <glibmm/private/interface_p.h>
+
+namespace Gtk
+{
+
+class CellLayout_Class : public Glib::Interface_Class
+{
+public:
+  typedef CellLayout CppObjectType;
+  typedef GtkCellLayout BaseObjectType;
+  typedef GtkCellLayoutIface BaseClassType;
+  typedef Glib::Interface_Class CppClassParent;
+
+  friend class CellLayout;
+
+  const Glib::Interface_Class& init();
+
+  static void iface_init_function(void* g_iface, void* iface_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+  static void pack_start_vfunc_callback(GtkCellLayout* self, GtkCellRenderer* cell, gboolean expand);
+  static void pack_end_vfunc_callback(GtkCellLayout* self, GtkCellRenderer* cell, gboolean expand);
+  static void clear_vfunc_callback(GtkCellLayout* self);
+  static void add_attribute_vfunc_callback(GtkCellLayout* self, GtkCellRenderer* cell, const gchar* attribute, gint column);
+  static void clear_attributes_vfunc_callback(GtkCellLayout* self, GtkCellRenderer* cell);
+  static void reorder_vfunc_callback(GtkCellLayout* self, GtkCellRenderer* cell, gint position);
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_CELLLAYOUT_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/cellrenderer_p.h b/libs/gtkmm2/gtk/gtkmm/private/cellrenderer_p.h
new file mode 100644
index 0000000000..c7fac80cb6
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/cellrenderer_p.h
@@ -0,0 +1,50 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_CELLRENDERER_P_H
+#define _GTKMM_CELLRENDERER_P_H
+#include <gtkmm/private/object_p.h>
+#include <gtk/gtkcellrenderer.h>
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class CellRenderer_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef CellRenderer CppObjectType;
+  typedef GtkCellRenderer BaseObjectType;
+  typedef GtkCellRendererClass BaseClassType;
+  typedef Gtk::Object_Class CppClassParent;
+  typedef GtkObjectClass BaseClassParent;
+
+  friend class CellRenderer;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+  static void editing_canceled_callback(GtkCellRenderer* self);
+
+  //Callbacks (virtual functions):
+  static void get_size_vfunc_callback(GtkCellRenderer* self, GtkWidget* widget, GdkRectangle* cell_area, gint* x_offset, gint* y_offset, gint* width, gint* height);
+  static void render_vfunc_callback(GtkCellRenderer* self, GdkDrawable* window, GtkWidget* widget, GdkRectangle* background_area, GdkRectangle* cell_area, GdkRectangle* expose_area, GtkCellRendererState flags);
+  static gboolean activate_vfunc_callback(GtkCellRenderer* self, GdkEvent* event, GtkWidget* widget, const gchar* path, GdkRectangle* background_area, GdkRectangle* cell_area, GtkCellRendererState flags);
+  static GtkCellEditable* start_editing_vfunc_callback(GtkCellRenderer* self, GdkEvent* event, GtkWidget* widget, const gchar* path, GdkRectangle* background_area, GdkRectangle* cell_area, GtkCellRendererState flags);
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_CELLRENDERER_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/cellrenderercombo_p.h b/libs/gtkmm2/gtk/gtkmm/private/cellrenderercombo_p.h
new file mode 100644
index 0000000000..af5eda9c5f
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/cellrenderercombo_p.h
@@ -0,0 +1,44 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_CELLRENDERERCOMBO_P_H
+#define _GTKMM_CELLRENDERERCOMBO_P_H
+#include <gtkmm/private/cellrenderertext_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class CellRendererCombo_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef CellRendererCombo CppObjectType;
+  typedef GtkCellRendererCombo BaseObjectType;
+  typedef GtkCellRendererComboClass BaseClassType;
+  typedef Gtk::CellRendererText_Class CppClassParent;
+  typedef GtkCellRendererTextClass BaseClassParent;
+
+  friend class CellRendererCombo;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_CELLRENDERERCOMBO_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/cellrendererpixbuf_p.h b/libs/gtkmm2/gtk/gtkmm/private/cellrendererpixbuf_p.h
new file mode 100644
index 0000000000..5bf100b376
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/cellrendererpixbuf_p.h
@@ -0,0 +1,44 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_CELLRENDERERPIXBUF_P_H
+#define _GTKMM_CELLRENDERERPIXBUF_P_H
+#include <gtkmm/private/cellrenderer_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class CellRendererPixbuf_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef CellRendererPixbuf CppObjectType;
+  typedef GtkCellRendererPixbuf BaseObjectType;
+  typedef GtkCellRendererPixbufClass BaseClassType;
+  typedef Gtk::CellRenderer_Class CppClassParent;
+  typedef GtkCellRendererClass BaseClassParent;
+
+  friend class CellRendererPixbuf;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_CELLRENDERERPIXBUF_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/cellrendererprogress_p.h b/libs/gtkmm2/gtk/gtkmm/private/cellrendererprogress_p.h
new file mode 100644
index 0000000000..f95a9f133b
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/cellrendererprogress_p.h
@@ -0,0 +1,44 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_CELLRENDERERPROGRESS_P_H
+#define _GTKMM_CELLRENDERERPROGRESS_P_H
+#include <gtkmm/private/cellrenderer_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class CellRendererProgress_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef CellRendererProgress CppObjectType;
+  typedef GtkCellRendererProgress BaseObjectType;
+  typedef GtkCellRendererProgressClass BaseClassType;
+  typedef Gtk::CellRenderer_Class CppClassParent;
+  typedef GtkCellRendererClass BaseClassParent;
+
+  friend class CellRendererProgress;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_CELLRENDERERPROGRESS_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/cellrenderertext_p.h b/libs/gtkmm2/gtk/gtkmm/private/cellrenderertext_p.h
new file mode 100644
index 0000000000..1505a568f9
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/cellrenderertext_p.h
@@ -0,0 +1,45 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_CELLRENDERERTEXT_P_H
+#define _GTKMM_CELLRENDERERTEXT_P_H
+#include <gtkmm/private/cellrenderer_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class CellRendererText_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef CellRendererText CppObjectType;
+  typedef GtkCellRendererText BaseObjectType;
+  typedef GtkCellRendererTextClass BaseClassType;
+  typedef Gtk::CellRenderer_Class CppClassParent;
+  typedef GtkCellRendererClass BaseClassParent;
+
+  friend class CellRendererText;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+  static void edited_callback(GtkCellRendererText* self, const gchar* p0, const gchar* p1);
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_CELLRENDERERTEXT_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/cellrenderertoggle_p.h b/libs/gtkmm2/gtk/gtkmm/private/cellrenderertoggle_p.h
new file mode 100644
index 0000000000..6566624b9d
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/cellrenderertoggle_p.h
@@ -0,0 +1,45 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_CELLRENDERERTOGGLE_P_H
+#define _GTKMM_CELLRENDERERTOGGLE_P_H
+#include <gtkmm/private/cellrenderer_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class CellRendererToggle_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef CellRendererToggle CppObjectType;
+  typedef GtkCellRendererToggle BaseObjectType;
+  typedef GtkCellRendererToggleClass BaseClassType;
+  typedef Gtk::CellRenderer_Class CppClassParent;
+  typedef GtkCellRendererClass BaseClassParent;
+
+  friend class CellRendererToggle;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+  static void toggled_callback(GtkCellRendererToggle* self, const gchar* p0);
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_CELLRENDERERTOGGLE_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/cellview_p.h b/libs/gtkmm2/gtk/gtkmm/private/cellview_p.h
new file mode 100644
index 0000000000..6046537896
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/cellview_p.h
@@ -0,0 +1,44 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_CELLVIEW_P_H
+#define _GTKMM_CELLVIEW_P_H
+#include <gtkmm/private/widget_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class CellView_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef CellView CppObjectType;
+  typedef GtkCellView BaseObjectType;
+  typedef GtkCellViewClass BaseClassType;
+  typedef Gtk::Widget_Class CppClassParent;
+  typedef GtkWidgetClass BaseClassParent;
+
+  friend class CellView;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_CELLVIEW_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/checkbutton_p.h b/libs/gtkmm2/gtk/gtkmm/private/checkbutton_p.h
new file mode 100644
index 0000000000..1e579d79b9
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/checkbutton_p.h
@@ -0,0 +1,45 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_CHECKBUTTON_P_H
+#define _GTKMM_CHECKBUTTON_P_H
+#include <gtkmm/private/togglebutton_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class CheckButton_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef CheckButton CppObjectType;
+  typedef GtkCheckButton BaseObjectType;
+  typedef GtkCheckButtonClass BaseClassType;
+  typedef Gtk::ToggleButton_Class CppClassParent;
+  typedef GtkToggleButtonClass BaseClassParent;
+
+  friend class CheckButton;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+  static void draw_indicator_vfunc_callback(GtkCheckButton* self, GdkRectangle* area);
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_CHECKBUTTON_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/checkmenuitem_p.h b/libs/gtkmm2/gtk/gtkmm/private/checkmenuitem_p.h
new file mode 100644
index 0000000000..8ae77c14b7
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/checkmenuitem_p.h
@@ -0,0 +1,46 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_CHECKMENUITEM_P_H
+#define _GTKMM_CHECKMENUITEM_P_H
+#include <gtkmm/private/menuitem_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class CheckMenuItem_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef CheckMenuItem CppObjectType;
+  typedef GtkCheckMenuItem BaseObjectType;
+  typedef GtkCheckMenuItemClass BaseClassType;
+  typedef Gtk::MenuItem_Class CppClassParent;
+  typedef GtkMenuItemClass BaseClassParent;
+
+  friend class CheckMenuItem;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+  static void toggled_callback(GtkCheckMenuItem* self);
+
+  //Callbacks (virtual functions):
+  static void draw_indicator_vfunc_callback(GtkCheckMenuItem* self, GdkRectangle* area);
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_CHECKMENUITEM_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/clipboard_p.h b/libs/gtkmm2/gtk/gtkmm/private/clipboard_p.h
new file mode 100644
index 0000000000..1bad952a67
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/clipboard_p.h
@@ -0,0 +1,44 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_CLIPBOARD_P_H
+#define _GTKMM_CLIPBOARD_P_H
+#include <glibmm/private/object_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class Clipboard_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Clipboard CppObjectType;
+  typedef GtkClipboard BaseObjectType;
+  typedef GtkClipboardClass BaseClassType;
+  typedef Glib::Object_Class CppClassParent;
+  typedef GObjectClass BaseClassParent;
+
+  friend class Clipboard;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_CLIPBOARD_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/colorbutton_p.h b/libs/gtkmm2/gtk/gtkmm/private/colorbutton_p.h
new file mode 100644
index 0000000000..20b2dfb9e6
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/colorbutton_p.h
@@ -0,0 +1,45 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_COLORBUTTON_P_H
+#define _GTKMM_COLORBUTTON_P_H
+#include <gtkmm/private/button_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class ColorButton_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef ColorButton CppObjectType;
+  typedef GtkColorButton BaseObjectType;
+  typedef GtkColorButtonClass BaseClassType;
+  typedef Gtk::Button_Class CppClassParent;
+  typedef GtkButtonClass BaseClassParent;
+
+  friend class ColorButton;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+  static void color_set_callback(GtkColorButton* self);
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_COLORBUTTON_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/colorselection_p.h b/libs/gtkmm2/gtk/gtkmm/private/colorselection_p.h
new file mode 100644
index 0000000000..662aca3486
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/colorselection_p.h
@@ -0,0 +1,83 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_COLORSELECTION_P_H
+#define _GTKMM_COLORSELECTION_P_H
+#include <gtkmm/private/box_p.h>
+#include <gtkmm/private/dialog_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class ColorSelection_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef ColorSelection CppObjectType;
+  typedef GtkColorSelection BaseObjectType;
+  typedef GtkColorSelectionClass BaseClassType;
+  typedef Gtk::VBox_Class CppClassParent;
+  typedef GtkVBoxClass BaseClassParent;
+
+  friend class ColorSelection;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+  static void color_changed_callback(GtkColorSelection* self);
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class ColorSelectionDialog_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef ColorSelectionDialog CppObjectType;
+  typedef GtkColorSelectionDialog BaseObjectType;
+  typedef GtkColorSelectionDialogClass BaseClassType;
+  typedef Gtk::Dialog_Class CppClassParent;
+  typedef GtkDialogClass BaseClassParent;
+
+  friend class ColorSelectionDialog;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_COLORSELECTION_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/combo_p.h b/libs/gtkmm2/gtk/gtkmm/private/combo_p.h
new file mode 100644
index 0000000000..c272fe4afa
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/combo_p.h
@@ -0,0 +1,124 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_COMBO_P_H
+#define _GTKMM_COMBO_P_H
+#include <gtkmm/private/box_p.h>
+#include <gtkmm/private/item_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class ComboDropDownItem_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef ComboDropDownItem CppObjectType;
+  typedef GtkListItem BaseObjectType;
+  typedef GtkListItemClass BaseClassType;
+  typedef Gtk::Item_Class CppClassParent;
+  typedef GtkItemClass BaseClassParent;
+
+  friend class ComboDropDownItem;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+  static void scroll_horizontal_callback(GtkListItem* self, GtkScrollType p0, gfloat p1);
+  static void scroll_vertical_callback(GtkListItem* self, GtkScrollType p0, gfloat p1);
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class ComboDropDown_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef ComboDropDown CppObjectType;
+  typedef GtkList BaseObjectType;
+  typedef GtkListClass BaseClassType;
+  typedef Gtk::Container_Class CppClassParent;
+  typedef GtkContainerClass BaseClassParent;
+
+  friend class ComboDropDown;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+  static void select_child_callback(GtkList* self, GtkWidget* p0);
+  static void selection_changed_callback(GtkList* self);
+  static void unselect_child_callback(GtkList* self, GtkWidget* p0);
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class Combo_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Combo CppObjectType;
+  typedef GtkCombo BaseObjectType;
+  typedef GtkComboClass BaseClassType;
+  typedef Gtk::HBox_Class CppClassParent;
+  typedef GtkHBoxClass BaseClassParent;
+
+  friend class Combo;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_COMBO_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/combobox_p.h b/libs/gtkmm2/gtk/gtkmm/private/combobox_p.h
new file mode 100644
index 0000000000..242c755f70
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/combobox_p.h
@@ -0,0 +1,45 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_COMBOBOX_P_H
+#define _GTKMM_COMBOBOX_P_H
+#include <gtkmm/private/bin_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class ComboBox_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef ComboBox CppObjectType;
+  typedef GtkComboBox BaseObjectType;
+  typedef GtkComboBoxClass BaseClassType;
+  typedef Gtk::Bin_Class CppClassParent;
+  typedef GtkBinClass BaseClassParent;
+
+  friend class ComboBox;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+  static void changed_callback(GtkComboBox* self);
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_COMBOBOX_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/comboboxentry_p.h b/libs/gtkmm2/gtk/gtkmm/private/comboboxentry_p.h
new file mode 100644
index 0000000000..bbc8a5028a
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/comboboxentry_p.h
@@ -0,0 +1,44 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_COMBOBOXENTRY_P_H
+#define _GTKMM_COMBOBOXENTRY_P_H
+#include <gtkmm/private/combobox_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class ComboBoxEntry_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef ComboBoxEntry CppObjectType;
+  typedef GtkComboBoxEntry BaseObjectType;
+  typedef GtkComboBoxEntryClass BaseClassType;
+  typedef Gtk::ComboBox_Class CppClassParent;
+  typedef GtkComboBoxClass BaseClassParent;
+
+  friend class ComboBoxEntry;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_COMBOBOXENTRY_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/container_p.h b/libs/gtkmm2/gtk/gtkmm/private/container_p.h
new file mode 100644
index 0000000000..3f1b158887
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/container_p.h
@@ -0,0 +1,55 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_CONTAINER_P_H
+#define _GTKMM_CONTAINER_P_H
+#include <gtkmm/private/widget_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class Container_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Container CppObjectType;
+  typedef GtkContainer BaseObjectType;
+  typedef GtkContainerClass BaseClassType;
+  typedef Gtk::Widget_Class CppClassParent;
+  typedef GtkWidgetClass BaseClassParent;
+
+  friend class Container;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+  static void add_callback(GtkContainer* self, GtkWidget* p0);
+  static void remove_callback(GtkContainer* self, GtkWidget* p0);
+  static void check_resize_callback(GtkContainer* self);
+  static void set_focus_child_callback(GtkContainer* self, GtkWidget* p0);
+    static void destroy_callback(GtkObject* self);
+      static void remove_callback_custom(GtkContainer* self, GtkWidget* p0);
+  
+  //Callbacks (virtual functions):
+  static GtkType child_type_vfunc_callback(GtkContainer* self);
+  static void forall_vfunc_callback(GtkContainer* self, gboolean include_internals, GtkCallback callback, gpointer callback_data);
+  static gchar* composite_name_vfunc_callback(GtkContainer* self, GtkWidget* child);
+  static void set_child_property_vfunc_callback(GtkContainer* self, GtkWidget* child, guint property_id, const GValue* value, GParamSpec* pspec);
+  static void get_child_property_vfunc_callback(GtkContainer* self, GtkWidget* child, guint property_id, GValue* value, GParamSpec* pspec);
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_CONTAINER_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/curve_p.h b/libs/gtkmm2/gtk/gtkmm/private/curve_p.h
new file mode 100644
index 0000000000..dc07066521
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/curve_p.h
@@ -0,0 +1,83 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_CURVE_P_H
+#define _GTKMM_CURVE_P_H
+#include <gtkmm/private/drawingarea_p.h>
+#include <gtkmm/private/box_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class Curve_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Curve CppObjectType;
+  typedef GtkCurve BaseObjectType;
+  typedef GtkCurveClass BaseClassType;
+  typedef Gtk::DrawingArea_Class CppClassParent;
+  typedef GtkDrawingAreaClass BaseClassParent;
+
+  friend class Curve;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+  static void curve_type_changed_callback(GtkCurve* self);
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class GammaCurve_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef GammaCurve CppObjectType;
+  typedef GtkGammaCurve BaseObjectType;
+  typedef GtkGammaCurveClass BaseClassType;
+  typedef Gtk::VBox_Class CppClassParent;
+  typedef GtkVBoxClass BaseClassParent;
+
+  friend class GammaCurve;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_CURVE_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/dialog_p.h b/libs/gtkmm2/gtk/gtkmm/private/dialog_p.h
new file mode 100644
index 0000000000..9eeef1e8fe
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/dialog_p.h
@@ -0,0 +1,45 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_DIALOG_P_H
+#define _GTKMM_DIALOG_P_H
+#include <gtkmm/private/window_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class Dialog_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Dialog CppObjectType;
+  typedef GtkDialog BaseObjectType;
+  typedef GtkDialogClass BaseClassType;
+  typedef Gtk::Window_Class CppClassParent;
+  typedef GtkWindowClass BaseClassParent;
+
+  friend class Dialog;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+  static void response_callback(GtkDialog* self, gint p0);
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_DIALOG_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/drawingarea_p.h b/libs/gtkmm2/gtk/gtkmm/private/drawingarea_p.h
new file mode 100644
index 0000000000..cd639999b3
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/drawingarea_p.h
@@ -0,0 +1,44 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_DRAWINGAREA_P_H
+#define _GTKMM_DRAWINGAREA_P_H
+#include <gtkmm/private/widget_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class DrawingArea_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef DrawingArea CppObjectType;
+  typedef GtkDrawingArea BaseObjectType;
+  typedef GtkDrawingAreaClass BaseClassType;
+  typedef Gtk::Widget_Class CppClassParent;
+  typedef GtkWidgetClass BaseClassParent;
+
+  friend class DrawingArea;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_DRAWINGAREA_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/editable_p.h b/libs/gtkmm2/gtk/gtkmm/private/editable_p.h
new file mode 100644
index 0000000000..caf727830a
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/editable_p.h
@@ -0,0 +1,51 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_EDITABLE_P_H
+#define _GTKMM_EDITABLE_P_H
+#include <glibmm/private/interface_p.h>
+
+#include <glibmm/private/interface_p.h>
+
+namespace Gtk
+{
+
+class Editable_Class : public Glib::Interface_Class
+{
+public:
+  typedef Editable CppObjectType;
+  typedef GtkEditable BaseObjectType;
+  typedef GtkEditableClass BaseClassType;
+  typedef Glib::Interface_Class CppClassParent;
+
+  friend class Editable;
+
+  const Glib::Interface_Class& init();
+
+  static void iface_init_function(void* g_iface, void* iface_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+  static void insert_text_callback(GtkEditable* self, const gchar* text, gint length, gint* position);
+  static void delete_text_callback(GtkEditable* self, gint start_pos, gint end_pos);
+  static void changed_callback(GtkEditable* self);
+
+  //Callbacks (virtual functions):
+  static void do_insert_text_vfunc_callback(GtkEditable* self, const gchar* text, gint length, gint* position);
+  static void do_delete_text_vfunc_callback(GtkEditable* self, gint start_pos, gint end_pos);
+  static gchar* get_chars_vfunc_callback(GtkEditable* self, gint start_pos, gint end_pos);
+  static void set_selection_bounds_vfunc_callback(GtkEditable* self, gint start_pos, gint end_pos);
+  static gboolean get_selection_bounds_vfunc_callback(GtkEditable* self, gint* start_pos, gint* end_pos);
+  static void set_position_vfunc_callback(GtkEditable* self, gint position);
+  static gint get_position_vfunc_callback(GtkEditable* self);
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_EDITABLE_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/entry_p.h b/libs/gtkmm2/gtk/gtkmm/private/entry_p.h
new file mode 100644
index 0000000000..5d25b64902
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/entry_p.h
@@ -0,0 +1,47 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_ENTRY_P_H
+#define _GTKMM_ENTRY_P_H
+#include <gtkmm/private/widget_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class Entry_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Entry CppObjectType;
+  typedef GtkEntry BaseObjectType;
+  typedef GtkEntryClass BaseClassType;
+  typedef Gtk::Widget_Class CppClassParent;
+  typedef GtkWidgetClass BaseClassParent;
+
+  friend class Entry;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+  static void populate_popup_callback(GtkEntry* self, GtkMenu* p0);
+  static void insert_at_cursor_callback(GtkEntry* self, const gchar* p0);
+  static void activate_callback(GtkEntry* self);
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_ENTRY_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/entrycompletion_p.h b/libs/gtkmm2/gtk/gtkmm/private/entrycompletion_p.h
new file mode 100644
index 0000000000..2a9b97a3ad
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/entrycompletion_p.h
@@ -0,0 +1,46 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_ENTRYCOMPLETION_P_H
+#define _GTKMM_ENTRYCOMPLETION_P_H
+#include <glibmm/private/object_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class EntryCompletion_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef EntryCompletion CppObjectType;
+  typedef GtkEntryCompletion BaseObjectType;
+  typedef GtkEntryCompletionClass BaseClassType;
+  typedef Glib::Object_Class CppClassParent;
+  typedef GObjectClass BaseClassParent;
+
+  friend class EntryCompletion;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+  static void action_activated_callback(GtkEntryCompletion* self, gint p0);
+    static gboolean match_selected_callback_custom(GtkEntryCompletion* self, GtkTreeModel* c_model, GtkTreeIter* c_iter);
+  
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_ENTRYCOMPLETION_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/enums_p.h b/libs/gtkmm2/gtk/gtkmm/private/enums_p.h
new file mode 100644
index 0000000000..68c26cc900
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/enums_p.h
@@ -0,0 +1,6 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_ENUMS_P_H
+#define _GTKMM_ENUMS_P_H
+#endif /* _GTKMM_ENUMS_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/eventbox_p.h b/libs/gtkmm2/gtk/gtkmm/private/eventbox_p.h
new file mode 100644
index 0000000000..91b3303f1f
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/eventbox_p.h
@@ -0,0 +1,44 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_EVENTBOX_P_H
+#define _GTKMM_EVENTBOX_P_H
+#include <gtkmm/private/bin_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class EventBox_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef EventBox CppObjectType;
+  typedef GtkEventBox BaseObjectType;
+  typedef GtkEventBoxClass BaseClassType;
+  typedef Gtk::Bin_Class CppClassParent;
+  typedef GtkBinClass BaseClassParent;
+
+  friend class EventBox;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_EVENTBOX_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/expander_p.h b/libs/gtkmm2/gtk/gtkmm/private/expander_p.h
new file mode 100644
index 0000000000..674bf038cd
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/expander_p.h
@@ -0,0 +1,44 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_EXPANDER_P_H
+#define _GTKMM_EXPANDER_P_H
+#include <gtkmm/private/bin_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class Expander_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Expander CppObjectType;
+  typedef GtkExpander BaseObjectType;
+  typedef GtkExpanderClass BaseClassType;
+  typedef Gtk::Bin_Class CppClassParent;
+  typedef GtkBinClass BaseClassParent;
+
+  friend class Expander;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_EXPANDER_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/filechooser_p.h b/libs/gtkmm2/gtk/gtkmm/private/filechooser_p.h
new file mode 100644
index 0000000000..9b864a7dda
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/filechooser_p.h
@@ -0,0 +1,41 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_FILECHOOSER_P_H
+#define _GTKMM_FILECHOOSER_P_H
+#include <glibmm/private/interface_p.h>
+
+#include <glibmm/private/interface_p.h>
+
+namespace Gtk
+{
+
+class FileChooser_Class : public Glib::Interface_Class
+{
+public:
+  typedef FileChooser CppObjectType;
+  typedef GtkFileChooser BaseObjectType;
+  typedef GtkFileChooserClass BaseClassType;
+  typedef Glib::Interface_Class CppClassParent;
+
+  friend class FileChooser;
+
+  const Glib::Interface_Class& init();
+
+  static void iface_init_function(void* g_iface, void* iface_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_FILECHOOSER_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/filechooserbutton_p.h b/libs/gtkmm2/gtk/gtkmm/private/filechooserbutton_p.h
new file mode 100644
index 0000000000..60aa6eff06
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/filechooserbutton_p.h
@@ -0,0 +1,44 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_FILECHOOSERBUTTON_P_H
+#define _GTKMM_FILECHOOSERBUTTON_P_H
+#include <gtkmm/private/box_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class FileChooserButton_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef FileChooserButton CppObjectType;
+  typedef GtkFileChooserButton BaseObjectType;
+  typedef GtkFileChooserButtonClass BaseClassType;
+  typedef Gtk::HBox_Class CppClassParent;
+  typedef GtkHBoxClass BaseClassParent;
+
+  friend class FileChooserButton;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_FILECHOOSERBUTTON_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/filechooserdialog_p.h b/libs/gtkmm2/gtk/gtkmm/private/filechooserdialog_p.h
new file mode 100644
index 0000000000..38e4d9aa12
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/filechooserdialog_p.h
@@ -0,0 +1,44 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_FILECHOOSERDIALOG_P_H
+#define _GTKMM_FILECHOOSERDIALOG_P_H
+#include <gtkmm/private/dialog_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class FileChooserDialog_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef FileChooserDialog CppObjectType;
+  typedef GtkFileChooserDialog BaseObjectType;
+  typedef GtkFileChooserDialogClass BaseClassType;
+  typedef Gtk::Dialog_Class CppClassParent;
+  typedef GtkDialogClass BaseClassParent;
+
+  friend class FileChooserDialog;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_FILECHOOSERDIALOG_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/filechooserwidget_p.h b/libs/gtkmm2/gtk/gtkmm/private/filechooserwidget_p.h
new file mode 100644
index 0000000000..09e093dca1
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/filechooserwidget_p.h
@@ -0,0 +1,44 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_FILECHOOSERWIDGET_P_H
+#define _GTKMM_FILECHOOSERWIDGET_P_H
+#include <gtkmm/private/box_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class FileChooserWidget_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef FileChooserWidget CppObjectType;
+  typedef GtkFileChooserWidget BaseObjectType;
+  typedef GtkFileChooserWidgetClass BaseClassType;
+  typedef Gtk::VBox_Class CppClassParent;
+  typedef GtkVBoxClass BaseClassParent;
+
+  friend class FileChooserWidget;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_FILECHOOSERWIDGET_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/filefilter_p.h b/libs/gtkmm2/gtk/gtkmm/private/filefilter_p.h
new file mode 100644
index 0000000000..cfc5b84d36
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/filefilter_p.h
@@ -0,0 +1,44 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_FILEFILTER_P_H
+#define _GTKMM_FILEFILTER_P_H
+#include <gtkmm/private/object_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class FileFilter_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef FileFilter CppObjectType;
+  typedef GtkFileFilter BaseObjectType;
+  typedef GtkFileFilterClass BaseClassType;
+  typedef Gtk::Object_Class CppClassParent;
+  typedef GtkObjectClass BaseClassParent;
+
+  friend class FileFilter;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_FILEFILTER_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/fileselection_p.h b/libs/gtkmm2/gtk/gtkmm/private/fileselection_p.h
new file mode 100644
index 0000000000..9ab7fc7c1f
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/fileselection_p.h
@@ -0,0 +1,44 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_FILESELECTION_P_H
+#define _GTKMM_FILESELECTION_P_H
+#include <gtkmm/private/dialog_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class FileSelection_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef FileSelection CppObjectType;
+  typedef GtkFileSelection BaseObjectType;
+  typedef GtkFileSelectionClass BaseClassType;
+  typedef Gtk::Dialog_Class CppClassParent;
+  typedef GtkDialogClass BaseClassParent;
+
+  friend class FileSelection;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_FILESELECTION_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/fixed_p.h b/libs/gtkmm2/gtk/gtkmm/private/fixed_p.h
new file mode 100644
index 0000000000..b1c4abe756
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/fixed_p.h
@@ -0,0 +1,44 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_FIXED_P_H
+#define _GTKMM_FIXED_P_H
+#include <gtkmm/private/container_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class Fixed_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Fixed CppObjectType;
+  typedef GtkFixed BaseObjectType;
+  typedef GtkFixedClass BaseClassType;
+  typedef Gtk::Container_Class CppClassParent;
+  typedef GtkContainerClass BaseClassParent;
+
+  friend class Fixed;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_FIXED_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/fontbutton_p.h b/libs/gtkmm2/gtk/gtkmm/private/fontbutton_p.h
new file mode 100644
index 0000000000..746f160914
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/fontbutton_p.h
@@ -0,0 +1,45 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_FONTBUTTON_P_H
+#define _GTKMM_FONTBUTTON_P_H
+#include <gtkmm/private/button_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class FontButton_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef FontButton CppObjectType;
+  typedef GtkFontButton BaseObjectType;
+  typedef GtkFontButtonClass BaseClassType;
+  typedef Gtk::Button_Class CppClassParent;
+  typedef GtkButtonClass BaseClassParent;
+
+  friend class FontButton;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+  static void font_set_callback(GtkFontButton* self);
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_FONTBUTTON_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/fontselection_p.h b/libs/gtkmm2/gtk/gtkmm/private/fontselection_p.h
new file mode 100644
index 0000000000..50da4e3401
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/fontselection_p.h
@@ -0,0 +1,82 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_FONTSELECTION_P_H
+#define _GTKMM_FONTSELECTION_P_H
+#include <gtkmm/private/box_p.h>
+#include <gtkmm/private/dialog_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class FontSelection_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef FontSelection CppObjectType;
+  typedef GtkFontSelection BaseObjectType;
+  typedef GtkFontSelectionClass BaseClassType;
+  typedef Gtk::VBox_Class CppClassParent;
+  typedef GtkVBoxClass BaseClassParent;
+
+  friend class FontSelection;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class FontSelectionDialog_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef FontSelectionDialog CppObjectType;
+  typedef GtkFontSelectionDialog BaseObjectType;
+  typedef GtkFontSelectionDialogClass BaseClassType;
+  typedef Gtk::Dialog_Class CppClassParent;
+  typedef GtkDialogClass BaseClassParent;
+
+  friend class FontSelectionDialog;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_FONTSELECTION_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/frame_p.h b/libs/gtkmm2/gtk/gtkmm/private/frame_p.h
new file mode 100644
index 0000000000..297c7efbe7
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/frame_p.h
@@ -0,0 +1,45 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_FRAME_P_H
+#define _GTKMM_FRAME_P_H
+#include <gtkmm/private/bin_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class Frame_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Frame CppObjectType;
+  typedef GtkFrame BaseObjectType;
+  typedef GtkFrameClass BaseClassType;
+  typedef Gtk::Bin_Class CppClassParent;
+  typedef GtkBinClass BaseClassParent;
+
+  friend class Frame;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+  static void compute_child_allocation_vfunc_callback(GtkFrame* self, GtkAllocation* allocation);
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_FRAME_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/handlebox_p.h b/libs/gtkmm2/gtk/gtkmm/private/handlebox_p.h
new file mode 100644
index 0000000000..d1e0b3c30d
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/handlebox_p.h
@@ -0,0 +1,46 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_HANDLEBOX_P_H
+#define _GTKMM_HANDLEBOX_P_H
+#include <gtkmm/private/bin_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class HandleBox_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef HandleBox CppObjectType;
+  typedef GtkHandleBox BaseObjectType;
+  typedef GtkHandleBoxClass BaseClassType;
+  typedef Gtk::Bin_Class CppClassParent;
+  typedef GtkBinClass BaseClassParent;
+
+  friend class HandleBox;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+  static void child_attached_callback(GtkHandleBox* self, GtkWidget* p0);
+  static void child_detached_callback(GtkHandleBox* self, GtkWidget* p0);
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_HANDLEBOX_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/iconfactory_p.h b/libs/gtkmm2/gtk/gtkmm/private/iconfactory_p.h
new file mode 100644
index 0000000000..8840e8abde
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/iconfactory_p.h
@@ -0,0 +1,44 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_ICONFACTORY_P_H
+#define _GTKMM_ICONFACTORY_P_H
+#include <glibmm/private/object_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class IconFactory_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef IconFactory CppObjectType;
+  typedef GtkIconFactory BaseObjectType;
+  typedef GtkIconFactoryClass BaseClassType;
+  typedef Glib::Object_Class CppClassParent;
+  typedef GObjectClass BaseClassParent;
+
+  friend class IconFactory;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_ICONFACTORY_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/iconinfo_p.h b/libs/gtkmm2/gtk/gtkmm/private/iconinfo_p.h
new file mode 100644
index 0000000000..e391510843
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/iconinfo_p.h
@@ -0,0 +1,6 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_ICONINFO_P_H
+#define _GTKMM_ICONINFO_P_H
+#endif /* _GTKMM_ICONINFO_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/iconset_p.h b/libs/gtkmm2/gtk/gtkmm/private/iconset_p.h
new file mode 100644
index 0000000000..1e861df94c
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/iconset_p.h
@@ -0,0 +1,6 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_ICONSET_P_H
+#define _GTKMM_ICONSET_P_H
+#endif /* _GTKMM_ICONSET_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/iconsource_p.h b/libs/gtkmm2/gtk/gtkmm/private/iconsource_p.h
new file mode 100644
index 0000000000..304da67691
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/iconsource_p.h
@@ -0,0 +1,6 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_ICONSOURCE_P_H
+#define _GTKMM_ICONSOURCE_P_H
+#endif /* _GTKMM_ICONSOURCE_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/icontheme_p.h b/libs/gtkmm2/gtk/gtkmm/private/icontheme_p.h
new file mode 100644
index 0000000000..a54fdbc17e
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/icontheme_p.h
@@ -0,0 +1,45 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_ICONTHEME_P_H
+#define _GTKMM_ICONTHEME_P_H
+#include <glibmm/private/object_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class IconTheme_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef IconTheme CppObjectType;
+  typedef GtkIconTheme BaseObjectType;
+  typedef GtkIconThemeClass BaseClassType;
+  typedef Glib::Object_Class CppClassParent;
+  typedef GObjectClass BaseClassParent;
+
+  friend class IconTheme;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+  static void changed_callback(GtkIconTheme* self);
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_ICONTHEME_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/iconview_p.h b/libs/gtkmm2/gtk/gtkmm/private/iconview_p.h
new file mode 100644
index 0000000000..beed996eda
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/iconview_p.h
@@ -0,0 +1,47 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_ICONVIEW_P_H
+#define _GTKMM_ICONVIEW_P_H
+#include <gtkmm/private/container_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class IconView_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef IconView CppObjectType;
+  typedef GtkIconView BaseObjectType;
+  typedef GtkIconViewClass BaseClassType;
+  typedef Gtk::Container_Class CppClassParent;
+  typedef GtkContainerClass BaseClassParent;
+
+  friend class IconView;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+  static void set_scroll_adjustments_callback(GtkIconView* self, GtkAdjustment* p0, GtkAdjustment* p1);
+  static void item_activated_callback(GtkIconView* self, GtkTreePath* p0);
+  static void selection_changed_callback(GtkIconView* self);
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_ICONVIEW_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/image_p.h b/libs/gtkmm2/gtk/gtkmm/private/image_p.h
new file mode 100644
index 0000000000..c01599d6c7
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/image_p.h
@@ -0,0 +1,44 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_IMAGE_P_H
+#define _GTKMM_IMAGE_P_H
+#include <gtkmm/private/misc_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class Image_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Image CppObjectType;
+  typedef GtkImage BaseObjectType;
+  typedef GtkImageClass BaseClassType;
+  typedef Gtk::Misc_Class CppClassParent;
+  typedef GtkMiscClass BaseClassParent;
+
+  friend class Image;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_IMAGE_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/imagemenuitem_p.h b/libs/gtkmm2/gtk/gtkmm/private/imagemenuitem_p.h
new file mode 100644
index 0000000000..4099489f25
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/imagemenuitem_p.h
@@ -0,0 +1,44 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_IMAGEMENUITEM_P_H
+#define _GTKMM_IMAGEMENUITEM_P_H
+#include <gtkmm/private/menuitem_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class ImageMenuItem_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef ImageMenuItem CppObjectType;
+  typedef GtkImageMenuItem BaseObjectType;
+  typedef GtkImageMenuItemClass BaseClassType;
+  typedef Gtk::MenuItem_Class CppClassParent;
+  typedef GtkMenuItemClass BaseClassParent;
+
+  friend class ImageMenuItem;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_IMAGEMENUITEM_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/inputdialog_p.h b/libs/gtkmm2/gtk/gtkmm/private/inputdialog_p.h
new file mode 100644
index 0000000000..3197f6efb5
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/inputdialog_p.h
@@ -0,0 +1,46 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_INPUTDIALOG_P_H
+#define _GTKMM_INPUTDIALOG_P_H
+#include <gtkmm/private/dialog_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class InputDialog_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef InputDialog CppObjectType;
+  typedef GtkInputDialog BaseObjectType;
+  typedef GtkInputDialogClass BaseClassType;
+  typedef Gtk::Dialog_Class CppClassParent;
+  typedef GtkDialogClass BaseClassParent;
+
+  friend class InputDialog;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+  static void enable_device_callback(GtkInputDialog* self, GdkDevice* p0);
+  static void disable_device_callback(GtkInputDialog* self, GdkDevice* p0);
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_INPUTDIALOG_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/invisible_p.h b/libs/gtkmm2/gtk/gtkmm/private/invisible_p.h
new file mode 100644
index 0000000000..0709dc8989
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/invisible_p.h
@@ -0,0 +1,44 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_INVISIBLE_P_H
+#define _GTKMM_INVISIBLE_P_H
+#include <gtkmm/private/widget_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class Invisible_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Invisible CppObjectType;
+  typedef GtkInvisible BaseObjectType;
+  typedef GtkInvisibleClass BaseClassType;
+  typedef Gtk::Widget_Class CppClassParent;
+  typedef GtkWidgetClass BaseClassParent;
+
+  friend class Invisible;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_INVISIBLE_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/item_p.h b/libs/gtkmm2/gtk/gtkmm/private/item_p.h
new file mode 100644
index 0000000000..2baa4fa0de
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/item_p.h
@@ -0,0 +1,47 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_ITEM_P_H
+#define _GTKMM_ITEM_P_H
+#include <gtkmm/private/bin_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class Item_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Item CppObjectType;
+  typedef GtkItem BaseObjectType;
+  typedef GtkItemClass BaseClassType;
+  typedef Gtk::Bin_Class CppClassParent;
+  typedef GtkBinClass BaseClassParent;
+
+  friend class Item;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+  static void select_callback(GtkItem* self);
+  static void deselect_callback(GtkItem* self);
+  static void toggle_callback(GtkItem* self);
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_ITEM_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/label_p.h b/libs/gtkmm2/gtk/gtkmm/private/label_p.h
new file mode 100644
index 0000000000..5254aba319
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/label_p.h
@@ -0,0 +1,46 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_LABEL_P_H
+#define _GTKMM_LABEL_P_H
+#include <gtkmm/private/misc_p.h>
+#include <gtk/gtkmenu.h>
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class Label_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Label CppObjectType;
+  typedef GtkLabel BaseObjectType;
+  typedef GtkLabelClass BaseClassType;
+  typedef Gtk::Misc_Class CppClassParent;
+  typedef GtkMiscClass BaseClassParent;
+
+  friend class Label;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+  static void populate_popup_callback(GtkLabel* self, GtkMenu* p0);
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_LABEL_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/layout_p.h b/libs/gtkmm2/gtk/gtkmm/private/layout_p.h
new file mode 100644
index 0000000000..1c4c2773c5
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/layout_p.h
@@ -0,0 +1,45 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_LAYOUT_P_H
+#define _GTKMM_LAYOUT_P_H
+#include <gtkmm/private/container_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class Layout_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Layout CppObjectType;
+  typedef GtkLayout BaseObjectType;
+  typedef GtkLayoutClass BaseClassType;
+  typedef Gtk::Container_Class CppClassParent;
+  typedef GtkContainerClass BaseClassParent;
+
+  friend class Layout;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+  static void set_scroll_adjustments_callback(GtkLayout* self, GtkAdjustment* p0, GtkAdjustment* p1);
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_LAYOUT_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/liststore_p.h b/libs/gtkmm2/gtk/gtkmm/private/liststore_p.h
new file mode 100644
index 0000000000..522ec0b0ca
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/liststore_p.h
@@ -0,0 +1,44 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_LISTSTORE_P_H
+#define _GTKMM_LISTSTORE_P_H
+#include <glibmm/private/object_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class ListStore_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef ListStore CppObjectType;
+  typedef GtkListStore BaseObjectType;
+  typedef GtkListStoreClass BaseClassType;
+  typedef Glib::Object_Class CppClassParent;
+  typedef GObjectClass BaseClassParent;
+
+  friend class ListStore;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_LISTSTORE_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/main_p.h b/libs/gtkmm2/gtk/gtkmm/private/main_p.h
new file mode 100644
index 0000000000..a911a52b39
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/main_p.h
@@ -0,0 +1,6 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_MAIN_P_H
+#define _GTKMM_MAIN_P_H
+#endif /* _GTKMM_MAIN_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/menu_p.h b/libs/gtkmm2/gtk/gtkmm/private/menu_p.h
new file mode 100644
index 0000000000..97d6e21f30
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/menu_p.h
@@ -0,0 +1,44 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_MENU_P_H
+#define _GTKMM_MENU_P_H
+#include <gtkmm/private/menushell_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class Menu_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Menu CppObjectType;
+  typedef GtkMenu BaseObjectType;
+  typedef GtkMenuClass BaseClassType;
+  typedef Gtk::MenuShell_Class CppClassParent;
+  typedef GtkMenuShellClass BaseClassParent;
+
+  friend class Menu;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_MENU_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/menubar_p.h b/libs/gtkmm2/gtk/gtkmm/private/menubar_p.h
new file mode 100644
index 0000000000..e36353f8c6
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/menubar_p.h
@@ -0,0 +1,44 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_MENUBAR_P_H
+#define _GTKMM_MENUBAR_P_H
+#include <gtkmm/private/menushell_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class MenuBar_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef MenuBar CppObjectType;
+  typedef GtkMenuBar BaseObjectType;
+  typedef GtkMenuBarClass BaseClassType;
+  typedef Gtk::MenuShell_Class CppClassParent;
+  typedef GtkMenuShellClass BaseClassParent;
+
+  friend class MenuBar;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_MENUBAR_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/menuitem_p.h b/libs/gtkmm2/gtk/gtkmm/private/menuitem_p.h
new file mode 100644
index 0000000000..c900ddc67f
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/menuitem_p.h
@@ -0,0 +1,48 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_MENUITEM_P_H
+#define _GTKMM_MENUITEM_P_H
+#include <gtkmm/private/item_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class MenuItem_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef MenuItem CppObjectType;
+  typedef GtkMenuItem BaseObjectType;
+  typedef GtkMenuItemClass BaseClassType;
+  typedef Gtk::Item_Class CppClassParent;
+  typedef GtkItemClass BaseClassParent;
+
+  friend class MenuItem;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+  static void activate_callback(GtkMenuItem* self);
+  static void activate_item_callback(GtkMenuItem* self);
+  static void toggle_size_request_callback(GtkMenuItem* self, int* p0);
+  static void toggle_size_allocate_callback(GtkMenuItem* self, gint p0);
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_MENUITEM_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/menushell_p.h b/libs/gtkmm2/gtk/gtkmm/private/menushell_p.h
new file mode 100644
index 0000000000..676e85d40e
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/menushell_p.h
@@ -0,0 +1,50 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_MENUSHELL_P_H
+#define _GTKMM_MENUSHELL_P_H
+#include <gtkmm/private/container_p.h>
+#include <gtkmm/menu.h>
+#include <gtkmm/menubar.h>
+#include <gtkmm/window.h>
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class MenuShell_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef MenuShell CppObjectType;
+  typedef GtkMenuShell BaseObjectType;
+  typedef GtkMenuShellClass BaseClassType;
+  typedef Gtk::Container_Class CppClassParent;
+  typedef GtkContainerClass BaseClassParent;
+
+  friend class MenuShell;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+  static void deactivate_callback(GtkMenuShell* self);
+  static void selection_done_callback(GtkMenuShell* self);
+
+  //Callbacks (virtual functions):
+    static void insert_vfunc_callback(GtkMenuShell* self, GtkWidget* child, int position);
+  };
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_MENUSHELL_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/menutoolbutton_p.h b/libs/gtkmm2/gtk/gtkmm/private/menutoolbutton_p.h
new file mode 100644
index 0000000000..401e1b5242
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/menutoolbutton_p.h
@@ -0,0 +1,45 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_MENUTOOLBUTTON_P_H
+#define _GTKMM_MENUTOOLBUTTON_P_H
+#include <gtkmm/private/toolbutton_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class MenuToolButton_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef MenuToolButton CppObjectType;
+  typedef GtkMenuToolButton BaseObjectType;
+  typedef GtkMenuToolButtonClass BaseClassType;
+  typedef Gtk::ToolButton_Class CppClassParent;
+  typedef GtkToolButtonClass BaseClassParent;
+
+  friend class MenuToolButton;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+  static void show_menu_callback(GtkMenuToolButton* self);
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_MENUTOOLBUTTON_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/messagedialog_p.h b/libs/gtkmm2/gtk/gtkmm/private/messagedialog_p.h
new file mode 100644
index 0000000000..829b79c77e
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/messagedialog_p.h
@@ -0,0 +1,44 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_MESSAGEDIALOG_P_H
+#define _GTKMM_MESSAGEDIALOG_P_H
+#include <gtkmm/private/dialog_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class MessageDialog_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef MessageDialog CppObjectType;
+  typedef GtkMessageDialog BaseObjectType;
+  typedef GtkMessageDialogClass BaseClassType;
+  typedef Gtk::Dialog_Class CppClassParent;
+  typedef GtkDialogClass BaseClassParent;
+
+  friend class MessageDialog;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_MESSAGEDIALOG_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/misc_p.h b/libs/gtkmm2/gtk/gtkmm/private/misc_p.h
new file mode 100644
index 0000000000..adeb898dfe
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/misc_p.h
@@ -0,0 +1,44 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_MISC_P_H
+#define _GTKMM_MISC_P_H
+#include <gtkmm/private/widget_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class Misc_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Misc CppObjectType;
+  typedef GtkMisc BaseObjectType;
+  typedef GtkMiscClass BaseClassType;
+  typedef Gtk::Widget_Class CppClassParent;
+  typedef GtkWidgetClass BaseClassParent;
+
+  friend class Misc;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_MISC_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/notebook_p.h b/libs/gtkmm2/gtk/gtkmm/private/notebook_p.h
new file mode 100644
index 0000000000..de761d21c9
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/notebook_p.h
@@ -0,0 +1,45 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_NOTEBOOK_P_H
+#define _GTKMM_NOTEBOOK_P_H
+#include <gtkmm/private/container_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class Notebook_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Notebook CppObjectType;
+  typedef GtkNotebook BaseObjectType;
+  typedef GtkNotebookClass BaseClassType;
+  typedef Gtk::Container_Class CppClassParent;
+  typedef GtkContainerClass BaseClassParent;
+
+  friend class Notebook;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+  static void switch_page_callback(GtkNotebook* self, GtkNotebookPage* p0, guint p1);
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_NOTEBOOK_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/object_p.h b/libs/gtkmm2/gtk/gtkmm/private/object_p.h
new file mode 100644
index 0000000000..dc4ba98bef
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/object_p.h
@@ -0,0 +1,44 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_OBJECT_P_H
+#define _GTKMM_OBJECT_P_H
+#include <glibmm/private/object_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class Object_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Object CppObjectType;
+  typedef GtkObject BaseObjectType;
+  typedef GtkObjectClass BaseClassType;
+  typedef Glib::Object_Class CppClassParent;
+  typedef GObjectClass BaseClassParent;
+
+  friend class Object;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_OBJECT_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/optionmenu_p.h b/libs/gtkmm2/gtk/gtkmm/private/optionmenu_p.h
new file mode 100644
index 0000000000..414d3e631d
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/optionmenu_p.h
@@ -0,0 +1,45 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_OPTIONMENU_P_H
+#define _GTKMM_OPTIONMENU_P_H
+#include <gtkmm/private/button_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class OptionMenu_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef OptionMenu CppObjectType;
+  typedef GtkOptionMenu BaseObjectType;
+  typedef GtkOptionMenuClass BaseClassType;
+  typedef Gtk::Button_Class CppClassParent;
+  typedef GtkButtonClass BaseClassParent;
+
+  friend class OptionMenu;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+  static void changed_callback(GtkOptionMenu* self);
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_OPTIONMENU_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/paned_p.h b/libs/gtkmm2/gtk/gtkmm/private/paned_p.h
new file mode 100644
index 0000000000..8d8af1f20d
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/paned_p.h
@@ -0,0 +1,118 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_PANED_P_H
+#define _GTKMM_PANED_P_H
+#include <gtkmm/private/container_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class Paned_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Paned CppObjectType;
+  typedef GtkPaned BaseObjectType;
+  typedef GtkPanedClass BaseClassType;
+  typedef Gtk::Container_Class CppClassParent;
+  typedef GtkContainerClass BaseClassParent;
+
+  friend class Paned;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class HPaned_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef HPaned CppObjectType;
+  typedef GtkHPaned BaseObjectType;
+  typedef GtkHPanedClass BaseClassType;
+  typedef Gtk::Paned_Class CppClassParent;
+  typedef GtkPanedClass BaseClassParent;
+
+  friend class HPaned;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class VPaned_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef VPaned CppObjectType;
+  typedef GtkVPaned BaseObjectType;
+  typedef GtkVPanedClass BaseClassType;
+  typedef Gtk::Paned_Class CppClassParent;
+  typedef GtkPanedClass BaseClassParent;
+
+  friend class VPaned;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_PANED_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/plug_p.h b/libs/gtkmm2/gtk/gtkmm/private/plug_p.h
new file mode 100644
index 0000000000..86c6e9b3f6
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/plug_p.h
@@ -0,0 +1,45 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_PLUG_P_H
+#define _GTKMM_PLUG_P_H
+#include <gtkmm/private/window_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class Plug_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Plug CppObjectType;
+  typedef GtkPlug BaseObjectType;
+  typedef GtkPlugClass BaseClassType;
+  typedef Gtk::Window_Class CppClassParent;
+  typedef GtkWindowClass BaseClassParent;
+
+  friend class Plug;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+  static void embedded_callback(GtkPlug* self);
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_PLUG_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/progressbar_p.h b/libs/gtkmm2/gtk/gtkmm/private/progressbar_p.h
new file mode 100644
index 0000000000..783de015ea
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/progressbar_p.h
@@ -0,0 +1,45 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_PROGRESSBAR_P_H
+#define _GTKMM_PROGRESSBAR_P_H
+#include <gtkmm/private/widget_p.h>
+#include <gtk/gtkprogress.h>
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class ProgressBar_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef ProgressBar CppObjectType;
+  typedef GtkProgressBar BaseObjectType;
+  typedef GtkProgressBarClass BaseClassType;
+  typedef Gtk::Widget_Class CppClassParent;
+  typedef GtkProgressClass BaseClassParent;
+
+  friend class ProgressBar;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_PROGRESSBAR_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/radioaction_p.h b/libs/gtkmm2/gtk/gtkmm/private/radioaction_p.h
new file mode 100644
index 0000000000..ab9ae13b95
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/radioaction_p.h
@@ -0,0 +1,45 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_RADIOACTION_P_H
+#define _GTKMM_RADIOACTION_P_H
+#include <gtkmm/private/toggleaction_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class RadioAction_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef RadioAction CppObjectType;
+  typedef GtkRadioAction BaseObjectType;
+  typedef GtkRadioActionClass BaseClassType;
+  typedef Gtk::ToggleAction_Class CppClassParent;
+  typedef GtkToggleActionClass BaseClassParent;
+
+  friend class RadioAction;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+  static void changed_callback(GtkRadioAction* self, GtkRadioAction* p0);
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_RADIOACTION_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/radiobutton_p.h b/libs/gtkmm2/gtk/gtkmm/private/radiobutton_p.h
new file mode 100644
index 0000000000..bb0797be6c
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/radiobutton_p.h
@@ -0,0 +1,45 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_RADIOBUTTON_P_H
+#define _GTKMM_RADIOBUTTON_P_H
+#include <gtkmm/private/checkbutton_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class RadioButton_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef RadioButton CppObjectType;
+  typedef GtkRadioButton BaseObjectType;
+  typedef GtkRadioButtonClass BaseClassType;
+  typedef Gtk::CheckButton_Class CppClassParent;
+  typedef GtkCheckButtonClass BaseClassParent;
+
+  friend class RadioButton;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+  static void group_changed_callback(GtkRadioButton* self);
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_RADIOBUTTON_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/radiomenuitem_p.h b/libs/gtkmm2/gtk/gtkmm/private/radiomenuitem_p.h
new file mode 100644
index 0000000000..aa49592fc7
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/radiomenuitem_p.h
@@ -0,0 +1,45 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_RADIOMENUITEM_P_H
+#define _GTKMM_RADIOMENUITEM_P_H
+#include <gtkmm/private/checkmenuitem_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class RadioMenuItem_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef RadioMenuItem CppObjectType;
+  typedef GtkRadioMenuItem BaseObjectType;
+  typedef GtkRadioMenuItemClass BaseClassType;
+  typedef Gtk::CheckMenuItem_Class CppClassParent;
+  typedef GtkCheckMenuItemClass BaseClassParent;
+
+  friend class RadioMenuItem;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+  static void group_changed_callback(GtkRadioMenuItem* self);
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_RADIOMENUITEM_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/radiotoolbutton_p.h b/libs/gtkmm2/gtk/gtkmm/private/radiotoolbutton_p.h
new file mode 100644
index 0000000000..034902a829
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/radiotoolbutton_p.h
@@ -0,0 +1,44 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_RADIOTOOLBUTTON_P_H
+#define _GTKMM_RADIOTOOLBUTTON_P_H
+#include <gtkmm/private/toggletoolbutton_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class RadioToolButton_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef RadioToolButton CppObjectType;
+  typedef GtkRadioToolButton BaseObjectType;
+  typedef GtkRadioToolButtonClass BaseClassType;
+  typedef Gtk::ToggleToolButton_Class CppClassParent;
+  typedef GtkToggleToolButtonClass BaseClassParent;
+
+  friend class RadioToolButton;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_RADIOTOOLBUTTON_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/range_p.h b/libs/gtkmm2/gtk/gtkmm/private/range_p.h
new file mode 100644
index 0000000000..78c6b0c5a3
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/range_p.h
@@ -0,0 +1,48 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_RANGE_P_H
+#define _GTKMM_RANGE_P_H
+#include <gtkmm/private/widget_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class Range_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Range CppObjectType;
+  typedef GtkRange BaseObjectType;
+  typedef GtkRangeClass BaseClassType;
+  typedef Gtk::Widget_Class CppClassParent;
+  typedef GtkWidgetClass BaseClassParent;
+
+  friend class Range;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+  static void value_changed_callback(GtkRange* self);
+  static void adjust_bounds_callback(GtkRange* self, gdouble p0);
+  static void move_slider_callback(GtkRange* self, GtkScrollType p0);
+
+  //Callbacks (virtual functions):
+  static void get_range_border_vfunc_callback(GtkRange* self, GtkBorder* border);
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_RANGE_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/rc_p.h b/libs/gtkmm2/gtk/gtkmm/private/rc_p.h
new file mode 100644
index 0000000000..963495fb4f
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/rc_p.h
@@ -0,0 +1,44 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_RC_P_H
+#define _GTKMM_RC_P_H
+#include <glibmm/private/object_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class RcStyle_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef RcStyle CppObjectType;
+  typedef GtkRcStyle BaseObjectType;
+  typedef GtkRcStyleClass BaseClassType;
+  typedef Glib::Object_Class CppClassParent;
+  typedef GObjectClass BaseClassParent;
+
+  friend class RcStyle;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_RC_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/ruler_p.h b/libs/gtkmm2/gtk/gtkmm/private/ruler_p.h
new file mode 100644
index 0000000000..9c44986646
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/ruler_p.h
@@ -0,0 +1,120 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_RULER_P_H
+#define _GTKMM_RULER_P_H
+#include <gtkmm/private/widget_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class Ruler_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Ruler CppObjectType;
+  typedef GtkRuler BaseObjectType;
+  typedef GtkRulerClass BaseClassType;
+  typedef Gtk::Widget_Class CppClassParent;
+  typedef GtkWidgetClass BaseClassParent;
+
+  friend class Ruler;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+  static void draw_ticks_vfunc_callback(GtkRuler* self);
+  static void draw_pos_vfunc_callback(GtkRuler* self);
+};
+
+
+} // namespace Gtk
+
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class VRuler_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef VRuler CppObjectType;
+  typedef GtkVRuler BaseObjectType;
+  typedef GtkVRulerClass BaseClassType;
+  typedef Gtk::Ruler_Class CppClassParent;
+  typedef GtkRulerClass BaseClassParent;
+
+  friend class VRuler;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class HRuler_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef HRuler CppObjectType;
+  typedef GtkHRuler BaseObjectType;
+  typedef GtkHRulerClass BaseClassType;
+  typedef Gtk::Ruler_Class CppClassParent;
+  typedef GtkRulerClass BaseClassParent;
+
+  friend class HRuler;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_RULER_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/scale_p.h b/libs/gtkmm2/gtk/gtkmm/private/scale_p.h
new file mode 100644
index 0000000000..aa5dddf050
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/scale_p.h
@@ -0,0 +1,120 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_SCALE_P_H
+#define _GTKMM_SCALE_P_H
+#include <gtkmm/private/range_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class Scale_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Scale CppObjectType;
+  typedef GtkScale BaseObjectType;
+  typedef GtkScaleClass BaseClassType;
+  typedef Gtk::Range_Class CppClassParent;
+  typedef GtkRangeClass BaseClassParent;
+
+  friend class Scale;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+  static gchar* format_value_callback(GtkScale* self, gdouble p0);
+
+  //Callbacks (virtual functions):
+  static void draw_value_vfunc_callback(GtkScale* self);
+};
+
+
+} // namespace Gtk
+
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class VScale_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef VScale CppObjectType;
+  typedef GtkVScale BaseObjectType;
+  typedef GtkVScaleClass BaseClassType;
+  typedef Gtk::Scale_Class CppClassParent;
+  typedef GtkScaleClass BaseClassParent;
+
+  friend class VScale;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class HScale_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef HScale CppObjectType;
+  typedef GtkHScale BaseObjectType;
+  typedef GtkHScaleClass BaseClassType;
+  typedef Gtk::Scale_Class CppClassParent;
+  typedef GtkScaleClass BaseClassParent;
+
+  friend class HScale;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_SCALE_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/scrollbar_p.h b/libs/gtkmm2/gtk/gtkmm/private/scrollbar_p.h
new file mode 100644
index 0000000000..4781e3f466
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/scrollbar_p.h
@@ -0,0 +1,118 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_SCROLLBAR_P_H
+#define _GTKMM_SCROLLBAR_P_H
+#include <gtkmm/private/range_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class Scrollbar_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Scrollbar CppObjectType;
+  typedef GtkScrollbar BaseObjectType;
+  typedef GtkScrollbarClass BaseClassType;
+  typedef Gtk::Range_Class CppClassParent;
+  typedef GtkRangeClass BaseClassParent;
+
+  friend class Scrollbar;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class VScrollbar_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef VScrollbar CppObjectType;
+  typedef GtkVScrollbar BaseObjectType;
+  typedef GtkVScrollbarClass BaseClassType;
+  typedef Gtk::Scrollbar_Class CppClassParent;
+  typedef GtkScrollbarClass BaseClassParent;
+
+  friend class VScrollbar;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class HScrollbar_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef HScrollbar CppObjectType;
+  typedef GtkHScrollbar BaseObjectType;
+  typedef GtkHScrollbarClass BaseClassType;
+  typedef Gtk::Scrollbar_Class CppClassParent;
+  typedef GtkScrollbarClass BaseClassParent;
+
+  friend class HScrollbar;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_SCROLLBAR_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/scrolledwindow_p.h b/libs/gtkmm2/gtk/gtkmm/private/scrolledwindow_p.h
new file mode 100644
index 0000000000..f66dde8f03
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/scrolledwindow_p.h
@@ -0,0 +1,44 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_SCROLLEDWINDOW_P_H
+#define _GTKMM_SCROLLEDWINDOW_P_H
+#include <gtkmm/private/bin_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class ScrolledWindow_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef ScrolledWindow CppObjectType;
+  typedef GtkScrolledWindow BaseObjectType;
+  typedef GtkScrolledWindowClass BaseClassType;
+  typedef Gtk::Bin_Class CppClassParent;
+  typedef GtkBinClass BaseClassParent;
+
+  friend class ScrolledWindow;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_SCROLLEDWINDOW_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/selectiondata_p.h b/libs/gtkmm2/gtk/gtkmm/private/selectiondata_p.h
new file mode 100644
index 0000000000..cb52061df2
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/selectiondata_p.h
@@ -0,0 +1,6 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_SELECTIONDATA_P_H
+#define _GTKMM_SELECTIONDATA_P_H
+#endif /* _GTKMM_SELECTIONDATA_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/separator_p.h b/libs/gtkmm2/gtk/gtkmm/private/separator_p.h
new file mode 100644
index 0000000000..a82c02557d
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/separator_p.h
@@ -0,0 +1,118 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_SEPARATOR_P_H
+#define _GTKMM_SEPARATOR_P_H
+#include <gtkmm/private/widget_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class Separator_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Separator CppObjectType;
+  typedef GtkSeparator BaseObjectType;
+  typedef GtkSeparatorClass BaseClassType;
+  typedef Gtk::Widget_Class CppClassParent;
+  typedef GtkWidgetClass BaseClassParent;
+
+  friend class Separator;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class VSeparator_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef VSeparator CppObjectType;
+  typedef GtkVSeparator BaseObjectType;
+  typedef GtkVSeparatorClass BaseClassType;
+  typedef Gtk::Separator_Class CppClassParent;
+  typedef GtkSeparatorClass BaseClassParent;
+
+  friend class VSeparator;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class HSeparator_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef HSeparator CppObjectType;
+  typedef GtkHSeparator BaseObjectType;
+  typedef GtkHSeparatorClass BaseClassType;
+  typedef Gtk::Separator_Class CppClassParent;
+  typedef GtkSeparatorClass BaseClassParent;
+
+  friend class HSeparator;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_SEPARATOR_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/separatormenuitem_p.h b/libs/gtkmm2/gtk/gtkmm/private/separatormenuitem_p.h
new file mode 100644
index 0000000000..1987425009
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/separatormenuitem_p.h
@@ -0,0 +1,44 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_SEPARATORMENUITEM_P_H
+#define _GTKMM_SEPARATORMENUITEM_P_H
+#include <gtkmm/private/menuitem_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class SeparatorMenuItem_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef SeparatorMenuItem CppObjectType;
+  typedef GtkSeparatorMenuItem BaseObjectType;
+  typedef GtkSeparatorMenuItemClass BaseClassType;
+  typedef Gtk::MenuItem_Class CppClassParent;
+  typedef GtkMenuItemClass BaseClassParent;
+
+  friend class SeparatorMenuItem;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_SEPARATORMENUITEM_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/separatortoolitem_p.h b/libs/gtkmm2/gtk/gtkmm/private/separatortoolitem_p.h
new file mode 100644
index 0000000000..5de5fc7e88
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/separatortoolitem_p.h
@@ -0,0 +1,44 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_SEPARATORTOOLITEM_P_H
+#define _GTKMM_SEPARATORTOOLITEM_P_H
+#include <gtkmm/private/toolitem_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class SeparatorToolItem_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef SeparatorToolItem CppObjectType;
+  typedef GtkSeparatorToolItem BaseObjectType;
+  typedef GtkSeparatorToolItemClass BaseClassType;
+  typedef Gtk::ToolItem_Class CppClassParent;
+  typedef GtkToolItemClass BaseClassParent;
+
+  friend class SeparatorToolItem;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_SEPARATORTOOLITEM_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/settings_p.h b/libs/gtkmm2/gtk/gtkmm/private/settings_p.h
new file mode 100644
index 0000000000..72e13b447a
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/settings_p.h
@@ -0,0 +1,44 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_SETTINGS_P_H
+#define _GTKMM_SETTINGS_P_H
+#include <glibmm/private/object_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class Settings_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Settings CppObjectType;
+  typedef GtkSettings BaseObjectType;
+  typedef GtkSettingsClass BaseClassType;
+  typedef Glib::Object_Class CppClassParent;
+  typedef GObjectClass BaseClassParent;
+
+  friend class Settings;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_SETTINGS_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/sizegroup_p.h b/libs/gtkmm2/gtk/gtkmm/private/sizegroup_p.h
new file mode 100644
index 0000000000..f33b8bdf58
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/sizegroup_p.h
@@ -0,0 +1,44 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_SIZEGROUP_P_H
+#define _GTKMM_SIZEGROUP_P_H
+#include <glibmm/private/object_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class SizeGroup_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef SizeGroup CppObjectType;
+  typedef GtkSizeGroup BaseObjectType;
+  typedef GtkSizeGroupClass BaseClassType;
+  typedef Glib::Object_Class CppClassParent;
+  typedef GObjectClass BaseClassParent;
+
+  friend class SizeGroup;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_SIZEGROUP_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/socket_p.h b/libs/gtkmm2/gtk/gtkmm/private/socket_p.h
new file mode 100644
index 0000000000..5689897e40
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/socket_p.h
@@ -0,0 +1,46 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_SOCKET_P_H
+#define _GTKMM_SOCKET_P_H
+#include <gtkmm/private/container_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class Socket_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Socket CppObjectType;
+  typedef GtkSocket BaseObjectType;
+  typedef GtkSocketClass BaseClassType;
+  typedef Gtk::Container_Class CppClassParent;
+  typedef GtkContainerClass BaseClassParent;
+
+  friend class Socket;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+  static void plug_added_callback(GtkSocket* self);
+  static gboolean plug_removed_callback(GtkSocket* self);
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_SOCKET_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/spinbutton_p.h b/libs/gtkmm2/gtk/gtkmm/private/spinbutton_p.h
new file mode 100644
index 0000000000..f69aee70cf
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/spinbutton_p.h
@@ -0,0 +1,47 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_SPINBUTTON_P_H
+#define _GTKMM_SPINBUTTON_P_H
+#include <gtkmm/private/entry_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class SpinButton_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef SpinButton CppObjectType;
+  typedef GtkSpinButton BaseObjectType;
+  typedef GtkSpinButtonClass BaseClassType;
+  typedef Gtk::Entry_Class CppClassParent;
+  typedef GtkEntryClass BaseClassParent;
+
+  friend class SpinButton;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+  static gint input_callback(GtkSpinButton* self, gdouble* p0);
+  static gboolean output_callback(GtkSpinButton* self);
+  static void value_changed_callback(GtkSpinButton* self);
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_SPINBUTTON_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/statusbar_p.h b/libs/gtkmm2/gtk/gtkmm/private/statusbar_p.h
new file mode 100644
index 0000000000..23efc95695
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/statusbar_p.h
@@ -0,0 +1,46 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_STATUSBAR_P_H
+#define _GTKMM_STATUSBAR_P_H
+#include <gtkmm/private/box_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class Statusbar_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Statusbar CppObjectType;
+  typedef GtkStatusbar BaseObjectType;
+  typedef GtkStatusbarClass BaseClassType;
+  typedef Gtk::HBox_Class CppClassParent;
+  typedef GtkHBoxClass BaseClassParent;
+
+  friend class Statusbar;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+  static void text_pushed_callback(GtkStatusbar* self, guint p0, const gchar* p1);
+  static void text_popped_callback(GtkStatusbar* self, guint p0, const gchar* p1);
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_STATUSBAR_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/stockitem_p.h b/libs/gtkmm2/gtk/gtkmm/private/stockitem_p.h
new file mode 100644
index 0000000000..0ac19c3f37
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/stockitem_p.h
@@ -0,0 +1,6 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_STOCKITEM_P_H
+#define _GTKMM_STOCKITEM_P_H
+#endif /* _GTKMM_STOCKITEM_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/style_p.h b/libs/gtkmm2/gtk/gtkmm/private/style_p.h
new file mode 100644
index 0000000000..8c10fca392
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/style_p.h
@@ -0,0 +1,75 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_STYLE_P_H
+#define _GTKMM_STYLE_P_H
+#include <glibmm/private/object_p.h>
+#include <gtk/gtkrc.h>
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class Style_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Style CppObjectType;
+  typedef GtkStyle BaseObjectType;
+  typedef GtkStyleClass BaseClassType;
+  typedef Glib::Object_Class CppClassParent;
+  typedef GObjectClass BaseClassParent;
+
+  friend class Style;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+  static void realize_callback(GtkStyle* self);
+  static void unrealize_callback(GtkStyle* self);
+
+  //Callbacks (virtual functions):
+  static void realize_vfunc_callback(GtkStyle* self);
+  static void unrealize_vfunc_callback(GtkStyle* self);
+  static void copy_vfunc_callback(GtkStyle* self, GtkStyle* src);
+  static GtkStyle* clone_vfunc_callback(GtkStyle* self);
+  static void init_from_rc_vfunc_callback(GtkStyle* self, GtkRcStyle* rc_style);
+  static void set_background_vfunc_callback(GtkStyle* self, GdkWindow* window, GtkStateType state_type);
+  static GdkPixbuf* render_icon_vfunc_callback(GtkStyle* self, const GtkIconSource* source, GtkTextDirection direction, GtkStateType state, GtkIconSize size, GtkWidget* widget, const gchar* detail);
+  static void draw_hline_vfunc_callback(GtkStyle* self, GdkWindow* window, GtkStateType state_type, GdkRectangle* area, GtkWidget* widget, const gchar* detail, gint x1, gint x2, gint y);
+  static void draw_vline_vfunc_callback(GtkStyle* self, GdkWindow* window, GtkStateType state_type, GdkRectangle* area, GtkWidget* widget, const gchar* detail, gint y1, gint y2, gint x);
+  static void draw_shadow_vfunc_callback(GtkStyle* self, GdkWindow* window, GtkStateType state_type, GtkShadowType shadow_type, GdkRectangle* area, GtkWidget* widget, const gchar* detail, gint x, gint y, gint width, gint height);
+  static void draw_polygon_vfunc_callback(GtkStyle* self, GdkWindow* window, GtkStateType state_type, GtkShadowType shadow_type, GdkRectangle* area, GtkWidget* widget, const gchar* detail, GdkPoint* point, gint npoints, gboolean fill);
+  static void draw_arrow_vfunc_callback(GtkStyle* self, GdkWindow* window, GtkStateType state_type, GtkShadowType shadow_type, GdkRectangle* area, GtkWidget* widget, const gchar* detail, GtkArrowType arrow_type, gboolean fill, gint x, gint y, gint width, gint height);
+  static void draw_diamond_vfunc_callback(GtkStyle* self, GdkWindow* window, GtkStateType state_type, GtkShadowType shadow_type, GdkRectangle* area, GtkWidget* widget, const gchar* detail, gint x, gint y, gint width, gint height);
+  static void draw_string_vfunc_callback(GtkStyle* self, GdkWindow* window, GtkStateType state_type, GdkRectangle* area, GtkWidget* widget, const gchar* detail, gint x, gint y, const gchar* string);
+  static void draw_box_vfunc_callback(GtkStyle* self, GdkWindow* window, GtkStateType state_type, GtkShadowType shadow_type, GdkRectangle* area, GtkWidget* widget, const gchar* detail, gint x, gint y, gint width, gint height);
+  static void draw_flat_box_vfunc_callback(GtkStyle* self, GdkWindow* window, GtkStateType state_type, GtkShadowType shadow_type, GdkRectangle* area, GtkWidget* widget, const gchar* detail, gint x, gint y, gint width, gint height);
+  static void draw_check_vfunc_callback(GtkStyle* self, GdkWindow* window, GtkStateType state_type, GtkShadowType shadow_type, GdkRectangle* area, GtkWidget* widget, const gchar* detail, gint x, gint y, gint width, gint height);
+  static void draw_option_vfunc_callback(GtkStyle* self, GdkWindow* window, GtkStateType state_type, GtkShadowType shadow_type, GdkRectangle* area, GtkWidget* widget, const gchar* detail, gint x, gint y, gint width, gint height);
+  static void draw_tab_vfunc_callback(GtkStyle* self, GdkWindow* window, GtkStateType state_type, GtkShadowType shadow_type, GdkRectangle* area, GtkWidget* widget, const gchar* detail, gint x, gint y, gint width, gint height);
+  static void draw_shadow_gap_vfunc_callback(GtkStyle* self, GdkWindow* window, GtkStateType state_type, GtkShadowType shadow_type, GdkRectangle* area, GtkWidget* widget, const gchar* detail, gint x, gint y, gint width, gint height, GtkPositionType gap_side, gint gap_x, gint gap_width);
+  static void draw_box_gap_vfunc_callback(GtkStyle* self, GdkWindow* window, GtkStateType state_type, GtkShadowType shadow_type, GdkRectangle* area, GtkWidget* widget, const gchar* detail, gint x, gint y, gint width, gint height, GtkPositionType gap_side, gint gap_x, gint gap_width);
+  static void draw_extension_vfunc_callback(GtkStyle* self, GdkWindow* window, GtkStateType state_type, GtkShadowType shadow_type, GdkRectangle* area, GtkWidget* widget, const gchar* detail, gint x, gint y, gint width, gint height, GtkPositionType gap_side);
+  static void draw_focus_vfunc_callback(GtkStyle* self, GdkWindow* window, GtkStateType state_type, GdkRectangle* area, GtkWidget* widget, const gchar* detail, gint x, gint y, gint width, gint height);
+  static void draw_slider_vfunc_callback(GtkStyle* self, GdkWindow* window, GtkStateType state_type, GtkShadowType shadow_type, GdkRectangle* area, GtkWidget* widget, const gchar* detail, gint x, gint y, gint width, gint height, GtkOrientation orientation);
+  static void draw_handle_vfunc_callback(GtkStyle* self, GdkWindow* window, GtkStateType state_type, GtkShadowType shadow_type, GdkRectangle* area, GtkWidget* widget, const gchar* detail, gint x, gint y, gint width, gint height, GtkOrientation orientation);
+  static void draw_expander_vfunc_callback(GtkStyle* self, GdkWindow* window, GtkStateType state_type, GdkRectangle* area, GtkWidget* widget, const gchar* detail, gint x, gint y, GtkExpanderStyle expander_style);
+  static void draw_layout_vfunc_callback(GtkStyle* self, GdkWindow* window, GtkStateType state_type, gboolean use_text, GdkRectangle* area, GtkWidget* widget, const gchar* detail, gint x, gint y, PangoLayout* layout);
+  static void draw_resize_grip_vfunc_callback(GtkStyle* self, GdkWindow* window, GtkStateType state_type, GdkRectangle* area, GtkWidget* widget, const gchar* detail, GdkWindowEdge edge, gint x, gint y, gint width, gint height);
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_STYLE_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/table_p.h b/libs/gtkmm2/gtk/gtkmm/private/table_p.h
new file mode 100644
index 0000000000..8fae19b7cf
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/table_p.h
@@ -0,0 +1,44 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_TABLE_P_H
+#define _GTKMM_TABLE_P_H
+#include <gtkmm/private/container_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class Table_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Table CppObjectType;
+  typedef GtkTable BaseObjectType;
+  typedef GtkTableClass BaseClassType;
+  typedef Gtk::Container_Class CppClassParent;
+  typedef GtkContainerClass BaseClassParent;
+
+  friend class Table;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_TABLE_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/targetlist_p.h b/libs/gtkmm2/gtk/gtkmm/private/targetlist_p.h
new file mode 100644
index 0000000000..508f488cfd
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/targetlist_p.h
@@ -0,0 +1,6 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_TARGETLIST_P_H
+#define _GTKMM_TARGETLIST_P_H
+#endif /* _GTKMM_TARGETLIST_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/tearoffmenuitem_p.h b/libs/gtkmm2/gtk/gtkmm/private/tearoffmenuitem_p.h
new file mode 100644
index 0000000000..e6378ac638
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/tearoffmenuitem_p.h
@@ -0,0 +1,44 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_TEAROFFMENUITEM_P_H
+#define _GTKMM_TEAROFFMENUITEM_P_H
+#include <gtkmm/private/menuitem_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class TearoffMenuItem_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef TearoffMenuItem CppObjectType;
+  typedef GtkTearoffMenuItem BaseObjectType;
+  typedef GtkTearoffMenuItemClass BaseClassType;
+  typedef Gtk::MenuItem_Class CppClassParent;
+  typedef GtkMenuItemClass BaseClassParent;
+
+  friend class TearoffMenuItem;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_TEAROFFMENUITEM_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/textattributes_p.h b/libs/gtkmm2/gtk/gtkmm/private/textattributes_p.h
new file mode 100644
index 0000000000..4b922c4c44
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/textattributes_p.h
@@ -0,0 +1,6 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_TEXTATTRIBUTES_P_H
+#define _GTKMM_TEXTATTRIBUTES_P_H
+#endif /* _GTKMM_TEXTATTRIBUTES_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/textbuffer_p.h b/libs/gtkmm2/gtk/gtkmm/private/textbuffer_p.h
new file mode 100644
index 0000000000..59db070205
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/textbuffer_p.h
@@ -0,0 +1,56 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_TEXTBUFFER_P_H
+#define _GTKMM_TEXTBUFFER_P_H
+#include <glibmm/private/object_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class TextBuffer_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef TextBuffer CppObjectType;
+  typedef GtkTextBuffer BaseObjectType;
+  typedef GtkTextBufferClass BaseClassType;
+  typedef Glib::Object_Class CppClassParent;
+  typedef GObjectClass BaseClassParent;
+
+  friend class TextBuffer;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+  static void insert_text_callback(GtkTextBuffer* self, GtkTextIter* p0, const gchar* p1, gint p2);
+  static void insert_pixbuf_callback(GtkTextBuffer* self, GtkTextIter* p0, GdkPixbuf* p1);
+  static void insert_child_anchor_callback(GtkTextBuffer* self, GtkTextIter* p0, GtkTextChildAnchor* p1);
+  static void delete_range_callback(GtkTextBuffer* self, GtkTextIter* p0, GtkTextIter* p1);
+  static void changed_callback(GtkTextBuffer* self);
+  static void modified_changed_callback(GtkTextBuffer* self);
+  static void mark_set_callback(GtkTextBuffer* self, const GtkTextIter* p0, GtkTextMark* p1);
+  static void mark_deleted_callback(GtkTextBuffer* self, GtkTextMark* p0);
+  static void apply_tag_callback(GtkTextBuffer* self, GtkTextTag* p0, const GtkTextIter* p1, const GtkTextIter* p2);
+  static void remove_tag_callback(GtkTextBuffer* self, GtkTextTag* p0, const GtkTextIter* p1, const GtkTextIter* p2);
+  static void begin_user_action_callback(GtkTextBuffer* self);
+  static void end_user_action_callback(GtkTextBuffer* self);
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_TEXTBUFFER_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/textchildanchor_p.h b/libs/gtkmm2/gtk/gtkmm/private/textchildanchor_p.h
new file mode 100644
index 0000000000..a3a9822c45
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/textchildanchor_p.h
@@ -0,0 +1,44 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_TEXTCHILDANCHOR_P_H
+#define _GTKMM_TEXTCHILDANCHOR_P_H
+#include <glibmm/private/object_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class TextChildAnchor_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef TextChildAnchor CppObjectType;
+  typedef GtkTextChildAnchor BaseObjectType;
+  typedef GtkTextChildAnchorClass BaseClassType;
+  typedef Glib::Object_Class CppClassParent;
+  typedef GObjectClass BaseClassParent;
+
+  friend class TextChildAnchor;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_TEXTCHILDANCHOR_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/textiter_p.h b/libs/gtkmm2/gtk/gtkmm/private/textiter_p.h
new file mode 100644
index 0000000000..b234c358b0
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/textiter_p.h
@@ -0,0 +1,6 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_TEXTITER_P_H
+#define _GTKMM_TEXTITER_P_H
+#endif /* _GTKMM_TEXTITER_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/textmark_p.h b/libs/gtkmm2/gtk/gtkmm/private/textmark_p.h
new file mode 100644
index 0000000000..bba46d8c62
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/textmark_p.h
@@ -0,0 +1,44 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_TEXTMARK_P_H
+#define _GTKMM_TEXTMARK_P_H
+#include <glibmm/private/object_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class TextMark_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef TextMark CppObjectType;
+  typedef GtkTextMark BaseObjectType;
+  typedef GtkTextMarkClass BaseClassType;
+  typedef Glib::Object_Class CppClassParent;
+  typedef GObjectClass BaseClassParent;
+
+  friend class TextMark;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_TEXTMARK_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/texttag_p.h b/libs/gtkmm2/gtk/gtkmm/private/texttag_p.h
new file mode 100644
index 0000000000..8cab5dac5b
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/texttag_p.h
@@ -0,0 +1,46 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_TEXTTAG_P_H
+#define _GTKMM_TEXTTAG_P_H
+#include <glibmm/private/object_p.h>
+#include <gtk/gtktexttag.h>
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class TextTag_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef TextTag CppObjectType;
+  typedef GtkTextTag BaseObjectType;
+  typedef GtkTextTagClass BaseClassType;
+  typedef Glib::Object_Class CppClassParent;
+  typedef GObjectClass BaseClassParent;
+
+  friend class TextTag;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+  static gboolean event_callback(GtkTextTag* self, GObject* p0, GdkEvent* p1, const GtkTextIter* p2);
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_TEXTTAG_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/texttagtable_p.h b/libs/gtkmm2/gtk/gtkmm/private/texttagtable_p.h
new file mode 100644
index 0000000000..19964742d5
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/texttagtable_p.h
@@ -0,0 +1,47 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_TEXTTAGTABLE_P_H
+#define _GTKMM_TEXTTAGTABLE_P_H
+#include <glibmm/private/object_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class TextTagTable_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef TextTagTable CppObjectType;
+  typedef GtkTextTagTable BaseObjectType;
+  typedef GtkTextTagTableClass BaseClassType;
+  typedef Glib::Object_Class CppClassParent;
+  typedef GObjectClass BaseClassParent;
+
+  friend class TextTagTable;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+  static void tag_changed_callback(GtkTextTagTable* self, GtkTextTag* p0, gboolean p1);
+  static void tag_added_callback(GtkTextTagTable* self, GtkTextTag* p0);
+  static void tag_removed_callback(GtkTextTagTable* self, GtkTextTag* p0);
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_TEXTTAGTABLE_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/textview_p.h b/libs/gtkmm2/gtk/gtkmm/private/textview_p.h
new file mode 100644
index 0000000000..328d08f8d2
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/textview_p.h
@@ -0,0 +1,48 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_TEXTVIEW_P_H
+#define _GTKMM_TEXTVIEW_P_H
+#include <gtkmm/private/container_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class TextView_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef TextView CppObjectType;
+  typedef GtkTextView BaseObjectType;
+  typedef GtkTextViewClass BaseClassType;
+  typedef Gtk::Container_Class CppClassParent;
+  typedef GtkContainerClass BaseClassParent;
+
+  friend class TextView;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+  static void set_scroll_adjustments_callback(GtkTextView* self, GtkAdjustment* p0, GtkAdjustment* p1);
+  static void populate_popup_callback(GtkTextView* self, GtkMenu* p0);
+  static void set_anchor_callback(GtkTextView* self);
+  static void insert_at_cursor_callback(GtkTextView* self, const gchar* p0);
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_TEXTVIEW_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/toggleaction_p.h b/libs/gtkmm2/gtk/gtkmm/private/toggleaction_p.h
new file mode 100644
index 0000000000..61de249561
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/toggleaction_p.h
@@ -0,0 +1,45 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_TOGGLEACTION_P_H
+#define _GTKMM_TOGGLEACTION_P_H
+#include <gtkmm/private/action_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class ToggleAction_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef ToggleAction CppObjectType;
+  typedef GtkToggleAction BaseObjectType;
+  typedef GtkToggleActionClass BaseClassType;
+  typedef Gtk::Action_Class CppClassParent;
+  typedef GtkActionClass BaseClassParent;
+
+  friend class ToggleAction;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+  static void toggled_callback(GtkToggleAction* self);
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_TOGGLEACTION_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/togglebutton_p.h b/libs/gtkmm2/gtk/gtkmm/private/togglebutton_p.h
new file mode 100644
index 0000000000..73b571158f
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/togglebutton_p.h
@@ -0,0 +1,45 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_TOGGLEBUTTON_P_H
+#define _GTKMM_TOGGLEBUTTON_P_H
+#include <gtkmm/private/button_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class ToggleButton_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef ToggleButton CppObjectType;
+  typedef GtkToggleButton BaseObjectType;
+  typedef GtkToggleButtonClass BaseClassType;
+  typedef Gtk::Button_Class CppClassParent;
+  typedef GtkButtonClass BaseClassParent;
+
+  friend class ToggleButton;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+  static void toggled_callback(GtkToggleButton* self);
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_TOGGLEBUTTON_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/toggletoolbutton_p.h b/libs/gtkmm2/gtk/gtkmm/private/toggletoolbutton_p.h
new file mode 100644
index 0000000000..9ed1cd4da0
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/toggletoolbutton_p.h
@@ -0,0 +1,45 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_TOGGLETOOLBUTTON_P_H
+#define _GTKMM_TOGGLETOOLBUTTON_P_H
+#include <gtkmm/private/toolbutton_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class ToggleToolButton_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef ToggleToolButton CppObjectType;
+  typedef GtkToggleToolButton BaseObjectType;
+  typedef GtkToggleToolButtonClass BaseClassType;
+  typedef Gtk::ToolButton_Class CppClassParent;
+  typedef GtkToolButtonClass BaseClassParent;
+
+  friend class ToggleToolButton;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+  static void toggled_callback(GtkToggleToolButton* self);
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_TOGGLETOOLBUTTON_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/toolbar_p.h b/libs/gtkmm2/gtk/gtkmm/private/toolbar_p.h
new file mode 100644
index 0000000000..f2bb20e0d3
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/toolbar_p.h
@@ -0,0 +1,47 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_TOOLBAR_P_H
+#define _GTKMM_TOOLBAR_P_H
+#include <gtkmm/private/container_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class Toolbar_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Toolbar CppObjectType;
+  typedef GtkToolbar BaseObjectType;
+  typedef GtkToolbarClass BaseClassType;
+  typedef Gtk::Container_Class CppClassParent;
+  typedef GtkContainerClass BaseClassParent;
+
+  friend class Toolbar;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+  static void orientation_changed_callback(GtkToolbar* self, GtkOrientation p0);
+  static void style_changed_callback(GtkToolbar* self, GtkToolbarStyle p0);
+  static gboolean popup_context_menu_callback(GtkToolbar* self, gint p0, gint p1, gint p2);
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_TOOLBAR_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/toolbutton_p.h b/libs/gtkmm2/gtk/gtkmm/private/toolbutton_p.h
new file mode 100644
index 0000000000..2cac2dda6b
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/toolbutton_p.h
@@ -0,0 +1,45 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_TOOLBUTTON_P_H
+#define _GTKMM_TOOLBUTTON_P_H
+#include <gtkmm/private/toolitem_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class ToolButton_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef ToolButton CppObjectType;
+  typedef GtkToolButton BaseObjectType;
+  typedef GtkToolButtonClass BaseClassType;
+  typedef Gtk::ToolItem_Class CppClassParent;
+  typedef GtkToolItemClass BaseClassParent;
+
+  friend class ToolButton;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+  static void clicked_callback(GtkToolButton* self);
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_TOOLBUTTON_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/toolitem_p.h b/libs/gtkmm2/gtk/gtkmm/private/toolitem_p.h
new file mode 100644
index 0000000000..a35fb73560
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/toolitem_p.h
@@ -0,0 +1,46 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_TOOLITEM_P_H
+#define _GTKMM_TOOLITEM_P_H
+#include <gtkmm/private/bin_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class ToolItem_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef ToolItem CppObjectType;
+  typedef GtkToolItem BaseObjectType;
+  typedef GtkToolItemClass BaseClassType;
+  typedef Gtk::Bin_Class CppClassParent;
+  typedef GtkBinClass BaseClassParent;
+
+  friend class ToolItem;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+  static gboolean create_menu_proxy_callback(GtkToolItem* self);
+  static void toolbar_reconfigured_callback(GtkToolItem* self);
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_TOOLITEM_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/tooltips_p.h b/libs/gtkmm2/gtk/gtkmm/private/tooltips_p.h
new file mode 100644
index 0000000000..1872000504
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/tooltips_p.h
@@ -0,0 +1,44 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_TOOLTIPS_P_H
+#define _GTKMM_TOOLTIPS_P_H
+#include <gtkmm/private/object_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class Tooltips_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Tooltips CppObjectType;
+  typedef GtkTooltips BaseObjectType;
+  typedef GtkTooltipsClass BaseClassType;
+  typedef Gtk::Object_Class CppClassParent;
+  typedef GtkObjectClass BaseClassParent;
+
+  friend class Tooltips;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_TOOLTIPS_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/treedragdest_p.h b/libs/gtkmm2/gtk/gtkmm/private/treedragdest_p.h
new file mode 100644
index 0000000000..0486146e02
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/treedragdest_p.h
@@ -0,0 +1,43 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_TREEDRAGDEST_P_H
+#define _GTKMM_TREEDRAGDEST_P_H
+#include <glibmm/private/interface_p.h>
+
+#include <glibmm/private/interface_p.h>
+
+namespace Gtk
+{
+
+class TreeDragDest_Class : public Glib::Interface_Class
+{
+public:
+  typedef TreeDragDest CppObjectType;
+  typedef GtkTreeDragDest BaseObjectType;
+  typedef GtkTreeDragDestIface BaseClassType;
+  typedef Glib::Interface_Class CppClassParent;
+
+  friend class TreeDragDest;
+
+  const Glib::Interface_Class& init();
+
+  static void iface_init_function(void* g_iface, void* iface_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+  static gboolean drag_data_received_vfunc_callback(GtkTreeDragDest* self, GtkTreePath* dest, GtkSelectionData* selection_data);
+  static gboolean row_drop_possible_vfunc_callback(GtkTreeDragDest* self, GtkTreePath* dest_path, GtkSelectionData* selection_data);
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_TREEDRAGDEST_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/treedragsource_p.h b/libs/gtkmm2/gtk/gtkmm/private/treedragsource_p.h
new file mode 100644
index 0000000000..07f02f964f
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/treedragsource_p.h
@@ -0,0 +1,44 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_TREEDRAGSOURCE_P_H
+#define _GTKMM_TREEDRAGSOURCE_P_H
+#include <glibmm/private/interface_p.h>
+
+#include <glibmm/private/interface_p.h>
+
+namespace Gtk
+{
+
+class TreeDragSource_Class : public Glib::Interface_Class
+{
+public:
+  typedef TreeDragSource CppObjectType;
+  typedef GtkTreeDragSource BaseObjectType;
+  typedef GtkTreeDragSourceIface BaseClassType;
+  typedef Glib::Interface_Class CppClassParent;
+
+  friend class TreeDragSource;
+
+  const Glib::Interface_Class& init();
+
+  static void iface_init_function(void* g_iface, void* iface_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+    static gboolean drag_data_get_vfunc_callback(GtkTreeDragSource* self, GtkTreePath* path, GtkSelectionData* selection_data);
+    static gboolean row_draggable_vfunc_callback(GtkTreeDragSource* self, GtkTreePath* path);
+  static gboolean drag_data_delete_vfunc_callback(GtkTreeDragSource* self, GtkTreePath* path);
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_TREEDRAGSOURCE_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/treeiter_p.h b/libs/gtkmm2/gtk/gtkmm/private/treeiter_p.h
new file mode 100644
index 0000000000..bc45469e97
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/treeiter_p.h
@@ -0,0 +1,6 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_TREEITER_P_H
+#define _GTKMM_TREEITER_P_H
+#endif /* _GTKMM_TREEITER_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/treemodel_p.h b/libs/gtkmm2/gtk/gtkmm/private/treemodel_p.h
new file mode 100644
index 0000000000..401d707834
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/treemodel_p.h
@@ -0,0 +1,60 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_TREEMODEL_P_H
+#define _GTKMM_TREEMODEL_P_H
+#include <glibmm/private/interface_p.h>
+
+#include <glibmm/private/interface_p.h>
+
+namespace Gtk
+{
+
+class TreeModel_Class : public Glib::Interface_Class
+{
+public:
+  typedef TreeModel CppObjectType;
+  typedef GtkTreeModel BaseObjectType;
+  typedef GtkTreeModelIface BaseClassType;
+  typedef Glib::Interface_Class CppClassParent;
+
+  friend class TreeModel;
+
+  const Glib::Interface_Class& init();
+
+  static void iface_init_function(void* g_iface, void* iface_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+  static void row_changed_callback(GtkTreeModel* self, GtkTreePath* path, GtkTreeIter* iter);
+  static void row_inserted_callback(GtkTreeModel* self, GtkTreePath* path, GtkTreeIter* iter);
+  static void row_has_child_toggled_callback(GtkTreeModel* self, GtkTreePath* path, GtkTreeIter* iter);
+  static void row_deleted_callback(GtkTreeModel* self, GtkTreePath* path);
+  static void rows_reordered_callback(GtkTreeModel* self, GtkTreePath* path, GtkTreeIter* iter, gint* new_order);
+
+  //Callbacks (virtual functions):
+  static GtkTreeModelFlags get_flags_vfunc_callback(GtkTreeModel* self);
+  static gint get_n_columns_vfunc_callback(GtkTreeModel* self);
+  static GType get_column_type_vfunc_callback(GtkTreeModel* self, gint index);
+    static gboolean iter_next_vfunc_callback(GtkTreeModel* self, GtkTreeIter* iter);
+    static gboolean get_iter_vfunc_callback(GtkTreeModel* self, GtkTreeIter* iter, GtkTreePath* path);
+    static gboolean iter_children_vfunc_callback(GtkTreeModel* self, GtkTreeIter* iter, GtkTreeIter* parent);
+    static gboolean iter_parent_vfunc_callback(GtkTreeModel* self, GtkTreeIter* iter, GtkTreeIter* child);
+    static gboolean iter_nth_child_vfunc_callback(GtkTreeModel* self, GtkTreeIter* iter, GtkTreeIter* parent, int n);
+    static int iter_n_children_vfunc_callback(GtkTreeModel* self, GtkTreeIter* iter);
+    static gboolean iter_has_child_vfunc_callback(GtkTreeModel* self, GtkTreeIter* iter);
+  static void ref_node_vfunc_callback(GtkTreeModel* self, GtkTreeIter* iter);
+  static void unref_node_vfunc_callback(GtkTreeModel* self, GtkTreeIter* iter);
+  static GtkTreePath* get_path_vfunc_callback(GtkTreeModel* self, GtkTreeIter* iter);
+  static void get_value_vfunc_callback(GtkTreeModel* self, GtkTreeIter* iter, gint column, GValue* value);
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_TREEMODEL_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/treemodelfilter_p.h b/libs/gtkmm2/gtk/gtkmm/private/treemodelfilter_p.h
new file mode 100644
index 0000000000..cd4f27a229
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/treemodelfilter_p.h
@@ -0,0 +1,44 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_TREEMODELFILTER_P_H
+#define _GTKMM_TREEMODELFILTER_P_H
+#include <glibmm/private/object_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class TreeModelFilter_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef TreeModelFilter CppObjectType;
+  typedef GtkTreeModelFilter BaseObjectType;
+  typedef GtkTreeModelFilterClass BaseClassType;
+  typedef Glib::Object_Class CppClassParent;
+  typedef GObjectClass BaseClassParent;
+
+  friend class TreeModelFilter;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_TREEMODELFILTER_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/treemodelsort_p.h b/libs/gtkmm2/gtk/gtkmm/private/treemodelsort_p.h
new file mode 100644
index 0000000000..ce050925cb
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/treemodelsort_p.h
@@ -0,0 +1,44 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_TREEMODELSORT_P_H
+#define _GTKMM_TREEMODELSORT_P_H
+#include <glibmm/private/object_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class TreeModelSort_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef TreeModelSort CppObjectType;
+  typedef GtkTreeModelSort BaseObjectType;
+  typedef GtkTreeModelSortClass BaseClassType;
+  typedef Glib::Object_Class CppClassParent;
+  typedef GObjectClass BaseClassParent;
+
+  friend class TreeModelSort;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_TREEMODELSORT_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/treepath_p.h b/libs/gtkmm2/gtk/gtkmm/private/treepath_p.h
new file mode 100644
index 0000000000..829820cfe5
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/treepath_p.h
@@ -0,0 +1,6 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_TREEPATH_P_H
+#define _GTKMM_TREEPATH_P_H
+#endif /* _GTKMM_TREEPATH_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/treerowreference_p.h b/libs/gtkmm2/gtk/gtkmm/private/treerowreference_p.h
new file mode 100644
index 0000000000..00bcc4b2fe
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/treerowreference_p.h
@@ -0,0 +1,6 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_TREEROWREFERENCE_P_H
+#define _GTKMM_TREEROWREFERENCE_P_H
+#endif /* _GTKMM_TREEROWREFERENCE_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/treeselection_p.h b/libs/gtkmm2/gtk/gtkmm/private/treeselection_p.h
new file mode 100644
index 0000000000..ee7fcce1e7
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/treeselection_p.h
@@ -0,0 +1,45 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_TREESELECTION_P_H
+#define _GTKMM_TREESELECTION_P_H
+#include <glibmm/private/object_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class TreeSelection_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef TreeSelection CppObjectType;
+  typedef GtkTreeSelection BaseObjectType;
+  typedef GtkTreeSelectionClass BaseClassType;
+  typedef Glib::Object_Class CppClassParent;
+  typedef GObjectClass BaseClassParent;
+
+  friend class TreeSelection;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+  static void changed_callback(GtkTreeSelection* self);
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_TREESELECTION_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/treesortable_p.h b/libs/gtkmm2/gtk/gtkmm/private/treesortable_p.h
new file mode 100644
index 0000000000..f93f94c10d
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/treesortable_p.h
@@ -0,0 +1,48 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_TREESORTABLE_P_H
+#define _GTKMM_TREESORTABLE_P_H
+#include <glibmm/private/interface_p.h>
+
+#include <glibmm/private/interface_p.h>
+
+namespace Gtk
+{
+
+class TreeSortable_Class : public Glib::Interface_Class
+{
+public:
+  typedef TreeSortable CppObjectType;
+  typedef GtkTreeSortable BaseObjectType;
+  typedef GtkTreeSortableIface BaseClassType;
+  typedef Glib::Interface_Class CppClassParent;
+
+  friend class TreeSortable;
+
+  const Glib::Interface_Class& init();
+
+  static void iface_init_function(void* g_iface, void* iface_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+  static void sort_column_changed_callback(GtkTreeSortable* self);
+
+  //Callbacks (virtual functions):
+  static gboolean get_sort_column_id_vfunc_callback(GtkTreeSortable* self, int* sort_column_id, GtkSortType* order);
+  static void set_sort_column_id_vfunc_callback(GtkTreeSortable* self, int sort_column_id, GtkSortType order);
+  static void set_sort_func_vfunc_callback(GtkTreeSortable* self, int sort_column_id, GtkTreeIterCompareFunc func, gpointer data, GtkDestroyNotify destroy);
+  static void set_default_sort_func_vfunc_callback(GtkTreeSortable* self, GtkTreeIterCompareFunc func, gpointer data, GtkDestroyNotify destroy);
+  static gboolean has_default_sort_func_vfunc_callback(GtkTreeSortable* self);
+  static void sort_column_changed_vfunc_callback(GtkTreeSortable* self);
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_TREESORTABLE_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/treestore_p.h b/libs/gtkmm2/gtk/gtkmm/private/treestore_p.h
new file mode 100644
index 0000000000..fb1c7bc681
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/treestore_p.h
@@ -0,0 +1,44 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_TREESTORE_P_H
+#define _GTKMM_TREESTORE_P_H
+#include <glibmm/private/object_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class TreeStore_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef TreeStore CppObjectType;
+  typedef GtkTreeStore BaseObjectType;
+  typedef GtkTreeStoreClass BaseClassType;
+  typedef Glib::Object_Class CppClassParent;
+  typedef GObjectClass BaseClassParent;
+
+  friend class TreeStore;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_TREESTORE_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/treeview_p.h b/libs/gtkmm2/gtk/gtkmm/private/treeview_p.h
new file mode 100644
index 0000000000..127465f857
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/treeview_p.h
@@ -0,0 +1,52 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_TREEVIEW_P_H
+#define _GTKMM_TREEVIEW_P_H
+#include <gtkmm/private/container_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class TreeView_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef TreeView CppObjectType;
+  typedef GtkTreeView BaseObjectType;
+  typedef GtkTreeViewClass BaseClassType;
+  typedef Gtk::Container_Class CppClassParent;
+  typedef GtkContainerClass BaseClassParent;
+
+  friend class TreeView;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+  static void set_scroll_adjustments_callback(GtkTreeView* self, GtkAdjustment* p0, GtkAdjustment* p1);
+  static void row_activated_callback(GtkTreeView* self, GtkTreePath* p0, GtkTreeViewColumn* p1);
+  static gboolean test_expand_row_callback(GtkTreeView* self, GtkTreeIter* p0, GtkTreePath* p1);
+  static gboolean test_collapse_row_callback(GtkTreeView* self, GtkTreeIter* p0, GtkTreePath* p1);
+  static void row_expanded_callback(GtkTreeView* self, GtkTreeIter* p0, GtkTreePath* p1);
+  static void row_collapsed_callback(GtkTreeView* self, GtkTreeIter* p0, GtkTreePath* p1);
+  static void cursor_changed_callback(GtkTreeView* self);
+  static void columns_changed_callback(GtkTreeView* self);
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_TREEVIEW_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/treeviewcolumn_p.h b/libs/gtkmm2/gtk/gtkmm/private/treeviewcolumn_p.h
new file mode 100644
index 0000000000..f47a4a3279
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/treeviewcolumn_p.h
@@ -0,0 +1,45 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_TREEVIEWCOLUMN_P_H
+#define _GTKMM_TREEVIEWCOLUMN_P_H
+#include <gtkmm/private/object_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class TreeViewColumn_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef TreeViewColumn CppObjectType;
+  typedef GtkTreeViewColumn BaseObjectType;
+  typedef GtkTreeViewColumnClass BaseClassType;
+  typedef Gtk::Object_Class CppClassParent;
+  typedef GtkObjectClass BaseClassParent;
+
+  friend class TreeViewColumn;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+  static void clicked_callback(GtkTreeViewColumn* self);
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_TREEVIEWCOLUMN_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/uimanager_p.h b/libs/gtkmm2/gtk/gtkmm/private/uimanager_p.h
new file mode 100644
index 0000000000..6932d4f791
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/uimanager_p.h
@@ -0,0 +1,46 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_UIMANAGER_P_H
+#define _GTKMM_UIMANAGER_P_H
+#include <glibmm/private/object_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class UIManager_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef UIManager CppObjectType;
+  typedef GtkUIManager BaseObjectType;
+  typedef GtkUIManagerClass BaseClassType;
+  typedef Glib::Object_Class CppClassParent;
+  typedef GObjectClass BaseClassParent;
+
+  friend class UIManager;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+  static void add_widget_callback(GtkUIManager* self, GtkWidget* p0);
+  static void actions_changed_callback(GtkUIManager* self);
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_UIMANAGER_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/viewport_p.h b/libs/gtkmm2/gtk/gtkmm/private/viewport_p.h
new file mode 100644
index 0000000000..18fce1d06c
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/viewport_p.h
@@ -0,0 +1,45 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_VIEWPORT_P_H
+#define _GTKMM_VIEWPORT_P_H
+#include <gtkmm/private/bin_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class Viewport_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Viewport CppObjectType;
+  typedef GtkViewport BaseObjectType;
+  typedef GtkViewportClass BaseClassType;
+  typedef Gtk::Bin_Class CppClassParent;
+  typedef GtkBinClass BaseClassParent;
+
+  friend class Viewport;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+  static void set_scroll_adjustments_callback(GtkViewport* self, GtkAdjustment* p0, GtkAdjustment* p1);
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_VIEWPORT_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/widget_p.h b/libs/gtkmm2/gtk/gtkmm/private/widget_p.h
new file mode 100644
index 0000000000..ce8df67d36
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/widget_p.h
@@ -0,0 +1,107 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_WIDGET_P_H
+#define _GTKMM_WIDGET_P_H
+#include <gtkmm/private/object_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class Widget_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Widget CppObjectType;
+  typedef GtkWidget BaseObjectType;
+  typedef GtkWidgetClass BaseClassType;
+  typedef Gtk::Object_Class CppClassParent;
+  typedef GtkObjectClass BaseClassParent;
+
+  friend class Widget;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+  static void show_callback(GtkWidget* self);
+  static void hide_callback(GtkWidget* self);
+  static void map_callback(GtkWidget* self);
+  static void unmap_callback(GtkWidget* self);
+  static void realize_callback(GtkWidget* self);
+  static void unrealize_callback(GtkWidget* self);
+  static void size_request_callback(GtkWidget* self, GtkRequisition* p0);
+  static void size_allocate_callback(GtkWidget* self, GtkAllocation* p0);
+  static void state_changed_callback(GtkWidget* self, GtkStateType p0);
+  static void parent_set_callback(GtkWidget* self, GtkWidget* p0);
+  static void hierarchy_changed_callback(GtkWidget* self, GtkWidget* p0);
+  static void style_set_callback(GtkWidget* self, GtkStyle* p0);
+  static void direction_changed_callback(GtkWidget* self, GtkTextDirection p0);
+  static void grab_notify_callback(GtkWidget* self, gboolean p0);
+  static void child_notify_callback(GtkWidget* self, GParamSpec* p0);
+  static gboolean mnemonic_activate_callback(GtkWidget* self, gboolean p0);
+  static void grab_focus_callback(GtkWidget* self);
+  static gboolean focus_callback(GtkWidget* self, GtkDirectionType p0);
+  static gboolean event_callback(GtkWidget* self, GdkEvent* p0);
+  static gboolean button_press_event_callback(GtkWidget* self, GdkEventButton* p0);
+  static gboolean button_release_event_callback(GtkWidget* self, GdkEventButton* p0);
+  static gboolean scroll_event_callback(GtkWidget* self, GdkEventScroll* p0);
+  static gboolean motion_notify_event_callback(GtkWidget* self, GdkEventMotion* p0);
+  static gboolean delete_event_callback(GtkWidget* self, GdkEventAny* p0);
+  static gboolean expose_event_callback(GtkWidget* self, GdkEventExpose* p0);
+  static gboolean key_press_event_callback(GtkWidget* self, GdkEventKey* p0);
+  static gboolean key_release_event_callback(GtkWidget* self, GdkEventKey* p0);
+  static gboolean enter_notify_event_callback(GtkWidget* self, GdkEventCrossing* p0);
+  static gboolean leave_notify_event_callback(GtkWidget* self, GdkEventCrossing* p0);
+  static gboolean configure_event_callback(GtkWidget* self, GdkEventConfigure* p0);
+  static gboolean focus_in_event_callback(GtkWidget* self, GdkEventFocus* p0);
+  static gboolean focus_out_event_callback(GtkWidget* self, GdkEventFocus* p0);
+  static gboolean map_event_callback(GtkWidget* self, GdkEventAny* p0);
+  static gboolean unmap_event_callback(GtkWidget* self, GdkEventAny* p0);
+  static gboolean property_notify_event_callback(GtkWidget* self, GdkEventProperty* p0);
+  static gboolean selection_clear_event_callback(GtkWidget* self, GdkEventSelection* p0);
+  static gboolean selection_request_event_callback(GtkWidget* self, GdkEventSelection* p0);
+  static gboolean selection_notify_event_callback(GtkWidget* self, GdkEventSelection* p0);
+  static gboolean proximity_in_event_callback(GtkWidget* self, GdkEventProximity* p0);
+  static gboolean proximity_out_event_callback(GtkWidget* self, GdkEventProximity* p0);
+  static gboolean visibility_notify_event_callback(GtkWidget* self, GdkEventVisibility* p0);
+  static gboolean client_event_callback(GtkWidget* self, GdkEventClient* p0);
+  static gboolean no_expose_event_callback(GtkWidget* self, GdkEventAny* p0);
+  static gboolean window_state_event_callback(GtkWidget* self, GdkEventWindowState* p0);
+  static void selection_get_callback(GtkWidget* self, GtkSelectionData* p0, guint p1, guint p2);
+  static void selection_received_callback(GtkWidget* self, GtkSelectionData* p0, guint p1);
+  static void drag_begin_callback(GtkWidget* self, GdkDragContext* p0);
+  static void drag_end_callback(GtkWidget* self, GdkDragContext* p0);
+  static void drag_data_get_callback(GtkWidget* self, GdkDragContext* p0, GtkSelectionData* p1, guint p2, guint p3);
+  static void drag_data_delete_callback(GtkWidget* self, GdkDragContext* p0);
+  static void drag_leave_callback(GtkWidget* self, GdkDragContext* p0, guint p1);
+  static gboolean drag_motion_callback(GtkWidget* self, GdkDragContext* p0, gint p1, gint p2, guint p3);
+  static gboolean drag_drop_callback(GtkWidget* self, GdkDragContext* p0, gint p1, gint p2, guint p3);
+  static void drag_data_received_callback(GtkWidget* self, GdkDragContext* p0, gint p1, gint p2, GtkSelectionData* p3, guint p4, guint p5);
+  static AtkObject* get_accessible_callback(GtkWidget* self);
+  static void screen_changed_callback(GtkWidget* self, GdkScreen* p0);
+    static void hierarchy_changed_callback_custom(GtkWidget* self, GtkWidget* p0);
+      static void parent_set_callback_custom(GtkWidget* self, GtkWidget* p0);
+  
+  //Callbacks (virtual functions):
+    static void dispose_vfunc_callback(GObject* self);
+    static void dispatch_child_properties_changed_vfunc_callback(GtkWidget* self, guint n_pspecs, GParamSpec** pspecs);
+  static void show_all_vfunc_callback(GtkWidget* self);
+  static void hide_all_vfunc_callback(GtkWidget* self);
+  static AtkObject* get_accessible_vfunc_callback(GtkWidget* self);
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_WIDGET_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/window_p.h b/libs/gtkmm2/gtk/gtkmm/private/window_p.h
new file mode 100644
index 0000000000..5413a7284a
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/private/window_p.h
@@ -0,0 +1,84 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_WINDOW_P_H
+#define _GTKMM_WINDOW_P_H
+#include <gtkmm/private/bin_p.h>
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class Window_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Window CppObjectType;
+  typedef GtkWindow BaseObjectType;
+  typedef GtkWindowClass BaseClassType;
+  typedef Gtk::Bin_Class CppClassParent;
+  typedef GtkBinClass BaseClassParent;
+
+  friend class Window;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+  static void set_focus_callback(GtkWindow* self, GtkWidget* p0);
+  static gboolean frame_event_callback(GtkWindow* self, GdkEvent* p0);
+
+  //Callbacks (virtual functions):
+    static void dispose_vfunc_callback(GObject* self);
+  };
+
+
+} // namespace Gtk
+
+
+#include <glibmm/class.h>
+
+namespace Gtk
+{
+
+class WindowGroup_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef WindowGroup CppObjectType;
+  typedef GtkWindowGroup BaseObjectType;
+  typedef GtkWindowGroupClass BaseClassType;
+  typedef Glib::Object_Class CppClassParent;
+  typedef GObjectClass BaseClassParent;
+
+  friend class WindowGroup;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Gtk
+
+#endif /* _GTKMM_WINDOW_P_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/progressbar.cc b/libs/gtkmm2/gtk/gtkmm/progressbar.cc
new file mode 100644
index 0000000000..fb515e88ad
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/progressbar.cc
@@ -0,0 +1,249 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/progressbar.h>
+#include <gtkmm/private/progressbar_p.h>
+
+#include <gtk/gtktypebuiltins.h>
+// -*- c++ -*-
+/* $Id$ */
+
+/* 
+ *
+ * Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/adjustment.h>
+#include <gtk/gtkprogressbar.h>
+
+
+namespace
+{
+} // anonymous namespace
+
+// static
+GType Glib::Value<Gtk::ProgressBarStyle>::value_type()
+{
+  return gtk_progress_bar_style_get_type();
+}
+
+// static
+GType Glib::Value<Gtk::ProgressBarOrientation>::value_type()
+{
+  return gtk_progress_bar_orientation_get_type();
+}
+
+
+namespace Glib
+{
+
+Gtk::ProgressBar* wrap(GtkProgressBar* object, bool take_copy)
+{
+  return dynamic_cast<Gtk::ProgressBar *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& ProgressBar_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &ProgressBar_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_progress_bar_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void ProgressBar_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+}
+
+
+Glib::ObjectBase* ProgressBar_Class::wrap_new(GObject* o)
+{
+  return manage(new ProgressBar((GtkProgressBar*)(o)));
+
+}
+
+
+/* The implementation: */
+
+ProgressBar::ProgressBar(const Glib::ConstructParams& construct_params)
+:
+  Gtk::Widget(construct_params)
+{
+  }
+
+ProgressBar::ProgressBar(GtkProgressBar* castitem)
+:
+  Gtk::Widget((GtkWidget*)(castitem))
+{
+  }
+
+ProgressBar::~ProgressBar()
+{
+  destroy_();
+}
+
+ProgressBar::CppClassType ProgressBar::progressbar_class_; // initialize static member
+
+GType ProgressBar::get_type()
+{
+  return progressbar_class_.init().get_type();
+}
+
+GType ProgressBar::get_base_type()
+{
+  return gtk_progress_bar_get_type();
+}
+
+
+ProgressBar::ProgressBar()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Widget(Glib::ConstructParams(progressbar_class_.init()))
+{
+  }
+
+void ProgressBar::pulse()
+{
+  gtk_progress_bar_pulse(gobj());
+}
+
+Glib::ustring ProgressBar::get_text() const
+{
+  return Glib::convert_const_gchar_ptr_to_ustring(gtk_progress_bar_get_text(const_cast<GtkProgressBar*>(gobj())));
+}
+
+void ProgressBar::set_text(const Glib::ustring& text)
+{
+  gtk_progress_bar_set_text(gobj(), text.c_str());
+}
+
+double ProgressBar::get_fraction() const
+{
+  return gtk_progress_bar_get_fraction(const_cast<GtkProgressBar*>(gobj()));
+}
+
+void ProgressBar::set_fraction(double fraction)
+{
+  gtk_progress_bar_set_fraction(gobj(), fraction);
+}
+
+double ProgressBar::get_pulse_step() const
+{
+  return gtk_progress_bar_get_pulse_step(const_cast<GtkProgressBar*>(gobj()));
+}
+
+void ProgressBar::set_pulse_step(double fraction)
+{
+  gtk_progress_bar_set_pulse_step(gobj(), fraction);
+}
+
+void ProgressBar::set_orientation(ProgressBarOrientation orientation)
+{
+  gtk_progress_bar_set_orientation(gobj(), ((GtkProgressBarOrientation)(orientation)));
+}
+
+ProgressBarOrientation ProgressBar::get_orientation() const
+{
+  return ((ProgressBarOrientation)(gtk_progress_bar_get_orientation(const_cast<GtkProgressBar*>(gobj()))));
+}
+
+void ProgressBar::set_ellipsize(Pango::EllipsizeMode mode)
+{
+  gtk_progress_bar_set_ellipsize(gobj(), ((PangoEllipsizeMode)(mode)));
+}
+
+Pango::EllipsizeMode ProgressBar::get_ellipsize() const
+{
+  return ((Pango::EllipsizeMode)(gtk_progress_bar_get_ellipsize(const_cast<GtkProgressBar*>(gobj()))));
+}
+
+
+Glib::PropertyProxy<double> ProgressBar::property_fraction() 
+{
+  return Glib::PropertyProxy<double>(this, "fraction");
+}
+
+Glib::PropertyProxy_ReadOnly<double> ProgressBar::property_fraction() const
+{
+  return Glib::PropertyProxy_ReadOnly<double>(this, "fraction");
+}
+
+Glib::PropertyProxy<double> ProgressBar::property_pulse_step() 
+{
+  return Glib::PropertyProxy<double>(this, "pulse-step");
+}
+
+Glib::PropertyProxy_ReadOnly<double> ProgressBar::property_pulse_step() const
+{
+  return Glib::PropertyProxy_ReadOnly<double>(this, "pulse-step");
+}
+
+Glib::PropertyProxy<ProgressBarOrientation> ProgressBar::property_orientation() 
+{
+  return Glib::PropertyProxy<ProgressBarOrientation>(this, "orientation");
+}
+
+Glib::PropertyProxy_ReadOnly<ProgressBarOrientation> ProgressBar::property_orientation() const
+{
+  return Glib::PropertyProxy_ReadOnly<ProgressBarOrientation>(this, "orientation");
+}
+
+Glib::PropertyProxy<Glib::ustring> ProgressBar::property_text() 
+{
+  return Glib::PropertyProxy<Glib::ustring>(this, "text");
+}
+
+Glib::PropertyProxy_ReadOnly<Glib::ustring> ProgressBar::property_text() const
+{
+  return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "text");
+}
+
+Glib::PropertyProxy<bool> ProgressBar::property_ellipsize() 
+{
+  return Glib::PropertyProxy<bool>(this, "ellipsize");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> ProgressBar::property_ellipsize() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "ellipsize");
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/progressbar.h b/libs/gtkmm2/gtk/gtkmm/progressbar.h
new file mode 100644
index 0000000000..d79db97633
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/progressbar.h
@@ -0,0 +1,361 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_PROGRESSBAR_H
+#define _GTKMM_PROGRESSBAR_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* progressbar.h
+ * 
+ * Copyright (C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/widget.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkProgressBar GtkProgressBar;
+typedef struct _GtkProgressBarClass GtkProgressBarClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class ProgressBar_Class; } // namespace Gtk
+namespace Gtk
+{
+
+
+/** @addtogroup gtkmmEnums Enums and Flags */
+
+/**
+ * @ingroup gtkmmEnums
+ */
+enum ProgressBarStyle
+{
+  PROGRESS_CONTINUOUS,
+  PROGRESS_DISCRETE
+};
+
+} // namespace Gtk
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Gtk::ProgressBarStyle> : public Glib::Value_Enum<Gtk::ProgressBarStyle>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{
+
+/**
+ * @ingroup gtkmmEnums
+ */
+enum ProgressBarOrientation
+{
+  PROGRESS_LEFT_TO_RIGHT,
+  PROGRESS_RIGHT_TO_LEFT,
+  PROGRESS_BOTTOM_TO_TOP,
+  PROGRESS_TOP_TO_BOTTOM
+};
+
+} // namespace Gtk
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Gtk::ProgressBarOrientation> : public Glib::Value_Enum<Gtk::ProgressBarOrientation>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{
+
+
+/** A widget which indicates progress visually.
+ *
+ * The Gtk::ProgressBar is typically used to display the progress of a long
+ * running operation. It provides a visual clue that processing is underway.
+ * The Gtk::ProgressBar can be used in two different modes: percentage mode
+ * and activity mode.
+ *
+ * When an application can determine how much work needs to take place (e.g.
+ * read a fixed number of bytes from a file) and can monitor its progress,
+ * it can use the Gtk::ProgressBar in percentage mode and the user sees a
+ * growing bar indicating the percentage of the work that has been
+ * completed. In this mode, the application is required to call
+ * set_fraction() periodically to update the progress bar.
+ *
+ * When an application has no accurate way of knowing the amount of work to
+ * do, it can use the Gtk::ProgressBar in activity mode, which shows
+ * activity by a block moving back and forth within the progress area. In
+ * this mode, the application is required to call pulse() perodically to
+ * update the progress bar.
+ *
+ * There is quite a bit of flexibility provided to control the appearance of
+ * the Gtk::ProgressBar. Functions are provided to control the orientation of
+ * the bar, optional text can be displayed along with the bar, and the step
+ * size used in activity mode can be set. 
+ *
+ * @ingroup Widgets
+ */
+
+class ProgressBar : public Widget
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef ProgressBar CppObjectType;
+  typedef ProgressBar_Class CppClassType;
+  typedef GtkProgressBar BaseObjectType;
+  typedef GtkProgressBarClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~ProgressBar();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class ProgressBar_Class;
+  static CppClassType progressbar_class_;
+
+  // noncopyable
+  ProgressBar(const ProgressBar&);
+  ProgressBar& operator=(const ProgressBar&);
+
+protected:
+  explicit ProgressBar(const Glib::ConstructParams& construct_params);
+  explicit ProgressBar(GtkProgressBar* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GtkProgressBar*       gobj()       { return reinterpret_cast<GtkProgressBar*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GtkProgressBar* gobj() const { return reinterpret_cast<GtkProgressBar*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+private:
+
+  
+public:
+  ProgressBar();
+
+  
+  /** Indicates that some progress is made, but you don't know how much.
+   * Causes the progress bar to enter "activity mode," where a block
+   * bounces back and forth. Each call to pulse()
+   * causes the block to move by a little bit (the amount of movement
+   * per pulse is determined by set_pulse_step()).
+   */
+  void pulse();
+
+  
+  /** Retrieves the text displayed superimposed on the progress bar,
+   * if any, otherwise <tt>0</tt>. The return value is a reference
+   * to the text, not a copy of it, so will become invalid
+   * if you change the text in the progress bar.
+   * @return Text, or <tt>0</tt>; this string is owned by the widget
+   * and should not be modified or freed.
+   */
+  Glib::ustring get_text() const;
+  
+  /** Causes the given @a text  to appear superimposed on the progress bar.
+   * @param text A UTF-8 string.
+   */
+  void set_text(const Glib::ustring& text);
+
+  
+  /** Returns the current fraction of the task that's been completed.
+   * @return A fraction from 0.0 to 1.0.
+   */
+  double get_fraction() const;
+  
+  /** Causes the progress bar to "fill in" the given fraction
+   * of the bar. The fraction should be between 0.0 and 1.0,
+   * inclusive.
+   * @param fraction Fraction of the task that's been completed.
+   */
+  void set_fraction(double fraction);
+
+  
+  /** Retrieves the pulse step set with set_pulse_step()
+   * @return A fraction from 0.0 to 1.0.
+   */
+  double get_pulse_step() const;
+  
+  /** Sets the fraction of total progress bar length to move the
+   * bouncing block for each call to pulse().
+   * @param fraction Fraction between 0.0 and 1.0.
+   */
+  void set_pulse_step(double fraction);
+
+  
+  /** Causes the progress bar to switch to a different orientation
+   * (left-to-right, right-to-left, top-to-bottom, or bottom-to-top).
+   * @param orientation Orientation of the progress bar.
+   */
+  void set_orientation(ProgressBarOrientation orientation = PROGRESS_LEFT_TO_RIGHT);
+  
+  /** Retrieves the current progress bar orientation.
+   * @return Orientation of the progress bar.
+   */
+  ProgressBarOrientation get_orientation() const;
+
+  
+  /** Sets the mode used to ellipsize (add an ellipsis: "...") the text 
+   * if there is not enough space to render the entire string.
+   * 
+   * Since: 2.6
+   * @param mode A Pango::EllipsizeMode.
+   */
+  void set_ellipsize(Pango::EllipsizeMode mode);
+  
+  Pango::EllipsizeMode get_ellipsize() const;
+
+  /** The fraction of total work that has been completed.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<double> property_fraction() ;
+
+/** The fraction of total work that has been completed.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<double> property_fraction() const;
+
+  /** The fraction of total progress to move the bouncing block when pulsed.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<double> property_pulse_step() ;
+
+/** The fraction of total progress to move the bouncing block when pulsed.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<double> property_pulse_step() const;
+
+  /** Orientation and growth direction of the progress bar.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<ProgressBarOrientation> property_orientation() ;
+
+/** Orientation and growth direction of the progress bar.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<ProgressBarOrientation> property_orientation() const;
+
+  /** Text to be displayed in the progress bar.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Glib::ustring> property_text() ;
+
+/** Text to be displayed in the progress bar.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Glib::ustring> property_text() const;
+
+  /** The preferred place to ellipsize the string
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_ellipsize() ;
+
+/** The preferred place to ellipsize the string
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_ellipsize() const;
+
+
+};
+
+} // namespace Gtk
+
+
+namespace Glib
+{
+  /** @relates Gtk::ProgressBar
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gtk::ProgressBar* wrap(GtkProgressBar* object, bool take_copy = false);
+}
+#endif /* _GTKMM_PROGRESSBAR_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/radioaction.cc b/libs/gtkmm2/gtk/gtkmm/radioaction.cc
new file mode 100644
index 0000000000..bac64f9dc4
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/radioaction.cc
@@ -0,0 +1,274 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/radioaction.h>
+#include <gtkmm/private/radioaction_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* Copyright 2003 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtk/gtkradioaction.h>
+
+
+typedef Gtk::RadioAction::Group Group; //So that the generate get_group return type is parsed.
+
+namespace Gtk
+{
+
+RadioAction::RadioAction(Group& group, const Glib::ustring& name, const Gtk::StockID& stock_id, const Glib::ustring& label, const Glib::ustring& tooltip)
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::ToggleAction(Glib::ConstructParams(radioaction_class_.init(), "name",name.c_str(),"stock_id",stock_id.get_c_str(),"label",(label.empty() ? 0 : label.c_str()),"tooltip",(tooltip.empty() ? 0 : tooltip.c_str()), (char*) 0))
+{
+  set_group(group);
+}
+
+Glib::RefPtr<RadioAction> RadioAction::create(Group& group, const Glib::ustring& name, const Glib::ustring& label, const Glib::ustring& tooltip)
+{
+  return Glib::RefPtr<RadioAction>( new RadioAction(group, name, Gtk::StockID(), label, tooltip) );
+}
+
+Glib::RefPtr<RadioAction> RadioAction::create(Group& group, const Glib::ustring& name, const Gtk::StockID& stock_id, const Glib::ustring& label, const Glib::ustring& tooltip)
+{
+  return Glib::RefPtr<RadioAction>( new RadioAction(group, name, stock_id, label, tooltip) );
+}
+
+void RadioAction::set_group(Group& group)
+{
+  gtk_radio_action_set_group(gobj(), group.group_);
+
+  //The group will be updated, ready for use with the next radio action:
+  group = get_group();
+}
+
+
+} // namespace Gtk
+
+
+namespace
+{
+
+void RadioAction_signal_changed_callback(GtkRadioAction* self, GtkRadioAction* p0,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,const Glib::RefPtr<RadioAction>& > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(Glib::wrap(p0)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+}
+
+const Glib::SignalProxyInfo RadioAction_signal_changed_info =
+{
+  "changed",
+  (GCallback) &RadioAction_signal_changed_callback,
+  (GCallback) &RadioAction_signal_changed_callback
+};
+
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Glib::RefPtr<Gtk::RadioAction> wrap(GtkRadioAction* object, bool take_copy)
+{
+  return Glib::RefPtr<Gtk::RadioAction>( dynamic_cast<Gtk::RadioAction*> (Glib::wrap_auto ((GObject*)(object), take_copy)) );
+  //We use dynamic_cast<> in case of multiple inheritance.
+}
+
+} /* namespace Glib */
+
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& RadioAction_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &RadioAction_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_radio_action_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void RadioAction_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+  klass->changed = &changed_callback;
+}
+
+
+void RadioAction_Class::changed_callback(GtkRadioAction* self, GtkRadioAction* p0)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_changed(Glib::wrap(p0)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->changed)
+      (*base->changed)(self, p0);
+  }
+}
+
+
+Glib::ObjectBase* RadioAction_Class::wrap_new(GObject* object)
+{
+  return new RadioAction((GtkRadioAction*)object);
+}
+
+
+/* The implementation: */
+
+GtkRadioAction* RadioAction::gobj_copy()
+{
+  reference();
+  return gobj();
+}
+
+RadioAction::RadioAction(const Glib::ConstructParams& construct_params)
+:
+  Gtk::ToggleAction(construct_params)
+{}
+
+RadioAction::RadioAction(GtkRadioAction* castitem)
+:
+  Gtk::ToggleAction((GtkToggleAction*)(castitem))
+{}
+
+RadioAction::~RadioAction()
+{}
+
+
+RadioAction::CppClassType RadioAction::radioaction_class_; // initialize static member
+
+GType RadioAction::get_type()
+{
+  return radioaction_class_.init().get_type();
+}
+
+GType RadioAction::get_base_type()
+{
+  return gtk_radio_action_get_type();
+}
+
+
+RadioAction::RadioAction()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::ToggleAction(Glib::ConstructParams(radioaction_class_.init()))
+{
+  }
+
+Glib::RefPtr<RadioAction> RadioAction::create()
+{
+  return Glib::RefPtr<RadioAction>( new RadioAction() );
+}
+Group RadioAction::get_group()
+{
+  return Group(gtk_radio_action_get_group(gobj()));
+}
+
+int RadioAction::get_current_value() const
+{
+  return gtk_radio_action_get_current_value(const_cast<GtkRadioAction*>(gobj()));
+}
+
+
+Glib::SignalProxy1< void,const Glib::RefPtr<RadioAction>& > RadioAction::signal_changed()
+{
+  return Glib::SignalProxy1< void,const Glib::RefPtr<RadioAction>& >(this, &RadioAction_signal_changed_info);
+}
+
+
+Glib::PropertyProxy<int> RadioAction::property_value() 
+{
+  return Glib::PropertyProxy<int>(this, "value");
+}
+
+Glib::PropertyProxy_ReadOnly<int> RadioAction::property_value() const
+{
+  return Glib::PropertyProxy_ReadOnly<int>(this, "value");
+}
+
+
+void Gtk::RadioAction::on_changed(const Glib::RefPtr<RadioAction>& current)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->changed)
+    (*base->changed)(gobj(),Glib::unwrap(current));
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/radioaction.h b/libs/gtkmm2/gtk/gtkmm/radioaction.h
new file mode 100644
index 0000000000..7c4366c123
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/radioaction.h
@@ -0,0 +1,169 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_RADIOACTION_H
+#define _GTKMM_RADIOACTION_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* Copyright (C) 2003 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/toggleaction.h>
+#include <gtkmm/radiobuttongroup.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkRadioAction GtkRadioAction;
+typedef struct _GtkRadioActionClass GtkRadioActionClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class RadioAction_Class; } // namespace Gtk
+namespace Gtk
+{
+
+
+class RadioAction : public Gtk::ToggleAction
+{
+  
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+public:
+  typedef RadioAction CppObjectType;
+  typedef RadioAction_Class CppClassType;
+  typedef GtkRadioAction BaseObjectType;
+  typedef GtkRadioActionClass BaseClassType;
+
+private:  friend class RadioAction_Class;
+  static CppClassType radioaction_class_;
+
+private:
+  // noncopyable
+  RadioAction(const RadioAction&);
+  RadioAction& operator=(const RadioAction&);
+
+protected:
+  explicit RadioAction(const Glib::ConstructParams& construct_params);
+  explicit RadioAction(GtkRadioAction* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+  virtual ~RadioAction();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GObject.
+  GtkRadioAction*       gobj()       { return reinterpret_cast<GtkRadioAction*>(gobject_); }
+
+  ///Provides access to the underlying C GObject.
+  const GtkRadioAction* gobj() const { return reinterpret_cast<GtkRadioAction*>(gobject_); }
+
+  ///Provides access to the underlying C instance. The caller is responsible for unrefing it. Use when directly setting fields in structs.
+  GtkRadioAction* gobj_copy();
+
+private:
+
+public:
+  typedef RadioButtonGroup Group;
+  
+protected:
+  RadioAction();
+  explicit RadioAction(Group& group, const Glib::ustring& name, const StockID& stock_id, const Glib::ustring& label = Glib::ustring(), const Glib::ustring& tooltip = Glib::ustring());
+
+public:
+  
+  static Glib::RefPtr<RadioAction> create();
+
+  static Glib::RefPtr<RadioAction> create(Group& group, const Glib::ustring& name, const Glib::ustring& label =  Glib::ustring(), const Glib::ustring& tooltip = Glib::ustring());
+  static Glib::RefPtr<RadioAction> create(Group& group, const Glib::ustring& name, const Gtk::StockID& stock_id, const Glib::ustring& label = Glib::ustring(), const Glib::ustring& tooltip =  Glib::ustring());
+
+  
+  /** Returns the list representing the radio group for this object
+   * @return The list representing the radio group for this object
+   * 
+   * Since: 2.4.
+   */
+  Group get_group();
+   void set_group(Group& group);
+  
+  
+  /** Obtains the value property of the the currently active member of 
+   * the group to which @a action  belongs.
+   * @return The value of the currently active group member
+   * 
+   * Since: 2.4.
+   */
+  int get_current_value() const;
+
+  
+  Glib::SignalProxy1< void,const Glib::RefPtr<RadioAction>& > signal_changed();
+
+
+  /** The value returned by gtk_radio_action_get_current_value when this action is the current action of its group.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<int> property_value() ;
+
+/** The value returned by gtk_radio_action_get_current_value when this action is the current action of its group.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<int> property_value() const;
+
+
+public:
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+  virtual void on_changed(const Glib::RefPtr<RadioAction>& current);
+
+
+};
+
+} // namespace Gtk
+
+
+namespace Glib
+{
+  /** @relates Gtk::RadioAction
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Glib::RefPtr<Gtk::RadioAction> wrap(GtkRadioAction* object, bool take_copy = false);
+}
+
+
+#endif /* _GTKMM_RADIOACTION_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/radiobutton.cc b/libs/gtkmm2/gtk/gtkmm/radiobutton.cc
new file mode 100644
index 0000000000..6fb1b2985f
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/radiobutton.cc
@@ -0,0 +1,236 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/radiobutton.h>
+#include <gtkmm/private/radiobutton_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* 
+ *
+ * Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtk/gtkradiobutton.h>
+
+typedef Gtk::RadioButton::Group Group; //So that the generate get_group return type is parsed.
+
+namespace Gtk
+{
+
+RadioButton::RadioButton()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::CheckButton(Glib::ConstructParams(radiobutton_class_.init(), (char*) 0))
+{}
+
+RadioButton::RadioButton(const Glib::ustring& label, bool mnemonic)
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::CheckButton(Glib::ConstructParams(radiobutton_class_.init(), "label",label.c_str(),"use_underline",gboolean(mnemonic), (char*) 0))
+{}
+
+RadioButton::RadioButton(Group& group)
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::CheckButton(Glib::ConstructParams(radiobutton_class_.init(), (char*) 0))
+{
+  group.add(*this);
+}
+
+RadioButton::RadioButton(Group& group, const Glib::ustring& label, bool mnemonic)
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::CheckButton(Glib::ConstructParams(radiobutton_class_.init(), "label",label.c_str(),"use_underline",gboolean(mnemonic), (char*) 0))
+{
+  group.add(*this);
+}
+
+void RadioButton::set_group(Group& group)
+{
+  gtk_radio_button_set_group(gobj(), group.group_);
+
+  //The group will be updated, ready for use with the next radiobutton:
+  group = get_group();
+}
+
+void RadioButton::reset_group()
+{
+  gtk_radio_button_set_group(gobj(), 0);
+}
+
+} //namespace Gtk
+
+
+namespace
+{
+
+const Glib::SignalProxyInfo RadioButton_signal_group_changed_info =
+{
+  "group_changed",
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
+};
+
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Gtk::RadioButton* wrap(GtkRadioButton* object, bool take_copy)
+{
+  return dynamic_cast<Gtk::RadioButton *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& RadioButton_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &RadioButton_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_radio_button_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void RadioButton_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+  klass->group_changed = &group_changed_callback;
+}
+
+
+void RadioButton_Class::group_changed_callback(GtkRadioButton* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_group_changed();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->group_changed)
+      (*base->group_changed)(self);
+  }
+}
+
+
+Glib::ObjectBase* RadioButton_Class::wrap_new(GObject* o)
+{
+  return manage(new RadioButton((GtkRadioButton*)(o)));
+
+}
+
+
+/* The implementation: */
+
+RadioButton::RadioButton(const Glib::ConstructParams& construct_params)
+:
+  Gtk::CheckButton(construct_params)
+{
+  }
+
+RadioButton::RadioButton(GtkRadioButton* castitem)
+:
+  Gtk::CheckButton((GtkCheckButton*)(castitem))
+{
+  }
+
+RadioButton::~RadioButton()
+{
+  destroy_();
+}
+
+RadioButton::CppClassType RadioButton::radiobutton_class_; // initialize static member
+
+GType RadioButton::get_type()
+{
+  return radiobutton_class_.init().get_type();
+}
+
+GType RadioButton::get_base_type()
+{
+  return gtk_radio_button_get_type();
+}
+
+
+Group RadioButton::get_group()
+{
+  return Group(gtk_radio_button_get_group(gobj()));
+}
+
+
+Glib::SignalProxy0< void > RadioButton::signal_group_changed()
+{
+  return Glib::SignalProxy0< void >(this, &RadioButton_signal_group_changed_info);
+}
+
+
+void Gtk::RadioButton::on_group_changed()
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->group_changed)
+    (*base->group_changed)(gobj());
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/radiobutton.h b/libs/gtkmm2/gtk/gtkmm/radiobutton.h
new file mode 100644
index 0000000000..f81a6e624f
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/radiobutton.h
@@ -0,0 +1,151 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_RADIOBUTTON_H
+#define _GTKMM_RADIOBUTTON_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* radiobutton.h
+ * 
+ * Copyright (C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/checkbutton.h>
+#include <gtkmm/radiobuttongroup.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkRadioButton GtkRadioButton;
+typedef struct _GtkRadioButtonClass GtkRadioButtonClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class RadioButton_Class; } // namespace Gtk
+namespace Gtk
+{
+
+/** A single radio button performs the same basic function as a Gtk::CheckButton, as its position in the object hierarchy reflects. It is only when multiple radio buttons are grouped together that they become a different user interface component in their own right.
+ * Every radio button is a member of some group of radio buttons. When one is selected, all other radio buttons in the same group are deselected. A Gtk::RadioButton gives the user a choice from many options.
+ * After constructing the first RadioButton in a group, use get_group() and provide this Group to the constructors ot the other RadioButtons in the same group.
+ * To remove a Gtk::RadioButton from one group and make it part of a new one, use set_group().
+ *
+ * @ingroup Widgets
+ */
+
+class RadioButton : public CheckButton
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef RadioButton CppObjectType;
+  typedef RadioButton_Class CppClassType;
+  typedef GtkRadioButton BaseObjectType;
+  typedef GtkRadioButtonClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~RadioButton();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class RadioButton_Class;
+  static CppClassType radiobutton_class_;
+
+  // noncopyable
+  RadioButton(const RadioButton&);
+  RadioButton& operator=(const RadioButton&);
+
+protected:
+  explicit RadioButton(const Glib::ConstructParams& construct_params);
+  explicit RadioButton(GtkRadioButton* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GtkRadioButton*       gobj()       { return reinterpret_cast<GtkRadioButton*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GtkRadioButton* gobj() const { return reinterpret_cast<GtkRadioButton*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+  virtual void on_group_changed();
+
+
+private:
+
+  
+public:
+  typedef RadioButtonGroup Group;
+
+  RadioButton();
+  explicit RadioButton(const Glib::ustring& label, bool mnemonic = false);
+
+  /** Create an empty RadioButton belonging to the specified group,
+   * into which you can add() a widget.
+   * If you wish to add a Gtk::Label,
+   * you may want to
+   * use the Gtk::RadioButton(const Group& group, const Glib::ustring& label, bool mnemonic)
+   * constructor directly instead.
+   */
+  explicit RadioButton(Group& group);
+
+  /** Create a button belonging to the specified group, with a label inside.
+   * You won't be able to add a widget to this button
+   * since it already contains a Gtk::Label.
+   */
+  RadioButton(Group& group, const Glib::ustring& label, bool mnemonic = false);
+  
+
+  Group get_group();
+  void set_group(Group& group);
+  void reset_group();
+  
+
+  Glib::SignalProxy0< void > signal_group_changed();
+
+
+};
+
+} /* namespace Gtk */
+
+
+namespace Glib
+{
+  /** @relates Gtk::RadioButton
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gtk::RadioButton* wrap(GtkRadioButton* object, bool take_copy = false);
+}
+#endif /* _GTKMM_RADIOBUTTON_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/radiobuttongroup.cc b/libs/gtkmm2/gtk/gtkmm/radiobuttongroup.cc
new file mode 100644
index 0000000000..d70d06616e
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/radiobuttongroup.cc
@@ -0,0 +1,86 @@
+/* $Id$ */
+
+/* Copyright(C) 2003 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/radiobuttongroup.h>
+
+#include <gtkmm/radiobutton.h>
+#include <gtkmm/radiomenuitem.h>
+#include <gtkmm/radioaction.h>
+#include <gtkmm/radiotoolbutton.h>
+#include <gtk/gtkradiobutton.h>
+#include <gtk/gtkradioaction.h>
+#include <gtk/gtkradiomenuitem.h>
+#include <gtk/gtkradiotoolbutton.h>
+
+namespace Gtk
+{
+
+RadioButtonGroup::RadioButtonGroup()
+: group_(0)
+{}
+
+RadioButtonGroup::RadioButtonGroup(GSList* group)
+ : group_(group)
+{
+}
+
+RadioButtonGroup::RadioButtonGroup(const RadioButtonGroup& src)
+ : group_(src.group_)
+{
+}
+
+RadioButtonGroup& RadioButtonGroup::operator=(const RadioButtonGroup& src)
+{
+  group_ = src.group_;
+  return *this;
+}
+
+void RadioButtonGroup::add(RadioButton& item)
+{
+  item.set_group(*this);
+
+  //probably not necessary:
+  group_ = gtk_radio_button_get_group(item.gobj());
+}
+
+void RadioButtonGroup::add(RadioMenuItem& item)
+{
+  item.set_group(*this);
+
+  //probably not necessary:
+  group_ = item.gobj()->group;
+}
+
+void RadioButtonGroup::add(const Glib::RefPtr<RadioAction>& item)
+{
+  item->set_group(*this);
+
+  //probably not necessary:
+  group_ = gtk_radio_action_get_group(item->gobj());
+}
+
+void RadioButtonGroup::add(RadioToolButton& item)
+{
+  item.set_group(*this);
+
+  //probably not necessary:
+  group_ = gtk_radio_tool_button_get_group(item.gobj());
+}
+
+} //namespace Gtk
diff --git a/libs/gtkmm2/gtk/gtkmm/radiobuttongroup.h b/libs/gtkmm2/gtk/gtkmm/radiobuttongroup.h
new file mode 100644
index 0000000000..8a9e044293
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/radiobuttongroup.h
@@ -0,0 +1,80 @@
+#ifndef _GTKMM_RADIOBUTTONGROUP_H
+#define _GTKMM_RADIOBUTTONGROUP_H
+/* $Id$ */
+
+/* radiobuttongroup.h
+ *
+ * Copyright(C) 2001-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <glibmm/object.h> //For RefPtr<> and size_t
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+extern "C"
+{
+  typedef struct _GSList GSList;
+}
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+namespace Gtk
+{
+
+class RadioButton;
+class RadioMenuItem;
+class RadioAction;
+class RadioToolButton;
+
+/** RadioButtonGroup identifier for RadioButtons
+ * To set up this RadioButtonGroup, construct a RadioButtonGroup and then pass it
+ * to the constructor of all radio items.  You do not need
+ * to keep the RadioButtonGroup beyond the initial construction.
+ * It should not be instantiated with new, and it will be invalid after the RadioButtons have been deleted.
+ */
+class RadioButtonGroup
+{
+public:
+  RadioButtonGroup();
+  RadioButtonGroup(const RadioButtonGroup& src);
+
+  RadioButtonGroup& operator=(const RadioButtonGroup& src);
+
+protected:
+  explicit RadioButtonGroup(GSList* group);
+
+  friend class Gtk::RadioButton;
+  friend class Gtk::RadioMenuItem;
+  friend class Gtk::RadioAction;
+  friend class Gtk::RadioToolButton;
+
+
+  //These all have similar interfaces.
+  //TODO: Add a common multiply-inherited base class, with set_group()=0?
+  //      Would that anything useful other than being tidy? murrayc
+  void add(RadioButton& item);
+  void add(RadioMenuItem& item);
+  void add(const Glib::RefPtr<RadioAction>& item);
+  void add(RadioToolButton& item);
+
+  void* operator new(size_t); // not implemented
+
+  GSList* group_;
+};
+  
+} // namespace Gtk
+
+
+#endif /* _GTKMM_RADIOBUTTONGROUP_H */
diff --git a/libs/gtkmm2/gtk/gtkmm/radiomenuitem.cc b/libs/gtkmm2/gtk/gtkmm/radiomenuitem.cc
new file mode 100644
index 0000000000..15bff44cc2
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/radiomenuitem.cc
@@ -0,0 +1,228 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/radiomenuitem.h>
+#include <gtkmm/private/radiomenuitem_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* 
+ *
+ * Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/misc.h>
+#include <gtkmm/label.h>
+#include <gtk/gtkradiomenuitem.h>
+
+typedef Gtk::RadioMenuItem::Group Group; //So that the generate get_group return type is parsed.
+
+namespace Gtk
+{
+
+RadioMenuItem::RadioMenuItem(Group& groupx)
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::CheckMenuItem(Glib::ConstructParams(radiomenuitem_class_.init(), (char*) 0))
+{
+  groupx.add(*this);
+}
+
+RadioMenuItem::RadioMenuItem(Group& groupx, const Glib::ustring &label, bool mnemonic)
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::CheckMenuItem(Glib::ConstructParams(radiomenuitem_class_.init(), (char*) 0))
+{
+  groupx.add(*this);
+  add_accel_label(label, mnemonic);
+}
+
+void RadioMenuItem::set_group(Group& group)
+{
+  gtk_radio_menu_item_set_group(gobj(), group.group_);
+
+   //The group will be updated, ready for use with the next radiomenuitem:
+  group = get_group();
+}
+
+void RadioMenuItem::reset_group()
+{
+  gtk_radio_menu_item_set_group(gobj(), 0);
+}
+
+
+} // namespace Gtk
+
+
+namespace
+{
+
+const Glib::SignalProxyInfo RadioMenuItem_signal_group_changed_info =
+{
+  "group_changed",
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
+};
+
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Gtk::RadioMenuItem* wrap(GtkRadioMenuItem* object, bool take_copy)
+{
+  return dynamic_cast<Gtk::RadioMenuItem *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& RadioMenuItem_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &RadioMenuItem_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_radio_menu_item_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void RadioMenuItem_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+  klass->group_changed = &group_changed_callback;
+}
+
+
+void RadioMenuItem_Class::group_changed_callback(GtkRadioMenuItem* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_group_changed();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->group_changed)
+      (*base->group_changed)(self);
+  }
+}
+
+
+Glib::ObjectBase* RadioMenuItem_Class::wrap_new(GObject* o)
+{
+  return manage(new RadioMenuItem((GtkRadioMenuItem*)(o)));
+
+}
+
+
+/* The implementation: */
+
+RadioMenuItem::RadioMenuItem(const Glib::ConstructParams& construct_params)
+:
+  Gtk::CheckMenuItem(construct_params)
+{
+  }
+
+RadioMenuItem::RadioMenuItem(GtkRadioMenuItem* castitem)
+:
+  Gtk::CheckMenuItem((GtkCheckMenuItem*)(castitem))
+{
+  }
+
+RadioMenuItem::~RadioMenuItem()
+{
+  destroy_();
+}
+
+RadioMenuItem::CppClassType RadioMenuItem::radiomenuitem_class_; // initialize static member
+
+GType RadioMenuItem::get_type()
+{
+  return radiomenuitem_class_.init().get_type();
+}
+
+GType RadioMenuItem::get_base_type()
+{
+  return gtk_radio_menu_item_get_type();
+}
+
+
+Group RadioMenuItem::get_group()
+{
+  return Group(gtk_radio_menu_item_get_group(gobj()));
+}
+
+
+Glib::SignalProxy0< void > RadioMenuItem::signal_group_changed()
+{
+  return Glib::SignalProxy0< void >(this, &RadioMenuItem_signal_group_changed_info);
+}
+
+
+void Gtk::RadioMenuItem::on_group_changed()
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->group_changed)
+    (*base->group_changed)(gobj());
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/radiomenuitem.h b/libs/gtkmm2/gtk/gtkmm/radiomenuitem.h
new file mode 100644
index 0000000000..364a088131
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/radiomenuitem.h
@@ -0,0 +1,145 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_RADIOMENUITEM_H
+#define _GTKMM_RADIOMENUITEM_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* radiomenuitem.h
+ * 
+ * Copyright (C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/checkmenuitem.h>
+#include <gtkmm/radiobutton.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkRadioMenuItem GtkRadioMenuItem;
+typedef struct _GtkRadioMenuItemClass GtkRadioMenuItemClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class RadioMenuItem_Class; } // namespace Gtk
+namespace Gtk
+{
+
+class RadioMenuItem;
+
+/** A CheckMenuItem that belongs to a group.
+ * At each instant exactly one of the menu items from a group is selected.
+ * @ingroup Menus
+ * @ingroup Widgets
+ */
+
+class RadioMenuItem : public CheckMenuItem
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef RadioMenuItem CppObjectType;
+  typedef RadioMenuItem_Class CppClassType;
+  typedef GtkRadioMenuItem BaseObjectType;
+  typedef GtkRadioMenuItemClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~RadioMenuItem();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class RadioMenuItem_Class;
+  static CppClassType radiomenuitem_class_;
+
+  // noncopyable
+  RadioMenuItem(const RadioMenuItem&);
+  RadioMenuItem& operator=(const RadioMenuItem&);
+
+protected:
+  explicit RadioMenuItem(const Glib::ConstructParams& construct_params);
+  explicit RadioMenuItem(GtkRadioMenuItem* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GtkRadioMenuItem*       gobj()       { return reinterpret_cast<GtkRadioMenuItem*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GtkRadioMenuItem* gobj() const { return reinterpret_cast<GtkRadioMenuItem*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+  virtual void on_group_changed();
+
+
+private:
+
+public:
+  
+  typedef RadioButtonGroup Group;
+
+  RadioMenuItem(Group& groupx);
+  
+  RadioMenuItem(Group& groupx, const Glib::ustring& label, bool mnemonic = false);
+  
+
+  //We ignore the _new_*_from_widget() functions because they are just the same as calling get_group() and set_group() ourselves.
+  
+                    
+  Group get_group();
+  
+  void set_group(Group& group);
+  void reset_group();
+
+  
+  Glib::SignalProxy0< void > signal_group_changed();
+
+
+protected:
+  void constructor(const Group& group);
+
+
+};
+
+} /* namspace Gtk */
+
+
+namespace Glib
+{
+  /** @relates Gtk::RadioMenuItem
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gtk::RadioMenuItem* wrap(GtkRadioMenuItem* object, bool take_copy = false);
+}
+#endif /* _GTKMM_RADIOMENUITEM_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/radiotoolbutton.cc b/libs/gtkmm2/gtk/gtkmm/radiotoolbutton.cc
new file mode 100644
index 0000000000..19f716a33b
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/radiotoolbutton.cc
@@ -0,0 +1,183 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/radiotoolbutton.h>
+#include <gtkmm/private/radiotoolbutton_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* 
+ *
+ * Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtk/gtkradiotoolbutton.h>
+
+typedef Gtk::RadioToolButton::Group Group; //So that the generate get_group return type is parsed.
+
+namespace Gtk
+{
+
+RadioToolButton::RadioToolButton(Group& group, const Glib::ustring& label)
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::ToggleToolButton(Glib::ConstructParams(radiotoolbutton_class_.init(), "label", label.c_str(), (char*) 0))
+{
+  set_group(group);
+}
+
+RadioToolButton::RadioToolButton(Group& group, const Gtk::StockID& stock_id)
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::ToggleToolButton(Glib::ConstructParams(radiotoolbutton_class_.init(), "stock_id", (stock_id).get_c_str(), (char*) 0))
+{
+  //Based on the source of gtk_radio_tool_button_new_from_stock():
+  set_group(group);
+}
+
+/* This would look too much like a copy constructor:
+RadioToolButton::RadioToolButton(RadioToolButton& group, const Gtk::StockID& stock_id)
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::ToggleToolButton(Glib::ConstructParams(radiotoolbutton_class_.init(), "stock_id", (stock_id).get_c_str(), (char*) 0))
+{
+  //Based on the source of gtk_radio_tool_button_new_with_stock_from_widget():
+  Gtk::RadioButtonGroup radiogroup = group.get_group();
+  set_group(radiogroup);
+}
+*/
+
+RadioToolButton::RadioToolButton(Widget& icon_widget, const Glib::ustring& label)
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::ToggleToolButton(Glib::ConstructParams(radiotoolbutton_class_.init(), "icon_widget", (icon_widget).gobj(), "label", label.c_str(), (char*) 0))
+{
+}
+
+
+} // namespace Gtk
+
+
+namespace
+{
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Gtk::RadioToolButton* wrap(GtkRadioToolButton* object, bool take_copy)
+{
+  return dynamic_cast<Gtk::RadioToolButton *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& RadioToolButton_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &RadioToolButton_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_radio_tool_button_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void RadioToolButton_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+}
+
+
+Glib::ObjectBase* RadioToolButton_Class::wrap_new(GObject* o)
+{
+  return manage(new RadioToolButton((GtkRadioToolButton*)(o)));
+
+}
+
+
+/* The implementation: */
+
+RadioToolButton::RadioToolButton(const Glib::ConstructParams& construct_params)
+:
+  Gtk::ToggleToolButton(construct_params)
+{
+  }
+
+RadioToolButton::RadioToolButton(GtkRadioToolButton* castitem)
+:
+  Gtk::ToggleToolButton((GtkToggleToolButton*)(castitem))
+{
+  }
+
+RadioToolButton::~RadioToolButton()
+{
+  destroy_();
+}
+
+RadioToolButton::CppClassType RadioToolButton::radiotoolbutton_class_; // initialize static member
+
+GType RadioToolButton::get_type()
+{
+  return radiotoolbutton_class_.init().get_type();
+}
+
+GType RadioToolButton::get_base_type()
+{
+  return gtk_radio_tool_button_get_type();
+}
+
+
+RadioToolButton::RadioToolButton()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::ToggleToolButton(Glib::ConstructParams(radiotoolbutton_class_.init()))
+{
+  }
+
+Group RadioToolButton::get_group()
+{
+  return Group(gtk_radio_tool_button_get_group(gobj()));
+}
+
+void RadioToolButton::set_group(Group& group)
+{
+  gtk_radio_tool_button_set_group(gobj(), group.group_);
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/radiotoolbutton.h b/libs/gtkmm2/gtk/gtkmm/radiotoolbutton.h
new file mode 100644
index 0000000000..02eec24f74
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/radiotoolbutton.h
@@ -0,0 +1,195 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_RADIOTOOLBUTTON_H
+#define _GTKMM_RADIOTOOLBUTTON_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* box.h
+ *
+ * Copyright (C) 2003 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/toggletoolbutton.h>
+#include <gtkmm/radiobuttongroup.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkRadioToolButton GtkRadioToolButton;
+typedef struct _GtkRadioToolButtonClass GtkRadioToolButtonClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class RadioToolButton_Class; } // namespace Gtk
+namespace Gtk
+{
+
+/** A toolbar item that contains a radio button.
+ *
+ * A Gtk::RadioToolButton is a Gtk::ToolItem that contains a radio button, that is,
+ * a button that is part of a group of toggle buttons where only one button can be
+ * active at a time.
+ *
+ * @ingroup Widgets
+ */
+
+class RadioToolButton : public ToggleToolButton
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef RadioToolButton CppObjectType;
+  typedef RadioToolButton_Class CppClassType;
+  typedef GtkRadioToolButton BaseObjectType;
+  typedef GtkRadioToolButtonClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~RadioToolButton();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class RadioToolButton_Class;
+  static CppClassType radiotoolbutton_class_;
+
+  // noncopyable
+  RadioToolButton(const RadioToolButton&);
+  RadioToolButton& operator=(const RadioToolButton&);
+
+protected:
+  explicit RadioToolButton(const Glib::ConstructParams& construct_params);
+  explicit RadioToolButton(GtkRadioToolButton* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GtkRadioToolButton*       gobj()       { return reinterpret_cast<GtkRadioToolButton*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GtkRadioToolButton* gobj() const { return reinterpret_cast<GtkRadioToolButton*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+private:
+
+public:
+  typedef RadioButtonGroup Group;
+
+  /** Creates a new Gtk::RadioToolButton and a new group.
+   *
+   * The RadioToolButton will have an empty label and will reside in an newly created Group.
+   * Use get_group() to retrieve this group and pass it to other radio buttons to assign
+   * them to this group.
+   *
+   * Since: 2.4
+   */
+  RadioToolButton();
+  
+  /** Creates a new Gtk::RadioToolButton in an existing group.
+   *
+   * The RadioToolButton will have the label @a label and will be put into the Group
+   * @a group.
+   *
+   * @param group The existing group which will be used for this RadioButton.
+   * @param label The string used to display the label for this RadioToolButton.
+   *
+   * Since: 2.4
+   */
+  explicit RadioToolButton(Group& group, const Glib::ustring& label = Glib::ustring());
+  
+  
+  /** Creates a new Gtk::RadioToolButton in an existing group.
+   *
+   * The RadioToolButton will be created according to the StockID properties and put into
+   * the Group @a group.
+   * 
+   * @param group The existing group which will be used for this RadioButton.
+   * @param stock_id The StockID which determines the look of the RadioToolButton.
+   *
+   * Since: 2.4
+   */
+  RadioToolButton(Group& group, const Gtk::StockID& stock_id);
+  
+
+  //This would look to much like a copy constructor:
+  //People should use second.set_group(first.get_group()) instead.
+  //explicit RadioToolButton(RadioToolButton& group, const Gtk::StockID& stock_id = Gtk::StockID());
+  
+
+  //This does not correspond to any gtk_radio_tool_button_*_new() function,
+  //but it should work (it just sets properties), and it makes this class consistent with the
+  //other ToolButton classes.
+  
+  /** Creates a new Gtk::RadioToolButton with an image and a new group.
+   *
+   * The RadioToolButton will have the label @a label and an image widget @a icon_widget.
+   *
+   * @param icon_widget The widget placed as the RadioToolButton's icon.
+   * @param label The string used to display the label for this RadioToolButton.
+   *
+   * Since: 2.4
+   */
+  explicit RadioToolButton(Widget& icon_widget, const Glib::ustring& label = Glib::ustring());
+
+  
+  /** Returns the radio button group @a button  belongs to.
+   * @return The group @a button  belongs to.
+   * 
+   * Since: 2.4.
+   */
+  Group get_group();
+  
+  /** Adds @a button  to @a group , removing it from the group it belonged to before.
+   * 
+   * Since: 2.4
+   * @param group An existing radio button group.
+   */
+  void set_group(Group& group);
+
+
+};
+
+} // namespace Gtk
+
+
+namespace Glib
+{
+  /** @relates Gtk::RadioToolButton
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gtk::RadioToolButton* wrap(GtkRadioToolButton* object, bool take_copy = false);
+}
+#endif /* _GTKMM_RADIOTOOLBUTTON_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/range.cc b/libs/gtkmm2/gtk/gtkmm/range.cc
new file mode 100644
index 0000000000..f7bf958b2e
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/range.cc
@@ -0,0 +1,554 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/range.h>
+#include <gtkmm/private/range_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtk/gtkrange.h>
+#include <gtkmm/adjustment.h>
+
+namespace Gtk
+{
+
+void Range::unset_adjustment()
+{
+  gtk_range_set_adjustment(gobj(), 0);
+}
+
+} // namespace Gtk
+
+
+namespace
+{
+
+const Glib::SignalProxyInfo Range_signal_value_changed_info =
+{
+  "value_changed",
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
+};
+
+
+void Range_signal_adjust_bounds_callback(GtkRange* self, gdouble p0,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,double > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(p0
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+}
+
+const Glib::SignalProxyInfo Range_signal_adjust_bounds_info =
+{
+  "adjust_bounds",
+  (GCallback) &Range_signal_adjust_bounds_callback,
+  (GCallback) &Range_signal_adjust_bounds_callback
+};
+
+
+void Range_signal_move_slider_callback(GtkRange* self, GtkScrollType p0,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,ScrollType > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(((ScrollType)(p0))
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+}
+
+const Glib::SignalProxyInfo Range_signal_move_slider_info =
+{
+  "move_slider",
+  (GCallback) &Range_signal_move_slider_callback,
+  (GCallback) &Range_signal_move_slider_callback
+};
+
+
+gboolean Range_signal_change_value_callback(GtkRange* self, GtkScrollType p0,gdouble p1,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< bool,ScrollType,double > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        return static_cast<int>((*static_cast<SlotType*>(slot))(((ScrollType)(p0))
+, p1
+));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+gboolean Range_signal_change_value_notify_callback(GtkRange* self, GtkScrollType p0,gdouble p1, void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,ScrollType,double > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(((ScrollType)(p0))
+, p1
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+const Glib::SignalProxyInfo Range_signal_change_value_info =
+{
+  "change_value",
+  (GCallback) &Range_signal_change_value_callback,
+  (GCallback) &Range_signal_change_value_notify_callback
+};
+
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Gtk::Range* wrap(GtkRange* object, bool take_copy)
+{
+  return dynamic_cast<Gtk::Range *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& Range_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &Range_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_range_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void Range_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+  klass->get_range_border = &get_range_border_vfunc_callback;
+  klass->value_changed = &value_changed_callback;
+  klass->adjust_bounds = &adjust_bounds_callback;
+  klass->move_slider = &move_slider_callback;
+}
+
+void Range_Class::get_range_border_vfunc_callback(GtkRange* self, GtkBorder* border)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->get_range_border_vfunc(border);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->get_range_border)
+      (*base->get_range_border)(self, border);
+  }
+}
+
+
+void Range_Class::value_changed_callback(GtkRange* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_value_changed();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->value_changed)
+      (*base->value_changed)(self);
+  }
+}
+
+void Range_Class::adjust_bounds_callback(GtkRange* self, gdouble p0)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_adjust_bounds(p0
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->adjust_bounds)
+      (*base->adjust_bounds)(self, p0);
+  }
+}
+
+void Range_Class::move_slider_callback(GtkRange* self, GtkScrollType p0)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_move_slider(((ScrollType)(p0))
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->move_slider)
+      (*base->move_slider)(self, p0);
+  }
+}
+
+
+Glib::ObjectBase* Range_Class::wrap_new(GObject* o)
+{
+  return manage(new Range((GtkRange*)(o)));
+
+}
+
+
+/* The implementation: */
+
+Range::Range(const Glib::ConstructParams& construct_params)
+:
+  Gtk::Widget(construct_params)
+{
+  }
+
+Range::Range(GtkRange* castitem)
+:
+  Gtk::Widget((GtkWidget*)(castitem))
+{
+  }
+
+Range::~Range()
+{
+  destroy_();
+}
+
+Range::CppClassType Range::range_class_; // initialize static member
+
+GType Range::get_type()
+{
+  return range_class_.init().get_type();
+}
+
+GType Range::get_base_type()
+{
+  return gtk_range_get_type();
+}
+
+
+Range::Range()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Widget(Glib::ConstructParams(range_class_.init()))
+{
+  }
+
+void Range::set_update_policy(UpdateType policy)
+{
+  gtk_range_set_update_policy(gobj(), ((GtkUpdateType)(policy)));
+}
+
+UpdateType Range::get_update_policy() const
+{
+  return ((UpdateType)(gtk_range_get_update_policy(const_cast<GtkRange*>(gobj()))));
+}
+
+void Range::set_adjustment(Gtk::Adjustment& adjustment)
+{
+  gtk_range_set_adjustment(gobj(), (adjustment).gobj());
+}
+
+Gtk::Adjustment* Range::get_adjustment()
+{
+  return Glib::wrap(gtk_range_get_adjustment(gobj()));
+}
+
+const Gtk::Adjustment* Range::get_adjustment() const
+{
+  return Glib::wrap(gtk_range_get_adjustment(const_cast<GtkRange*>(gobj())));
+}
+
+void Range::set_inverted(bool setting)
+{
+  gtk_range_set_inverted(gobj(), static_cast<int>(setting));
+}
+
+bool Range::get_inverted() const
+{
+  return gtk_range_get_inverted(const_cast<GtkRange*>(gobj()));
+}
+
+void Range::set_increments(double step, double page)
+{
+  gtk_range_set_increments(gobj(), step, page);
+}
+
+void Range::set_range(double min, double max)
+{
+  gtk_range_set_range(gobj(), min, max);
+}
+
+void Range::set_value(double value)
+{
+  gtk_range_set_value(gobj(), value);
+}
+
+double Range::get_value() const
+{
+  return gtk_range_get_value(const_cast<GtkRange*>(gobj()));
+}
+
+
+Glib::SignalProxy0< void > Range::signal_value_changed()
+{
+  return Glib::SignalProxy0< void >(this, &Range_signal_value_changed_info);
+}
+
+Glib::SignalProxy1< void,double > Range::signal_adjust_bounds()
+{
+  return Glib::SignalProxy1< void,double >(this, &Range_signal_adjust_bounds_info);
+}
+
+Glib::SignalProxy1< void,ScrollType > Range::signal_move_slider()
+{
+  return Glib::SignalProxy1< void,ScrollType >(this, &Range_signal_move_slider_info);
+}
+
+Glib::SignalProxy2< bool,ScrollType,double > Range::signal_change_value()
+{
+  return Glib::SignalProxy2< bool,ScrollType,double >(this, &Range_signal_change_value_info);
+}
+
+
+Glib::PropertyProxy<UpdateType> Range::property_update_policy() 
+{
+  return Glib::PropertyProxy<UpdateType>(this, "update-policy");
+}
+
+Glib::PropertyProxy_ReadOnly<UpdateType> Range::property_update_policy() const
+{
+  return Glib::PropertyProxy_ReadOnly<UpdateType>(this, "update-policy");
+}
+
+Glib::PropertyProxy<Adjustment*> Range::property_adjustment() 
+{
+  return Glib::PropertyProxy<Adjustment*>(this, "adjustment");
+}
+
+Glib::PropertyProxy_ReadOnly<Adjustment*> Range::property_adjustment() const
+{
+  return Glib::PropertyProxy_ReadOnly<Adjustment*>(this, "adjustment");
+}
+
+Glib::PropertyProxy<bool> Range::property_inverted() 
+{
+  return Glib::PropertyProxy<bool>(this, "inverted");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> Range::property_inverted() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "inverted");
+}
+
+
+void Gtk::Range::on_value_changed()
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->value_changed)
+    (*base->value_changed)(gobj());
+}
+
+void Gtk::Range::on_adjust_bounds(double new_value)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->adjust_bounds)
+    (*base->adjust_bounds)(gobj(),new_value);
+}
+
+void Gtk::Range::on_move_slider(ScrollType scroll)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->move_slider)
+    (*base->move_slider)(gobj(),((GtkScrollType)(scroll)));
+}
+
+
+void Gtk::Range::get_range_border_vfunc(GtkBorder* border) const
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->get_range_border)
+    (*base->get_range_border)(const_cast<GtkRange*>(gobj()),border);
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/range.h b/libs/gtkmm2/gtk/gtkmm/range.h
new file mode 100644
index 0000000000..f84118bb65
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/range.h
@@ -0,0 +1,282 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_RANGE_H
+#define _GTKMM_RANGE_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* Copyright (C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/widget.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkRange GtkRange;
+typedef struct _GtkRangeClass GtkRangeClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class Range_Class; } // namespace Gtk
+namespace Gtk
+{
+
+class Adjustment;
+
+/** Base class for widgets which visualize an adjustment.
+ *
+ * @ingroup Widgets
+ */
+
+class Range : public Widget
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Range CppObjectType;
+  typedef Range_Class CppClassType;
+  typedef GtkRange BaseObjectType;
+  typedef GtkRangeClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~Range();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class Range_Class;
+  static CppClassType range_class_;
+
+  // noncopyable
+  Range(const Range&);
+  Range& operator=(const Range&);
+
+protected:
+  explicit Range(const Glib::ConstructParams& construct_params);
+  explicit Range(GtkRange* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GtkRange*       gobj()       { return reinterpret_cast<GtkRange*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GtkRange* gobj() const { return reinterpret_cast<GtkRange*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+  virtual void on_value_changed();
+  virtual void on_adjust_bounds(double new_value);
+  virtual void on_move_slider(ScrollType scroll);
+
+
+private:
+
+protected:
+  Range();
+public:
+  
+
+  /** Sets the update policy for the range. Gtk::UPDATE_CONTINUOUS means that
+   * anytime the range slider is moved, the range value will change and the
+   * value_changed signal will be emitted. Gtk::UPDATE_DELAYED means that
+   * the value will be updated after a brief timeout where no slider motion
+   * occurs, so updates are spaced by a short time rather than
+   * continuous. Gtk::UPDATE_DISCONTINUOUS means that the value will only
+   * be updated when the user releases the button and ends the slider
+   * drag operation.
+   * @param policy Update policy.
+   */
+  void set_update_policy(UpdateType policy);
+  
+  /** Gets the update policy of @a range . See set_update_policy().
+   * @return The current update policy.
+   */
+  UpdateType get_update_policy() const;
+  
+  /** Sets the adjustment to be used as the "model" object for this range
+   * widget. The adjustment indicates the current range value, the
+   * minimum and maximum range values, the step/page increments used
+   * for keybindings and scrolling, and the page size. The page size
+   * is normally 0 for Gtk::Scale and nonzero for Gtk::Scrollbar, and
+   * indicates the size of the visible area of the widget being scrolled.
+   * The page size affects the size of the scrollbar slider.
+   * @param adjustment A Gtk::Adjustment.
+   */
+  void set_adjustment(Gtk::Adjustment& adjustment);
+  void unset_adjustment();
+
+  
+  /** Get the Gtk::Adjustment which is the "model" object for Gtk::Range.
+   * See set_adjustment() for details.
+   * The return value does not have a reference added, so should not
+   * be unreferenced.
+   * @return A Gtk::Adjustment.
+   */
+  Gtk::Adjustment* get_adjustment();
+  
+  /** Get the Gtk::Adjustment which is the "model" object for Gtk::Range.
+   * See set_adjustment() for details.
+   * The return value does not have a reference added, so should not
+   * be unreferenced.
+   * @return A Gtk::Adjustment.
+   */
+  const Gtk::Adjustment* get_adjustment() const;
+  
+  /** Ranges normally move from lower to higher values as the
+   * slider moves from top to bottom or left to right. Inverted
+   * ranges have higher values at the top or on the right rather than
+   * on the bottom or left.
+   * @param setting <tt>true</tt> to invert the range.
+   */
+  void set_inverted(bool setting = true);
+  
+  /** Gets the value set by set_inverted().
+   * @return <tt>true</tt> if the range is inverted.
+   */
+  bool get_inverted() const;
+  
+  /** Sets the step and page sizes for the range.
+   * The step size is used when the user clicks the Gtk::Scrollbar
+   * arrows or moves Gtk::Scale via arrow keys. The page size
+   * is used for example when moving via Page Up or Page Down keys.
+   * @param step Step size.
+   * @param page Page size.
+   */
+  void set_increments(double step, double  page);
+  
+  /** Sets the allowable values in the Gtk::Range, and clamps the range
+   * value to be between @a min  and @a max . (If the range has a non-zero
+   * page size, it is clamped between @a min  and @a max  - page-size.)
+   * @param min Minimum range value.
+   * @param max Maximum range value.
+   */
+  void set_range(double min, double max);
+  
+  /** Sets the current value of the range; if the value is outside the
+   * minimum or maximum range values, it will be clamped to fit inside
+   * them. The range emits the "value_changed" signal if the value
+   * changes.
+   * @param value New value of the range.
+   */
+  void set_value(double value);
+  
+  /** Gets the current value of the range.
+   * @return Current value of the range.
+   */
+  double get_value() const;
+
+  
+  Glib::SignalProxy0< void > signal_value_changed();
+
+  
+  Glib::SignalProxy1< void,double > signal_adjust_bounds();
+
+  
+  Glib::SignalProxy1< void,ScrollType > signal_move_slider();
+
+  
+  //We use no_default_handler for this, because we can not add a new vfunc to 2.5 without breaking ABI.
+  //TODO: Remove no_default_handler when we do an ABI-break-with-parallel-install.
+  
+
+  Glib::SignalProxy2< bool,ScrollType,double > signal_change_value();
+
+
+  /** How the range should be updated on the screen.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<UpdateType> property_update_policy() ;
+
+/** How the range should be updated on the screen.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<UpdateType> property_update_policy() const;
+
+  /** The GtkAdjustment that contains the current value of this range object.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Adjustment*> property_adjustment() ;
+
+/** The GtkAdjustment that contains the current value of this range object.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Adjustment*> property_adjustment() const;
+
+  /** Invert direction slider moves to increase range value.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_inverted() ;
+
+/** Invert direction slider moves to increase range value.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_inverted() const;
+
+  
+protected:
+    virtual void get_range_border_vfunc(GtkBorder* border) const;
+
+
+};
+
+} // namespace Gtk
+
+
+namespace Glib
+{
+  /** @relates Gtk::Range
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gtk::Range* wrap(GtkRange* object, bool take_copy = false);
+}
+#endif /* _GTKMM_RANGE_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/rc.cc b/libs/gtkmm2/gtk/gtkmm/rc.cc
new file mode 100644
index 0000000000..7fcb207764
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/rc.cc
@@ -0,0 +1,357 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/rc.h>
+#include <gtkmm/private/rc_p.h>
+
+#include <gtk/gtktypebuiltins.h>
+// -*- c++ -*-
+/* $Id$ */
+
+/* Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <glibmm/utility.h>
+#include <gtkmm/settings.h>
+#include <gtkmm/widget.h>
+#include <gtkmm/style.h>
+#include <gtk/gtkrc.h>
+
+
+namespace Gtk
+{
+
+void RcStyle::set_name(const Glib::ustring& name)
+{
+  const Glib::ScopedPtr<char> old_name (gobj()->name);
+  gobj()->name = g_strdup(name.c_str());
+}
+
+void RcStyle::set_bg_pixmap_name(StateType state, const Glib::ustring& name)
+{
+  const Glib::ScopedPtr<char> old_name (gobj()->bg_pixmap_name[state]);
+  gobj()->bg_pixmap_name[state] = g_strdup(name.c_str());
+}
+
+Glib::ustring RcStyle::get_bg_pixmap_name(StateType state) const
+{
+  if(const char *const name = gobj()->bg_pixmap_name[state])
+    return Glib::ustring(name);
+  else
+    return Glib::ustring();
+}
+
+void RcStyle::set_font(const Pango::FontDescription& font_desc)
+{
+  g_return_if_fail(font_desc.gobj() != 0);
+
+  const Pango::FontDescription old_font_desc (gobj()->font_desc, false);
+  gobj()->font_desc = font_desc.gobj_copy();
+}
+
+Pango::FontDescription RcStyle::get_font() const
+{
+  return Pango::FontDescription(gobj()->font_desc, true);
+}
+
+void RcStyle::set_color_flags(StateType state, RcFlags flags)
+{
+  gobj()->color_flags[state] = static_cast<GtkRcFlags>(gobj()->color_flags[state] | flags);
+}
+
+void RcStyle::unset_color_flags(StateType state, RcFlags flags)
+{
+  gobj()->color_flags[state] = static_cast<GtkRcFlags>(gobj()->color_flags[state] & ~flags);
+}
+
+RcFlags RcStyle::get_color_flags(StateType state) const
+{
+  return static_cast<RcFlags>(unsigned(gobj()->color_flags[state]));
+}
+
+void RcStyle::set_xthickness(int xthickness)
+{
+  gobj()->xthickness = xthickness;
+}
+
+void RcStyle::set_ythickness(int ythickness)
+{
+  gobj()->ythickness = ythickness;
+}
+
+
+RC::RC(const Glib::ustring& filename)
+{
+  //gtk_rc_init();
+  gtk_rc_parse(filename.c_str());
+}
+
+Glib::RefPtr<Style>
+RC::get_style(const Widget &widget)
+{
+  return Glib::wrap(gtk_rc_get_style(const_cast<GtkWidget*>(widget.gobj())));
+}
+
+void
+RC::parse_string(const Glib::ustring& rc_string)
+{
+  gtk_rc_parse_string(const_cast<char*>(rc_string.c_str()));
+}
+
+
+void
+RC::add_default_file(const Glib::ustring& filename)
+{
+  gtk_rc_add_default_file(const_cast<char*>(filename.c_str()));
+}
+
+void
+RC::set_default_files(const Glib::ArrayHandle<Glib::ustring>& filenames)
+{
+  gtk_rc_set_default_files(const_cast<char**>(filenames.data()));
+}
+
+Glib::ArrayHandle<Glib::ustring>
+RC::get_default_files()
+{
+  return Glib::ArrayHandle<Glib::ustring>(
+      const_cast<const char**>(gtk_rc_get_default_files()), Glib::OWNERSHIP_NONE);
+}
+
+bool RC::reparse_all()
+{
+  return gtk_rc_reparse_all();
+}
+
+bool RC::reparse_all(const Glib::RefPtr<Settings>& settings, bool force_load)
+{
+  return gtk_rc_reparse_all_for_settings(settings->gobj(), force_load);
+}
+
+void RC::reset_styles(const Glib::RefPtr<Settings>& settings)
+{
+  gtk_rc_reset_styles(settings->gobj());        
+}
+
+Glib::ustring
+RC::find_pixmap_in_path(const Glib::RefPtr<Settings>& context, GScanner *scanner, const Glib::ustring& pixmap_file)
+{
+  return Glib::convert_return_gchar_ptr_to_ustring(
+      gtk_rc_find_pixmap_in_path(context->gobj(), scanner, const_cast<char*>(pixmap_file.c_str())));
+}
+
+Glib::ustring
+RC::find_pixmap_in_path(const Glib::RefPtr<Settings>& context, const Glib::ustring& pixmap_file)
+{
+  return Glib::convert_return_gchar_ptr_to_ustring(
+      gtk_rc_find_pixmap_in_path(context->gobj(), 0 /* see C docs */, const_cast<char*>(pixmap_file.c_str())));
+}
+
+Glib::ustring
+RC::find_module_in_path(const Glib::ustring& module_file)
+{
+  return Glib::convert_return_gchar_ptr_to_ustring(
+      gtk_rc_find_module_in_path(const_cast<char*>(module_file.c_str())));
+}
+
+Glib::ustring
+RC::get_theme_dir()
+{
+  return Glib::convert_return_gchar_ptr_to_ustring(gtk_rc_get_theme_dir());
+}
+
+Glib::ustring
+RC::get_module_dir()
+{
+  return Glib::convert_return_gchar_ptr_to_ustring(gtk_rc_get_module_dir());
+}
+
+}
+
+
+namespace
+{
+} // anonymous namespace
+
+// static
+GType Glib::Value<Gtk::RcFlags>::value_type()
+{
+  return gtk_rc_flags_get_type();
+}
+
+
+namespace Glib
+{
+
+Glib::RefPtr<Gtk::RcStyle> wrap(GtkRcStyle* object, bool take_copy)
+{
+  return Glib::RefPtr<Gtk::RcStyle>( dynamic_cast<Gtk::RcStyle*> (Glib::wrap_auto ((GObject*)(object), take_copy)) );
+  //We use dynamic_cast<> in case of multiple inheritance.
+}
+
+} /* namespace Glib */
+
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& RcStyle_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &RcStyle_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_rc_style_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void RcStyle_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+}
+
+
+Glib::ObjectBase* RcStyle_Class::wrap_new(GObject* object)
+{
+  return new RcStyle((GtkRcStyle*)object);
+}
+
+
+/* The implementation: */
+
+GtkRcStyle* RcStyle::gobj_copy()
+{
+  reference();
+  return gobj();
+}
+
+RcStyle::RcStyle(const Glib::ConstructParams& construct_params)
+:
+  Glib::Object(construct_params)
+{}
+
+RcStyle::RcStyle(GtkRcStyle* castitem)
+:
+  Glib::Object((GObject*)(castitem))
+{}
+
+RcStyle::~RcStyle()
+{}
+
+
+RcStyle::CppClassType RcStyle::rcstyle_class_; // initialize static member
+
+GType RcStyle::get_type()
+{
+  return rcstyle_class_.init().get_type();
+}
+
+GType RcStyle::get_base_type()
+{
+  return gtk_rc_style_get_type();
+}
+
+
+RcStyle::RcStyle()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Glib::Object(Glib::ConstructParams(rcstyle_class_.init()))
+{
+  }
+
+Glib::RefPtr<RcStyle> RcStyle::create()
+{
+  return Glib::RefPtr<RcStyle>( new RcStyle() );
+}
+Glib::RefPtr<RcStyle> RcStyle::copy() const
+{
+  return Glib::wrap(gtk_rc_style_copy(const_cast<GtkRcStyle*>(gobj())));
+}
+
+Glib::ustring RcStyle::get_name() const
+{
+  return Glib::convert_const_gchar_ptr_to_ustring(gobj()->name);
+}
+
+void RcStyle::set_fg(StateType state, const Gdk::Color& color)
+{
+  gobj()->fg[state] = *color.gobj();
+}
+
+Gdk::Color RcStyle::get_fg(StateType state) const
+{
+  return Gdk::Color(const_cast<GdkColor*>(&gobj()->fg[state]), true);
+}
+
+void RcStyle::set_bg(StateType state, const Gdk::Color& color)
+{
+  gobj()->bg[state] = *color.gobj();
+}
+
+Gdk::Color RcStyle::get_bg(StateType state) const
+{
+  return Gdk::Color(const_cast<GdkColor*>(&gobj()->bg[state]), true);
+}
+
+void RcStyle::set_text(StateType state, const Gdk::Color& color)
+{
+  gobj()->text[state] = *color.gobj();
+}
+
+Gdk::Color RcStyle::get_text(StateType state) const
+{
+  return Gdk::Color(const_cast<GdkColor*>(&gobj()->text[state]), true);
+}
+
+void RcStyle::set_base(StateType state, const Gdk::Color& color)
+{
+  gobj()->base[state] = *color.gobj();
+}
+
+Gdk::Color RcStyle::get_base(StateType state) const
+{
+  return Gdk::Color(const_cast<GdkColor*>(&gobj()->base[state]), true);
+}
+
+int RcStyle::get_xthickness() const
+{
+  return gobj()->xthickness;
+}
+
+int RcStyle::get_ythickness() const
+{
+  return gobj()->ythickness;
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/rc.h b/libs/gtkmm2/gtk/gtkmm/rc.h
new file mode 100644
index 0000000000..003fd91c15
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/rc.h
@@ -0,0 +1,352 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_RC_H
+#define _GTKMM_RC_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* Copyright (C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+
+//#include <gtkmm/settings.h>
+#include <gtkmm/style.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkRcStyle GtkRcStyle;
+typedef struct _GtkRcStyleClass GtkRcStyleClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class RcStyle_Class; } // namespace Gtk
+namespace Gtk
+{
+
+class Widget;
+class Settings;
+class Style;
+
+
+/** @addtogroup gtkmmEnums Enums and Flags */
+
+/**
+ * @ingroup gtkmmEnums
+ * @par Bitwise operators:
+ * <tt>%RcFlags operator|(RcFlags, RcFlags)</tt><br>
+ * <tt>%RcFlags operator&(RcFlags, RcFlags)</tt><br>
+ * <tt>%RcFlags operator^(RcFlags, RcFlags)</tt><br>
+ * <tt>%RcFlags operator~(RcFlags)</tt><br>
+ * <tt>%RcFlags& operator|=(RcFlags&, RcFlags)</tt><br>
+ * <tt>%RcFlags& operator&=(RcFlags&, RcFlags)</tt><br>
+ * <tt>%RcFlags& operator^=(RcFlags&, RcFlags)</tt><br>
+ */
+enum RcFlags
+{
+  RC_FG = 1 << 0,
+  RC_BG = 1 << 1,
+  RC_TEXT = 1 << 2,
+  RC_BASE = 1 << 3
+};
+
+/** @ingroup gtkmmEnums */
+inline RcFlags operator|(RcFlags lhs, RcFlags rhs)
+  { return static_cast<RcFlags>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs)); }
+
+/** @ingroup gtkmmEnums */
+inline RcFlags operator&(RcFlags lhs, RcFlags rhs)
+  { return static_cast<RcFlags>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs)); }
+
+/** @ingroup gtkmmEnums */
+inline RcFlags operator^(RcFlags lhs, RcFlags rhs)
+  { return static_cast<RcFlags>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs)); }
+
+/** @ingroup gtkmmEnums */
+inline RcFlags operator~(RcFlags flags)
+  { return static_cast<RcFlags>(~static_cast<unsigned>(flags)); }
+
+/** @ingroup gtkmmEnums */
+inline RcFlags& operator|=(RcFlags& lhs, RcFlags rhs)
+  { return (lhs = static_cast<RcFlags>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs))); }
+
+/** @ingroup gtkmmEnums */
+inline RcFlags& operator&=(RcFlags& lhs, RcFlags rhs)
+  { return (lhs = static_cast<RcFlags>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs))); }
+
+/** @ingroup gtkmmEnums */
+inline RcFlags& operator^=(RcFlags& lhs, RcFlags rhs)
+  { return (lhs = static_cast<RcFlags>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs))); }
+
+} // namespace Gtk
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Gtk::RcFlags> : public Glib::Value_Flags<Gtk::RcFlags>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{
+
+
+class RcStyle : public Glib::Object
+{
+  
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+public:
+  typedef RcStyle CppObjectType;
+  typedef RcStyle_Class CppClassType;
+  typedef GtkRcStyle BaseObjectType;
+  typedef GtkRcStyleClass BaseClassType;
+
+private:  friend class RcStyle_Class;
+  static CppClassType rcstyle_class_;
+
+private:
+  // noncopyable
+  RcStyle(const RcStyle&);
+  RcStyle& operator=(const RcStyle&);
+
+protected:
+  explicit RcStyle(const Glib::ConstructParams& construct_params);
+  explicit RcStyle(GtkRcStyle* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+  virtual ~RcStyle();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GObject.
+  GtkRcStyle*       gobj()       { return reinterpret_cast<GtkRcStyle*>(gobject_); }
+
+  ///Provides access to the underlying C GObject.
+  const GtkRcStyle* gobj() const { return reinterpret_cast<GtkRcStyle*>(gobject_); }
+
+  ///Provides access to the underlying C instance. The caller is responsible for unrefing it. Use when directly setting fields in structs.
+  GtkRcStyle* gobj_copy();
+
+private:
+
+  
+protected:
+  RcStyle();
+
+public:
+  
+  static Glib::RefPtr<RcStyle> create();
+
+  
+  /** Makes a copy of the specified Gtk::RcStyle. This function
+   * will correctly copy an RC style that is a member of a class
+   * derived from Gtk::RcStyle.
+   * @return The resulting Gtk::RcStyle.
+   */
+  Glib::RefPtr<RcStyle> copy() const;
+
+  void set_name(const Glib::ustring& name);
+  Glib::ustring get_name() const;
+
+  void set_bg_pixmap_name(Gtk::StateType state, const Glib::ustring& name);
+  Glib::ustring get_bg_pixmap_name(Gtk::StateType state) const;
+
+  void set_font(const Pango::FontDescription& font_desc);
+  Pango::FontDescription get_font() const;
+ 
+  void set_color_flags(Gtk::StateType state, RcFlags flags);
+  void unset_color_flags(Gtk::StateType state, RcFlags flags);
+  RcFlags get_color_flags(Gtk::StateType state) const;
+
+  void set_fg(Gtk::StateType state, const Gdk::Color& color);
+  Gdk::Color get_fg(Gtk::StateType state) const;
+
+  void set_bg(Gtk::StateType state, const Gdk::Color& color);
+  Gdk::Color get_bg(Gtk::StateType state) const;
+
+  void set_text(Gtk::StateType state, const Gdk::Color& color);
+  Gdk::Color get_text(Gtk::StateType state) const;
+
+  void set_base(Gtk::StateType state, const Gdk::Color& color);
+  Gdk::Color get_base(Gtk::StateType state) const;
+
+
+  void set_xthickness(int xthickness);
+  int get_xthickness() const;
+
+  void set_ythickness(int ythickness);
+  int get_ythickness() const;
+
+
+public:
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+};
+
+
+class RC
+{
+public:
+  explicit RC(const Glib::ustring& filename);
+
+  /** Finds all matching RC styles for a given widget,
+   * composites them together, and then creates a
+   * Gtk::Style representing the composite appearance.
+   *
+   * @param widget a Gtk::Widget.
+   * @result the resulting style.
+   */
+  static Glib::RefPtr<Style> get_style(const Widget& widget);
+
+  static void parse_string(const Glib::ustring &rc_string);
+
+  /** Adds a file to the list of files to be parsed at the end of gtk_init().
+   *
+   * @param filename the pathname to the file. If @a filename is not absolute, it is searched in the current directory.
+   */
+  static void add_default_file(const Glib::ustring& filename);
+
+  /** Sets the list of files that GTK+ will read at the end of gtk_init().
+   *
+   * @param filenames A list of filenames.
+   */
+  static void set_default_files(const Glib::StringArrayHandle& filenames);
+
+  /** Retrieves the current list of RC files that will be parsed
+   * at the end of gtk_init().
+   *
+   * @result An array of filenames.
+   */
+  static Glib::StringArrayHandle get_default_files();
+
+  /** If the modification time on any previously read file for the
+   * default Gtk::Settings has changed, discard all style information
+   * and then reread all previously read RC files.
+   *
+   * @result true if the files were reread.
+   */
+  static bool reparse_all();
+
+  /** If the modification time on any previously read file
+   * for the given Gtk::Settings has changed, discard all style information
+   * and then reread all previously read RC files.
+   *
+   * @param settings a Gtk::Settings
+   * @param force_load load whether or not anything changed
+   * @result true if the files were reread.
+   */
+  static bool reparse_all(const Glib::RefPtr<Settings>& settings, bool force_load = true);
+
+  /** This method recomputes the styles for all widgets that use a
+   * particular Gtk::Settings object. (There is one Gtk::Settings object
+   * per Gdk::Screen -  see Gtk::Settings::get_for_screen()); It is useful
+   * when some global parameter has changed that affects the appearance
+   * of all widgets, because when a widget gets a new style, it will
+   * both redraw and recompute any cached information about its
+   * appearance. As an example, it is used when the default font size
+   * set by the operating system changes. Note that this function
+   * doesn't affect widgets that have a style set explicitely on them
+   * with Gtk::Widget::set_style().
+   *
+   * @param settings a Gtk::Settings
+   *
+   * Since: 2.4
+   */
+  static void reset_styles(const Glib::RefPtr<Settings>& settings);
+
+  /** Looks up a file in pixmap path for the specified Gtk::Settings.
+   * If the file is not found, it outputs a warning message using
+   * g_warning() and returns an empty string.
+   *
+   * @param settings a Gtk::Settings
+   * @param scanner Scanner used to get line number information for the warning message.
+   * @param pixmap_file name of the pixmap file to locate.
+   * @result the filename.
+   */
+  static Glib::ustring find_pixmap_in_path(const Glib::RefPtr<Settings>& settings, GScanner* scanner, const Glib::ustring& pixmap_file);
+
+  /** Looks up a file in pixmap path for the specified Gtk::Settings.
+   * If the file is not found, it outputs a warning message using
+   * g_warning() and returns an empty string.
+   *
+   * @param settings a Gtk::Settings
+   * @param pixmap_file name of the pixmap file to locate.
+   * @result the filename.
+   */
+  static Glib::ustring find_pixmap_in_path(const Glib::RefPtr<Settings>& settings, const Glib::ustring& pixmap_file);
+
+  /** Searches for a theme engine in the GTK+ search path. This function
+   * is not useful for applications and should not be used.
+   *
+   * @param pixmap_file  name of a theme engine.
+   * @result The filename, if found, otherwise an empty string.
+   **/
+  static Glib::ustring find_module_in_path(const Glib::ustring& pixmap_file);
+
+  static Glib::ustring get_theme_dir();
+
+  /** Returns a directory in which GTK+ looks for theme engines.
+   * For full information about the search for theme engines,
+   * see the GTK+ docs.
+   *
+   * @result the directory.
+   **/
+  static Glib::ustring get_module_dir();
+  
+};
+
+} // namespace Gtk
+
+
+namespace Glib
+{
+  /** @relates Gtk::RcStyle
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Glib::RefPtr<Gtk::RcStyle> wrap(GtkRcStyle* object, bool take_copy = false);
+}
+
+
+#endif /* _GTKMM_RC_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/ruler.cc b/libs/gtkmm2/gtk/gtkmm/ruler.cc
new file mode 100644
index 0000000000..0983eb0210
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/ruler.cc
@@ -0,0 +1,506 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/ruler.h>
+#include <gtkmm/private/ruler_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* 
+ *
+ * Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtk/gtkruler.h>
+#include <gtk/gtkhruler.h>
+#include <gtk/gtkvruler.h>
+#include <cstring>
+
+
+namespace Gtk
+{
+
+MetricType Ruler::get_metric() const
+{
+  MetricType metric = PIXELS;
+
+  if     (strcmp(gobj()->metric->abbrev, "In") == 0) metric = INCHES;
+  else if(strcmp(gobj()->metric->abbrev, "Cn") == 0) metric = CENTIMETERS;
+
+  return metric;
+}
+
+} // namespace Gtk
+
+
+namespace
+{
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Gtk::Ruler* wrap(GtkRuler* object, bool take_copy)
+{
+  return dynamic_cast<Gtk::Ruler *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& Ruler_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &Ruler_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_ruler_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void Ruler_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+  klass->draw_ticks = &draw_ticks_vfunc_callback;
+  klass->draw_pos = &draw_pos_vfunc_callback;
+}
+
+void Ruler_Class::draw_ticks_vfunc_callback(GtkRuler* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->draw_ticks_vfunc();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->draw_ticks)
+      (*base->draw_ticks)(self);
+  }
+}
+
+void Ruler_Class::draw_pos_vfunc_callback(GtkRuler* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->draw_pos_vfunc();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->draw_pos)
+      (*base->draw_pos)(self);
+  }
+}
+
+
+Glib::ObjectBase* Ruler_Class::wrap_new(GObject* o)
+{
+  return manage(new Ruler((GtkRuler*)(o)));
+
+}
+
+
+/* The implementation: */
+
+Ruler::Ruler(const Glib::ConstructParams& construct_params)
+:
+  Gtk::Widget(construct_params)
+{
+  }
+
+Ruler::Ruler(GtkRuler* castitem)
+:
+  Gtk::Widget((GtkWidget*)(castitem))
+{
+  }
+
+Ruler::~Ruler()
+{
+  destroy_();
+}
+
+Ruler::CppClassType Ruler::ruler_class_; // initialize static member
+
+GType Ruler::get_type()
+{
+  return ruler_class_.init().get_type();
+}
+
+GType Ruler::get_base_type()
+{
+  return gtk_ruler_get_type();
+}
+
+
+Ruler::Ruler()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Widget(Glib::ConstructParams(ruler_class_.init()))
+{
+  }
+
+void Ruler::set_metric(MetricType metric)
+{
+  gtk_ruler_set_metric(gobj(), ((GtkMetricType)(metric)));
+}
+
+MetricType Ruler::get_metric()
+{
+  return ((MetricType)(gtk_ruler_get_metric(gobj())));
+}
+
+double Ruler::get_range_lower() const
+{
+  return gobj()->lower;
+}
+
+double Ruler::get_range_upper() const
+{
+  return gobj()->upper;
+}
+
+void Ruler::set_range(double lower, double upper, double position, double max_size)
+{
+  gtk_ruler_set_range(gobj(), lower, upper, position, max_size);
+}
+
+void Ruler::get_range(double& lower, double& upper, double& position, double& max_size)
+{
+  gtk_ruler_get_range(gobj(), &(lower), &(upper), &(position), &(max_size));
+}
+
+void Ruler::draw_ticks()
+{
+  gtk_ruler_draw_ticks(gobj());
+}
+
+void Ruler::draw_pos()
+{
+  gtk_ruler_draw_pos(gobj());
+}
+
+
+Glib::PropertyProxy<double> Ruler::property_lower() 
+{
+  return Glib::PropertyProxy<double>(this, "lower");
+}
+
+Glib::PropertyProxy_ReadOnly<double> Ruler::property_lower() const
+{
+  return Glib::PropertyProxy_ReadOnly<double>(this, "lower");
+}
+
+Glib::PropertyProxy<double> Ruler::property_upper() 
+{
+  return Glib::PropertyProxy<double>(this, "upper");
+}
+
+Glib::PropertyProxy_ReadOnly<double> Ruler::property_upper() const
+{
+  return Glib::PropertyProxy_ReadOnly<double>(this, "upper");
+}
+
+Glib::PropertyProxy<double> Ruler::property_position() 
+{
+  return Glib::PropertyProxy<double>(this, "position");
+}
+
+Glib::PropertyProxy_ReadOnly<double> Ruler::property_position() const
+{
+  return Glib::PropertyProxy_ReadOnly<double>(this, "position");
+}
+
+Glib::PropertyProxy<double> Ruler::property_max_size() 
+{
+  return Glib::PropertyProxy<double>(this, "max-size");
+}
+
+Glib::PropertyProxy_ReadOnly<double> Ruler::property_max_size() const
+{
+  return Glib::PropertyProxy_ReadOnly<double>(this, "max-size");
+}
+
+
+void Gtk::Ruler::draw_ticks_vfunc() 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->draw_ticks)
+    (*base->draw_ticks)(gobj());
+}
+
+void Gtk::Ruler::draw_pos_vfunc() 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->draw_pos)
+    (*base->draw_pos)(gobj());
+}
+
+
+} // namespace Gtk
+
+
+namespace Glib
+{
+
+Gtk::VRuler* wrap(GtkVRuler* object, bool take_copy)
+{
+  return dynamic_cast<Gtk::VRuler *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& VRuler_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &VRuler_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_vruler_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void VRuler_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+}
+
+
+Glib::ObjectBase* VRuler_Class::wrap_new(GObject* o)
+{
+  return manage(new VRuler((GtkVRuler*)(o)));
+
+}
+
+
+/* The implementation: */
+
+VRuler::VRuler(const Glib::ConstructParams& construct_params)
+:
+  Gtk::Ruler(construct_params)
+{
+  }
+
+VRuler::VRuler(GtkVRuler* castitem)
+:
+  Gtk::Ruler((GtkRuler*)(castitem))
+{
+  }
+
+VRuler::~VRuler()
+{
+  destroy_();
+}
+
+VRuler::CppClassType VRuler::vruler_class_; // initialize static member
+
+GType VRuler::get_type()
+{
+  return vruler_class_.init().get_type();
+}
+
+GType VRuler::get_base_type()
+{
+  return gtk_vruler_get_type();
+}
+
+VRuler::VRuler()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Ruler(Glib::ConstructParams(vruler_class_.init()))
+{
+  }
+
+
+} // namespace Gtk
+
+
+namespace Glib
+{
+
+Gtk::HRuler* wrap(GtkHRuler* object, bool take_copy)
+{
+  return dynamic_cast<Gtk::HRuler *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& HRuler_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &HRuler_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_hruler_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void HRuler_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+}
+
+
+Glib::ObjectBase* HRuler_Class::wrap_new(GObject* o)
+{
+  return manage(new HRuler((GtkHRuler*)(o)));
+
+}
+
+
+/* The implementation: */
+
+HRuler::HRuler(const Glib::ConstructParams& construct_params)
+:
+  Gtk::Ruler(construct_params)
+{
+  }
+
+HRuler::HRuler(GtkHRuler* castitem)
+:
+  Gtk::Ruler((GtkRuler*)(castitem))
+{
+  }
+
+HRuler::~HRuler()
+{
+  destroy_();
+}
+
+HRuler::CppClassType HRuler::hruler_class_; // initialize static member
+
+GType HRuler::get_type()
+{
+  return hruler_class_.init().get_type();
+}
+
+GType HRuler::get_base_type()
+{
+  return gtk_hruler_get_type();
+}
+
+HRuler::HRuler()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Ruler(Glib::ConstructParams(hruler_class_.init()))
+{
+  }
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/ruler.h b/libs/gtkmm2/gtk/gtkmm/ruler.h
new file mode 100644
index 0000000000..510df8c7b4
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/ruler.h
@@ -0,0 +1,403 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_RULER_H
+#define _GTKMM_RULER_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* ruler.h
+ * 
+ * Copyright (C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/widget.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkRuler GtkRuler;
+typedef struct _GtkRulerClass GtkRulerClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class Ruler_Class; } // namespace Gtk
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkVRuler GtkVRuler;
+typedef struct _GtkVRulerClass GtkVRulerClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class VRuler_Class; } // namespace Gtk
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkHRuler GtkHRuler;
+typedef struct _GtkHRulerClass GtkHRulerClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class HRuler_Class; } // namespace Gtk
+namespace Gtk
+{
+
+/** Base class for horizontal or vertical rulers.
+ *
+ * NOTE this widget is considered too specialized/little-used for GTK+, and will in the future be moved to some other package. If your application needs this widget, feel free to use it, as the widget does work and is useful in some applications; it's just not of general interest. However, we are not accepting new features for the widget, and it will eventually move out of the GTK+ distribution.
+ * Rulers are used to show the mouse pointer's location in a window. The ruler can either be horizontal or vertical. Within the ruler a small triangle indicates the location of the mouse relative to the horixontal or vertical ruler.
+
+ * This is an abstract base for Gtk::HRuler and
+ * Gtk::VRuler.  Users should only instantiate those types.
+ *
+ * @ingroup Widgets
+ */
+
+class Ruler : public Widget
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Ruler CppObjectType;
+  typedef Ruler_Class CppClassType;
+  typedef GtkRuler BaseObjectType;
+  typedef GtkRulerClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~Ruler();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class Ruler_Class;
+  static CppClassType ruler_class_;
+
+  // noncopyable
+  Ruler(const Ruler&);
+  Ruler& operator=(const Ruler&);
+
+protected:
+  explicit Ruler(const Glib::ConstructParams& construct_params);
+  explicit Ruler(GtkRuler* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GtkRuler*       gobj()       { return reinterpret_cast<GtkRuler*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GtkRuler* gobj() const { return reinterpret_cast<GtkRuler*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+private:
+
+protected:
+  Ruler();
+
+public:
+  
+
+  MetricType get_metric() const; 
+
+  /** Sets the desired metric of the ruler.  The possible choices are:
+   * <ul><li>Gtk::PIXELS
+   * <li>Gtk::INCHES
+   * <li>Gtk::CENTIMETERS
+   * </ul>The default metric is Gtk::PIXELS.
+   */
+  
+  void set_metric(MetricType metric = PIXELS);
+  
+  /** Gets the units used for a Gtk::Ruler. See set_metric().
+   * @return The units currently used for @a ruler .
+   */
+  MetricType get_metric();
+
+  double get_range_lower() const;
+  double get_range_upper() const;
+
+  /** sets the range of the ruler.
+   * <i>upper</i> and <i>lower</i> arguments denote the extents of the Ruler.
+   * <i>max_size</i> is the largest number displayed by the ruler.
+   * <i>position</i> gives the initial value of the ruler.
+   * Rulers do not have sane defaults so this function should always be called.
+   */
+  
+  void set_range(double lower, double upper, double position, double max_size);
+  
+  /** Retrieves values indicating the range and current position of a Gtk::Ruler.
+   * See set_range().
+   * @param lower Location to store lower limit of the ruler, or <tt>0</tt>.
+   * @param upper Location to store upper limit of the ruler, or <tt>0</tt>.
+   * @param position Location to store the current position of the mark on the ruler, or <tt>0</tt>.
+   * @param max_size Location to store the maximum size of the ruler used when calculating
+   * the space to leave for the text, or <tt>0</tt>.
+   */
+  void get_range(double& lower, double& upper, double& position, double& max_size);
+
+  /// draw tick marks on the ruler
+  
+  void draw_ticks();
+
+  /// draw a position indicator on the ruler
+  
+  void draw_pos();
+
+    virtual void draw_ticks_vfunc();
+    virtual void draw_pos_vfunc();
+
+  /** Lower limit of ruler.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<double> property_lower() ;
+
+/** Lower limit of ruler.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<double> property_lower() const;
+
+  /** Upper limit of ruler.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<double> property_upper() ;
+
+/** Upper limit of ruler.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<double> property_upper() const;
+
+  /** Position of mark on the ruler.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<double> property_position() ;
+
+/** Position of mark on the ruler.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<double> property_position() const;
+
+  /** Maximum size of the ruler.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<double> property_max_size() ;
+
+/** Maximum size of the ruler.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<double> property_max_size() const;
+
+
+};
+
+
+/** Vertical Ruler
+ *
+ * @ingroup Widgets
+ */
+
+class VRuler : public Ruler
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef VRuler CppObjectType;
+  typedef VRuler_Class CppClassType;
+  typedef GtkVRuler BaseObjectType;
+  typedef GtkVRulerClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~VRuler();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class VRuler_Class;
+  static CppClassType vruler_class_;
+
+  // noncopyable
+  VRuler(const VRuler&);
+  VRuler& operator=(const VRuler&);
+
+protected:
+  explicit VRuler(const Glib::ConstructParams& construct_params);
+  explicit VRuler(GtkVRuler* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GtkVRuler*       gobj()       { return reinterpret_cast<GtkVRuler*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GtkVRuler* gobj() const { return reinterpret_cast<GtkVRuler*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+private:
+
+public:
+  VRuler();
+  
+
+};
+
+
+/** Horizontal Ruler
+ *
+ * @ingroup Widgets
+ */
+
+class HRuler : public Ruler
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef HRuler CppObjectType;
+  typedef HRuler_Class CppClassType;
+  typedef GtkHRuler BaseObjectType;
+  typedef GtkHRulerClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~HRuler();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class HRuler_Class;
+  static CppClassType hruler_class_;
+
+  // noncopyable
+  HRuler(const HRuler&);
+  HRuler& operator=(const HRuler&);
+
+protected:
+  explicit HRuler(const Glib::ConstructParams& construct_params);
+  explicit HRuler(GtkHRuler* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GtkHRuler*       gobj()       { return reinterpret_cast<GtkHRuler*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GtkHRuler* gobj() const { return reinterpret_cast<GtkHRuler*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+private:
+
+public:
+  HRuler();
+  
+
+};
+
+} /* namespace Gtk */
+
+
+namespace Glib
+{
+  /** @relates Gtk::Ruler
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gtk::Ruler* wrap(GtkRuler* object, bool take_copy = false);
+}
+namespace Glib
+{
+  /** @relates Gtk::VRuler
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gtk::VRuler* wrap(GtkVRuler* object, bool take_copy = false);
+}
+namespace Glib
+{
+  /** @relates Gtk::HRuler
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gtk::HRuler* wrap(GtkHRuler* object, bool take_copy = false);
+}
+#endif /* _GTKMM_RULER_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/scale.cc b/libs/gtkmm2/gtk/gtkmm/scale.cc
new file mode 100644
index 0000000000..6b7042daa7
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/scale.cc
@@ -0,0 +1,640 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/scale.h>
+#include <gtkmm/private/scale_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* 
+ *
+ * Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/adjustment.h>
+
+#include <gtk/gtkscale.h>
+#include <gtk/gtkhscale.h>
+#include <gtk/gtkvscale.h>
+#include <math.h>
+
+namespace Gtk
+{
+
+int Scale::calc_digits_(double step) const
+{
+  int digits = 0;
+
+  //Copied from gtk_[h|v]scale_new_with_range():
+  if (fabs (step) >= 1.0 || step == 0.0)
+     digits = 0;
+  else {
+    digits = abs ((int) floor (log10 (fabs (step))));
+    if (digits > 5)
+      digits = 5;
+  }
+
+  return digits;
+}
+
+VScale::VScale(double min, double max, double step)
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Scale(Glib::ConstructParams(vscale_class_.init(), (char*) 0))
+{
+  Adjustment* adjustment = manage(new Adjustment(min, min, max, step, 10 * step, step));
+  // The adjustment will be destroyed along with the object
+  set_adjustment(*adjustment);
+
+  set_digits( calc_digits_(step) );
+}
+
+VScale::VScale(Adjustment& adjustment)
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Scale(Glib::ConstructParams(vscale_class_.init(), (char*) 0))
+{
+  set_adjustment(adjustment);
+}
+
+VScale::VScale()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Scale(Glib::ConstructParams(vscale_class_.init(), (char*) 0))
+{
+  Adjustment* adjustment = manage(new Adjustment(0.0, 0.0, 0.0,
+						  0.0, 0.0, 0.0));
+  // The adjustment will be destroyed along with the object
+  set_adjustment(*adjustment);
+}
+
+
+HScale::HScale(double min, double max, double step)
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Scale(Glib::ConstructParams(hscale_class_.init(), (char*) 0))
+{
+  Adjustment* adjustment = manage(new Adjustment(min, min, max, step, 10 * step, step));
+  // The adjustment will be destroyed along with the object
+  set_adjustment(*adjustment);
+
+  set_digits( calc_digits_(step) );
+}
+
+HScale::HScale()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Scale(Glib::ConstructParams(hscale_class_.init(), (char*) 0))
+{
+  Adjustment* adjustment = manage(new Adjustment(0.0, 0.0, 0.0,
+						  0.0, 0.0, 0.0));
+  // The adjustment will be destroyed along with the object
+  set_adjustment(*adjustment);
+}
+
+HScale::HScale(Adjustment& adjustment)
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Scale(Glib::ConstructParams(hscale_class_.init(), (char*) 0))
+{
+  set_adjustment(adjustment);
+}
+
+} // namespace Gtk
+
+
+namespace
+{
+
+gchar* Scale_signal_format_value_callback(GtkScale* self, gdouble p0,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< Glib::ustring,double > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        return (strlen((*static_cast<SlotType*>(slot))(p0
+).c_str()) ? g_strdup((*static_cast<SlotType*>(slot))(p0
+).c_str()) : 0);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+
+  typedef gchar* RType;
+  return RType();
+}
+
+gchar* Scale_signal_format_value_notify_callback(GtkScale* self, gdouble p0, void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,double > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(p0
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+
+  typedef gchar* RType;
+  return RType();
+}
+
+const Glib::SignalProxyInfo Scale_signal_format_value_info =
+{
+  "format_value",
+  (GCallback) &Scale_signal_format_value_callback,
+  (GCallback) &Scale_signal_format_value_notify_callback
+};
+
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Gtk::Scale* wrap(GtkScale* object, bool take_copy)
+{
+  return dynamic_cast<Gtk::Scale *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& Scale_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &Scale_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_scale_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void Scale_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+  klass->draw_value = &draw_value_vfunc_callback;
+  klass->format_value = &format_value_callback;
+}
+
+void Scale_Class::draw_value_vfunc_callback(GtkScale* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->draw_value_vfunc();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->draw_value)
+      (*base->draw_value)(self);
+  }
+}
+
+
+gchar* Scale_Class::format_value_callback(GtkScale* self, gdouble p0)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return (strlen(obj->on_format_value(p0
+).c_str()) ? g_strdup(obj->on_format_value(p0
+).c_str()) : 0);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->format_value)
+      return (*base->format_value)(self, p0);
+  }
+
+  typedef gchar* RType;
+  return RType();
+}
+
+
+Glib::ObjectBase* Scale_Class::wrap_new(GObject* o)
+{
+  return manage(new Scale((GtkScale*)(o)));
+
+}
+
+
+/* The implementation: */
+
+Scale::Scale(const Glib::ConstructParams& construct_params)
+:
+  Gtk::Range(construct_params)
+{
+  }
+
+Scale::Scale(GtkScale* castitem)
+:
+  Gtk::Range((GtkRange*)(castitem))
+{
+  }
+
+Scale::~Scale()
+{
+  destroy_();
+}
+
+Scale::CppClassType Scale::scale_class_; // initialize static member
+
+GType Scale::get_type()
+{
+  return scale_class_.init().get_type();
+}
+
+GType Scale::get_base_type()
+{
+  return gtk_scale_get_type();
+}
+
+
+Scale::Scale()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Range(Glib::ConstructParams(scale_class_.init()))
+{
+  }
+
+void Scale::set_digits(int digits)
+{
+  gtk_scale_set_digits(gobj(), digits);
+}
+
+int Scale::get_digits() const
+{
+  return gtk_scale_get_digits(const_cast<GtkScale*>(gobj()));
+}
+
+void Scale::set_draw_value(bool draw_value)
+{
+  gtk_scale_set_draw_value(gobj(), static_cast<int>(draw_value));
+}
+
+bool Scale::get_draw_value() const
+{
+  return gtk_scale_get_draw_value(const_cast<GtkScale*>(gobj()));
+}
+
+void Scale::set_value_pos(PositionType pos)
+{
+  gtk_scale_set_value_pos(gobj(), ((GtkPositionType)(pos)));
+}
+
+PositionType Scale::get_value_pos() const
+{
+  return ((PositionType)(gtk_scale_get_value_pos(const_cast<GtkScale*>(gobj()))));
+}
+
+Glib::RefPtr<Pango::Layout> Scale::get_layout()
+{
+
+  Glib::RefPtr<Pango::Layout> retvalue = Glib::wrap(gtk_scale_get_layout(gobj()));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::RefPtr<const Pango::Layout> Scale::get_layout() const
+{
+
+  Glib::RefPtr<const Pango::Layout> retvalue = Glib::wrap(gtk_scale_get_layout(const_cast<GtkScale*>(gobj())));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+void Scale::get_layout_offsets(int& x, int& y) const
+{
+  gtk_scale_get_layout_offsets(const_cast<GtkScale*>(gobj()), &x, &y);
+}
+
+
+Glib::SignalProxy1< Glib::ustring,double > Scale::signal_format_value()
+{
+  return Glib::SignalProxy1< Glib::ustring,double >(this, &Scale_signal_format_value_info);
+}
+
+
+Glib::PropertyProxy<int> Scale::property_digits() 
+{
+  return Glib::PropertyProxy<int>(this, "digits");
+}
+
+Glib::PropertyProxy_ReadOnly<int> Scale::property_digits() const
+{
+  return Glib::PropertyProxy_ReadOnly<int>(this, "digits");
+}
+
+Glib::PropertyProxy<bool> Scale::property_draw_value() 
+{
+  return Glib::PropertyProxy<bool>(this, "draw-value");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> Scale::property_draw_value() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "draw-value");
+}
+
+Glib::PropertyProxy<PositionType> Scale::property_value_pos() 
+{
+  return Glib::PropertyProxy<PositionType>(this, "value-pos");
+}
+
+Glib::PropertyProxy_ReadOnly<PositionType> Scale::property_value_pos() const
+{
+  return Glib::PropertyProxy_ReadOnly<PositionType>(this, "value-pos");
+}
+
+
+Glib::ustring Gtk::Scale::on_format_value(double value)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->format_value)
+    return Glib::convert_const_gchar_ptr_to_ustring((*base->format_value)(gobj(),value));
+
+  typedef Glib::ustring RType;
+  return RType();
+}
+
+
+void Gtk::Scale::draw_value_vfunc() 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->draw_value)
+    (*base->draw_value)(gobj());
+}
+
+
+} // namespace Gtk
+
+
+namespace Glib
+{
+
+Gtk::VScale* wrap(GtkVScale* object, bool take_copy)
+{
+  return dynamic_cast<Gtk::VScale *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& VScale_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &VScale_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_vscale_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void VScale_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+}
+
+
+Glib::ObjectBase* VScale_Class::wrap_new(GObject* o)
+{
+  return manage(new VScale((GtkVScale*)(o)));
+
+}
+
+
+/* The implementation: */
+
+VScale::VScale(const Glib::ConstructParams& construct_params)
+:
+  Gtk::Scale(construct_params)
+{
+  }
+
+VScale::VScale(GtkVScale* castitem)
+:
+  Gtk::Scale((GtkScale*)(castitem))
+{
+  }
+
+VScale::~VScale()
+{
+  destroy_();
+}
+
+VScale::CppClassType VScale::vscale_class_; // initialize static member
+
+GType VScale::get_type()
+{
+  return vscale_class_.init().get_type();
+}
+
+GType VScale::get_base_type()
+{
+  return gtk_vscale_get_type();
+}
+
+
+} // namespace Gtk
+
+
+namespace Glib
+{
+
+Gtk::HScale* wrap(GtkHScale* object, bool take_copy)
+{
+  return dynamic_cast<Gtk::HScale *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& HScale_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &HScale_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_hscale_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void HScale_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+}
+
+
+Glib::ObjectBase* HScale_Class::wrap_new(GObject* o)
+{
+  return manage(new HScale((GtkHScale*)(o)));
+
+}
+
+
+/* The implementation: */
+
+HScale::HScale(const Glib::ConstructParams& construct_params)
+:
+  Gtk::Scale(construct_params)
+{
+  }
+
+HScale::HScale(GtkHScale* castitem)
+:
+  Gtk::Scale((GtkScale*)(castitem))
+{
+  }
+
+HScale::~HScale()
+{
+  destroy_();
+}
+
+HScale::CppClassType HScale::hscale_class_; // initialize static member
+
+GType HScale::get_type()
+{
+  return hscale_class_.init().get_type();
+}
+
+GType HScale::get_base_type()
+{
+  return gtk_hscale_get_type();
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/scale.h b/libs/gtkmm2/gtk/gtkmm/scale.h
new file mode 100644
index 0000000000..fb4d39dbad
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/scale.h
@@ -0,0 +1,460 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_SCALE_H
+#define _GTKMM_SCALE_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* scale.h
+ * 
+ * Copyright (C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/range.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkScale GtkScale;
+typedef struct _GtkScaleClass GtkScaleClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class Scale_Class; } // namespace Gtk
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkVScale GtkVScale;
+typedef struct _GtkVScaleClass GtkVScaleClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class VScale_Class; } // namespace Gtk
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkHScale GtkHScale;
+typedef struct _GtkHScaleClass GtkHScaleClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class HScale_Class; } // namespace Gtk
+namespace Gtk
+{
+
+/** Abstract base clase for Gtk::HScale and Gtk::VScale.
+ * 
+ * A Gtk::Scale is a slider control used to select a numeric value. To use it,
+ * you'll probably want to investigate the methods on its base class,
+ * Gtk::Range, in addition to the methods for Gtk::Scale itself. To set the
+ * value of a scale, you would normally use set_value(). To detect
+ * changes to the value, you would normally use signal_value_changed().
+ *
+ * The Gtk::Scale widget is an abstract class, used only for deriving the
+ * subclasses Gtk::HScale and Gtk::VScale, so you should instantiate them
+ * instead.
+ *
+ * @ingroup Widgets
+ */
+
+class Scale : public Range
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Scale CppObjectType;
+  typedef Scale_Class CppClassType;
+  typedef GtkScale BaseObjectType;
+  typedef GtkScaleClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~Scale();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class Scale_Class;
+  static CppClassType scale_class_;
+
+  // noncopyable
+  Scale(const Scale&);
+  Scale& operator=(const Scale&);
+
+protected:
+  explicit Scale(const Glib::ConstructParams& construct_params);
+  explicit Scale(GtkScale* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GtkScale*       gobj()       { return reinterpret_cast<GtkScale*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GtkScale* gobj() const { return reinterpret_cast<GtkScale*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+  virtual Glib::ustring on_format_value(double value);
+
+
+private:
+
+protected:
+  Scale();
+public:
+  
+  /** Set the number of decimal digits.
+   * 
+   * This also causes the adjustment to be rounded off so the retrieved value
+   * matches the value the user sees. Setting digits to 1 gives for example
+   * 1.0, 2 gives 1.00, etc.
+   */
+  
+  void set_digits(int digits);
+
+  /** Get the number of decimal digits.
+   */
+  
+  int get_digits() const;
+
+  /** Set whether the current value is displayed as a string next to the slider. 
+   */
+  
+  void set_draw_value(bool draw_value = true);
+
+  /** Get whether the current value is displayed as a string next to the slider. 
+   */
+  
+  bool get_draw_value() const;
+
+
+  /** Set the position in which the value is displayed.
+   */
+  
+  void set_value_pos(PositionType pos);
+
+  /** Get the position in which the value is displayed.
+   */
+  
+  PositionType get_value_pos() const;
+
+  
+  /** Gets the Pango::Layout used to display the scale. The returned object
+   * is owned by the scale so does not need to be freed by the caller.
+   * @return The Pango::Layout for this scale, or <tt>0</tt> if the draw_value property
+   * is <tt>false</tt>.
+   * 
+   * Since: 2.4.
+   */
+  Glib::RefPtr<Pango::Layout> get_layout();
+  
+  /** Gets the Pango::Layout used to display the scale. The returned object
+   * is owned by the scale so does not need to be freed by the caller.
+   * @return The Pango::Layout for this scale, or <tt>0</tt> if the draw_value property
+   * is <tt>false</tt>.
+   * 
+   * Since: 2.4.
+   */
+  Glib::RefPtr<const Pango::Layout> get_layout() const;
+  
+  /** Obtains the coordinates where the scale will draw the Pango::Layout
+   * representing the text in the scale. Remember
+   * when using the Pango::Layout function you need to convert to
+   * and from pixels using PANGO_PIXELS() or Pango::SCALE. 
+   * 
+   * If the draw_value property is <tt>false</tt>, the return values are 
+   * undefined.
+   * 
+   * Since: 2.4
+   * @param x Location to store X offset of layout, or <tt>0</tt>.
+   * @param y Location to store Y offset of layout, or <tt>0</tt>.
+   */
+  void get_layout_offsets(int& x, int& y) const;
+  
+      
+  /** Determines how the value is formatted.
+   * 
+   * This can be used to connect a custom function for determining how the
+   * value is formatted. The function (or function object) is given a the value
+   * as a double and should return the representation of it as a Glib::ustring.
+   */ 
+  
+
+  Glib::SignalProxy1< Glib::ustring,double > signal_format_value();
+
+  // TODO: When we can break ABI, this signal needs to be
+  // Glib::ustring format_value(double value, bool& use_default_formatting), 
+  // where use_default_formatting specifies whether the return value will actually be a null char*.
+
+  /** Number of displayed decimal digits.
+   */
+  /** The number of decimal places that are displayed in the value.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<int> property_digits() ;
+
+/** The number of decimal places that are displayed in the value.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<int> property_digits() const;
+
+
+  /** Whether to draw the value as a string next to slider.
+   */
+  /** Whether the current value is displayed as a string next to the slider.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_draw_value() ;
+
+/** Whether the current value is displayed as a string next to the slider.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_draw_value() const;
+
+
+  /** The position in which the value is displayed.
+   */
+  /** The position in which the current value is displayed.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<PositionType> property_value_pos() ;
+
+/** The position in which the current value is displayed.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<PositionType> property_value_pos() const;
+
+
+protected:
+
+    virtual void draw_value_vfunc();
+  
+  virtual int calc_digits_(double step) const;
+
+
+};
+
+/** A vertical slider for selecting values.
+ * 
+ * The Gtk::VScale widget is used to allow the user to select a value using a
+ * vertical slider. See the Gtk::Scale documentation for more information
+ * on how to use a Gtk::VScale.
+ *
+ * @ingroup Widgets
+ */
+
+class VScale : public Scale
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef VScale CppObjectType;
+  typedef VScale_Class CppClassType;
+  typedef GtkVScale BaseObjectType;
+  typedef GtkVScaleClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~VScale();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class VScale_Class;
+  static CppClassType vscale_class_;
+
+  // noncopyable
+  VScale(const VScale&);
+  VScale& operator=(const VScale&);
+
+protected:
+  explicit VScale(const Glib::ConstructParams& construct_params);
+  explicit VScale(GtkVScale* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GtkVScale*       gobj()       { return reinterpret_cast<GtkVScale*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GtkVScale* gobj() const { return reinterpret_cast<GtkVScale*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+private:
+
+public:
+  VScale();
+
+  /**
+  * Construct a VScale with the given minimum and maximum. The step size is the
+  * distance the slider moves when the arrow keys are used to adjust the scale
+  * value.
+  */
+  VScale(double min, double max, double step);
+  explicit VScale(Adjustment& adjustment);
+  
+
+};
+
+/** A horizontal slider for selecting values.
+ *
+ * The Gtk::HScale widget is used to allow the user to select a value using a
+ * horizontal slider. See the Gtk::Scale documentation for more information
+ * on how to use a Gtk::HScale.
+ * 
+ * @ingroup Widgets
+ */
+
+class HScale : public Scale
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef HScale CppObjectType;
+  typedef HScale_Class CppClassType;
+  typedef GtkHScale BaseObjectType;
+  typedef GtkHScaleClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~HScale();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class HScale_Class;
+  static CppClassType hscale_class_;
+
+  // noncopyable
+  HScale(const HScale&);
+  HScale& operator=(const HScale&);
+
+protected:
+  explicit HScale(const Glib::ConstructParams& construct_params);
+  explicit HScale(GtkHScale* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GtkHScale*       gobj()       { return reinterpret_cast<GtkHScale*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GtkHScale* gobj() const { return reinterpret_cast<GtkHScale*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+private:
+
+public:
+  HScale();
+  /**
+  * Construct a HScale with the given minimum and maximum. The step size is the
+  * distance the slider moves when the arrow keys are used to adjust the scale
+  * value.
+  */
+  HScale(double min, double max, double step);
+  explicit HScale(Adjustment& adjustment);
+  
+
+};
+
+} /* namespace Gtk */
+
+
+namespace Glib
+{
+  /** @relates Gtk::Scale
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gtk::Scale* wrap(GtkScale* object, bool take_copy = false);
+}
+namespace Glib
+{
+  /** @relates Gtk::VScale
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gtk::VScale* wrap(GtkVScale* object, bool take_copy = false);
+}
+namespace Glib
+{
+  /** @relates Gtk::HScale
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gtk::HScale* wrap(GtkHScale* object, bool take_copy = false);
+}
+#endif /* _GTKMM_SCALE_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/scrollbar.cc b/libs/gtkmm2/gtk/gtkmm/scrollbar.cc
new file mode 100644
index 0000000000..1bf19b3cb8
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/scrollbar.cc
@@ -0,0 +1,341 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/scrollbar.h>
+#include <gtkmm/private/scrollbar_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* 
+ *
+ * Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/adjustment.h>
+
+#include <gtk/gtkscrollbar.h>
+#include <gtk/gtkhscrollbar.h>
+#include <gtk/gtkvscrollbar.h>
+
+namespace Gtk
+{
+
+VScrollbar::VScrollbar(Adjustment& adjustment)
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Scrollbar(Glib::ConstructParams(vscrollbar_class_.init(), (char*) 0))
+{
+  set_adjustment(adjustment);
+}
+
+VScrollbar::VScrollbar()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Scrollbar(Glib::ConstructParams(vscrollbar_class_.init(), (char*) 0))
+{
+  Adjustment* adjustment = manage(new Adjustment(0.0, 0.0, 0.0, 0.0, 0.0, 0.0));
+
+  // The adjustment will be destroyed along with the object
+  set_adjustment(*adjustment);
+}
+
+
+HScrollbar::HScrollbar()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Scrollbar(Glib::ConstructParams(hscrollbar_class_.init(), (char*) 0))
+{
+  Adjustment* adjustment = manage(new Adjustment(0.0, 0.0, 0.0, 0.0, 0.0, 0.0));
+
+  // The adjustment will be destroyed along with the object
+  set_adjustment(*adjustment);
+}
+
+HScrollbar::HScrollbar(Adjustment& adjustment)
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Scrollbar(Glib::ConstructParams(hscrollbar_class_.init(), (char*) 0))
+{
+  set_adjustment(adjustment);
+}
+
+} // namespace Gtk
+
+
+namespace
+{
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Gtk::Scrollbar* wrap(GtkScrollbar* object, bool take_copy)
+{
+  return dynamic_cast<Gtk::Scrollbar *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& Scrollbar_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &Scrollbar_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_scrollbar_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void Scrollbar_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+}
+
+
+Glib::ObjectBase* Scrollbar_Class::wrap_new(GObject* o)
+{
+  return manage(new Scrollbar((GtkScrollbar*)(o)));
+
+}
+
+
+/* The implementation: */
+
+Scrollbar::Scrollbar(const Glib::ConstructParams& construct_params)
+:
+  Gtk::Range(construct_params)
+{
+  }
+
+Scrollbar::Scrollbar(GtkScrollbar* castitem)
+:
+  Gtk::Range((GtkRange*)(castitem))
+{
+  }
+
+Scrollbar::~Scrollbar()
+{
+  destroy_();
+}
+
+Scrollbar::CppClassType Scrollbar::scrollbar_class_; // initialize static member
+
+GType Scrollbar::get_type()
+{
+  return scrollbar_class_.init().get_type();
+}
+
+GType Scrollbar::get_base_type()
+{
+  return gtk_scrollbar_get_type();
+}
+
+
+} // namespace Gtk
+
+
+namespace Glib
+{
+
+Gtk::VScrollbar* wrap(GtkVScrollbar* object, bool take_copy)
+{
+  return dynamic_cast<Gtk::VScrollbar *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& VScrollbar_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &VScrollbar_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_vscrollbar_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void VScrollbar_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+}
+
+
+Glib::ObjectBase* VScrollbar_Class::wrap_new(GObject* o)
+{
+  return manage(new VScrollbar((GtkVScrollbar*)(o)));
+
+}
+
+
+/* The implementation: */
+
+VScrollbar::VScrollbar(const Glib::ConstructParams& construct_params)
+:
+  Gtk::Scrollbar(construct_params)
+{
+  }
+
+VScrollbar::VScrollbar(GtkVScrollbar* castitem)
+:
+  Gtk::Scrollbar((GtkScrollbar*)(castitem))
+{
+  }
+
+VScrollbar::~VScrollbar()
+{
+  destroy_();
+}
+
+VScrollbar::CppClassType VScrollbar::vscrollbar_class_; // initialize static member
+
+GType VScrollbar::get_type()
+{
+  return vscrollbar_class_.init().get_type();
+}
+
+GType VScrollbar::get_base_type()
+{
+  return gtk_vscrollbar_get_type();
+}
+
+
+} // namespace Gtk
+
+
+namespace Glib
+{
+
+Gtk::HScrollbar* wrap(GtkHScrollbar* object, bool take_copy)
+{
+  return dynamic_cast<Gtk::HScrollbar *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& HScrollbar_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &HScrollbar_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_hscrollbar_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void HScrollbar_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+}
+
+
+Glib::ObjectBase* HScrollbar_Class::wrap_new(GObject* o)
+{
+  return manage(new HScrollbar((GtkHScrollbar*)(o)));
+
+}
+
+
+/* The implementation: */
+
+HScrollbar::HScrollbar(const Glib::ConstructParams& construct_params)
+:
+  Gtk::Scrollbar(construct_params)
+{
+  }
+
+HScrollbar::HScrollbar(GtkHScrollbar* castitem)
+:
+  Gtk::Scrollbar((GtkScrollbar*)(castitem))
+{
+  }
+
+HScrollbar::~HScrollbar()
+{
+  destroy_();
+}
+
+HScrollbar::CppClassType HScrollbar::hscrollbar_class_; // initialize static member
+
+GType HScrollbar::get_type()
+{
+  return hscrollbar_class_.init().get_type();
+}
+
+GType HScrollbar::get_base_type()
+{
+  return gtk_hscrollbar_get_type();
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/scrollbar.h b/libs/gtkmm2/gtk/gtkmm/scrollbar.h
new file mode 100644
index 0000000000..36c7d1b8f8
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/scrollbar.h
@@ -0,0 +1,307 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_SCROLLBAR_H
+#define _GTKMM_SCROLLBAR_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* scrollbar.h
+ * 
+ * Copyright (C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/range.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkScrollbar GtkScrollbar;
+typedef struct _GtkScrollbarClass GtkScrollbarClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class Scrollbar_Class; } // namespace Gtk
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkVScrollbar GtkVScrollbar;
+typedef struct _GtkVScrollbarClass GtkVScrollbarClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class VScrollbar_Class; } // namespace Gtk
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkHScrollbar GtkHScrollbar;
+typedef struct _GtkHScrollbarClass GtkHScrollbarClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class HScrollbar_Class; } // namespace Gtk
+namespace Gtk
+{
+
+/** 
+ * The Gtk::Scrollbar widget is an abstract base class for Gtk::HScrollbar
+ * and Gtk::VScrollbar. It is not very useful in itself. 
+ *
+ * The position of the thumb in a scrollbar is controlled by the scroll
+ * adjustments. See Gtk::Adjustment for the fields in an adjustment - for
+ * Gtk::Scrollbar, the "value" field represents the position of the scrollbar,
+ * which must be between the "lower" field and "upper - page_size." The
+ * "page_size" field represents the size of the visible scrollable area. The
+ * "step_increment" and "page_increment" fields are used when the user asks
+ * to step down (using the small stepper arrows) or page down (using for
+ * example the PageDown key).
+ *
+ * @ingroup Widgets
+ */
+
+class Scrollbar : public Range
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Scrollbar CppObjectType;
+  typedef Scrollbar_Class CppClassType;
+  typedef GtkScrollbar BaseObjectType;
+  typedef GtkScrollbarClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~Scrollbar();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class Scrollbar_Class;
+  static CppClassType scrollbar_class_;
+
+  // noncopyable
+  Scrollbar(const Scrollbar&);
+  Scrollbar& operator=(const Scrollbar&);
+
+protected:
+  explicit Scrollbar(const Glib::ConstructParams& construct_params);
+  explicit Scrollbar(GtkScrollbar* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GtkScrollbar*       gobj()       { return reinterpret_cast<GtkScrollbar*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GtkScrollbar* gobj() const { return reinterpret_cast<GtkScrollbar*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+private:
+
+
+protected:
+  
+
+};
+
+/** A vertical scrollbar.
+ *
+ * The Gtk::VScrollbar widget is a widget arranged vertically creating a
+ * scrollbar. See Gtk::Scrollbar for details on scrollbars.
+ *
+ * A Gtk::Adjustment may may be passed to the constructor  to handle the
+ * adjustment of the scrollbar. If not specified, one will be created for
+ * you. See Gtk::Adjustment for details.
+ *
+ * @ingroup Widgets
+ */
+
+class VScrollbar : public Scrollbar
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef VScrollbar CppObjectType;
+  typedef VScrollbar_Class CppClassType;
+  typedef GtkVScrollbar BaseObjectType;
+  typedef GtkVScrollbarClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~VScrollbar();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class VScrollbar_Class;
+  static CppClassType vscrollbar_class_;
+
+  // noncopyable
+  VScrollbar(const VScrollbar&);
+  VScrollbar& operator=(const VScrollbar&);
+
+protected:
+  explicit VScrollbar(const Glib::ConstructParams& construct_params);
+  explicit VScrollbar(GtkVScrollbar* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GtkVScrollbar*       gobj()       { return reinterpret_cast<GtkVScrollbar*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GtkVScrollbar* gobj() const { return reinterpret_cast<GtkVScrollbar*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+private:
+
+public:
+  VScrollbar();
+  explicit VScrollbar(Adjustment& gtkadjustment);
+  
+
+};
+
+/** A horizontal scrollbar.
+ *
+ * The Gtk::HScrollbar widget is a widget arranged horizontally creating a
+ * scrollbar. See Gtk::Scrollbar for details on scrollbars.
+ *
+ * A Gtk::Adjustment may may be passed to the constructor  to handle the
+ * adjustment of the scrollbar. If not specified, one will be created for
+ * you. See Gtk::Adjustment for details.
+ *
+ * @ingroup Widgets
+ */
+
+class HScrollbar : public Scrollbar
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef HScrollbar CppObjectType;
+  typedef HScrollbar_Class CppClassType;
+  typedef GtkHScrollbar BaseObjectType;
+  typedef GtkHScrollbarClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~HScrollbar();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class HScrollbar_Class;
+  static CppClassType hscrollbar_class_;
+
+  // noncopyable
+  HScrollbar(const HScrollbar&);
+  HScrollbar& operator=(const HScrollbar&);
+
+protected:
+  explicit HScrollbar(const Glib::ConstructParams& construct_params);
+  explicit HScrollbar(GtkHScrollbar* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GtkHScrollbar*       gobj()       { return reinterpret_cast<GtkHScrollbar*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GtkHScrollbar* gobj() const { return reinterpret_cast<GtkHScrollbar*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+private:
+
+public:
+  HScrollbar();
+  explicit HScrollbar(Adjustment& gtkadjustment);
+  
+
+};
+
+
+} /* namespace Gtk */
+
+
+namespace Glib
+{
+  /** @relates Gtk::Scrollbar
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gtk::Scrollbar* wrap(GtkScrollbar* object, bool take_copy = false);
+}
+namespace Glib
+{
+  /** @relates Gtk::VScrollbar
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gtk::VScrollbar* wrap(GtkVScrollbar* object, bool take_copy = false);
+}
+namespace Glib
+{
+  /** @relates Gtk::HScrollbar
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gtk::HScrollbar* wrap(GtkHScrollbar* object, bool take_copy = false);
+}
+#endif /* _GTKMM_SCROLLBAR_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/scrolledwindow.cc b/libs/gtkmm2/gtk/gtkmm/scrolledwindow.cc
new file mode 100644
index 0000000000..aa297a6daa
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/scrolledwindow.cc
@@ -0,0 +1,323 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/scrolledwindow.h>
+#include <gtkmm/private/scrolledwindow_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* 
+ *
+ * Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/scrollbar.h>
+#include <gtkmm/viewport.h>
+#include <gtkmm/adjustment.h>
+#include <gtk/gtkscrolledwindow.h>
+
+
+namespace Gtk
+{
+
+void ScrolledWindow::add(Gtk::Widget& widget)
+{
+  GtkWidget* gwidget = widget.gobj();
+
+  //This check is courtesy of James Henstridge on gtk-devel-list@gnome.org.
+  if( GTK_WIDGET_GET_CLASS(gwidget)->set_scroll_adjustments_signal == 0)
+  {
+    //It doesn't have native scrolling capability, so it should be put inside a viewport first:
+    gtk_scrolled_window_add_with_viewport(gobj(), gwidget);
+  }
+  else
+  {
+    //It can work directly with a GtkScrolledWindow, so just use the Container::add():
+    Bin::add(widget);
+  }
+}
+
+} //namespace Gtk
+
+
+namespace
+{
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Gtk::ScrolledWindow* wrap(GtkScrolledWindow* object, bool take_copy)
+{
+  return dynamic_cast<Gtk::ScrolledWindow *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& ScrolledWindow_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &ScrolledWindow_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_scrolled_window_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void ScrolledWindow_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+}
+
+
+Glib::ObjectBase* ScrolledWindow_Class::wrap_new(GObject* o)
+{
+  return manage(new ScrolledWindow((GtkScrolledWindow*)(o)));
+
+}
+
+
+/* The implementation: */
+
+ScrolledWindow::ScrolledWindow(const Glib::ConstructParams& construct_params)
+:
+  Gtk::Bin(construct_params)
+{
+  }
+
+ScrolledWindow::ScrolledWindow(GtkScrolledWindow* castitem)
+:
+  Gtk::Bin((GtkBin*)(castitem))
+{
+  }
+
+ScrolledWindow::~ScrolledWindow()
+{
+  destroy_();
+}
+
+ScrolledWindow::CppClassType ScrolledWindow::scrolledwindow_class_; // initialize static member
+
+GType ScrolledWindow::get_type()
+{
+  return scrolledwindow_class_.init().get_type();
+}
+
+GType ScrolledWindow::get_base_type()
+{
+  return gtk_scrolled_window_get_type();
+}
+
+
+ScrolledWindow::ScrolledWindow()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Bin(Glib::ConstructParams(scrolledwindow_class_.init()))
+{
+  }
+
+ScrolledWindow::ScrolledWindow(Adjustment& hadjustment, Adjustment& vadjustment)
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Bin(Glib::ConstructParams(scrolledwindow_class_.init(), "hadjustment", (hadjustment).gobj(), "vadjustment", (vadjustment).gobj(), (char*) 0))
+{
+  }
+
+void ScrolledWindow::set_hadjustment(Gtk::Adjustment* hadjustment)
+{
+  gtk_scrolled_window_set_hadjustment(gobj(), (GtkAdjustment*)Glib::unwrap(hadjustment));
+}
+
+void ScrolledWindow::set_vadjustment(Gtk::Adjustment* vadjustment)
+{
+  gtk_scrolled_window_set_vadjustment(gobj(), (GtkAdjustment*)Glib::unwrap(vadjustment));
+}
+
+void ScrolledWindow::set_hadjustment(Gtk::Adjustment& hadjustment)
+{
+  gtk_scrolled_window_set_hadjustment(gobj(), (hadjustment).gobj());
+}
+
+void ScrolledWindow::set_vadjustment(Gtk::Adjustment& vadjustment)
+{
+  gtk_scrolled_window_set_vadjustment(gobj(), (vadjustment).gobj());
+}
+
+Gtk::Adjustment* ScrolledWindow::get_hadjustment()
+{
+  return Glib::wrap(gtk_scrolled_window_get_hadjustment(gobj()));
+}
+
+const Gtk::Adjustment* ScrolledWindow::get_hadjustment() const
+{
+  return Glib::wrap(gtk_scrolled_window_get_hadjustment(const_cast<GtkScrolledWindow*>(gobj())));
+}
+
+Gtk::Adjustment* ScrolledWindow::get_vadjustment()
+{
+  return Glib::wrap(gtk_scrolled_window_get_vadjustment(gobj()));
+}
+
+const Gtk::Adjustment* ScrolledWindow::get_vadjustment() const
+{
+  return Glib::wrap(gtk_scrolled_window_get_vadjustment(const_cast<GtkScrolledWindow*>(gobj())));
+}
+
+void ScrolledWindow::set_policy(PolicyType hscrollbar_policy, PolicyType vscrollbar_policy)
+{
+  gtk_scrolled_window_set_policy(gobj(), ((GtkPolicyType)(hscrollbar_policy)), ((GtkPolicyType)(vscrollbar_policy)));
+}
+
+void ScrolledWindow::get_policy(PolicyType& hscrollbar_policy, PolicyType& vscrollbar_policy) const
+{
+  gtk_scrolled_window_get_policy(const_cast<GtkScrolledWindow*>(gobj()), ((GtkPolicyType*) &(hscrollbar_policy)), ((GtkPolicyType*) &(vscrollbar_policy)));
+}
+
+void ScrolledWindow::set_placement(CornerType window_placement)
+{
+  gtk_scrolled_window_set_placement(gobj(), ((GtkCornerType)(window_placement)));
+}
+
+CornerType ScrolledWindow::get_placement() const
+{
+  return ((CornerType)(gtk_scrolled_window_get_placement(const_cast<GtkScrolledWindow*>(gobj()))));
+}
+
+void ScrolledWindow::set_shadow_type(ShadowType type)
+{
+  gtk_scrolled_window_set_shadow_type(gobj(), ((GtkShadowType)(type)));
+}
+
+ShadowType ScrolledWindow::get_shadow_type() const
+{
+  return ((ShadowType)(gtk_scrolled_window_get_shadow_type(const_cast<GtkScrolledWindow*>(gobj()))));
+}
+
+bool ScrolledWindow::get_vscrollbar_visible() const
+{
+  return gobj()->hscrollbar_visible;
+}
+
+bool ScrolledWindow::get_hscrollbar_visible() const
+{
+  return gobj()->vscrollbar_visible;
+}
+
+Gtk::HScrollbar* ScrolledWindow::get_hscrollbar()
+{
+  return Glib::wrap((GtkHScrollbar*)(gobj()->hscrollbar));
+}
+
+const Gtk::HScrollbar* ScrolledWindow::get_hscrollbar() const
+{
+  return Glib::wrap((GtkHScrollbar*)(gobj()->hscrollbar));
+}
+
+Gtk::VScrollbar* ScrolledWindow::get_vscrollbar()
+{
+  return Glib::wrap((GtkVScrollbar*)(gobj()->vscrollbar));
+}
+
+const Gtk::VScrollbar* ScrolledWindow::get_vscrollbar() const
+{
+  return Glib::wrap((GtkVScrollbar*)(gobj()->vscrollbar));
+}
+
+
+Glib::PropertyProxy<Gtk::Adjustment*> ScrolledWindow::property_hadjustment() 
+{
+  return Glib::PropertyProxy<Gtk::Adjustment*>(this, "hadjustment");
+}
+
+Glib::PropertyProxy_ReadOnly<Gtk::Adjustment*> ScrolledWindow::property_hadjustment() const
+{
+  return Glib::PropertyProxy_ReadOnly<Gtk::Adjustment*>(this, "hadjustment");
+}
+
+Glib::PropertyProxy<Gtk::Adjustment*> ScrolledWindow::property_vadjustment() 
+{
+  return Glib::PropertyProxy<Gtk::Adjustment*>(this, "vadjustment");
+}
+
+Glib::PropertyProxy_ReadOnly<Gtk::Adjustment*> ScrolledWindow::property_vadjustment() const
+{
+  return Glib::PropertyProxy_ReadOnly<Gtk::Adjustment*>(this, "vadjustment");
+}
+
+Glib::PropertyProxy<PolicyType> ScrolledWindow::property_hscrollbar_policy() 
+{
+  return Glib::PropertyProxy<PolicyType>(this, "hscrollbar-policy");
+}
+
+Glib::PropertyProxy_ReadOnly<PolicyType> ScrolledWindow::property_hscrollbar_policy() const
+{
+  return Glib::PropertyProxy_ReadOnly<PolicyType>(this, "hscrollbar-policy");
+}
+
+Glib::PropertyProxy<PolicyType> ScrolledWindow::property_vscrollbar_policy() 
+{
+  return Glib::PropertyProxy<PolicyType>(this, "vscrollbar-policy");
+}
+
+Glib::PropertyProxy_ReadOnly<PolicyType> ScrolledWindow::property_vscrollbar_policy() const
+{
+  return Glib::PropertyProxy_ReadOnly<PolicyType>(this, "vscrollbar-policy");
+}
+
+Glib::PropertyProxy<CornerType> ScrolledWindow::property_window_placement() 
+{
+  return Glib::PropertyProxy<CornerType>(this, "window-placement");
+}
+
+Glib::PropertyProxy_ReadOnly<CornerType> ScrolledWindow::property_window_placement() const
+{
+  return Glib::PropertyProxy_ReadOnly<CornerType>(this, "window-placement");
+}
+
+Glib::PropertyProxy<ShadowType> ScrolledWindow::property_shadow_type() 
+{
+  return Glib::PropertyProxy<ShadowType>(this, "shadow-type");
+}
+
+Glib::PropertyProxy_ReadOnly<ShadowType> ScrolledWindow::property_shadow_type() const
+{
+  return Glib::PropertyProxy_ReadOnly<ShadowType>(this, "shadow-type");
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/scrolledwindow.h b/libs/gtkmm2/gtk/gtkmm/scrolledwindow.h
new file mode 100644
index 0000000000..8bb8c66230
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/scrolledwindow.h
@@ -0,0 +1,298 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_SCROLLEDWINDOW_H
+#define _GTKMM_SCROLLEDWINDOW_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* scrolledwindow.h
+ * 
+ * Copyright (C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/bin.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkScrolledWindow GtkScrolledWindow;
+typedef struct _GtkScrolledWindowClass GtkScrolledWindowClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class ScrolledWindow_Class; } // namespace Gtk
+namespace Gtk
+{
+
+class Adjustment;
+class HScrollbar;
+class VScrollbar;
+
+/** Adds scrollbars to its child widget.
+ *
+ * This container accepts a single child widget. It adds scrollbars to the child widget and optionally draws a beveled frame around the child widget.
+ * The scrolled window can work in two ways:
+ * 1) Some widgets have native scrolling support; these widgets handle certain Gtk::Adjustment signals. Widgets with native scroll support include Gtk::TreeView, Gtk::TextView, and Gtk::Layout.
+ * 2) For widgets that lack native scrolling support, such as Gtk::Table, Gtk::Box, and so on, the widget will be placed inside a Gtk::Viewport.
+ *
+ * The position of the scrollbars is controlled by the scroll adjustments. See Gtk::Adjustment for the fields in an adjustment - for Gtk::Scrollbar, used by Gtk::ScrolledWindow,
+ * the "value" field represents the position of the scrollbar, which must be between the "lower" field and "upper - page_size."
+ * The "page_size" field represents the size of the visible scrollable area.
+ * The "step_increment" and "page_increment" fields are used when the user asks to step down (using the small stepper arrows) or page down (using for example the PageDown key).
+ *
+ * If a Gtk::ScrolledWindow doesn't behave quite as you would like, or doesn't have exactly the right layout, it's very possible to set up your own scrolling with Gtk::Scrollbar and, for example, a Gtk::Table.
+ *
+ * @ingroup Widgets
+ * @ingroup Containers
+ */
+
+class ScrolledWindow : public Bin
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef ScrolledWindow CppObjectType;
+  typedef ScrolledWindow_Class CppClassType;
+  typedef GtkScrolledWindow BaseObjectType;
+  typedef GtkScrolledWindowClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~ScrolledWindow();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class ScrolledWindow_Class;
+  static CppClassType scrolledwindow_class_;
+
+  // noncopyable
+  ScrolledWindow(const ScrolledWindow&);
+  ScrolledWindow& operator=(const ScrolledWindow&);
+
+protected:
+  explicit ScrolledWindow(const Glib::ConstructParams& construct_params);
+  explicit ScrolledWindow(GtkScrolledWindow* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GtkScrolledWindow*       gobj()       { return reinterpret_cast<GtkScrolledWindow*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GtkScrolledWindow* gobj() const { return reinterpret_cast<GtkScrolledWindow*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+private:
+
+
+public:
+  ScrolledWindow();
+  explicit ScrolledWindow(Adjustment& hadjustment, Adjustment& vadjustment);
+  
+
+  void set_hadjustment(Gtk::Adjustment* hadjustment = 0);
+  
+  void set_vadjustment(Gtk::Adjustment* vadjustment = 0);
+  
+  void set_hadjustment(Gtk::Adjustment& hadjustment);
+  
+  void set_vadjustment(Gtk::Adjustment& vadjustment);
+
+  
+  Gtk::Adjustment* get_hadjustment();
+  
+  const Gtk::Adjustment* get_hadjustment() const;
+  
+  Gtk::Adjustment* get_vadjustment();
+  
+  const Gtk::Adjustment* get_vadjustment() const;
+
+  
+  void set_policy(PolicyType hscrollbar_policy, PolicyType vscrollbar_policy);
+  
+  /** Retrieves the current policy values for the horizontal and vertical
+   * scrollbars. See set_policy().
+   * @param hscrollbar_policy Location to store the policy for the horizontal scrollbar, or <tt>0</tt>.
+   * @param vscrollbar_policy Location to store the policy for the horizontal scrollbar, or <tt>0</tt>.
+   */
+  void get_policy(PolicyType& hscrollbar_policy, PolicyType& vscrollbar_policy) const;
+
+  
+  void set_placement(CornerType window_placement);
+  
+  /** Gets the placement of the scrollbars for the scrolled window. See 
+   * set_placement().
+   * @return The current placement value.
+   */
+  CornerType get_placement() const;
+
+  
+  /** Changes the type of shadow drawn around the contents of
+   *  @a scrolled_window .
+   * @param type Kind of shadow to draw around scrolled window contents.
+   */
+  void set_shadow_type(ShadowType type);
+  
+  /** Gets the shadow type of the scrolled window. See 
+   * set_shadow_type().
+   * @return The current shadow type.
+   */
+  ShadowType get_shadow_type() const;
+
+  ///Puts the child inside a Gtk::Viewport if it doesn't have native scrolling capability.
+  virtual void add(Gtk::Widget& widget);
+  
+
+  bool get_vscrollbar_visible() const;
+  bool get_hscrollbar_visible() const;
+  Gtk::HScrollbar* get_hscrollbar();
+  const Gtk::HScrollbar* get_hscrollbar() const;
+  Gtk::VScrollbar* get_vscrollbar();
+  const Gtk::VScrollbar* get_vscrollbar() const;
+
+  //Keybinding signals:
+  
+  
+  /** The GtkAdjustment for the horizontal position.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Gtk::Adjustment*> property_hadjustment() ;
+
+/** The GtkAdjustment for the horizontal position.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Gtk::Adjustment*> property_hadjustment() const;
+
+  /** The GtkAdjustment for the vertical position.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Gtk::Adjustment*> property_vadjustment() ;
+
+/** The GtkAdjustment for the vertical position.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Gtk::Adjustment*> property_vadjustment() const;
+
+  /** When the horizontal scrollbar is displayed.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<PolicyType> property_hscrollbar_policy() ;
+
+/** When the horizontal scrollbar is displayed.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<PolicyType> property_hscrollbar_policy() const;
+
+  /** When the vertical scrollbar is displayed.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<PolicyType> property_vscrollbar_policy() ;
+
+/** When the vertical scrollbar is displayed.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<PolicyType> property_vscrollbar_policy() const;
+
+  /** Where the contents are located with respect to the scrollbars.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<CornerType> property_window_placement() ;
+
+/** Where the contents are located with respect to the scrollbars.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<CornerType> property_window_placement() const;
+
+  /** Style of bevel around the contents.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<ShadowType> property_shadow_type() ;
+
+/** Style of bevel around the contents.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<ShadowType> property_shadow_type() const;
+
+
+};
+
+} /* namespace Gtk */
+
+
+namespace Glib
+{
+  /** @relates Gtk::ScrolledWindow
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gtk::ScrolledWindow* wrap(GtkScrolledWindow* object, bool take_copy = false);
+}
+#endif /* _GTKMM_SCROLLEDWINDOW_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/selectiondata.cc b/libs/gtkmm2/gtk/gtkmm/selectiondata.cc
new file mode 100644
index 0000000000..4770c896fc
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/selectiondata.cc
@@ -0,0 +1,261 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/selectiondata.h>
+#include <gtkmm/private/selectiondata_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* Copyright 2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gdkmm/pixbuf.h>
+#include <glibmm/utility.h> //For ScopedPtr<>.
+#include <gtk/gtkselection.h>
+
+
+namespace Gtk
+{
+
+void SelectionData::set(const std::string& type, int format, const guint8* data, int length)
+{
+  gtk_selection_data_set(gobj(), gdk_atom_intern(type.c_str(), 0), format, data, length);
+}
+
+void SelectionData::set(int format, const guint8* data, int length)
+{
+  //The C examples do this - that's why I added this method overload. murrayc.
+  set(get_target(), format, data, length);
+}
+
+void SelectionData::set(const std::string& type, const std::string& data)
+{
+  gtk_selection_data_set(gobj(), gdk_atom_intern(type.c_str(), 0),
+                         sizeof(char) * 8, // format is 8 bits per unit
+                         reinterpret_cast<const guint8*>(data.data()), data.size());
+}
+
+bool SelectionData::set_text(const Glib::ustring& data)
+{
+  return gtk_selection_data_set_text(gobj(), data.data(), data.bytes());
+}
+
+Glib::ustring SelectionData::get_text() const
+{
+  return Glib::convert_return_gchar_ptr_to_ustring(
+      reinterpret_cast<char*>(gtk_selection_data_get_text(const_cast<GtkSelectionData*>(gobj()))));
+}
+
+std::string SelectionData::get_data_as_string() const
+{
+  if(gobj()->data && gobj()->length > 0)
+    return std::string(reinterpret_cast<char*>(gobj()->data), gobj()->length);
+  else
+    return std::string();
+}
+
+std::string SelectionData::get_target() const
+{
+  return Glib::convert_return_gchar_ptr_to_stdstring(
+      gdk_atom_name(const_cast<GtkSelectionData*>(gobj())->target));
+}
+
+Glib::StringArrayHandle SelectionData::get_targets() const
+{
+  GdkAtom* targets = 0;
+  int    n_targets = 0;
+
+  if(!gtk_selection_data_get_targets(const_cast<GtkSelectionData*>(gobj()), &targets, &n_targets))
+    n_targets = 0; // it's set to -1 otherwise
+
+  //Build a C++ list containing the target names:
+  std::list<Glib::ustring> listTargets;
+  for(int i = 0; i < n_targets; n_targets++)
+  {
+    //Convert the atom to a string:
+    gchar* const atom_name = gdk_atom_name(targets[i]);
+
+    Glib::ustring target;
+    if(atom_name)
+      target = Glib::ScopedPtr<char>(atom_name).get(); //This frees the gchar*.
+
+    listTargets.push_back(target);
+  }
+
+  g_free(targets);
+
+  return listTargets;
+}
+
+std::string SelectionData::get_data_type() const
+{
+  return Glib::convert_return_gchar_ptr_to_stdstring(
+      gdk_atom_name(const_cast<GtkSelectionData*>(gobj())->type));
+}
+
+} // namespace Gtk
+
+
+namespace
+{
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Gtk::SelectionData wrap(GtkSelectionData* object, bool take_copy)
+{
+  return Gtk::SelectionData(object, take_copy);
+}
+
+} // namespace Glib
+
+
+namespace Gtk
+{
+
+
+// static
+GType SelectionData::get_type()
+{
+  return gtk_selection_data_get_type();
+}
+
+SelectionData::SelectionData()
+:
+  gobject_ (0) // Allows creation of invalid wrapper, e.g. for output arguments to methods.
+{}
+
+SelectionData::SelectionData(const SelectionData& other)
+:
+  gobject_ ((other.gobject_) ? gtk_selection_data_copy(other.gobject_) : 0)
+{}
+
+SelectionData::SelectionData(GtkSelectionData* gobject, bool make_a_copy)
+:
+  // For BoxedType wrappers, make_a_copy is true by default.  The static
+  // BoxedType wrappers must always take a copy, thus make_a_copy = true
+  // ensures identical behaviour if the default argument is used.
+  gobject_ ((make_a_copy && gobject) ? gtk_selection_data_copy(gobject) : gobject)
+{}
+
+SelectionData& SelectionData::operator=(const SelectionData& other)
+{
+  SelectionData temp (other);
+  swap(temp);
+  return *this;
+}
+
+SelectionData::~SelectionData()
+{
+  if(gobject_)
+    gtk_selection_data_free(gobject_);
+}
+
+void SelectionData::swap(SelectionData& other)
+{
+  GtkSelectionData *const temp = gobject_;
+  gobject_ = other.gobject_;
+  other.gobject_ = temp;
+}
+
+GtkSelectionData* SelectionData::gobj_copy() const
+{
+  return gtk_selection_data_copy(gobject_);
+}
+
+
+bool SelectionData::set_pixbuf(const Glib::RefPtr<Gdk::Pixbuf>& pixbuf)
+{
+  return gtk_selection_data_set_pixbuf(gobj(), Glib::unwrap(pixbuf));
+}
+
+Glib::RefPtr<Gdk::Pixbuf> SelectionData::get_pixbuf()
+{
+  return Glib::wrap(gtk_selection_data_get_pixbuf(gobj()));
+}
+
+Glib::RefPtr<const Gdk::Pixbuf> SelectionData::get_pixbuf() const
+{
+  return Glib::wrap(gtk_selection_data_get_pixbuf(const_cast<GtkSelectionData*>(gobj())));
+}
+
+bool SelectionData::set_uris(const Glib::StringArrayHandle& uris)
+{
+  return gtk_selection_data_set_uris(gobj(), const_cast<char**>((uris).data()));
+}
+
+Glib::StringArrayHandle SelectionData::get_uris() const
+{
+  return Glib::StringArrayHandle(gtk_selection_data_get_uris(const_cast<GtkSelectionData*>(gobj())));
+}
+
+const guint8* SelectionData::get_data() const
+{
+  return gobj()->data;
+}
+
+int SelectionData::get_length() const
+{
+  return gobj()->length;
+}
+
+GdkAtom SelectionData::get_selection() const
+{
+  return gobj()->selection;
+}
+
+int SelectionData::get_format() const
+{
+  return gobj()->format;
+}
+
+Glib::RefPtr<Gdk::Display> SelectionData::get_display()
+{
+  Glib::RefPtr<Gdk::Display> ref_ptr(Glib::wrap(gobj()->display));
+
+  if(ref_ptr)
+    ref_ptr->reference();
+
+  return ref_ptr;
+}
+
+Glib::RefPtr<const Gdk::Display> SelectionData::get_display() const
+{
+  Glib::RefPtr<const Gdk::Display> ref_ptr(Glib::wrap(gobj()->display));
+
+  if(ref_ptr)
+    ref_ptr->reference();
+
+  return ref_ptr;
+}
+
+bool SelectionData::targets_include_text() const
+{
+  return gtk_selection_data_targets_include_text(const_cast<GtkSelectionData*>(gobj()));
+}
+
+bool SelectionData::targets_include_image(bool writable) const
+{
+  return gtk_selection_data_targets_include_image(const_cast<GtkSelectionData*>(gobj()), static_cast<int>(writable));
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/selectiondata.h b/libs/gtkmm2/gtk/gtkmm/selectiondata.h
new file mode 100644
index 0000000000..b76bda790a
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/selectiondata.h
@@ -0,0 +1,253 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_SELECTIONDATA_H
+#define _GTKMM_SELECTIONDATA_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* Copyright(C) 2002 The gtkmm Development Team
+ *
+ * This library is free software, ) you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library, ) if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+
+#include <gdkmm/display.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+extern "C" { typedef struct _GtkSelectionData GtkSelectionData; }
+#endif
+
+namespace Gtk
+{
+
+class SelectionData
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef SelectionData CppObjectType;
+  typedef GtkSelectionData BaseObjectType;
+
+  static GType get_type() G_GNUC_CONST;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  SelectionData();
+
+  explicit SelectionData(GtkSelectionData* gobject, bool make_a_copy = true);
+
+  SelectionData(const SelectionData& other);
+  SelectionData& operator=(const SelectionData& other);
+
+  ~SelectionData();
+
+  void swap(SelectionData& other);
+
+  ///Provides access to the underlying C instance.
+  GtkSelectionData*       gobj()       { return gobject_; }
+
+  ///Provides access to the underlying C instance.
+  const GtkSelectionData* gobj() const { return gobject_; }
+
+  ///Provides access to the underlying C instance. The caller is responsible for freeing it. Use when directly setting fields in structs.
+  GtkSelectionData* gobj_copy() const;
+
+protected:
+  GtkSelectionData* gobject_;
+
+private:
+
+  
+public:
+
+  //TODO : document this. It's like the other set(), but it uses this SelectionData's target type.
+  //Why would you ever want to use any other type?
+  void set(int format, const guint8* data, int length);
+  
+  /** Assign a memory block of raw data.
+   * Store new data into the Gtk::SelectionData object. Should _only_ by called
+   * from a selection handler callback.  A 0-byte terminates the stored data.
+   * @param type The type of the selection.
+   * @param format The data format, i.e. the number of bits in a unit.
+   * @param data Pointer to the data (will be copied).
+   * @param length The length of the data block in bytes.
+   */
+  void set(const std::string& type, int format, const guint8* data, int length);
+
+  /** Assign a string of raw data.
+   * Store new data into the Gtk::SelectionData object. Should _only_ by called
+   * from a selection handler callback. 
+   * @param type The type of the selection.
+   * @param data A string that contains the data (does not have to be text).
+   */
+  void set(const std::string& type, const std::string& data);
+  
+
+  /** Assign UTF-8 encoded text.
+   * Sets the contents of the selection from a UTF-8 encoded string.
+   * The string is converted to the form determined by get_target().
+   * @param data A UTF-8 encoded string.
+   * @return <tt>true</tt> if the selection was successfully set,
+   * otherwise <tt>false</tt>.
+   */
+  bool set_text(const Glib::ustring& data);
+  
+
+  /** Gets the contents of the selection data as a UTF-8 string.
+   * @return If the selection data contained a recognized text type and
+   * it could be converted to UTF-8, a string containing the converted text,
+   * otherwise an empty string.
+   */
+  Glib::ustring get_text() const;
+  
+
+  /** Sets the contents of the selection from a Gdk::Pixbuf
+   * The pixbuf is converted to the form determined by
+   *  @a selection_data -&gt;target.
+   * @param pixbuf A Gdk::Pixbuf.
+   * @return <tt>true</tt> if the selection was successfully set,
+   * otherwise <tt>false</tt>.
+   * 
+   * Since: 2.6.
+   */
+  bool set_pixbuf(const Glib::RefPtr<Gdk::Pixbuf>& pixbuf);
+  
+  /** Gets the contents of the selection data as a Gdk::Pixbuf.
+   * @return If the selection data contained a recognized
+   * image type and it could be converted to a Gdk::Pixbuf, a 
+   * newly allocated pixbuf is returned, otherwise <tt>0</tt>.
+   * If the result is non-<tt>0</tt> it must be freed with Glib::object_unref().
+   * 
+   * Since: 2.6.
+   */
+  Glib::RefPtr<Gdk::Pixbuf> get_pixbuf();
+  
+  /** Gets the contents of the selection data as a Gdk::Pixbuf.
+   * @return If the selection data contained a recognized
+   * image type and it could be converted to a Gdk::Pixbuf, a 
+   * newly allocated pixbuf is returned, otherwise <tt>0</tt>.
+   * If the result is non-<tt>0</tt> it must be freed with Glib::object_unref().
+   * 
+   * Since: 2.6.
+   */
+  Glib::RefPtr<const Gdk::Pixbuf> get_pixbuf() const;
+  
+# 
+
+ 
+  /** Sets the contents of the selection from a list of URIs.
+   * The string is converted to the form determined by
+   *  @a selection_data -&gt;target.
+   * @param uris A <tt>0</tt>-terminated array of strings hilding URIs.
+   * @return <tt>true</tt> if the selection was successfully set,
+   * otherwise <tt>false</tt>.
+   * 
+   * Since: 2.6.
+   */
+  bool set_uris(const Glib::StringArrayHandle& uris);
+  
+  /** Gets the contents of the selection data as array of URIs.
+   * @return If the selection data contains a list of
+   * URIs, a newly allocated <tt>0</tt>-terminated string array
+   * containing the URIs, otherwise <tt>0</tt>. If the result is 
+   * non-<tt>0</tt> it must be freed with Glib::strfreev().
+   * 
+   * Since: 2.6.
+   */
+  Glib::StringArrayHandle get_uris() const;
+
+  const guint8* get_data() const;
+  int get_length() const;
+
+  std::string get_data_as_string() const;
+
+  std::string get_target() const;
+
+  /// See also Gtk::Clipboard::request_targets()
+  Glib::StringArrayHandle get_targets() const;
+  
+
+  /** Returns the ID of the selection.
+   */
+  GdkAtom get_selection() const;
+
+  /** Returns the type of the data as set by SelectionData::set().
+   */
+  std::string get_data_type() const; // get_type() already exists
+
+  int get_format() const;
+  Glib::RefPtr<Gdk::Display> get_display();
+  Glib::RefPtr<const Gdk::Display> get_display() const;
+
+  
+  /** Given a Gtk::SelectionData object holding a list of targets,
+   * determines if any of the targets in @a targets  can be used to
+   * provide text.
+   * @return <tt>true</tt> if @a selection_data  holds a list of targets,
+   * and a suitable target for text is included, otherwise <tt>false</tt>.
+   */
+  bool targets_include_text() const;
+  
+  /** Given a Gtk::SelectionData object holding a list of targets,
+   * determines if any of the targets in @a targets  can be used to
+   * provide a Gdk::Pixbuf.
+   * @param writable Whether to accept only targets for which GTK+ knows
+   * how to convert a pixbuf into the format.
+   * @return <tt>true</tt> if @a selection_data  holds a list of targets,
+   * and a suitable target for images is included, otherwise <tt>false</tt>.
+   * 
+   * Since: 2.6.
+   */
+  bool targets_include_image(bool writable = true) const;
+
+
+};
+
+} // namespace Gtk
+
+
+namespace Gtk
+{
+
+/** @relates Gtk::SelectionData
+ * @param lhs The left-hand side
+ * @param rhs The right-hand side
+ */
+inline void swap(SelectionData& lhs, SelectionData& rhs)
+  { lhs.swap(rhs); }
+
+} // namespace Gtk
+
+namespace Glib
+{
+
+/** @relates Gtk::SelectionData
+ * @param object The C instance
+ * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+ * @result A C++ instance that wraps this C instance.
+ */
+Gtk::SelectionData wrap(GtkSelectionData* object, bool take_copy = false);
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+template <>
+class Value<Gtk::SelectionData> : public Glib::Value_Boxed<Gtk::SelectionData>
+{};
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+} // namespace Glib
+
+#endif /* _GTKMM_SELECTIONDATA_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/selectiondata_private.cc b/libs/gtkmm2/gtk/gtkmm/selectiondata_private.cc
new file mode 100644
index 0000000000..3be6f7f413
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/selectiondata_private.cc
@@ -0,0 +1,40 @@
+// -*- c++ -*-
+
+/*
+ *
+ * Copyright 2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/selectiondata_private.h>
+
+namespace Gtk
+{
+
+SelectionData_WithoutOwnership::SelectionData_WithoutOwnership(GtkSelectionData* gobject)
+: SelectionData(gobject, false /* take_copy */)
+{
+}
+
+SelectionData_WithoutOwnership::~SelectionData_WithoutOwnership()
+{
+  //Prevent the base class's destructor from free-ing the underlying gobject:
+  gobject_ = 0;
+}
+
+} //namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/selectiondata_private.h b/libs/gtkmm2/gtk/gtkmm/selectiondata_private.h
new file mode 100644
index 0000000000..b27c5481d1
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/selectiondata_private.h
@@ -0,0 +1,49 @@
+// -*- c++ -*-
+
+/* sectiondata_private.h
+ *
+ * Copyright(C) 2002 The gtkmm Development Team
+ *
+ * This library is free software, ) you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library, ) if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#ifndef _GTKMM_SELECTIONDATA_PRIVATE_H
+#define _GTKMM_SELECTIONDATA_PRIVATE_H
+
+#include <gtkmm/selectiondata.h>
+
+
+namespace Gtk
+{
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+/** This class allows GtkSelectionData to be manipulated via a C++ API, but doesn't take a copy
+ * or try to free the underlying instance in its destructor.
+ * So far it's only used by gtkmm internally.
+ */
+class SelectionData_WithoutOwnership : public SelectionData
+{
+public:
+  explicit SelectionData_WithoutOwnership(GtkSelectionData* gobject);
+  ~SelectionData_WithoutOwnership();
+};
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+} // namespace Gtk
+
+#endif /* _GTKMM_SELECTIONDATA_PRIVATE_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/separator.cc b/libs/gtkmm2/gtk/gtkmm/separator.cc
new file mode 100644
index 0000000000..8f2b72cba6
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/separator.cc
@@ -0,0 +1,317 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/separator.h>
+#include <gtkmm/private/separator_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* 
+ *
+ * Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtk/gtkseparator.h>
+#include <gtk/gtkhseparator.h>
+#include <gtk/gtkvseparator.h>
+
+
+namespace
+{
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Gtk::Separator* wrap(GtkSeparator* object, bool take_copy)
+{
+  return dynamic_cast<Gtk::Separator *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& Separator_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &Separator_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_separator_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void Separator_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+}
+
+
+Glib::ObjectBase* Separator_Class::wrap_new(GObject* o)
+{
+  return manage(new Separator((GtkSeparator*)(o)));
+
+}
+
+
+/* The implementation: */
+
+Separator::Separator(const Glib::ConstructParams& construct_params)
+:
+  Gtk::Widget(construct_params)
+{
+  }
+
+Separator::Separator(GtkSeparator* castitem)
+:
+  Gtk::Widget((GtkWidget*)(castitem))
+{
+  }
+
+Separator::~Separator()
+{
+  destroy_();
+}
+
+Separator::CppClassType Separator::separator_class_; // initialize static member
+
+GType Separator::get_type()
+{
+  return separator_class_.init().get_type();
+}
+
+GType Separator::get_base_type()
+{
+  return gtk_separator_get_type();
+}
+
+
+Separator::Separator()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Widget(Glib::ConstructParams(separator_class_.init()))
+{
+  }
+
+
+} // namespace Gtk
+
+
+namespace Glib
+{
+
+Gtk::VSeparator* wrap(GtkVSeparator* object, bool take_copy)
+{
+  return dynamic_cast<Gtk::VSeparator *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& VSeparator_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &VSeparator_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_vseparator_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void VSeparator_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+}
+
+
+Glib::ObjectBase* VSeparator_Class::wrap_new(GObject* o)
+{
+  return manage(new VSeparator((GtkVSeparator*)(o)));
+
+}
+
+
+/* The implementation: */
+
+VSeparator::VSeparator(const Glib::ConstructParams& construct_params)
+:
+  Gtk::Separator(construct_params)
+{
+  }
+
+VSeparator::VSeparator(GtkVSeparator* castitem)
+:
+  Gtk::Separator((GtkSeparator*)(castitem))
+{
+  }
+
+VSeparator::~VSeparator()
+{
+  destroy_();
+}
+
+VSeparator::CppClassType VSeparator::vseparator_class_; // initialize static member
+
+GType VSeparator::get_type()
+{
+  return vseparator_class_.init().get_type();
+}
+
+GType VSeparator::get_base_type()
+{
+  return gtk_vseparator_get_type();
+}
+
+VSeparator::VSeparator()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Separator(Glib::ConstructParams(vseparator_class_.init()))
+{
+  }
+
+
+} // namespace Gtk
+
+
+namespace Glib
+{
+
+Gtk::HSeparator* wrap(GtkHSeparator* object, bool take_copy)
+{
+  return dynamic_cast<Gtk::HSeparator *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& HSeparator_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &HSeparator_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_hseparator_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void HSeparator_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+}
+
+
+Glib::ObjectBase* HSeparator_Class::wrap_new(GObject* o)
+{
+  return manage(new HSeparator((GtkHSeparator*)(o)));
+
+}
+
+
+/* The implementation: */
+
+HSeparator::HSeparator(const Glib::ConstructParams& construct_params)
+:
+  Gtk::Separator(construct_params)
+{
+  }
+
+HSeparator::HSeparator(GtkHSeparator* castitem)
+:
+  Gtk::Separator((GtkSeparator*)(castitem))
+{
+  }
+
+HSeparator::~HSeparator()
+{
+  destroy_();
+}
+
+HSeparator::CppClassType HSeparator::hseparator_class_; // initialize static member
+
+GType HSeparator::get_type()
+{
+  return hseparator_class_.init().get_type();
+}
+
+GType HSeparator::get_base_type()
+{
+  return gtk_hseparator_get_type();
+}
+
+HSeparator::HSeparator()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Separator(Glib::ConstructParams(hseparator_class_.init()))
+{
+  }
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/separator.h b/libs/gtkmm2/gtk/gtkmm/separator.h
new file mode 100644
index 0000000000..914fe80308
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/separator.h
@@ -0,0 +1,286 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_SEPARATOR_H
+#define _GTKMM_SEPARATOR_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* separator.h
+ * 
+ * Copyright (C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/widget.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkSeparator GtkSeparator;
+typedef struct _GtkSeparatorClass GtkSeparatorClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class Separator_Class; } // namespace Gtk
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkVSeparator GtkVSeparator;
+typedef struct _GtkVSeparatorClass GtkVSeparatorClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class VSeparator_Class; } // namespace Gtk
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkHSeparator GtkHSeparator;
+typedef struct _GtkHSeparatorClass GtkHSeparatorClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class HSeparator_Class; } // namespace Gtk
+namespace Gtk
+{
+
+/** Separator base class.
+ * Abstract base class for Gtk::VSeperator and Gtk::HSeperator.
+ */
+
+class Separator : public Widget
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Separator CppObjectType;
+  typedef Separator_Class CppClassType;
+  typedef GtkSeparator BaseObjectType;
+  typedef GtkSeparatorClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~Separator();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class Separator_Class;
+  static CppClassType separator_class_;
+
+  // noncopyable
+  Separator(const Separator&);
+  Separator& operator=(const Separator&);
+
+protected:
+  explicit Separator(const Glib::ConstructParams& construct_params);
+  explicit Separator(GtkSeparator* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GtkSeparator*       gobj()       { return reinterpret_cast<GtkSeparator*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GtkSeparator* gobj() const { return reinterpret_cast<GtkSeparator*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+private:
+
+public:
+  
+
+protected:
+  Separator();
+
+
+};
+
+/** Vertical line widget.
+ * Filler widget used to separate widgets with a visible line.
+ * This widget has no window and receives no configuration events.
+ * It should be considered a leaf widget.
+ * @ingroup Widgets
+ */
+
+class VSeparator : public Separator
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef VSeparator CppObjectType;
+  typedef VSeparator_Class CppClassType;
+  typedef GtkVSeparator BaseObjectType;
+  typedef GtkVSeparatorClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~VSeparator();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class VSeparator_Class;
+  static CppClassType vseparator_class_;
+
+  // noncopyable
+  VSeparator(const VSeparator&);
+  VSeparator& operator=(const VSeparator&);
+
+protected:
+  explicit VSeparator(const Glib::ConstructParams& construct_params);
+  explicit VSeparator(GtkVSeparator* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GtkVSeparator*       gobj()       { return reinterpret_cast<GtkVSeparator*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GtkVSeparator* gobj() const { return reinterpret_cast<GtkVSeparator*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+private:
+
+public:
+  VSeparator();
+  
+
+};
+
+
+/** Horizontal line widget.
+ * Filler widget used to separate widgets with a visible line.
+ * This widget has no window and receives no configuration events.
+ * It should be considered a leaf widget.
+ * @ingroup Widgets
+ */
+
+class HSeparator : public Separator
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef HSeparator CppObjectType;
+  typedef HSeparator_Class CppClassType;
+  typedef GtkHSeparator BaseObjectType;
+  typedef GtkHSeparatorClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~HSeparator();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class HSeparator_Class;
+  static CppClassType hseparator_class_;
+
+  // noncopyable
+  HSeparator(const HSeparator&);
+  HSeparator& operator=(const HSeparator&);
+
+protected:
+  explicit HSeparator(const Glib::ConstructParams& construct_params);
+  explicit HSeparator(GtkHSeparator* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GtkHSeparator*       gobj()       { return reinterpret_cast<GtkHSeparator*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GtkHSeparator* gobj() const { return reinterpret_cast<GtkHSeparator*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+private:
+
+public:
+  HSeparator();
+  
+
+};
+
+} /* namespace Gtk */
+
+
+namespace Glib
+{
+  /** @relates Gtk::Separator
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gtk::Separator* wrap(GtkSeparator* object, bool take_copy = false);
+}
+namespace Glib
+{
+  /** @relates Gtk::VSeparator
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gtk::VSeparator* wrap(GtkVSeparator* object, bool take_copy = false);
+}
+namespace Glib
+{
+  /** @relates Gtk::HSeparator
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gtk::HSeparator* wrap(GtkHSeparator* object, bool take_copy = false);
+}
+#endif /* _GTKMM_SEPARATOR_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/separatormenuitem.cc b/libs/gtkmm2/gtk/gtkmm/separatormenuitem.cc
new file mode 100644
index 0000000000..1b06d797c6
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/separatormenuitem.cc
@@ -0,0 +1,129 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/separatormenuitem.h>
+#include <gtkmm/private/separatormenuitem_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* 
+ *
+ * Copyright 2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtk/gtkseparatormenuitem.h>
+
+
+namespace
+{
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Gtk::SeparatorMenuItem* wrap(GtkSeparatorMenuItem* object, bool take_copy)
+{
+  return dynamic_cast<Gtk::SeparatorMenuItem *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& SeparatorMenuItem_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &SeparatorMenuItem_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_separator_menu_item_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void SeparatorMenuItem_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+}
+
+
+Glib::ObjectBase* SeparatorMenuItem_Class::wrap_new(GObject* o)
+{
+  return manage(new SeparatorMenuItem((GtkSeparatorMenuItem*)(o)));
+
+}
+
+
+/* The implementation: */
+
+SeparatorMenuItem::SeparatorMenuItem(const Glib::ConstructParams& construct_params)
+:
+  Gtk::MenuItem(construct_params)
+{
+  }
+
+SeparatorMenuItem::SeparatorMenuItem(GtkSeparatorMenuItem* castitem)
+:
+  Gtk::MenuItem((GtkMenuItem*)(castitem))
+{
+  }
+
+SeparatorMenuItem::~SeparatorMenuItem()
+{
+  destroy_();
+}
+
+SeparatorMenuItem::CppClassType SeparatorMenuItem::separatormenuitem_class_; // initialize static member
+
+GType SeparatorMenuItem::get_type()
+{
+  return separatormenuitem_class_.init().get_type();
+}
+
+GType SeparatorMenuItem::get_base_type()
+{
+  return gtk_separator_menu_item_get_type();
+}
+
+
+SeparatorMenuItem::SeparatorMenuItem()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::MenuItem(Glib::ConstructParams(separatormenuitem_class_.init()))
+{
+  }
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/separatormenuitem.h b/libs/gtkmm2/gtk/gtkmm/separatormenuitem.h
new file mode 100644
index 0000000000..614bb98d78
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/separatormenuitem.h
@@ -0,0 +1,121 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_SEPARATORMENUITEM_H
+#define _GTKMM_SEPARATORMENUITEM_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+
+/* separator.h
+ * 
+ * Copyright (C) 2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/menuitem.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkSeparatorMenuItem GtkSeparatorMenuItem;
+typedef struct _GtkSeparatorMenuItemClass GtkSeparatorMenuItemClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class SeparatorMenuItem_Class; } // namespace Gtk
+namespace Gtk
+{
+
+/** A separator used to group items within a menu.
+ * It displays a horizontal line with a shadow to make it appear sunken into the interface.
+ * @ingroup Widgets
+ * @ingroup Menus
+ */
+
+class SeparatorMenuItem : public MenuItem
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef SeparatorMenuItem CppObjectType;
+  typedef SeparatorMenuItem_Class CppClassType;
+  typedef GtkSeparatorMenuItem BaseObjectType;
+  typedef GtkSeparatorMenuItemClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~SeparatorMenuItem();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class SeparatorMenuItem_Class;
+  static CppClassType separatormenuitem_class_;
+
+  // noncopyable
+  SeparatorMenuItem(const SeparatorMenuItem&);
+  SeparatorMenuItem& operator=(const SeparatorMenuItem&);
+
+protected:
+  explicit SeparatorMenuItem(const Glib::ConstructParams& construct_params);
+  explicit SeparatorMenuItem(GtkSeparatorMenuItem* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GtkSeparatorMenuItem*       gobj()       { return reinterpret_cast<GtkSeparatorMenuItem*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GtkSeparatorMenuItem* gobj() const { return reinterpret_cast<GtkSeparatorMenuItem*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+private:
+
+public:
+  SeparatorMenuItem();
+
+
+};
+
+} /* namespace Gtk */
+
+
+namespace Glib
+{
+  /** @relates Gtk::SeparatorMenuItem
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gtk::SeparatorMenuItem* wrap(GtkSeparatorMenuItem* object, bool take_copy = false);
+}
+#endif /* _GTKMM_SEPARATORMENUITEM_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/separatortoolitem.cc b/libs/gtkmm2/gtk/gtkmm/separatortoolitem.cc
new file mode 100644
index 0000000000..4949789d2e
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/separatortoolitem.cc
@@ -0,0 +1,134 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/separatortoolitem.h>
+#include <gtkmm/private/separatortoolitem_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* 
+ *
+ * Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtk/gtkseparatortoolitem.h>
+
+namespace Gtk
+{
+
+} // namespace Gtk
+
+
+namespace
+{
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Gtk::SeparatorToolItem* wrap(GtkSeparatorToolItem* object, bool take_copy)
+{
+  return dynamic_cast<Gtk::SeparatorToolItem *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& SeparatorToolItem_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &SeparatorToolItem_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_separator_tool_item_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void SeparatorToolItem_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+}
+
+
+Glib::ObjectBase* SeparatorToolItem_Class::wrap_new(GObject* o)
+{
+  return manage(new SeparatorToolItem((GtkSeparatorToolItem*)(o)));
+
+}
+
+
+/* The implementation: */
+
+SeparatorToolItem::SeparatorToolItem(const Glib::ConstructParams& construct_params)
+:
+  Gtk::ToolItem(construct_params)
+{
+  }
+
+SeparatorToolItem::SeparatorToolItem(GtkSeparatorToolItem* castitem)
+:
+  Gtk::ToolItem((GtkToolItem*)(castitem))
+{
+  }
+
+SeparatorToolItem::~SeparatorToolItem()
+{
+  destroy_();
+}
+
+SeparatorToolItem::CppClassType SeparatorToolItem::separatortoolitem_class_; // initialize static member
+
+GType SeparatorToolItem::get_type()
+{
+  return separatortoolitem_class_.init().get_type();
+}
+
+GType SeparatorToolItem::get_base_type()
+{
+  return gtk_separator_tool_item_get_type();
+}
+
+
+SeparatorToolItem::SeparatorToolItem()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::ToolItem(Glib::ConstructParams(separatortoolitem_class_.init()))
+{
+  }
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/separatortoolitem.h b/libs/gtkmm2/gtk/gtkmm/separatortoolitem.h
new file mode 100644
index 0000000000..00f27cc12e
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/separatortoolitem.h
@@ -0,0 +1,125 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_SEPARATORTOOLITEM_H
+#define _GTKMM_SEPARATORTOOLITEM_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* separatortoolitem.h
+ * 
+ * Copyright (C) 2003 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/toolitem.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkSeparatorToolItem GtkSeparatorToolItem;
+typedef struct _GtkSeparatorToolItemClass GtkSeparatorToolItemClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class SeparatorToolItem_Class; } // namespace Gtk
+namespace Gtk
+{
+
+/** A toolbar item that separates groups of other toolbar items.
+ *
+ * A Gtk::SeparatorToolItem is a Gtk::ToolItem that separates groups of other Gtk::ToolItems.
+ * Depending on the theme, it will often look like a vertical line on
+ * horizontally docked toolbars. If the property "expand" is <tt>true</tt> and the property "draw"
+ * is <tt>false</tt>, a Gtk::SeparatorToolItem will act as a "spring" that forces other items to the
+ * ends of the toolbar. 
+ *
+ * @ingroup Widgets
+ */
+
+class SeparatorToolItem : public ToolItem
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef SeparatorToolItem CppObjectType;
+  typedef SeparatorToolItem_Class CppClassType;
+  typedef GtkSeparatorToolItem BaseObjectType;
+  typedef GtkSeparatorToolItemClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~SeparatorToolItem();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class SeparatorToolItem_Class;
+  static CppClassType separatortoolitem_class_;
+
+  // noncopyable
+  SeparatorToolItem(const SeparatorToolItem&);
+  SeparatorToolItem& operator=(const SeparatorToolItem&);
+
+protected:
+  explicit SeparatorToolItem(const Glib::ConstructParams& construct_params);
+  explicit SeparatorToolItem(GtkSeparatorToolItem* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GtkSeparatorToolItem*       gobj()       { return reinterpret_cast<GtkSeparatorToolItem*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GtkSeparatorToolItem* gobj() const { return reinterpret_cast<GtkSeparatorToolItem*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+private:
+
+public:
+  SeparatorToolItem();
+
+
+};
+
+} // namespace Gtk
+
+
+namespace Glib
+{
+  /** @relates Gtk::SeparatorToolItem
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gtk::SeparatorToolItem* wrap(GtkSeparatorToolItem* object, bool take_copy = false);
+}
+#endif /* _GTKMM_SEPARATORTOOLITEM_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/settings.cc b/libs/gtkmm2/gtk/gtkmm/settings.cc
new file mode 100644
index 0000000000..7cf9c0738a
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/settings.cc
@@ -0,0 +1,380 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/settings.h>
+#include <gtkmm/private/settings_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* 
+ *
+ * Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtk/gtksettings.h>
+
+namespace Gtk
+{
+
+Glib::RefPtr<Settings> Settings::get_default()
+{
+  Glib::RefPtr<Settings> result = Glib::RefPtr<Settings>( new Settings( gtk_settings_get_default() ) );
+  result->reference(); //gtk_settings_get_default() does not give a reference, so we take one.
+  return result;
+}
+
+
+} //namespace Gtk
+
+
+namespace
+{
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Glib::RefPtr<Gtk::Settings> wrap(GtkSettings* object, bool take_copy)
+{
+  return Glib::RefPtr<Gtk::Settings>( dynamic_cast<Gtk::Settings*> (Glib::wrap_auto ((GObject*)(object), take_copy)) );
+  //We use dynamic_cast<> in case of multiple inheritance.
+}
+
+} /* namespace Glib */
+
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& Settings_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &Settings_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_settings_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void Settings_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+}
+
+
+Glib::ObjectBase* Settings_Class::wrap_new(GObject* object)
+{
+  return new Settings((GtkSettings*)object);
+}
+
+
+/* The implementation: */
+
+GtkSettings* Settings::gobj_copy()
+{
+  reference();
+  return gobj();
+}
+
+Settings::Settings(const Glib::ConstructParams& construct_params)
+:
+  Glib::Object(construct_params)
+{}
+
+Settings::Settings(GtkSettings* castitem)
+:
+  Glib::Object((GObject*)(castitem))
+{}
+
+Settings::~Settings()
+{}
+
+
+Settings::CppClassType Settings::settings_class_; // initialize static member
+
+GType Settings::get_type()
+{
+  return settings_class_.init().get_type();
+}
+
+GType Settings::get_base_type()
+{
+  return gtk_settings_get_type();
+}
+
+
+Glib::RefPtr<Settings> Settings::get_for_screen(const Glib::RefPtr<Gdk::Screen>& screen)
+{
+
+  Glib::RefPtr<Settings> retvalue = Glib::wrap(gtk_settings_get_for_screen(Glib::unwrap(screen)));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+
+Glib::PropertyProxy<int> Settings::property_gtk_double_click_time() 
+{
+  return Glib::PropertyProxy<int>(this, "gtk-double-click-time");
+}
+
+Glib::PropertyProxy_ReadOnly<int> Settings::property_gtk_double_click_time() const
+{
+  return Glib::PropertyProxy_ReadOnly<int>(this, "gtk-double-click-time");
+}
+
+Glib::PropertyProxy<int> Settings::property_gtk_double_click_distance() 
+{
+  return Glib::PropertyProxy<int>(this, "gtk-double-click-distance");
+}
+
+Glib::PropertyProxy_ReadOnly<int> Settings::property_gtk_double_click_distance() const
+{
+  return Glib::PropertyProxy_ReadOnly<int>(this, "gtk-double-click-distance");
+}
+
+Glib::PropertyProxy<bool> Settings::property_gtk_cursor_blink() 
+{
+  return Glib::PropertyProxy<bool>(this, "gtk-cursor-blink");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> Settings::property_gtk_cursor_blink() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "gtk-cursor-blink");
+}
+
+Glib::PropertyProxy<int> Settings::property_gtk_cursor_blink_time() 
+{
+  return Glib::PropertyProxy<int>(this, "gtk-cursor-blink-time");
+}
+
+Glib::PropertyProxy_ReadOnly<int> Settings::property_gtk_cursor_blink_time() const
+{
+  return Glib::PropertyProxy_ReadOnly<int>(this, "gtk-cursor-blink-time");
+}
+
+Glib::PropertyProxy<bool> Settings::property_gtk_split_cursor() 
+{
+  return Glib::PropertyProxy<bool>(this, "gtk-split-cursor");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> Settings::property_gtk_split_cursor() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "gtk-split-cursor");
+}
+
+Glib::PropertyProxy<Glib::ustring> Settings::property_gtk_theme_name() 
+{
+  return Glib::PropertyProxy<Glib::ustring>(this, "gtk-theme-name");
+}
+
+Glib::PropertyProxy_ReadOnly<Glib::ustring> Settings::property_gtk_theme_name() const
+{
+  return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "gtk-theme-name");
+}
+
+Glib::PropertyProxy<Glib::ustring> Settings::property_gtk_key_theme_name() 
+{
+  return Glib::PropertyProxy<Glib::ustring>(this, "gtk-key-theme-name");
+}
+
+Glib::PropertyProxy_ReadOnly<Glib::ustring> Settings::property_gtk_key_theme_name() const
+{
+  return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "gtk-key-theme-name");
+}
+
+Glib::PropertyProxy<Glib::ustring> Settings::property_gtk_menu_bar_accel() 
+{
+  return Glib::PropertyProxy<Glib::ustring>(this, "gtk-menu-bar-accel");
+}
+
+Glib::PropertyProxy_ReadOnly<Glib::ustring> Settings::property_gtk_menu_bar_accel() const
+{
+  return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "gtk-menu-bar-accel");
+}
+
+Glib::PropertyProxy<int> Settings::property_gtk_dnd_drag_threshold() 
+{
+  return Glib::PropertyProxy<int>(this, "gtk-dnd-drag-threshold");
+}
+
+Glib::PropertyProxy_ReadOnly<int> Settings::property_gtk_dnd_drag_threshold() const
+{
+  return Glib::PropertyProxy_ReadOnly<int>(this, "gtk-dnd-drag-threshold");
+}
+
+Glib::PropertyProxy<Glib::ustring> Settings::property_gtk_font_name() 
+{
+  return Glib::PropertyProxy<Glib::ustring>(this, "gtk-font-name");
+}
+
+Glib::PropertyProxy_ReadOnly<Glib::ustring> Settings::property_gtk_font_name() const
+{
+  return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "gtk-font-name");
+}
+
+Glib::PropertyProxy<int> Settings::property_gtk_xft_antialias() 
+{
+  return Glib::PropertyProxy<int>(this, "gtk-xft-antialias");
+}
+
+Glib::PropertyProxy_ReadOnly<int> Settings::property_gtk_xft_antialias() const
+{
+  return Glib::PropertyProxy_ReadOnly<int>(this, "gtk-xft-antialias");
+}
+
+Glib::PropertyProxy<int> Settings::property_gtk_xft_hinting() 
+{
+  return Glib::PropertyProxy<int>(this, "gtk-xft-hinting");
+}
+
+Glib::PropertyProxy_ReadOnly<int> Settings::property_gtk_xft_hinting() const
+{
+  return Glib::PropertyProxy_ReadOnly<int>(this, "gtk-xft-hinting");
+}
+
+Glib::PropertyProxy<Glib::ustring> Settings::property_gtk_xft_hintstyle() 
+{
+  return Glib::PropertyProxy<Glib::ustring>(this, "gtk-xft-hintstyle");
+}
+
+Glib::PropertyProxy_ReadOnly<Glib::ustring> Settings::property_gtk_xft_hintstyle() const
+{
+  return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "gtk-xft-hintstyle");
+}
+
+Glib::PropertyProxy<Glib::ustring> Settings::property_gtk_xft_rgba() 
+{
+  return Glib::PropertyProxy<Glib::ustring>(this, "gtk-xft-rgba");
+}
+
+Glib::PropertyProxy_ReadOnly<Glib::ustring> Settings::property_gtk_xft_rgba() const
+{
+  return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "gtk-xft-rgba");
+}
+
+Glib::PropertyProxy<int> Settings::property_gtk_xft_dpi() 
+{
+  return Glib::PropertyProxy<int>(this, "gtk-xft-dpi");
+}
+
+Glib::PropertyProxy_ReadOnly<int> Settings::property_gtk_xft_dpi() const
+{
+  return Glib::PropertyProxy_ReadOnly<int>(this, "gtk-xft-dpi");
+}
+
+Glib::PropertyProxy<ToolbarStyle> Settings::property_gtk_toolbar_style() 
+{
+  return Glib::PropertyProxy<ToolbarStyle>(this, "gtk-toolbar-style");
+}
+
+Glib::PropertyProxy_ReadOnly<ToolbarStyle> Settings::property_gtk_toolbar_style() const
+{
+  return Glib::PropertyProxy_ReadOnly<ToolbarStyle>(this, "gtk-toolbar-style");
+}
+
+Glib::PropertyProxy<IconSize> Settings::property_gtk_toolbar_icon_size() 
+{
+  return Glib::PropertyProxy<IconSize>(this, "gtk-toolbar-icon-size");
+}
+
+Glib::PropertyProxy_ReadOnly<IconSize> Settings::property_gtk_toolbar_icon_size() const
+{
+  return Glib::PropertyProxy_ReadOnly<IconSize>(this, "gtk-toolbar-icon-size");
+}
+
+Glib::PropertyProxy<bool> Settings::property_gtk_can_change_accels() 
+{
+  return Glib::PropertyProxy<bool>(this, "gtk-can-change-accels");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> Settings::property_gtk_can_change_accels() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "gtk-can-change-accels");
+}
+
+Glib::PropertyProxy<bool> Settings::property_gtk_entry_select_on_focus() 
+{
+  return Glib::PropertyProxy<bool>(this, "gtk-entry-select-on-focus");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> Settings::property_gtk_entry_select_on_focus() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "gtk-entry-select-on-focus");
+}
+
+Glib::PropertyProxy<Glib::ustring> Settings::property_gtk_color_palette() 
+{
+  return Glib::PropertyProxy<Glib::ustring>(this, "gtk-color-palette");
+}
+
+Glib::PropertyProxy_ReadOnly<Glib::ustring> Settings::property_gtk_color_palette() const
+{
+  return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "gtk-color-palette");
+}
+
+Glib::PropertyProxy<bool> Settings::property_gtk_button_images() 
+{
+  return Glib::PropertyProxy<bool>(this, "gtk-button-images");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> Settings::property_gtk_button_images() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "gtk-button-images");
+}
+
+Glib::PropertyProxy<Glib::ustring> Settings::property_gtk_icon_theme_name() 
+{
+  return Glib::PropertyProxy<Glib::ustring>(this, "gtk-icon-theme-name");
+}
+
+Glib::PropertyProxy_ReadOnly<Glib::ustring> Settings::property_gtk_icon_theme_name() const
+{
+  return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "gtk-icon-theme-name");
+}
+
+Glib::PropertyProxy<Glib::ustring> Settings::property_gtk_icon_sizes() 
+{
+  return Glib::PropertyProxy<Glib::ustring>(this, "gtk-icon-sizes");
+}
+
+Glib::PropertyProxy_ReadOnly<Glib::ustring> Settings::property_gtk_icon_sizes() const
+{
+  return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "gtk-icon-sizes");
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/settings.h b/libs/gtkmm2/gtk/gtkmm/settings.h
new file mode 100644
index 0000000000..08cd78d90d
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/settings.h
@@ -0,0 +1,515 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_SETTINGS_H
+#define _GTKMM_SETTINGS_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* settings.h
+ * 
+ * Copyright (C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+
+#include <gtkmm/toolbar.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkSettings GtkSettings;
+typedef struct _GtkSettingsClass GtkSettingsClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class Settings_Class; } // namespace Gtk
+namespace Gtk
+{
+
+
+class Settings : public Glib::Object
+{
+   
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+public:
+  typedef Settings CppObjectType;
+  typedef Settings_Class CppClassType;
+  typedef GtkSettings BaseObjectType;
+  typedef GtkSettingsClass BaseClassType;
+
+private:  friend class Settings_Class;
+  static CppClassType settings_class_;
+
+private:
+  // noncopyable
+  Settings(const Settings&);
+  Settings& operator=(const Settings&);
+
+protected:
+  explicit Settings(const Glib::ConstructParams& construct_params);
+  explicit Settings(GtkSettings* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+  virtual ~Settings();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GObject.
+  GtkSettings*       gobj()       { return reinterpret_cast<GtkSettings*>(gobject_); }
+
+  ///Provides access to the underlying C GObject.
+  const GtkSettings* gobj() const { return reinterpret_cast<GtkSettings*>(gobject_); }
+
+  ///Provides access to the underlying C instance. The caller is responsible for unrefing it. Use when directly setting fields in structs.
+  GtkSettings* gobj_copy();
+
+private:
+
+   
+protected:
+
+
+public:
+
+  static Glib::RefPtr<Settings> get_default();
+
+  
+  /** Gets the Gtk::Settings object for @a screen , creating it if necessary.
+   * @param screen A Gdk::Screen.
+   * @return A Gtk::Settings object.
+   * 
+   * Since: 2.2.
+   */
+  static Glib::RefPtr<Settings> get_for_screen(const Glib::RefPtr<Gdk::Screen>& screen);
+
+  /** Maximum time allowed between two clicks for them to be considered a double click (in milliseconds).
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<int> property_gtk_double_click_time() ;
+
+/** Maximum time allowed between two clicks for them to be considered a double click (in milliseconds).
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<int> property_gtk_double_click_time() const;
+
+  /** Maximum distance allowed between two clicks for them to be considered a double click (in pixels).
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<int> property_gtk_double_click_distance() ;
+
+/** Maximum distance allowed between two clicks for them to be considered a double click (in pixels).
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<int> property_gtk_double_click_distance() const;
+
+  /** Whether the cursor should blink.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_gtk_cursor_blink() ;
+
+/** Whether the cursor should blink.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_gtk_cursor_blink() const;
+
+  /** Length of the cursor blink cycle
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<int> property_gtk_cursor_blink_time() ;
+
+/** Length of the cursor blink cycle
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<int> property_gtk_cursor_blink_time() const;
+
+  /** Whether two cursors should be displayed for mixed left-to-right and right-to-left text.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_gtk_split_cursor() ;
+
+/** Whether two cursors should be displayed for mixed left-to-right and right-to-left text.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_gtk_split_cursor() const;
+
+  /** Name of theme RC file to load.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Glib::ustring> property_gtk_theme_name() ;
+
+/** Name of theme RC file to load.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Glib::ustring> property_gtk_theme_name() const;
+
+  /** Name of key theme RC file to load.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Glib::ustring> property_gtk_key_theme_name() ;
+
+/** Name of key theme RC file to load.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Glib::ustring> property_gtk_key_theme_name() const;
+
+  /** Keybinding to activate the menu bar.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Glib::ustring> property_gtk_menu_bar_accel() ;
+
+/** Keybinding to activate the menu bar.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Glib::ustring> property_gtk_menu_bar_accel() const;
+
+  /** Number of pixels the cursor can move before dragging.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<int> property_gtk_dnd_drag_threshold() ;
+
+/** Number of pixels the cursor can move before dragging.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<int> property_gtk_dnd_drag_threshold() const;
+
+  /** Name of default font to use.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Glib::ustring> property_gtk_font_name() ;
+
+/** Name of default font to use.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Glib::ustring> property_gtk_font_name() const;
+
+  /** Whether to antialias Xft fonts; 0=no
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<int> property_gtk_xft_antialias() ;
+
+/** Whether to antialias Xft fonts; 0=no
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<int> property_gtk_xft_antialias() const;
+
+  /** Whether to hint Xft fonts; 0=no
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<int> property_gtk_xft_hinting() ;
+
+/** Whether to hint Xft fonts; 0=no
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<int> property_gtk_xft_hinting() const;
+
+  /** What degree of hinting to use; none
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Glib::ustring> property_gtk_xft_hintstyle() ;
+
+/** What degree of hinting to use; none
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Glib::ustring> property_gtk_xft_hintstyle() const;
+
+  /** Type of subpixel antialiasing; none
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Glib::ustring> property_gtk_xft_rgba() ;
+
+/** Type of subpixel antialiasing; none
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Glib::ustring> property_gtk_xft_rgba() const;
+
+  /** Resolution for Xft
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<int> property_gtk_xft_dpi() ;
+
+/** Resolution for Xft
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<int> property_gtk_xft_dpi() const;
+
+
+  // from GtkToolbar
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<ToolbarStyle> property_gtk_toolbar_style() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<ToolbarStyle> property_gtk_toolbar_style() const;
+
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<IconSize> property_gtk_toolbar_icon_size() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<IconSize> property_gtk_toolbar_icon_size() const;
+
+
+  // from GtkMenu
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_gtk_can_change_accels() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_gtk_can_change_accels() const;
+
+
+  // from GtkEntry
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_gtk_entry_select_on_focus() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_gtk_entry_select_on_focus() const;
+
+
+  // from GtkColorSelection
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Glib::ustring> property_gtk_color_palette() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Glib::ustring> property_gtk_color_palette() const;
+
+
+  // from GtkButton
+  /** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_gtk_button_images() ;
+
+/** 
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_gtk_button_images() const;
+
+
+  // from GtkIconTheme
+  /** Name of icon theme to use.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Glib::ustring> property_gtk_icon_theme_name() ;
+
+/** Name of icon theme to use.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Glib::ustring> property_gtk_icon_theme_name() const;
+
+  /** List of icon sizes gtk-menu=16
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Glib::ustring> property_gtk_icon_sizes() ;
+
+/** List of icon sizes gtk-menu=16
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Glib::ustring> property_gtk_icon_sizes() const;
+
+
+public:
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+};
+
+} /* namespace Gtk */
+
+
+namespace Glib
+{
+  /** @relates Gtk::Settings
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Glib::RefPtr<Gtk::Settings> wrap(GtkSettings* object, bool take_copy = false);
+}
+
+
+#endif /* _GTKMM_SETTINGS_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/sizegroup.cc b/libs/gtkmm2/gtk/gtkmm/sizegroup.cc
new file mode 100644
index 0000000000..40c350749f
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/sizegroup.cc
@@ -0,0 +1,179 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/sizegroup.h>
+#include <gtkmm/private/sizegroup_p.h>
+
+#include <gtk/gtktypebuiltins.h>
+// -*- c++ -*-
+/* $Id$ */
+
+/* 
+ *
+ * Copyright 2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtk/gtksizegroup.h>
+
+namespace Gtk
+{
+
+SizeGroup::SizeGroup(SizeGroupMode mode)
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Glib::Object(Glib::ConstructParams(sizegroup_class_.init(), "mode",(GtkSizeGroupMode) mode, (char*) 0))
+{}
+
+} // namespace Gtk
+
+
+namespace
+{
+} // anonymous namespace
+
+// static
+GType Glib::Value<Gtk::SizeGroupMode>::value_type()
+{
+  return gtk_size_group_mode_get_type();
+}
+
+
+namespace Glib
+{
+
+Glib::RefPtr<Gtk::SizeGroup> wrap(GtkSizeGroup* object, bool take_copy)
+{
+  return Glib::RefPtr<Gtk::SizeGroup>( dynamic_cast<Gtk::SizeGroup*> (Glib::wrap_auto ((GObject*)(object), take_copy)) );
+  //We use dynamic_cast<> in case of multiple inheritance.
+}
+
+} /* namespace Glib */
+
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& SizeGroup_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &SizeGroup_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_size_group_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void SizeGroup_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+}
+
+
+Glib::ObjectBase* SizeGroup_Class::wrap_new(GObject* object)
+{
+  return new SizeGroup((GtkSizeGroup*)object);
+}
+
+
+/* The implementation: */
+
+GtkSizeGroup* SizeGroup::gobj_copy()
+{
+  reference();
+  return gobj();
+}
+
+SizeGroup::SizeGroup(const Glib::ConstructParams& construct_params)
+:
+  Glib::Object(construct_params)
+{}
+
+SizeGroup::SizeGroup(GtkSizeGroup* castitem)
+:
+  Glib::Object((GObject*)(castitem))
+{}
+
+SizeGroup::~SizeGroup()
+{}
+
+
+SizeGroup::CppClassType SizeGroup::sizegroup_class_; // initialize static member
+
+GType SizeGroup::get_type()
+{
+  return sizegroup_class_.init().get_type();
+}
+
+GType SizeGroup::get_base_type()
+{
+  return gtk_size_group_get_type();
+}
+
+
+Glib::RefPtr<SizeGroup> SizeGroup::create(SizeGroupMode mode)
+{
+  return Glib::RefPtr<SizeGroup>( new SizeGroup(mode) );
+}
+void SizeGroup::set_mode(SizeGroupMode mode)
+{
+  gtk_size_group_set_mode(gobj(), ((GtkSizeGroupMode)(mode)));
+}
+
+SizeGroupMode SizeGroup::get_mode() const
+{
+  return ((SizeGroupMode)(gtk_size_group_get_mode(const_cast<GtkSizeGroup*>(gobj()))));
+}
+
+void SizeGroup::add_widget(Widget& widget)
+{
+  gtk_size_group_add_widget(gobj(), (widget).gobj());
+}
+
+void SizeGroup::remove_widget(Widget& widget)
+{
+  gtk_size_group_remove_widget(gobj(), (widget).gobj());
+}
+
+
+Glib::PropertyProxy<SizeGroupMode> SizeGroup::property_mode() 
+{
+  return Glib::PropertyProxy<SizeGroupMode>(this, "mode");
+}
+
+Glib::PropertyProxy_ReadOnly<SizeGroupMode> SizeGroup::property_mode() const
+{
+  return Glib::PropertyProxy_ReadOnly<SizeGroupMode>(this, "mode");
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/sizegroup.h b/libs/gtkmm2/gtk/gtkmm/sizegroup.h
new file mode 100644
index 0000000000..d3fb6991eb
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/sizegroup.h
@@ -0,0 +1,207 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_SIZEGROUP_H
+#define _GTKMM_SIZEGROUP_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* box.h
+ *
+ * Copyright 2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <glibmm/object.h>
+#include <gtkmm/widget.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkSizeGroup GtkSizeGroup;
+typedef struct _GtkSizeGroupClass GtkSizeGroupClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class SizeGroup_Class; } // namespace Gtk
+namespace Gtk
+{
+
+
+/** @addtogroup gtkmmEnums Enums and Flags */
+
+/**
+ * @ingroup gtkmmEnums
+ */
+enum SizeGroupMode
+{
+  SIZE_GROUP_NONE,
+  SIZE_GROUP_HORIZONTAL,
+  SIZE_GROUP_VERTICAL,
+  SIZE_GROUP_BOTH
+};
+
+} // namespace Gtk
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Gtk::SizeGroupMode> : public Glib::Value_Enum<Gtk::SizeGroupMode>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{
+
+
+class SizeGroup : public Glib::Object
+{
+  
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+public:
+  typedef SizeGroup CppObjectType;
+  typedef SizeGroup_Class CppClassType;
+  typedef GtkSizeGroup BaseObjectType;
+  typedef GtkSizeGroupClass BaseClassType;
+
+private:  friend class SizeGroup_Class;
+  static CppClassType sizegroup_class_;
+
+private:
+  // noncopyable
+  SizeGroup(const SizeGroup&);
+  SizeGroup& operator=(const SizeGroup&);
+
+protected:
+  explicit SizeGroup(const Glib::ConstructParams& construct_params);
+  explicit SizeGroup(GtkSizeGroup* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+  virtual ~SizeGroup();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GObject.
+  GtkSizeGroup*       gobj()       { return reinterpret_cast<GtkSizeGroup*>(gobject_); }
+
+  ///Provides access to the underlying C GObject.
+  const GtkSizeGroup* gobj() const { return reinterpret_cast<GtkSizeGroup*>(gobject_); }
+
+  ///Provides access to the underlying C instance. The caller is responsible for unrefing it. Use when directly setting fields in structs.
+  GtkSizeGroup* gobj_copy();
+
+private:
+
+protected:
+  explicit SizeGroup(SizeGroupMode mode);
+
+public:
+
+  
+  static Glib::RefPtr<SizeGroup> create(SizeGroupMode mode);
+
+
+  /** Sets the Gtk::SizeGroupMode of the size group. The mode of the size
+   * group determines whether the widgets in the size group should
+   * all have the same horizontal requisition (Gtk::SIZE_GROUP_MODE_HORIZONTAL)
+   * all have the same vertical requisition (Gtk::SIZE_GROUP_MODE_VERTICAL),
+   * or should all have the same requisition in both directions
+   * (Gtk::SIZE_GROUP_MODE_BOTH).
+   * @param mode The mode to set for the size group.
+   */
+  void set_mode(SizeGroupMode mode);
+  
+  /** Gets the current mode of the size group. See set_mode().
+   * @return The current mode of the size group.
+   */
+  SizeGroupMode get_mode() const;
+  
+  /** Adds a widget to a Gtk::SizeGroup. In the future, the requisition
+   * of the widget will be determined as the maximum of its requisition
+   * and the requisition of the other widgets in the size group.
+   * Whether this applies horizontally, vertically, or in both directions
+   * depends on the mode of the size group. See set_mode().
+   * @param widget The Gtk::Widget to add.
+   */
+  void add_widget(Widget& widget);
+  
+  /** Removes a widget from a Gtk::SizeGroup.
+   * @param widget The Gtk::Widget to remove.
+   */
+  void remove_widget(Widget& widget);
+
+  /** The directions in which the size group effects the requested sizes of its component widgets.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<SizeGroupMode> property_mode() ;
+
+/** The directions in which the size group effects the requested sizes of its component widgets.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<SizeGroupMode> property_mode() const;
+
+
+public:
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+};
+
+} /* namespace Gtk */
+
+
+namespace Glib
+{
+  /** @relates Gtk::SizeGroup
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Glib::RefPtr<Gtk::SizeGroup> wrap(GtkSizeGroup* object, bool take_copy = false);
+}
+
+
+#endif /* _GTKMM_SIZEGROUP_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/socket.cc b/libs/gtkmm2/gtk/gtkmm/socket.cc
new file mode 100644
index 0000000000..050d5a2dcd
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/socket.cc
@@ -0,0 +1,308 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/socket.h>
+#include <gtkmm/private/socket_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtk/gtksocket.h>
+
+
+namespace
+{
+
+const Glib::SignalProxyInfo Socket_signal_plug_added_info =
+{
+  "plug_added",
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
+};
+
+
+gboolean Socket_signal_plug_removed_callback(GtkSocket* self, void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< bool > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        return static_cast<int>((*static_cast<SlotType*>(slot))());
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+gboolean Socket_signal_plug_removed_notify_callback(GtkSocket* self,  void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+const Glib::SignalProxyInfo Socket_signal_plug_removed_info =
+{
+  "plug_removed",
+  (GCallback) &Socket_signal_plug_removed_callback,
+  (GCallback) &Socket_signal_plug_removed_notify_callback
+};
+
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Gtk::Socket* wrap(GtkSocket* object, bool take_copy)
+{
+  return dynamic_cast<Gtk::Socket *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& Socket_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &Socket_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_socket_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void Socket_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+  klass->plug_added = &plug_added_callback;
+  klass->plug_removed = &plug_removed_callback;
+}
+
+
+void Socket_Class::plug_added_callback(GtkSocket* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_plug_added();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->plug_added)
+      (*base->plug_added)(self);
+  }
+}
+
+gboolean Socket_Class::plug_removed_callback(GtkSocket* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return static_cast<int>(obj->on_plug_removed());
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->plug_removed)
+      return (*base->plug_removed)(self);
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+
+Glib::ObjectBase* Socket_Class::wrap_new(GObject* o)
+{
+  return manage(new Socket((GtkSocket*)(o)));
+
+}
+
+
+/* The implementation: */
+
+Socket::Socket(const Glib::ConstructParams& construct_params)
+:
+  Gtk::Container(construct_params)
+{
+  }
+
+Socket::Socket(GtkSocket* castitem)
+:
+  Gtk::Container((GtkContainer*)(castitem))
+{
+  }
+
+Socket::~Socket()
+{
+  destroy_();
+}
+
+Socket::CppClassType Socket::socket_class_; // initialize static member
+
+GType Socket::get_type()
+{
+  return socket_class_.init().get_type();
+}
+
+GType Socket::get_base_type()
+{
+  return gtk_socket_get_type();
+}
+
+
+Socket::Socket()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Container(Glib::ConstructParams(socket_class_.init()))
+{
+  }
+
+void Socket::add_id(Gdk::NativeWindow window_id)
+{
+  gtk_socket_add_id(gobj(), (GdkNativeWindow)(window_id));
+}
+
+Gdk::NativeWindow Socket::get_id() const
+{
+  return (Gdk::NativeWindow)(gtk_socket_get_id(const_cast<GtkSocket*>(gobj())));
+}
+
+
+Glib::SignalProxy0< void > Socket::signal_plug_added()
+{
+  return Glib::SignalProxy0< void >(this, &Socket_signal_plug_added_info);
+}
+
+Glib::SignalProxy0< bool > Socket::signal_plug_removed()
+{
+  return Glib::SignalProxy0< bool >(this, &Socket_signal_plug_removed_info);
+}
+
+
+void Gtk::Socket::on_plug_added()
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->plug_added)
+    (*base->plug_added)(gobj());
+}
+
+bool Gtk::Socket::on_plug_removed()
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->plug_removed)
+    return (*base->plug_removed)(gobj());
+
+  typedef bool RType;
+  return RType();
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/socket.h b/libs/gtkmm2/gtk/gtkmm/socket.h
new file mode 100644
index 0000000000..3b6d58aa96
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/socket.h
@@ -0,0 +1,200 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_SOCKET_H
+#define _GTKMM_SOCKET_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* Copyright (C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/container.h>
+#include <gdkmm/types.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkSocket GtkSocket;
+typedef struct _GtkSocketClass GtkSocketClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class Socket_Class; } // namespace Gtk
+namespace Gtk
+{
+
+/** Container for widgets from other processes.
+ * Together with Gtk::Plug, Gtk::Socket provides the ability to embed
+ * widgets from one process into another process in a fashion that is
+ * transparent to the user. One process creates a Gtk::Socket widget and,
+ * passes the that widget's window ID to the other process, which then
+ * creates a Gtk::Plug with that window ID. Any widgets contained in the
+ * Gtk::Plug then will appear inside the first applications window.
+ *
+ * The socket's window ID is obtained by using get_id(). Before using this
+ * function, the socket must have been realized, and for hence, have been
+ * added to its parent.
+ *
+ * @code
+ * Gtk::Socket socket;
+ * parent.add(socket);
+ *
+ * // The following call is only necessary if one of the ancestors of the
+ * // socket is not yet visible
+ * socket.realize();
+ *
+ * cout << "The ID of the sockets window is: " << socket.get_id() << endl;
+ *
+ * @endcode
+ *
+ * Note that if you pass the window ID of the socket to another process that
+ * will create a plug in the socket, you must make sure that the socket
+ * widget is not destroyed until that plug is created. Violating this rule
+ * will cause unpredictable consequences, the most likely consequence being
+ * that the plug will appear as a separate toplevel window. You can check if
+ * the plug has been created by examining the plug_window member of the
+ * GtkSocket structure returned by gobj(). If this field is non-NULL, then
+ * the plug has been successfully created inside of the socket.
+ *
+ * When gtkmm is notified that the embedded window has been destroyed, then
+ * it will destroy the socket as well. You should always, therefore, be
+ * prepared for your sockets to be destroyed at any time when the main event
+ * loop is running.
+ *
+ * The communication between a Gtk::Socket and a Gtk::Plug follows the
+ * XEmbed protocol. This protocol has also been implemented in other
+ * toolkits, e.g. Qt, allowing the same level of integration when embedding
+ * a Qt widget in gtkmm or vice versa.
+ *
+ * @ingroup Widgets
+ * @ingroup Containers
+ */
+
+class Socket : public Container
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Socket CppObjectType;
+  typedef Socket_Class CppClassType;
+  typedef GtkSocket BaseObjectType;
+  typedef GtkSocketClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~Socket();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class Socket_Class;
+  static CppClassType socket_class_;
+
+  // noncopyable
+  Socket(const Socket&);
+  Socket& operator=(const Socket&);
+
+protected:
+  explicit Socket(const Glib::ConstructParams& construct_params);
+  explicit Socket(GtkSocket* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GtkSocket*       gobj()       { return reinterpret_cast<GtkSocket*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GtkSocket* gobj() const { return reinterpret_cast<GtkSocket*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+  virtual void on_plug_added();
+  virtual bool on_plug_removed();
+
+
+private:
+
+  
+  //This is not available in on Win32.
+//This source file will not be compiled,
+//and the class will not be registered in wrap_init.h or wrap_init.cc
+
+public:
+  Socket();
+  
+
+  /** Adds an XEMBED client, such as a Gtk::Plug, to the Gtk::Socket.  The
+   * client may be in the same process or in a different process. 
+   * 
+   * To embed a Gtk::Plug in a Gtk::Socket, you can either create the
+   * Gtk::Plug with <tt>gtk_plug_new (0)</tt>, call 
+   * Gtk::Plug::get_id() to get the window ID of the plug, and then pass that to the
+   * add_id(), or you can call get_id() to get the
+   * window ID for the socket, and call Gtk::Plug::new() passing in that
+   * ID.
+   * 
+   * The Gtk::Socket must have already be added into a toplevel window
+   * before you can make this call.
+   * @param window_id The window ID of a client participating in the XEMBED protocol.
+   */
+  void add_id(Gdk::NativeWindow window_id);
+  
+  /** Gets the window ID of a Gtk::Socket widget, which can then
+   * be used to create a client embedded inside the socket, for
+   * instance with Gtk::Plug::new(). 
+   * 
+   * The Gtk::Socket must have already be added into a toplevel window 
+   * before you can make this call.
+   * @return The window ID for the socket.
+   */
+  Gdk::NativeWindow get_id() const;
+
+  
+  Glib::SignalProxy0< void > signal_plug_added();
+
+  
+  Glib::SignalProxy0< bool > signal_plug_removed();
+
+
+};
+
+} // namespace Gtk
+
+
+namespace Glib
+{
+  /** @relates Gtk::Socket
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gtk::Socket* wrap(GtkSocket* object, bool take_copy = false);
+}
+#endif /* _GTKMM_SOCKET_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/spinbutton.cc b/libs/gtkmm2/gtk/gtkmm/spinbutton.cc
new file mode 100644
index 0000000000..d82f8baab4
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/spinbutton.cc
@@ -0,0 +1,638 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/spinbutton.h>
+#include <gtkmm/private/spinbutton_p.h>
+
+#include <gtk/gtktypebuiltins.h>
+// -*- c++ -*-
+/* $Id$ */
+
+/* Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/adjustment.h>
+#include <gtk/gtkspinbutton.h>
+
+namespace Gtk
+{
+
+SpinButton::SpinButton(double climb_rate, guint digits)
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Entry(Glib::ConstructParams(spinbutton_class_.init(), "climb_rate",climb_rate,"digits",digits, (char*) 0))
+{}
+
+void SpinButton::unset_adjustment()
+{
+  gtk_spin_button_set_adjustment(gobj(), 0);
+}
+
+} // namespace Gtk
+
+
+namespace
+{
+
+gint SpinButton_signal_input_callback(GtkSpinButton* self, gdouble* p0,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< int,double* > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        return (*static_cast<SlotType*>(slot))(p0
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+
+  typedef gint RType;
+  return RType();
+}
+
+gint SpinButton_signal_input_notify_callback(GtkSpinButton* self, gdouble* p0, void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,double* > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(p0
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+
+  typedef gint RType;
+  return RType();
+}
+
+const Glib::SignalProxyInfo SpinButton_signal_input_info =
+{
+  "input",
+  (GCallback) &SpinButton_signal_input_callback,
+  (GCallback) &SpinButton_signal_input_notify_callback
+};
+
+
+gboolean SpinButton_signal_output_callback(GtkSpinButton* self, void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< bool > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        return static_cast<int>((*static_cast<SlotType*>(slot))());
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+gboolean SpinButton_signal_output_notify_callback(GtkSpinButton* self,  void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+const Glib::SignalProxyInfo SpinButton_signal_output_info =
+{
+  "output",
+  (GCallback) &SpinButton_signal_output_callback,
+  (GCallback) &SpinButton_signal_output_notify_callback
+};
+
+
+const Glib::SignalProxyInfo SpinButton_signal_value_changed_info =
+{
+  "value_changed",
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
+};
+
+} // anonymous namespace
+
+// static
+GType Glib::Value<Gtk::SpinButtonUpdatePolicy>::value_type()
+{
+  return gtk_spin_button_update_policy_get_type();
+}
+
+// static
+GType Glib::Value<Gtk::SpinType>::value_type()
+{
+  return gtk_spin_type_get_type();
+}
+
+
+namespace Glib
+{
+
+Gtk::SpinButton* wrap(GtkSpinButton* object, bool take_copy)
+{
+  return dynamic_cast<Gtk::SpinButton *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& SpinButton_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &SpinButton_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_spin_button_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  Editable::add_interface(get_type());
+  }
+
+  return *this;
+}
+
+void SpinButton_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+  klass->input = &input_callback;
+  klass->output = &output_callback;
+  klass->value_changed = &value_changed_callback;
+}
+
+
+gint SpinButton_Class::input_callback(GtkSpinButton* self, gdouble* p0)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return obj->on_input(p0
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->input)
+      return (*base->input)(self, p0);
+  }
+
+  typedef gint RType;
+  return RType();
+}
+
+gboolean SpinButton_Class::output_callback(GtkSpinButton* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return static_cast<int>(obj->on_output());
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->output)
+      return (*base->output)(self);
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+void SpinButton_Class::value_changed_callback(GtkSpinButton* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_value_changed();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->value_changed)
+      (*base->value_changed)(self);
+  }
+}
+
+
+Glib::ObjectBase* SpinButton_Class::wrap_new(GObject* o)
+{
+  return manage(new SpinButton((GtkSpinButton*)(o)));
+
+}
+
+
+/* The implementation: */
+
+SpinButton::SpinButton(const Glib::ConstructParams& construct_params)
+:
+  Gtk::Entry(construct_params)
+{
+  }
+
+SpinButton::SpinButton(GtkSpinButton* castitem)
+:
+  Gtk::Entry((GtkEntry*)(castitem))
+{
+  }
+
+SpinButton::~SpinButton()
+{
+  destroy_();
+}
+
+SpinButton::CppClassType SpinButton::spinbutton_class_; // initialize static member
+
+GType SpinButton::get_type()
+{
+  return spinbutton_class_.init().get_type();
+}
+
+GType SpinButton::get_base_type()
+{
+  return gtk_spin_button_get_type();
+}
+
+
+SpinButton::SpinButton(Adjustment& adjustment, double climb_rate, guint digits)
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Entry(Glib::ConstructParams(spinbutton_class_.init(), "adjustment", (adjustment).gobj(), "climb_rate", climb_rate, "digits", digits, (char*) 0))
+{
+  }
+
+void SpinButton::configure(Adjustment& adjustment, double climb_rate, guint digits)
+{
+  gtk_spin_button_configure(gobj(), (adjustment).gobj(), climb_rate, digits);
+}
+
+void SpinButton::set_adjustment(Adjustment& adjustment)
+{
+  gtk_spin_button_set_adjustment(gobj(), (adjustment).gobj());
+}
+
+Gtk::Adjustment* SpinButton::get_adjustment()
+{
+  return Glib::wrap(gtk_spin_button_get_adjustment(gobj()));
+}
+
+const Gtk::Adjustment* SpinButton::get_adjustment() const
+{
+  return Glib::wrap(gtk_spin_button_get_adjustment(const_cast<GtkSpinButton*>(gobj())));
+}
+
+void SpinButton::set_digits(guint digits)
+{
+  gtk_spin_button_set_digits(gobj(), digits);
+}
+
+guint SpinButton::get_digits() const
+{
+  return gtk_spin_button_get_digits(const_cast<GtkSpinButton*>(gobj()));
+}
+
+void SpinButton::set_increments(double step, double page)
+{
+  gtk_spin_button_set_increments(gobj(), step, page);
+}
+
+void SpinButton::get_increments(double& step, double& page) const
+{
+  gtk_spin_button_get_increments(const_cast<GtkSpinButton*>(gobj()), &(step), &(page));
+}
+
+void SpinButton::set_range(double min, double max)
+{
+  gtk_spin_button_set_range(gobj(), min, max);
+}
+
+void SpinButton::get_range(double& min, double& max) const
+{
+  gtk_spin_button_get_range(const_cast<GtkSpinButton*>(gobj()), &(min), &(max));
+}
+
+double SpinButton::get_value() const
+{
+  return gtk_spin_button_get_value(const_cast<GtkSpinButton*>(gobj()));
+}
+
+int SpinButton::get_value_as_int() const
+{
+  return gtk_spin_button_get_value_as_int(const_cast<GtkSpinButton*>(gobj()));
+}
+
+void SpinButton::set_value(double value)
+{
+  gtk_spin_button_set_value(gobj(), value);
+}
+
+void SpinButton::set_update_policy(SpinButtonUpdatePolicy policy)
+{
+  gtk_spin_button_set_update_policy(gobj(), ((GtkSpinButtonUpdatePolicy)(policy)));
+}
+
+SpinButtonUpdatePolicy SpinButton::get_update_policy() const
+{
+  return ((SpinButtonUpdatePolicy)(gtk_spin_button_get_update_policy(const_cast<GtkSpinButton*>(gobj()))));
+}
+
+void SpinButton::set_numeric(bool numeric)
+{
+  gtk_spin_button_set_numeric(gobj(), static_cast<int>(numeric));
+}
+
+bool SpinButton::get_numeric() const
+{
+  return gtk_spin_button_get_numeric(const_cast<GtkSpinButton*>(gobj()));
+}
+
+void SpinButton::spin(SpinType direction, double increment)
+{
+  gtk_spin_button_spin(gobj(), ((GtkSpinType)(direction)), increment);
+}
+
+void SpinButton::set_wrap(bool wrap)
+{
+  gtk_spin_button_set_wrap(gobj(), static_cast<int>(wrap));
+}
+
+bool SpinButton::get_wrap() const
+{
+  return gtk_spin_button_get_wrap(const_cast<GtkSpinButton*>(gobj()));
+}
+
+void SpinButton::set_snap_to_ticks(bool snap_to_ticks)
+{
+  gtk_spin_button_set_snap_to_ticks(gobj(), static_cast<int>(snap_to_ticks));
+}
+
+bool SpinButton::get_snap_to_ticks() const
+{
+  return gtk_spin_button_get_snap_to_ticks(const_cast<GtkSpinButton*>(gobj()));
+}
+
+void SpinButton::update()
+{
+  gtk_spin_button_update(gobj());
+}
+
+
+Glib::SignalProxy1< int,double* > SpinButton::signal_input()
+{
+  return Glib::SignalProxy1< int,double* >(this, &SpinButton_signal_input_info);
+}
+
+Glib::SignalProxy0< bool > SpinButton::signal_output()
+{
+  return Glib::SignalProxy0< bool >(this, &SpinButton_signal_output_info);
+}
+
+Glib::SignalProxy0< void > SpinButton::signal_value_changed()
+{
+  return Glib::SignalProxy0< void >(this, &SpinButton_signal_value_changed_info);
+}
+
+
+Glib::PropertyProxy<Gtk::Adjustment*> SpinButton::property_adjustment() 
+{
+  return Glib::PropertyProxy<Gtk::Adjustment*>(this, "adjustment");
+}
+
+Glib::PropertyProxy_ReadOnly<Gtk::Adjustment*> SpinButton::property_adjustment() const
+{
+  return Glib::PropertyProxy_ReadOnly<Gtk::Adjustment*>(this, "adjustment");
+}
+
+Glib::PropertyProxy<double> SpinButton::property_climb_rate() 
+{
+  return Glib::PropertyProxy<double>(this, "climb-rate");
+}
+
+Glib::PropertyProxy_ReadOnly<double> SpinButton::property_climb_rate() const
+{
+  return Glib::PropertyProxy_ReadOnly<double>(this, "climb-rate");
+}
+
+Glib::PropertyProxy<guint> SpinButton::property_digits() 
+{
+  return Glib::PropertyProxy<guint>(this, "digits");
+}
+
+Glib::PropertyProxy_ReadOnly<guint> SpinButton::property_digits() const
+{
+  return Glib::PropertyProxy_ReadOnly<guint>(this, "digits");
+}
+
+Glib::PropertyProxy<bool> SpinButton::property_snap_to_ticks() 
+{
+  return Glib::PropertyProxy<bool>(this, "snap-to-ticks");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> SpinButton::property_snap_to_ticks() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "snap-to-ticks");
+}
+
+Glib::PropertyProxy<bool> SpinButton::property_numeric() 
+{
+  return Glib::PropertyProxy<bool>(this, "numeric");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> SpinButton::property_numeric() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "numeric");
+}
+
+Glib::PropertyProxy<bool> SpinButton::property_wrap() 
+{
+  return Glib::PropertyProxy<bool>(this, "wrap");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> SpinButton::property_wrap() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "wrap");
+}
+
+Glib::PropertyProxy<SpinButtonUpdatePolicy> SpinButton::property_update_policy() 
+{
+  return Glib::PropertyProxy<SpinButtonUpdatePolicy>(this, "update-policy");
+}
+
+Glib::PropertyProxy_ReadOnly<SpinButtonUpdatePolicy> SpinButton::property_update_policy() const
+{
+  return Glib::PropertyProxy_ReadOnly<SpinButtonUpdatePolicy>(this, "update-policy");
+}
+
+Glib::PropertyProxy<double> SpinButton::property_value() 
+{
+  return Glib::PropertyProxy<double>(this, "value");
+}
+
+Glib::PropertyProxy_ReadOnly<double> SpinButton::property_value() const
+{
+  return Glib::PropertyProxy_ReadOnly<double>(this, "value");
+}
+
+
+int Gtk::SpinButton::on_input(double* new_value)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->input)
+    return (*base->input)(gobj(),new_value);
+
+  typedef int RType;
+  return RType();
+}
+
+bool Gtk::SpinButton::on_output()
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->output)
+    return (*base->output)(gobj());
+
+  typedef bool RType;
+  return RType();
+}
+
+void Gtk::SpinButton::on_value_changed()
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->value_changed)
+    (*base->value_changed)(gobj());
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/spinbutton.h b/libs/gtkmm2/gtk/gtkmm/spinbutton.h
new file mode 100644
index 0000000000..d679054425
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/spinbutton.h
@@ -0,0 +1,503 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_SPINBUTTON_H
+#define _GTKMM_SPINBUTTON_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* Copyright (C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/entry.h>
+#include <gtkmm/editable.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkSpinButton GtkSpinButton;
+typedef struct _GtkSpinButtonClass GtkSpinButtonClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class SpinButton_Class; } // namespace Gtk
+namespace Gtk
+{
+
+
+/** @addtogroup gtkmmEnums Enums and Flags */
+
+/**
+ * @ingroup gtkmmEnums
+ */
+enum SpinButtonUpdatePolicy
+{
+  UPDATE_ALWAYS,
+  UPDATE_IF_VALID
+};
+
+} // namespace Gtk
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Gtk::SpinButtonUpdatePolicy> : public Glib::Value_Enum<Gtk::SpinButtonUpdatePolicy>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{
+
+/**
+ * @ingroup gtkmmEnums
+ */
+enum SpinType
+{
+  SPIN_STEP_FORWARD,
+  SPIN_STEP_BACKWARD,
+  SPIN_PAGE_FORWARD,
+  SPIN_PAGE_BACKWARD,
+  SPIN_HOME,
+  SPIN_END,
+  SPIN_USER_DEFINED
+};
+
+} // namespace Gtk
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Gtk::SpinType> : public Glib::Value_Enum<Gtk::SpinType>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{
+
+
+/** @ingroup gtkmmEnums */
+enum { INPUT_ERROR = -1 };
+
+class Adjustment;
+
+/** numeric Entry with up/down buttons
+ * Slightly misnamed, this should be called a SpinEntry.
+ *
+ * @ingroup Widgets
+ */
+
+class SpinButton : public Entry
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef SpinButton CppObjectType;
+  typedef SpinButton_Class CppClassType;
+  typedef GtkSpinButton BaseObjectType;
+  typedef GtkSpinButtonClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~SpinButton();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class SpinButton_Class;
+  static CppClassType spinbutton_class_;
+
+  // noncopyable
+  SpinButton(const SpinButton&);
+  SpinButton& operator=(const SpinButton&);
+
+protected:
+  explicit SpinButton(const Glib::ConstructParams& construct_params);
+  explicit SpinButton(GtkSpinButton* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GtkSpinButton*       gobj()       { return reinterpret_cast<GtkSpinButton*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GtkSpinButton* gobj() const { return reinterpret_cast<GtkSpinButton*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+  virtual int on_input(double* new_value);
+  virtual bool on_output();
+  virtual void on_value_changed();
+
+
+private:
+
+  
+public:
+
+  //: create instance
+  // adjustment: see Gtk::Adjustment
+  // climb_rate:
+  // digits: number of decimal digits (has to be < 6)
+  SpinButton(double climb_rate = 0.0, guint digits = 0);
+  explicit SpinButton(Adjustment& adjustment, double climb_rate = 0.0, guint digits = 0);
+
+
+  void configure(Adjustment& adjustment, double climb_rate, guint digits);
+
+  
+  /** Replaces the Gtk::Adjustment associated with @a spin_button .
+   * @param adjustment A Gtk::Adjustment to replace the existing adjustment.
+   */
+  void set_adjustment(Adjustment& adjustment);
+  void unset_adjustment();
+  
+  /** Get the adjustment associated with a Gtk::SpinButton
+   * @return The Gtk::Adjustment of @a spin_button .
+   */
+  Gtk::Adjustment* get_adjustment();
+  
+  /** Get the adjustment associated with a Gtk::SpinButton
+   * @return The Gtk::Adjustment of @a spin_button .
+   */
+  const Gtk::Adjustment* get_adjustment() const;
+
+  
+  /** Set the precision to be displayed by @a spin_button . Up to 20 digit precision
+   * is allowed.
+   * @param digits The number of digits after the decimal point to be displayed for the spin button's value.
+   */
+  void set_digits(guint digits);
+  
+  /** Fetches the precision of @a spin_button . See set_digits().
+   * @return The current precision.
+   */
+  guint get_digits() const;
+
+  
+  /** Sets the step and page increments for spin_button.  This affects how 
+   * quickly the value changes when the spin button's arrows are activated.
+   * @param step Increment applied for a button 1 press.
+   * @param page Increment applied for a button 2 press.
+   */
+  void set_increments(double step, double page);
+  
+  /** Gets the current step and page the increments used by @a spin_button . See
+   * set_increments().
+   * @param step Location to store step increment, or <tt>0</tt>.
+   * @param page Location to store page increment, or <tt>0</tt>.
+   */
+  void get_increments(double& step, double& page) const;
+
+  
+  /** Sets the minimum and maximum allowable values for @a spin_button 
+   * @param min Minimum allowable value.
+   * @param max Maximum allowable value.
+   */
+  void set_range(double min, double max);
+  
+  /** Gets the range allowed for @a spin_button . See
+   * set_range().
+   * @param min Location to store minimum allowed value, or <tt>0</tt>.
+   * @param max Location to store maximum allowed value, or <tt>0</tt>.
+   */
+  void get_range(double& min, double& max) const;
+
+  
+  /** Get the value in the @a spin_button .
+   * @return The value of @a spin_button .
+   */
+  double get_value() const;
+  
+  /** Get the value @a spin_button  represented as an integer.
+   * @return The value of @a spin_button .
+   */
+  int get_value_as_int() const;
+  
+  /** Set the value of @a spin_button .
+   * @param value The new value.
+   */
+  void set_value(double value);
+
+  
+  /** Sets the update behavior of a spin button. This determines whether the
+   * spin button is always updated or only when a valid value is set.
+   * @param policy A Gtk::SpinButtonUpdatePolicy value.
+   */
+  void set_update_policy(SpinButtonUpdatePolicy policy);
+  
+  /** Gets the update behavior of a spin button. See
+   * set_update_policy().
+   * @return The current update policy.
+   */
+  SpinButtonUpdatePolicy get_update_policy() const;
+
+  
+  /** Sets the flag that determines if non-numeric text can be typed into
+   * the spin button.
+   * @param numeric Flag indicating if only numeric entry is allowed.
+   */
+  void set_numeric(bool numeric = true);
+  
+  /** Returns whether non-numeric text can be typed into the spin button.
+   * See set_numeric().
+   * @return <tt>true</tt> if only numeric text can be entered.
+   */
+  bool get_numeric() const;
+
+  
+  /** Increment or decrement a spin button's value in a specified direction
+   * by a specified amount.
+   * @param direction A Gtk::SpinType indicating the direction to spin.
+   * @param increment Step increment to apply in the specified direction.
+   */
+  void spin(SpinType direction, double increment);
+
+  
+  /** Sets the flag that determines if a spin button value wraps around to the
+   * opposite limit when the upper or lower limit of the range is exceeded.
+   * @param wrap A flag indicating if wrapping behavior is performed.
+   */
+  void set_wrap(bool wrap = true);
+  
+  /** Returns whether the spin button's value wraps around to the
+   * opposite limit when the upper or lower limit of the range is
+   * exceeded. See set_wrap().
+   * @return <tt>true</tt> if the spin button wraps around.
+   */
+  bool get_wrap() const;
+
+  
+  /** Sets the policy as to whether values are corrected to the nearest step 
+   * increment when a spin button is activated after providing an invalid value.
+   * @param snap_to_ticks A flag indicating if invalid values should be corrected.
+   */
+  void set_snap_to_ticks(bool snap_to_ticks = true);
+  
+  /** Returns whether the values are corrected to the nearest step. See
+   * set_snap_to_ticks().
+   * @return <tt>true</tt> if values are snapped to the nearest step.
+   */
+  bool get_snap_to_ticks() const;
+
+  
+  /** Manually force an update of the spin button.
+   */
+  void update();
+
+  /** Convert the Entry text to a number.
+   * The computed number should be written to <tt>*new_value</tt>.
+   * @return
+   * @li <tt>false</tt>: No conversion done, continue with default handler.
+   * @li <tt>true</tt>: Conversion successful, don't call default handler.
+   * @li <tt>Gtk::INPUT_ERROR</tt>: Conversion failed, don't call default handler.
+   */
+  
+
+  Glib::SignalProxy1< int,double* > signal_input();
+
+
+  /** Convert the Adjustment position to text.
+   * The computed text should be written via Gtk::Entry::set_text().
+   * @return
+   * @li <tt>false</tt>: No conversion done, continue with default handler.
+   * @li <tt>true</tt>: Conversion successful, don't call default handler.
+   */
+  
+
+  Glib::SignalProxy0< bool > signal_output();
+
+
+  Glib::SignalProxy0< void > signal_value_changed();
+
+
+  //Keybinding signals:
+  
+
+  /** The adjustment that holds the value of the spinbutton.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Gtk::Adjustment*> property_adjustment() ;
+
+/** The adjustment that holds the value of the spinbutton.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Gtk::Adjustment*> property_adjustment() const;
+
+  /** The acceleration rate when you hold down a button.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<double> property_climb_rate() ;
+
+/** The acceleration rate when you hold down a button.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<double> property_climb_rate() const;
+
+  /** The number of decimal places to display.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<guint> property_digits() ;
+
+/** The number of decimal places to display.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<guint> property_digits() const;
+
+  /** Whether erroneous values are automatically changed to a spin button's nearest step increment.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_snap_to_ticks() ;
+
+/** Whether erroneous values are automatically changed to a spin button's nearest step increment.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_snap_to_ticks() const;
+
+  /** Whether non-numeric characters should be ignored.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_numeric() ;
+
+/** Whether non-numeric characters should be ignored.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_numeric() const;
+
+  /** Whether a spin button should wrap upon reaching its limits.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_wrap() ;
+
+/** Whether a spin button should wrap upon reaching its limits.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_wrap() const;
+
+  /** Whether the spin button should update always
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<SpinButtonUpdatePolicy> property_update_policy() ;
+
+/** Whether the spin button should update always
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<SpinButtonUpdatePolicy> property_update_policy() const;
+
+  /** Reads the current value
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<double> property_value() ;
+
+/** Reads the current value
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<double> property_value() const;
+
+
+};
+
+} // namespace Gtk
+
+
+namespace Glib
+{
+  /** @relates Gtk::SpinButton
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gtk::SpinButton* wrap(GtkSpinButton* object, bool take_copy = false);
+}
+#endif /* _GTKMM_SPINBUTTON_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/statusbar.cc b/libs/gtkmm2/gtk/gtkmm/statusbar.cc
new file mode 100644
index 0000000000..1e6e28071e
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/statusbar.cc
@@ -0,0 +1,338 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/statusbar.h>
+#include <gtkmm/private/statusbar_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* 
+ *
+ * Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtk/gtkstatusbar.h>
+
+namespace Gtk
+{
+
+guint Statusbar::push(const Glib::ustring& text, guint context_id /* = 0 */)
+{
+  return gtk_statusbar_push(gobj(), context_id, text.c_str());
+}
+
+void Statusbar::remove_message(guint message_id, guint context_id /* = 0 */)
+{
+  return gtk_statusbar_remove(gobj(), context_id, message_id);
+}
+
+} /* namespace Gtk */
+
+
+namespace
+{
+
+void Statusbar_signal_text_pushed_callback(GtkStatusbar* self, guint p0,const gchar* p1,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,guint,const Glib::ustring& > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(p0, Glib::convert_const_gchar_ptr_to_ustring(p1)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+}
+
+const Glib::SignalProxyInfo Statusbar_signal_text_pushed_info =
+{
+  "text_pushed",
+  (GCallback) &Statusbar_signal_text_pushed_callback,
+  (GCallback) &Statusbar_signal_text_pushed_callback
+};
+
+
+void Statusbar_signal_text_popped_callback(GtkStatusbar* self, guint p0,const gchar* p1,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,guint,const Glib::ustring& > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(p0, Glib::convert_const_gchar_ptr_to_ustring(p1)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+}
+
+const Glib::SignalProxyInfo Statusbar_signal_text_popped_info =
+{
+  "text_popped",
+  (GCallback) &Statusbar_signal_text_popped_callback,
+  (GCallback) &Statusbar_signal_text_popped_callback
+};
+
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Gtk::Statusbar* wrap(GtkStatusbar* object, bool take_copy)
+{
+  return dynamic_cast<Gtk::Statusbar *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& Statusbar_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &Statusbar_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_statusbar_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void Statusbar_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+  klass->text_pushed = &text_pushed_callback;
+  klass->text_popped = &text_popped_callback;
+}
+
+
+void Statusbar_Class::text_pushed_callback(GtkStatusbar* self, guint p0, const gchar* p1)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_text_pushed(p0, Glib::convert_const_gchar_ptr_to_ustring(p1)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->text_pushed)
+      (*base->text_pushed)(self, p0, p1);
+  }
+}
+
+void Statusbar_Class::text_popped_callback(GtkStatusbar* self, guint p0, const gchar* p1)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_text_popped(p0, Glib::convert_const_gchar_ptr_to_ustring(p1)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->text_popped)
+      (*base->text_popped)(self, p0, p1);
+  }
+}
+
+
+Glib::ObjectBase* Statusbar_Class::wrap_new(GObject* o)
+{
+  return manage(new Statusbar((GtkStatusbar*)(o)));
+
+}
+
+
+/* The implementation: */
+
+Statusbar::Statusbar(const Glib::ConstructParams& construct_params)
+:
+  Gtk::HBox(construct_params)
+{
+  }
+
+Statusbar::Statusbar(GtkStatusbar* castitem)
+:
+  Gtk::HBox((GtkHBox*)(castitem))
+{
+  }
+
+Statusbar::~Statusbar()
+{
+  destroy_();
+}
+
+Statusbar::CppClassType Statusbar::statusbar_class_; // initialize static member
+
+GType Statusbar::get_type()
+{
+  return statusbar_class_.init().get_type();
+}
+
+GType Statusbar::get_base_type()
+{
+  return gtk_statusbar_get_type();
+}
+
+
+Statusbar::Statusbar()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::HBox(Glib::ConstructParams(statusbar_class_.init()))
+{
+  }
+
+guint Statusbar::get_context_id(const Glib::ustring& context_description)
+{
+  return gtk_statusbar_get_context_id(gobj(), context_description.c_str());
+}
+
+void Statusbar::pop(guint context_id)
+{
+  gtk_statusbar_pop(gobj(), context_id);
+}
+
+void Statusbar::set_has_resize_grip(bool setting)
+{
+  gtk_statusbar_set_has_resize_grip(gobj(), static_cast<int>(setting));
+}
+
+bool Statusbar::get_has_resize_grip() const
+{
+  return gtk_statusbar_get_has_resize_grip(const_cast<GtkStatusbar*>(gobj()));
+}
+
+
+Glib::SignalProxy2< void,guint,const Glib::ustring& > Statusbar::signal_text_pushed()
+{
+  return Glib::SignalProxy2< void,guint,const Glib::ustring& >(this, &Statusbar_signal_text_pushed_info);
+}
+
+Glib::SignalProxy2< void,guint,const Glib::ustring& > Statusbar::signal_text_popped()
+{
+  return Glib::SignalProxy2< void,guint,const Glib::ustring& >(this, &Statusbar_signal_text_popped_info);
+}
+
+
+Glib::PropertyProxy<bool> Statusbar::property_has_resize_grip() 
+{
+  return Glib::PropertyProxy<bool>(this, "has-resize-grip");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> Statusbar::property_has_resize_grip() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "has-resize-grip");
+}
+
+
+void Gtk::Statusbar::on_text_pushed(guint context_id, const Glib::ustring& text)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->text_pushed)
+    (*base->text_pushed)(gobj(),context_id,text.c_str());
+}
+
+void Gtk::Statusbar::on_text_popped(guint context_id, const Glib::ustring& text)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->text_popped)
+    (*base->text_popped)(gobj(),context_id,text.c_str());
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/statusbar.h b/libs/gtkmm2/gtk/gtkmm/statusbar.h
new file mode 100644
index 0000000000..6bade10932
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/statusbar.h
@@ -0,0 +1,163 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_STATUSBAR_H
+#define _GTKMM_STATUSBAR_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* statusbar.h
+ * 
+ * Copyright (C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/box.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkStatusbar GtkStatusbar;
+typedef struct _GtkStatusbarClass GtkStatusbarClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class Statusbar_Class; } // namespace Gtk
+namespace Gtk
+{
+
+/** Text status indicator
+ * This widget is used to display status information.
+ * Messages are pushed and poped onto a message stack.
+ * When text is pushed it replaces the old contents.
+ * The old text is restored when popped.
+ *
+ * It derives from Gtk::HBox so that additional information can be added
+ * easily.
+ *
+ * @ingroup Widgets
+ */
+
+class Statusbar : public HBox
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Statusbar CppObjectType;
+  typedef Statusbar_Class CppClassType;
+  typedef GtkStatusbar BaseObjectType;
+  typedef GtkStatusbarClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~Statusbar();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class Statusbar_Class;
+  static CppClassType statusbar_class_;
+
+  // noncopyable
+  Statusbar(const Statusbar&);
+  Statusbar& operator=(const Statusbar&);
+
+protected:
+  explicit Statusbar(const Glib::ConstructParams& construct_params);
+  explicit Statusbar(GtkStatusbar* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GtkStatusbar*       gobj()       { return reinterpret_cast<GtkStatusbar*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GtkStatusbar* gobj() const { return reinterpret_cast<GtkStatusbar*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+  virtual void on_text_pushed(guint context_id, const Glib::ustring& text);
+  virtual void on_text_popped(guint context_id, const Glib::ustring& text);
+
+
+private:
+
+  
+public:
+  Statusbar();
+
+  
+  guint get_context_id(const Glib::ustring& context_description);
+  guint push(const Glib::ustring& text, guint context_id = 0);
+  
+  void pop(guint context_id = 0);
+  void remove_message(guint message_id, guint context_id = 0);
+  
+  void set_has_resize_grip(bool setting = true);
+  
+  bool get_has_resize_grip() const;
+
+  
+  Glib::SignalProxy2< void,guint,const Glib::ustring& > signal_text_pushed();
+
+  
+  Glib::SignalProxy2< void,guint,const Glib::ustring& > signal_text_popped();
+
+
+  /** Whether the statusbar has a grip for resizing the toplevel.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_has_resize_grip() ;
+
+/** Whether the statusbar has a grip for resizing the toplevel.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_has_resize_grip() const;
+
+
+};
+
+} /* namespace Gtk */
+
+
+namespace Glib
+{
+  /** @relates Gtk::Statusbar
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gtk::Statusbar* wrap(GtkStatusbar* object, bool take_copy = false);
+}
+#endif /* _GTKMM_STATUSBAR_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/stock.cc b/libs/gtkmm2/gtk/gtkmm/stock.cc
new file mode 100644
index 0000000000..eb13cc0ef8
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/stock.cc
@@ -0,0 +1,160 @@
+// -*- c++ -*-
+/* $Id$ */
+
+/* Copyright (C) 2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/stock.h>
+#include <gtkmm/stockitem.h>
+#include <gtk/gtkstock.h>
+
+// Get rid of macro DELETE (from winnt.h).  We have some macro
+// shadowing magic in stock.h, but it's safer to get rid of it
+// entirely in the .cc file.
+#undef DELETE
+
+
+namespace Gtk
+{
+
+namespace Stock
+{
+
+const Gtk::BuiltinStockID DIALOG_AUTHENTICATION = { GTK_STOCK_DIALOG_AUTHENTICATION };
+const Gtk::BuiltinStockID DIALOG_INFO = { GTK_STOCK_DIALOG_INFO };
+const Gtk::BuiltinStockID DIALOG_WARNING = { GTK_STOCK_DIALOG_WARNING };
+const Gtk::BuiltinStockID DIALOG_ERROR = { GTK_STOCK_DIALOG_ERROR };
+const Gtk::BuiltinStockID DIALOG_QUESTION  = { GTK_STOCK_DIALOG_QUESTION };
+const Gtk::BuiltinStockID DND = { GTK_STOCK_DND };
+const Gtk::BuiltinStockID DND_MULTIPLE = { GTK_STOCK_DND_MULTIPLE };
+const Gtk::BuiltinStockID ABOUT = { GTK_STOCK_ABOUT };
+const Gtk::BuiltinStockID ADD = { GTK_STOCK_ADD };
+const Gtk::BuiltinStockID APPLY= { GTK_STOCK_APPLY };
+const Gtk::BuiltinStockID BOLD= { GTK_STOCK_BOLD };
+const Gtk::BuiltinStockID CANCEL = { GTK_STOCK_CANCEL };
+const Gtk::BuiltinStockID CDROM = { GTK_STOCK_CDROM };
+const Gtk::BuiltinStockID CLEAR = { GTK_STOCK_CLEAR };
+const Gtk::BuiltinStockID CLOSE = { GTK_STOCK_CLOSE };
+const Gtk::BuiltinStockID COLOR_PICKER = { GTK_STOCK_COLOR_PICKER };
+const Gtk::BuiltinStockID CONVERT = { GTK_STOCK_CONVERT };
+const Gtk::BuiltinStockID CONNECT = { GTK_STOCK_CONNECT };
+const Gtk::BuiltinStockID COPY = { GTK_STOCK_COPY };
+const Gtk::BuiltinStockID CUT = { GTK_STOCK_CUT };
+const Gtk::BuiltinStockID DELETE = { GTK_STOCK_DELETE };
+const Gtk::BuiltinStockID DIRECTORY = { GTK_STOCK_DIRECTORY };
+const Gtk::BuiltinStockID DISCONNECT = { GTK_STOCK_DISCONNECT };
+const Gtk::BuiltinStockID EDIT = { GTK_STOCK_EDIT };
+const Gtk::BuiltinStockID EXECUTE = { GTK_STOCK_EXECUTE };
+const Gtk::BuiltinStockID FILE = { GTK_STOCK_FILE };
+const Gtk::BuiltinStockID FIND = { GTK_STOCK_FIND };
+const Gtk::BuiltinStockID FIND_AND_REPLACE = { GTK_STOCK_FIND_AND_REPLACE };
+const Gtk::BuiltinStockID FLOPPY = { GTK_STOCK_FLOPPY };
+const Gtk::BuiltinStockID GOTO_BOTTOM = { GTK_STOCK_GOTO_BOTTOM };
+const Gtk::BuiltinStockID GOTO_FIRST = { GTK_STOCK_GOTO_FIRST };
+const Gtk::BuiltinStockID GOTO_LAST = { GTK_STOCK_GOTO_LAST };
+const Gtk::BuiltinStockID GOTO_TOP = { GTK_STOCK_GOTO_TOP };
+const Gtk::BuiltinStockID GO_BACK = { GTK_STOCK_GO_BACK };
+const Gtk::BuiltinStockID GO_DOWN = { GTK_STOCK_GO_DOWN };
+const Gtk::BuiltinStockID GO_FORWARD = { GTK_STOCK_GO_FORWARD };
+const Gtk::BuiltinStockID GO_UP = { GTK_STOCK_GO_UP };
+const Gtk::BuiltinStockID HARDDISK = { GTK_STOCK_HARDDISK };
+const Gtk::BuiltinStockID HELP = { GTK_STOCK_HELP };
+const Gtk::BuiltinStockID HOME = { GTK_STOCK_HOME };
+const Gtk::BuiltinStockID INDEX = { GTK_STOCK_INDEX };
+const Gtk::BuiltinStockID INDENT = { GTK_STOCK_INDENT };
+const Gtk::BuiltinStockID UNINDENT = { GTK_STOCK_UNINDENT };
+const Gtk::BuiltinStockID ITALIC = { GTK_STOCK_ITALIC };
+const Gtk::BuiltinStockID JUMP_TO = { GTK_STOCK_JUMP_TO };
+const Gtk::BuiltinStockID JUSTIFY_CENTER = { GTK_STOCK_JUSTIFY_CENTER };
+const Gtk::BuiltinStockID JUSTIFY_FILL = { GTK_STOCK_JUSTIFY_FILL };
+const Gtk::BuiltinStockID JUSTIFY_LEFT = { GTK_STOCK_JUSTIFY_LEFT };
+const Gtk::BuiltinStockID JUSTIFY_RIGHT = { GTK_STOCK_JUSTIFY_RIGHT };
+const Gtk::BuiltinStockID MISSING_IMAGE = { GTK_STOCK_MISSING_IMAGE };
+const Gtk::BuiltinStockID MEDIA_FORWARD = { GTK_STOCK_MEDIA_FORWARD };
+const Gtk::BuiltinStockID MEDIA_NEXT = { GTK_STOCK_MEDIA_NEXT };
+const Gtk::BuiltinStockID MEDIA_PAUSE = { GTK_STOCK_MEDIA_PAUSE };
+const Gtk::BuiltinStockID MEDIA_PLAY = { GTK_STOCK_MEDIA_PLAY };
+const Gtk::BuiltinStockID MEDIA_PREVIOUS = { GTK_STOCK_MEDIA_PREVIOUS };
+const Gtk::BuiltinStockID MEDIA_RECORD = { GTK_STOCK_MEDIA_RECORD };
+const Gtk::BuiltinStockID MEDIA_REWIND = { GTK_STOCK_MEDIA_REWIND };
+const Gtk::BuiltinStockID MEDIA_STOP = { GTK_STOCK_MEDIA_STOP };
+const Gtk::BuiltinStockID NETWORK = { GTK_STOCK_NETWORK };
+const Gtk::BuiltinStockID NEW = { GTK_STOCK_NEW };
+const Gtk::BuiltinStockID NO = { GTK_STOCK_NO };
+const Gtk::BuiltinStockID OK = { GTK_STOCK_OK };
+const Gtk::BuiltinStockID OPEN = { GTK_STOCK_OPEN };
+const Gtk::BuiltinStockID PASTE = { GTK_STOCK_PASTE };
+const Gtk::BuiltinStockID PREFERENCES = { GTK_STOCK_PREFERENCES };
+const Gtk::BuiltinStockID PRINT = { GTK_STOCK_PRINT };
+const Gtk::BuiltinStockID PRINT_PREVIEW = { GTK_STOCK_PRINT_PREVIEW };
+const Gtk::BuiltinStockID PROPERTIES = { GTK_STOCK_PROPERTIES };
+const Gtk::BuiltinStockID QUIT = { GTK_STOCK_QUIT };
+const Gtk::BuiltinStockID REDO = { GTK_STOCK_REDO };
+const Gtk::BuiltinStockID REFRESH = { GTK_STOCK_REFRESH };
+const Gtk::BuiltinStockID REMOVE = { GTK_STOCK_REMOVE };
+const Gtk::BuiltinStockID REVERT_TO_SAVED = { GTK_STOCK_REVERT_TO_SAVED };
+const Gtk::BuiltinStockID SAVE = { GTK_STOCK_SAVE };
+const Gtk::BuiltinStockID SAVE_AS = { GTK_STOCK_SAVE_AS };
+const Gtk::BuiltinStockID SELECT_COLOR = { GTK_STOCK_SELECT_COLOR };
+const Gtk::BuiltinStockID SELECT_FONT = { GTK_STOCK_SELECT_FONT };
+const Gtk::BuiltinStockID SORT_ASCENDING = { GTK_STOCK_SORT_ASCENDING };
+const Gtk::BuiltinStockID SORT_DESCENDING = { GTK_STOCK_SORT_DESCENDING };
+const Gtk::BuiltinStockID SPELL_CHECK = { GTK_STOCK_SPELL_CHECK };
+const Gtk::BuiltinStockID STOP = { GTK_STOCK_STOP };
+const Gtk::BuiltinStockID STRIKETHROUGH = { GTK_STOCK_STRIKETHROUGH };
+const Gtk::BuiltinStockID UNDELETE = { GTK_STOCK_UNDELETE };
+const Gtk::BuiltinStockID UNDERLINE = { GTK_STOCK_UNDERLINE };
+const Gtk::BuiltinStockID UNDO = { GTK_STOCK_UNDO };
+const Gtk::BuiltinStockID YES = { GTK_STOCK_YES };
+const Gtk::BuiltinStockID ZOOM_100 = { GTK_STOCK_ZOOM_100 };
+const Gtk::BuiltinStockID ZOOM_FIT = { GTK_STOCK_ZOOM_FIT };
+const Gtk::BuiltinStockID ZOOM_IN = { GTK_STOCK_ZOOM_IN };
+const Gtk::BuiltinStockID ZOOM_OUT = { GTK_STOCK_ZOOM_OUT };
+
+
+void add(const Gtk::StockItem& item)
+{
+  gtk_stock_add(item.gobj(), 1);
+}
+
+bool lookup(const Gtk::StockID& stock_id, Gtk::StockItem& item)
+{
+  return Gtk::StockItem::lookup(stock_id, item);
+}
+
+bool lookup(const Gtk::StockID& stock_id, Gtk::IconSet& iconset)
+{
+  iconset = Gtk::IconSet::lookup_default(stock_id);
+  return (iconset.gobj() != 0);
+}
+
+bool lookup(const Gtk::StockID& stock_id, Gtk::IconSize size, Gtk::Image& image)
+{
+  image.set(stock_id, size);
+  return (image.gobj() != 0);
+}
+
+Glib::SListHandle<Gtk::StockID,Gtk::StockID_Traits> get_ids()
+{
+  return Glib::SListHandle<Gtk::StockID,Gtk::StockID_Traits>(
+      gtk_stock_list_ids(), Glib::OWNERSHIP_DEEP);
+}
+
+} // namespace Stock
+
+} // namespace Gtk
+
diff --git a/libs/gtkmm2/gtk/gtkmm/stock.h b/libs/gtkmm2/gtk/gtkmm/stock.h
new file mode 100644
index 0000000000..e7f3888241
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/stock.h
@@ -0,0 +1,166 @@
+// -*- c++ -*-
+#ifndef _GTKMM_STOCK_H
+#define _GTKMM_STOCK_H
+
+/* $Id$ */
+
+/* Copyright (C) 2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/stockitem.h>
+#include <gtkmm/stockid.h>
+#include <gtkmm/iconset.h>
+#include <gtkmm/image.h>
+
+/* Shadow DELETE macro (from winnt.h).
+ */
+#if defined(DELETE) && !defined(GTKMM_MACRO_SHADOW_DELETE)
+enum { GTKMM_MACRO_DEFINITION_DELETE = DELETE };
+#undef DELETE
+enum { DELETE = GTKMM_MACRO_DEFINITION_DELETE };
+#define DELETE DELETE
+#define GTKMM_MACRO_SHADOW_DELETE 1
+#endif
+
+
+namespace Gtk
+{
+
+// Created like so:
+// const BuiltinStockID DIALOG_INFO = { GTK_STOCK_DIALOG_INFO }
+
+/** See the list of pre-defined stock items, in the Stock namespace.
+ */
+struct BuiltinStockID
+{
+  const char* id;
+};
+
+namespace Stock
+{
+
+extern GTKMM_API const Gtk::BuiltinStockID DIALOG_AUTHENTICATION;   /*!< @image html stock_dialog_authentication_48.png     */
+
+extern GTKMM_API const Gtk::BuiltinStockID DIALOG_INFO;      /*!< @image html stock_dialog_info_48.png         */
+extern GTKMM_API const Gtk::BuiltinStockID DIALOG_WARNING;   /*!< @image html stock_dialog_warning_48.png      */
+extern GTKMM_API const Gtk::BuiltinStockID DIALOG_ERROR;     /*!< @image html stock_dialog_error_48.png        */
+extern GTKMM_API const Gtk::BuiltinStockID DIALOG_QUESTION;  /*!< @image html stock_dialog_question_48.png     */
+
+// These aren't real stock items, because they provide only an icon.
+extern GTKMM_API const Gtk::BuiltinStockID DND;              /*!< @image html stock_dnd_32.png                 */
+extern GTKMM_API const Gtk::BuiltinStockID DND_MULTIPLE;     /*!< @image html stock_dnd_multiple_32.png        */
+
+extern GTKMM_API const Gtk::BuiltinStockID ABOUT;            /*!< @image html stock_about_24.png               */
+extern GTKMM_API const Gtk::BuiltinStockID ADD;              /*!< @image html stock_add_24.png                 */
+extern GTKMM_API const Gtk::BuiltinStockID APPLY;            /*!< @image html stock_apply_20.png               */
+extern GTKMM_API const Gtk::BuiltinStockID BOLD;             /*!< @image html stock_text_bold_24.png           */
+extern GTKMM_API const Gtk::BuiltinStockID CANCEL;           /*!< @image html stock_cancel_20.png              */
+extern GTKMM_API const Gtk::BuiltinStockID CDROM;            /*!< @image html stock_cdrom_24.png               */
+extern GTKMM_API const Gtk::BuiltinStockID CLEAR;            /*!< @image html stock_clear_24.png               */
+extern GTKMM_API const Gtk::BuiltinStockID CLOSE;            /*!< @image html stock_close_24.png               */
+extern GTKMM_API const Gtk::BuiltinStockID COLOR_PICKER;     /*!< @image html stock_color_picker_24.png        */
+extern GTKMM_API const Gtk::BuiltinStockID CONVERT;          /*!< @image html stock_convert_24.png             */
+extern GTKMM_API const Gtk::BuiltinStockID CONNECT;          /*!< @image html stock_connect_24.png             */
+extern GTKMM_API const Gtk::BuiltinStockID COPY;             /*!< @image html stock_copy_24.png                */
+extern GTKMM_API const Gtk::BuiltinStockID CUT;              /*!< @image html stock_cut_24.png                 */
+extern GTKMM_API const Gtk::BuiltinStockID DELETE;           /*!< @image html stock_trash_24.png               */
+extern GTKMM_API const Gtk::BuiltinStockID DIRECTORY;        /*!< @image html stock_directory_24.png           */
+extern GTKMM_API const Gtk::BuiltinStockID DISCONNECT;       /*!< @image html stock_disconnect_24.png          */
+extern GTKMM_API const Gtk::BuiltinStockID EDIT;             /*!< @image html stock_edit_24.png                */
+extern GTKMM_API const Gtk::BuiltinStockID EXECUTE;          /*!< @image html stock_exec_24.png                */
+extern GTKMM_API const Gtk::BuiltinStockID FILE;             /*!< @image html stock_file_24.png                */
+extern GTKMM_API const Gtk::BuiltinStockID FIND;             /*!< @image html stock_search_24.png              */
+extern GTKMM_API const Gtk::BuiltinStockID FIND_AND_REPLACE; /*!< @image html stock_search_replace_24.png      */
+extern GTKMM_API const Gtk::BuiltinStockID FLOPPY;           /*!< @image html stock_save_24.png                */
+extern GTKMM_API const Gtk::BuiltinStockID GOTO_BOTTOM;      /*!< @image html stock_bottom_24.png              */
+extern GTKMM_API const Gtk::BuiltinStockID GOTO_FIRST;       /*!< @image html stock_first_24.png               */
+extern GTKMM_API const Gtk::BuiltinStockID GOTO_LAST;        /*!< @image html stock_last_24.png                */
+extern GTKMM_API const Gtk::BuiltinStockID GOTO_TOP;         /*!< @image html stock_top_24.png                 */
+extern GTKMM_API const Gtk::BuiltinStockID GO_BACK;          /*!< @image html stock_left_arrow_24.png          */
+extern GTKMM_API const Gtk::BuiltinStockID GO_DOWN;          /*!< @image html stock_down_arrow_24.png          */
+extern GTKMM_API const Gtk::BuiltinStockID GO_FORWARD;       /*!< @image html stock_right_arrow_24.png         */
+extern GTKMM_API const Gtk::BuiltinStockID GO_UP;            /*!< @image html stock_up_arrow_24.png            */
+extern GTKMM_API const Gtk::BuiltinStockID HARDDISK;         /*!< @image html stock_harddisk_24.png            */
+extern GTKMM_API const Gtk::BuiltinStockID HELP;             /*!< @image html stock_help_24.png                */
+extern GTKMM_API const Gtk::BuiltinStockID HOME;             /*!< @image html stock_home_24.png                */
+extern GTKMM_API const Gtk::BuiltinStockID INDEX;            /*!< @image html stock_index_24.png               */
+extern GTKMM_API const Gtk::BuiltinStockID INDENT;           /*!< @image html stock_indent_24.png              */
+extern GTKMM_API const Gtk::BuiltinStockID UNINDENT;         /*!< @image html stock_unindent_24.png            */
+extern GTKMM_API const Gtk::BuiltinStockID ITALIC;           /*!< @image html stock_text_italic_24.png         */
+extern GTKMM_API const Gtk::BuiltinStockID JUMP_TO;          /*!< @image html stock_jump_to_24.png             */
+extern GTKMM_API const Gtk::BuiltinStockID JUSTIFY_CENTER;   /*!< @image html stock_align_center_24.png        */
+extern GTKMM_API const Gtk::BuiltinStockID JUSTIFY_FILL;     /*!< @image html stock_align_justify_24.png       */
+extern GTKMM_API const Gtk::BuiltinStockID JUSTIFY_LEFT;     /*!< @image html stock_align_left_24.png          */
+extern GTKMM_API const Gtk::BuiltinStockID JUSTIFY_RIGHT;    /*!< @image html stock_align_right_24.png         */
+extern GTKMM_API const Gtk::BuiltinStockID MISSING_IMAGE;    /*!< @image html stock_broken_image_24.png        */
+extern GTKMM_API const Gtk::BuiltinStockID MEDIA_FORWARD;    /*!< @image html stock_media_forward_24.png       */
+extern GTKMM_API const Gtk::BuiltinStockID MEDIA_NEXT;       /*!< @image html stock_media_next_24.png          */
+extern GTKMM_API const Gtk::BuiltinStockID MEDIA_PAUSE;      /*!< @image html stock_media_pause_24.png         */
+extern GTKMM_API const Gtk::BuiltinStockID MEDIA_PLAY;       /*!< @image html stock_media_play_24.png          */
+extern GTKMM_API const Gtk::BuiltinStockID MEDIA_PREVIOUS;   /*!< @image html stock_media_previous_24.png      */
+extern GTKMM_API const Gtk::BuiltinStockID MEDIA_RECORD;     /*!< @image html stock_media_record_24.png        */
+extern GTKMM_API const Gtk::BuiltinStockID MEDIA_REWIND;     /*!< @image html stock_media_rewind_24.png        */
+extern GTKMM_API const Gtk::BuiltinStockID MEDIA_STOP;       /*!< @image html stock_media_stop_24.png          */
+extern GTKMM_API const Gtk::BuiltinStockID NETWORK;          /*!< @image html stock_network_24.png             */
+extern GTKMM_API const Gtk::BuiltinStockID NEW;              /*!< @image html stock_new_24.png                 */
+extern GTKMM_API const Gtk::BuiltinStockID NO;               /*!< @image html stock_no_20.png                  */
+extern GTKMM_API const Gtk::BuiltinStockID OK;               /*!< @image html stock_ok_20.png                  */
+extern GTKMM_API const Gtk::BuiltinStockID OPEN;             /*!< @image html stock_open_24.png                */
+extern GTKMM_API const Gtk::BuiltinStockID PASTE;            /*!< @image html stock_paste_24.png               */
+extern GTKMM_API const Gtk::BuiltinStockID PREFERENCES;      /*!< @image html stock_preferences_24.png         */
+extern GTKMM_API const Gtk::BuiltinStockID PRINT;            /*!< @image html stock_print_24.png               */
+extern GTKMM_API const Gtk::BuiltinStockID PRINT_PREVIEW;    /*!< @image html stock_print_preview_24.png       */
+extern GTKMM_API const Gtk::BuiltinStockID PROPERTIES;       /*!< @image html stock_properties_24.png          */
+extern GTKMM_API const Gtk::BuiltinStockID QUIT;             /*!< @image html stock_exit_24.png                */
+extern GTKMM_API const Gtk::BuiltinStockID REDO;             /*!< @image html stock_redo_24.png                */
+extern GTKMM_API const Gtk::BuiltinStockID REFRESH;          /*!< @image html stock_refresh_24.png             */
+extern GTKMM_API const Gtk::BuiltinStockID REMOVE;           /*!< @image html stock_remove_24.png              */
+extern GTKMM_API const Gtk::BuiltinStockID REVERT_TO_SAVED;  /*!< @image html stock_revert_24.png              */
+extern GTKMM_API const Gtk::BuiltinStockID SAVE;             /*!< @image html stock_save_24.png                */
+extern GTKMM_API const Gtk::BuiltinStockID SAVE_AS;          /*!< @image html stock_save_as_24.png             */
+extern GTKMM_API const Gtk::BuiltinStockID SELECT_COLOR;     /*!< @image html stock_colorselector_24.png       */
+extern GTKMM_API const Gtk::BuiltinStockID SELECT_FONT;      /*!< @image html stock_font_24.png                */
+extern GTKMM_API const Gtk::BuiltinStockID SORT_ASCENDING;   /*!< @image html stock_sort_ascending_24.png      */
+extern GTKMM_API const Gtk::BuiltinStockID SORT_DESCENDING;  /*!< @image html stock_sort_descending_24.png     */
+extern GTKMM_API const Gtk::BuiltinStockID SPELL_CHECK;      /*!< @image html stock_spellcheck_24.png          */
+extern GTKMM_API const Gtk::BuiltinStockID STOP;             /*!< @image html stock_stop_24.png                */
+extern GTKMM_API const Gtk::BuiltinStockID STRIKETHROUGH;    /*!< @image html stock_text_strikethrough_24.png  */
+extern GTKMM_API const Gtk::BuiltinStockID UNDELETE;         /*!< @image html stock_undelete_24.png            */
+extern GTKMM_API const Gtk::BuiltinStockID UNDERLINE;        /*!< @image html stock_text_underline_24.png      */
+extern GTKMM_API const Gtk::BuiltinStockID UNDO;             /*!< @image html stock_undo_24.png                */
+extern GTKMM_API const Gtk::BuiltinStockID YES;              /*!< @image html stock_yes_20.png                 */
+extern GTKMM_API const Gtk::BuiltinStockID ZOOM_100;         /*!< @image html stock_zoom_1_24.png              */
+extern GTKMM_API const Gtk::BuiltinStockID ZOOM_FIT;         /*!< @image html stock_zoom_fit_24.png            */
+extern GTKMM_API const Gtk::BuiltinStockID ZOOM_IN;          /*!< @image html stock_zoom_in_24.png             */
+extern GTKMM_API const Gtk::BuiltinStockID ZOOM_OUT;         /*!< @image html stock_zoom_out_24.png            */
+
+
+void add(const Gtk::StockItem& item);
+
+bool lookup(const Gtk::StockID& stock_id, Gtk::StockItem& item);
+bool lookup(const Gtk::StockID& stock_id, Gtk::IconSet& iconset);
+bool lookup(const Gtk::StockID& stock_id, Gtk::IconSize size, Gtk::Image& image);
+
+Glib::SListHandle<Gtk::StockID,Gtk::StockID_Traits> get_ids();
+
+} // namespace Stock
+
+} // namespace Gtk
+
+
+#endif /* _GTKMM_STOCK_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/stockid.cc b/libs/gtkmm2/gtk/gtkmm/stockid.cc
new file mode 100644
index 0000000000..93c50a1c2e
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/stockid.cc
@@ -0,0 +1,80 @@
+// -*- c++ -*-
+/* $Id$ */
+
+/* stockid.cc
+ *
+ * Copyright (C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/stockid.h>
+#include <gtkmm/stock.h>
+
+
+namespace Gtk
+{
+
+StockID::StockID()
+{}
+
+StockID::StockID(const BuiltinStockID& id)
+:
+  id_ (id.id)
+{}
+
+StockID::StockID(const Glib::ustring& id)
+:
+  id_ (id)
+{}
+
+StockID::StockID(const char* id)
+:
+  id_ ((id) ? id : "")
+{}
+
+StockID::~StockID()
+{}
+
+StockID::StockID(const StockID& other)
+:
+  id_ (other.id_)
+{}
+
+StockID& StockID::operator=(const StockID& other)
+{
+  id_ = other.id_;
+  return *this;
+}
+
+bool StockID::equal(const StockID& rhs) const
+{
+  // Do an exact per-byte comparison:
+  // Locale-dependent collation is probably not appropriate for stock IDs.
+  return (id_.raw() == rhs.id_.raw());
+}
+
+Glib::ustring StockID::get_string() const
+{
+  return id_;
+}
+
+const char* StockID::get_c_str() const
+{
+  return id_.c_str();
+}
+
+} // namespace Gtk
+
diff --git a/libs/gtkmm2/gtk/gtkmm/stockid.h b/libs/gtkmm2/gtk/gtkmm/stockid.h
new file mode 100644
index 0000000000..fac665dea4
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/stockid.h
@@ -0,0 +1,97 @@
+// -*- c++ -*-
+#ifndef _GTKMM_STOCKID_H
+#define _GTKMM_STOCKID_H
+
+/* $Id$ */
+
+/* stockid.h
+ *
+ * Copyright (C) 2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <glibmm.h>
+
+namespace Gtk
+{
+
+struct BuiltinStockID;
+
+/** See also Gtk::BuiltinStockID.
+ */
+class StockID
+{
+public:
+  StockID(); //TODO: This was added for Action::Action, but there might be a better way to do this.
+  StockID(const BuiltinStockID& id);
+  explicit StockID(const Glib::ustring& id);
+  explicit StockID(const char* id); // id can be 0
+  ~StockID();
+
+  StockID(const StockID& other);
+  StockID& operator=(const StockID& other);
+
+  bool equal(const StockID& rhs) const;
+
+  Glib::ustring get_string() const;
+  const char*   get_c_str()  const;
+
+protected:
+  Glib::ustring id_;
+};
+
+/** @relates Gtk::StockID */
+inline bool operator==(const StockID& lhs, const StockID& rhs)
+  { return lhs.equal(rhs); }
+
+/** @relates Gtk::StockID */
+inline bool operator!=(const StockID& lhs, const StockID& rhs)
+  { return !lhs.equal(rhs); }
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+struct StockID_Traits : public Glib::Container_Helpers::TypeTraits<Glib::ustring>
+{
+  typedef Gtk::StockID CppType;
+
+  static const char* to_c_type(const StockID& id) { return id.get_c_str(); }
+  static StockID     to_cpp_type(const char* str) { return StockID(str);   }
+};
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+} // namespace Gtk
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Gtk::StockID> : public Glib::ValueBase_String
+{
+public:
+  typedef Gtk::StockID CppType;
+
+  void set(const Gtk::StockID& data) { set_cstring(data.get_c_str());      }
+  Gtk::StockID get() const           { return Gtk::StockID(get_cstring()); }
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+#endif /* _GTKMM_STOCKID_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/stockitem.cc b/libs/gtkmm2/gtk/gtkmm/stockitem.cc
new file mode 100644
index 0000000000..3a2c10687e
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/stockitem.cc
@@ -0,0 +1,166 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/stockitem.h>
+#include <gtkmm/private/stockitem_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtk/gtkstock.h>
+ 
+namespace Gtk
+{
+
+StockItem::StockItem(const Gtk::StockID&  stock_id,
+                     const Glib::ustring& label,
+                     Gdk::ModifierType    modifier,
+                     unsigned int         keyval,
+                     const Glib::ustring& translation_domain)
+{
+  const GtkStockItem stock_item =
+  {
+    const_cast<char*>(stock_id.get_c_str()),
+    const_cast<char*>(label.c_str()),
+    static_cast<GdkModifierType>(unsigned(modifier)),
+    keyval,
+    (translation_domain.empty()) ? 0 : const_cast<char*>(translation_domain.c_str())
+  };
+
+  gobject_ = gtk_stock_item_copy(&stock_item);
+}
+
+// static
+bool StockItem::lookup(const Gtk::StockID& stock_id, Gtk::StockItem& item)
+{
+  GtkStockItem item_gobj = { 0, 0, GdkModifierType(0), 0, 0, };
+  const bool known_id = gtk_stock_lookup(stock_id.get_c_str(), &item_gobj);
+
+  if(item.gobject_)
+    gtk_stock_item_free(item.gobject_);
+
+  item.gobject_ = (known_id) ? gtk_stock_item_copy(&item_gobj) : 0;
+
+  return known_id;
+}
+
+} // namespace Gtk
+
+
+namespace
+{
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Gtk::StockItem wrap(GtkStockItem* object, bool take_copy /* = false */)
+{
+  return Gtk::StockItem(object, take_copy);
+}
+
+} // namespace Glib
+
+
+namespace Gtk
+{
+
+
+StockItem::StockItem()
+:
+  gobject_ (0) // Allows creation of invalid wrapper, e.g. for output arguments to methods.
+{}
+
+StockItem::StockItem(const StockItem& src)
+:
+  gobject_ ((src.gobject_) ? gtk_stock_item_copy(src.gobject_) : 0)
+{}
+
+StockItem::StockItem(GtkStockItem* castitem, bool make_a_copy /* = false */)
+{
+  if(!make_a_copy)
+  {
+    // It was given to us by a function which has already made a copy for us to keep.
+    gobject_ = castitem;
+  }
+  else
+  {
+    // We are probably getting it via direct access to a struct,
+    // so we can not just take it - we have to take a copy of it.
+    if(castitem)
+      gobject_ = gtk_stock_item_copy(castitem);
+    else
+      gobject_ = 0;
+  }
+}
+
+StockItem& StockItem::operator=(const StockItem& src)
+{
+  GtkStockItem *const new_gobject = (src.gobject_) ? gtk_stock_item_copy(src.gobject_) : 0;
+
+  if(gobject_)
+    gtk_stock_item_free(gobject_);
+
+  gobject_ = new_gobject;
+
+  return *this;
+}
+
+StockItem::~StockItem()
+{
+  if(gobject_)
+    gtk_stock_item_free(gobject_);
+}
+
+GtkStockItem* StockItem::gobj_copy() const
+{
+  return gtk_stock_item_copy(gobject_);
+}
+
+
+StockID StockItem::get_stock_id() const
+{
+  return StockID(gobj()->stock_id);
+}
+
+Glib::ustring StockItem::get_label() const
+{
+  return Glib::convert_const_gchar_ptr_to_ustring(gobj()->label);
+}
+
+Gdk::ModifierType StockItem::get_modifier() const
+{
+  return ((Gdk::ModifierType)(gobj()->modifier));
+}
+
+guint StockItem::get_keyval() const
+{
+  return gobj()->keyval;
+}
+
+Glib::ustring StockItem::get_translation_domain() const
+{
+  return Glib::convert_const_gchar_ptr_to_ustring(gobj()->translation_domain);
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/stockitem.h b/libs/gtkmm2/gtk/gtkmm/stockitem.h
new file mode 100644
index 0000000000..f500c0f12a
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/stockitem.h
@@ -0,0 +1,103 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_STOCKITEM_H
+#define _GTKMM_STOCKITEM_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* Copyright(C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software, ) you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library, ) if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gdkmm/types.h>
+#include <gtkmm/stockid.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+extern "C"
+{
+  typedef struct _GtkStockItem GtkStockItem;
+}
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+namespace Gtk
+{
+
+class StockItem
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef StockItem CppObjectType;
+  typedef GtkStockItem BaseObjectType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  StockItem();
+
+  // Use make_a_copy=true when getting it directly from a struct.
+  explicit StockItem(GtkStockItem* castitem, bool make_a_copy = false);
+
+  StockItem(const StockItem& src);
+  StockItem& operator=(const StockItem& src);
+
+  ~StockItem();
+
+  GtkStockItem*       gobj()       { return gobject_; }
+  const GtkStockItem* gobj() const { return gobject_; }
+
+  ///Provides access to the underlying C instance. The caller is responsible for freeing it. Use when directly setting fields in structs.
+  GtkStockItem* gobj_copy() const;
+
+protected:
+  GtkStockItem* gobject_;
+
+private:
+
+
+public:
+  StockItem(const Gtk::StockID& stock_id, const Glib::ustring& label,
+            Gdk::ModifierType modifier = Gdk::ModifierType(0), unsigned int keyval = 0,
+            const Glib::ustring& translation_domain = Glib::ustring());
+
+  StockID get_stock_id() const;
+  Glib::ustring get_label() const;
+  Gdk::ModifierType get_modifier() const;
+  guint get_keyval() const;
+  Glib::ustring get_translation_domain() const;
+
+  static bool lookup(const Gtk::StockID& stock_id, Gtk::StockItem& item);
+
+
+};
+
+} // namespace Gtk
+
+
+namespace Glib
+{
+
+  /** @relates Gtk::StockItem
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+Gtk::StockItem wrap(GtkStockItem* object, bool take_copy = false);
+
+} // namespace Glib
+
+#endif /* _GTKMM_STOCKITEM_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/style.cc b/libs/gtkmm2/gtk/gtkmm/style.cc
new file mode 100644
index 0000000000..ed4d97fcbc
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/style.cc
@@ -0,0 +1,2208 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/style.h>
+#include <gtkmm/private/style_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/widget.h>
+#include <gtkmm/rc.h>
+#include <gtk/gtkstyle.h>
+
+
+namespace Gtk
+{
+
+/* 
+Design notes:
+
+Okay these are my notes on how a GtkStyle works.
+They are not meant to be taken as documentation as I didn't
+write the code.  
+
+styles keeps a copy of itself for each color depth.  Thus
+changing a style after it has been attached wont work!
+
+At allocation time a Gtk Style has 
+  - all GC set to 0 as they will be allocated later
+  - has all color values set to default values.
+  - a ref count of 1 and an attach count of 0 (floating?)
+  - a properly referenced font.
+  - colormap and depth are invalid.
+  - The style list and rcstyle are 0. (??? styles wasn't set explicitly!)
+
+It returns to this state if the style is detatched from
+all widgets.
+
+Attach acts to sink the object removing it from the floating state.
+
+attaching a style for the first time initializes it. 
+Initializing a style
+  - sets the colormap and depth.
+  - sets the mid colors. (thus allowing user to set these would be pointless)
+  - gets black and white from the colormap.
+  - allocates all the colors.
+  - uses gtk_gc_get to share a gc if there is a matching one.
+
+Conclusions, we need to rework the concept of Gdk to allow
+for const objects.  
+
+*/
+
+void Style::set_font(const Pango::FontDescription& font_desc)
+{
+  g_return_if_fail(font_desc.gobj() != 0);
+
+  // It will be freed when it goes out of scope.
+  const Pango::FontDescription fontBefore (gobj()->font_desc, false);
+
+  gobj()->font_desc = font_desc.gobj_copy();
+}
+
+Pango::FontDescription Style::get_font() const
+{
+  // Direct struct access seems the only way.
+  return Pango::FontDescription(gobj()->font_desc, true); // true = make a copy.
+}
+
+Glib::RefPtr<Gdk::GC> Style::get_fg_gc(StateType state_type)
+{
+  return Glib::wrap(gobj()->fg_gc[state_type], true);
+}
+
+Glib::RefPtr<const Gdk::GC> Style::get_fg_gc(StateType state_type) const
+{
+  return Glib::wrap(gobj()->fg_gc[state_type], true);
+}
+
+Glib::RefPtr<Gdk::GC> Style::get_bg_gc(StateType state_type)
+{
+  return Glib::wrap(gobj()->bg_gc[state_type], true);
+}
+
+Glib::RefPtr<const Gdk::GC> Style::get_bg_gc(StateType state_type) const
+{
+  return Glib::wrap(gobj()->bg_gc[state_type], true);
+}
+
+Glib::RefPtr<Gdk::GC> Style::get_light_gc(StateType state_type)
+{
+  return Glib::wrap(gobj()->light_gc[state_type], true);
+}
+
+Glib::RefPtr<const Gdk::GC> Style::get_light_gc(StateType state_type) const
+{
+  return Glib::wrap(gobj()->light_gc[state_type], true);
+}
+
+Glib::RefPtr<Gdk::GC> Style::get_dark_gc(StateType state_type)
+{
+  return Glib::wrap(gobj()->dark_gc[state_type], true);
+}
+
+Glib::RefPtr<const Gdk::GC> Style::get_dark_gc(StateType state_type) const
+{
+  return Glib::wrap(gobj()->dark_gc[state_type], true);
+}
+
+Glib::RefPtr<Gdk::GC> Style::get_mid_gc(StateType state_type)
+{
+  return Glib::wrap(gobj()->mid_gc[state_type], true);
+}
+
+Glib::RefPtr<const Gdk::GC> Style::get_mid_gc(StateType state_type) const
+{
+  return Glib::wrap(gobj()->mid_gc[state_type], true);
+}
+
+Glib::RefPtr<Gdk::GC> Style::get_text_gc(StateType state_type)
+{
+  return Glib::wrap(gobj()->text_gc[state_type], true);
+}
+
+Glib::RefPtr<const Gdk::GC> Style::get_text_gc(StateType state_type) const
+{
+  return Glib::wrap(gobj()->text_gc[state_type], true);
+}
+
+Glib::RefPtr<Gdk::GC> Style::get_base_gc(StateType state_type)
+{
+  return Glib::wrap(gobj()->base_gc[state_type], true);
+}
+
+Glib::RefPtr<const Gdk::GC> Style::get_base_gc(StateType state_type) const
+{
+  return Glib::wrap(gobj()->base_gc[state_type], true);
+}
+
+Gdk::Color Style::get_background(StateType state_type) const
+{
+  GdkColor* pGdkColor = const_cast<GdkColor*>(&(gobj()->bg[state_type]));
+  return Glib::wrap(pGdkColor, true); //true = take_copy.
+}
+
+Glib::RefPtr<Gdk::Pixmap> Style::get_background_pixmap(StateType state_type)
+{
+  return Glib::wrap((GdkPixmapObject*) (gobj()->bg_pixmap[state_type]), true); //true = take_copy.
+}
+
+void Style::set_bg_pixmap(StateType state_type, const Glib::RefPtr<Gdk::Pixmap>& pixmap)
+{
+  GdkPixmap *const old_pixmap = gobj()->bg_pixmap[state_type];
+  gobj()->bg_pixmap[state_type] = Glib::unwrap_copy(pixmap);
+
+  if(old_pixmap)
+    g_object_unref(old_pixmap);
+}
+
+Glib::RefPtr<Gdk::Pixmap> Style::get_bg_pixmap(StateType state_type)
+{
+  return Glib::wrap((GdkPixmapObject*) (gobj()->bg_pixmap[state_type]), true); // true = take_copy
+}
+
+Glib::RefPtr<const Gdk::Pixmap> Style::get_bg_pixmap(StateType state_type) const
+{
+  return Glib::wrap((GdkPixmapObject*) (gobj()->bg_pixmap[state_type]), true); // true = take_copy
+}
+
+void Style::set_xthickness(int xthickness)
+{
+  gobj()->xthickness = xthickness;
+}
+
+void Style::set_ythickness(int ythickness)
+{
+  gobj()->ythickness = ythickness;
+}
+
+void Style::paint_polygon(const Glib::RefPtr<Gdk::Window>&      window,
+                          StateType                             state_type,
+                          ShadowType                            shadow_type,
+                          const Gdk::Rectangle&                 area,
+                          Widget&                               widget,
+                          const Glib::ustring&                  detail,
+                          const Glib::ArrayHandle<Gdk::Point>&  points,
+                          bool                                  fill) const
+{
+  gtk_paint_polygon(
+      const_cast<GtkStyle*>(gobj()),
+      Glib::unwrap(window),
+      (GtkStateType) state_type,
+      (GtkShadowType) shadow_type,
+      const_cast<GdkRectangle*>(area.gobj()),
+      widget.gobj(),
+      detail.c_str(),
+      reinterpret_cast<GdkPoint*>(const_cast<Gdk::Point*>(points.data())),
+      points.size(),
+      fill);
+}
+
+} // namespace Gtk
+
+
+namespace
+{
+
+const Glib::SignalProxyInfo Style_signal_realize_info =
+{
+  "realize",
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
+};
+
+
+const Glib::SignalProxyInfo Style_signal_unrealize_info =
+{
+  "unrealize",
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
+};
+
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Glib::RefPtr<Gtk::Style> wrap(GtkStyle* object, bool take_copy)
+{
+  return Glib::RefPtr<Gtk::Style>( dynamic_cast<Gtk::Style*> (Glib::wrap_auto ((GObject*)(object), take_copy)) );
+  //We use dynamic_cast<> in case of multiple inheritance.
+}
+
+} /* namespace Glib */
+
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& Style_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &Style_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_style_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void Style_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+  klass->realize = &realize_vfunc_callback;
+  klass->unrealize = &unrealize_vfunc_callback;
+  klass->copy = &copy_vfunc_callback;
+  klass->clone = &clone_vfunc_callback;
+  klass->init_from_rc = &init_from_rc_vfunc_callback;
+  klass->set_background = &set_background_vfunc_callback;
+  klass->render_icon = &render_icon_vfunc_callback;
+  klass->draw_hline = &draw_hline_vfunc_callback;
+  klass->draw_vline = &draw_vline_vfunc_callback;
+  klass->draw_shadow = &draw_shadow_vfunc_callback;
+  klass->draw_polygon = &draw_polygon_vfunc_callback;
+  klass->draw_arrow = &draw_arrow_vfunc_callback;
+  klass->draw_diamond = &draw_diamond_vfunc_callback;
+  klass->draw_string = &draw_string_vfunc_callback;
+  klass->draw_box = &draw_box_vfunc_callback;
+  klass->draw_flat_box = &draw_flat_box_vfunc_callback;
+  klass->draw_check = &draw_check_vfunc_callback;
+  klass->draw_option = &draw_option_vfunc_callback;
+  klass->draw_tab = &draw_tab_vfunc_callback;
+  klass->draw_shadow_gap = &draw_shadow_gap_vfunc_callback;
+  klass->draw_box_gap = &draw_box_gap_vfunc_callback;
+  klass->draw_extension = &draw_extension_vfunc_callback;
+  klass->draw_focus = &draw_focus_vfunc_callback;
+  klass->draw_slider = &draw_slider_vfunc_callback;
+  klass->draw_handle = &draw_handle_vfunc_callback;
+  klass->draw_expander = &draw_expander_vfunc_callback;
+  klass->draw_layout = &draw_layout_vfunc_callback;
+  klass->draw_resize_grip = &draw_resize_grip_vfunc_callback;
+  klass->realize = &realize_callback;
+  klass->unrealize = &unrealize_callback;
+}
+
+void Style_Class::realize_vfunc_callback(GtkStyle* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->realize_vfunc();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->realize)
+      (*base->realize)(self);
+  }
+}
+
+void Style_Class::unrealize_vfunc_callback(GtkStyle* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->unrealize_vfunc();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->unrealize)
+      (*base->unrealize)(self);
+  }
+}
+
+void Style_Class::copy_vfunc_callback(GtkStyle* self, GtkStyle* src)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->copy_vfunc(Glib::wrap(src, true)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->copy)
+      (*base->copy)(self, src);
+  }
+}
+
+GtkStyle* Style_Class::clone_vfunc_callback(GtkStyle* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return Glib::unwrap(obj->clone_vfunc());
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->clone)
+      return (*base->clone)(self);
+  }
+
+  typedef GtkStyle* RType;
+  return RType();
+}
+
+void Style_Class::init_from_rc_vfunc_callback(GtkStyle* self, GtkRcStyle* rc_style)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->init_from_rc_vfunc(Glib::wrap(rc_style)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->init_from_rc)
+      (*base->init_from_rc)(self, rc_style);
+  }
+}
+
+void Style_Class::set_background_vfunc_callback(GtkStyle* self, GdkWindow* window, GtkStateType state_type)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->set_background_vfunc(Glib::wrap((GdkWindowObject*)(window), true)
+, ((Gtk::StateType)(state_type))
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->set_background)
+      (*base->set_background)(self, window, state_type);
+  }
+}
+
+GdkPixbuf* Style_Class::render_icon_vfunc_callback(GtkStyle* self, const GtkIconSource* source, GtkTextDirection direction, GtkStateType state, GtkIconSize size, GtkWidget* widget, const gchar* detail)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return Glib::unwrap(obj->render_icon_vfunc(Glib::wrap(const_cast<GtkIconSource*>(source), true)
+, ((TextDirection)(direction))
+, ((Gtk::StateType)(state))
+, IconSize(static_cast<int>(size))
+, Glib::wrap(widget)
+, Glib::convert_const_gchar_ptr_to_ustring(detail)
+));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->render_icon)
+      return (*base->render_icon)(self, source, direction, state, size, widget, detail);
+  }
+
+  typedef GdkPixbuf* RType;
+  return RType();
+}
+
+void Style_Class::draw_hline_vfunc_callback(GtkStyle* self, GdkWindow* window, GtkStateType state_type, GdkRectangle* area, GtkWidget* widget, const gchar* detail, gint x1, gint x2, gint y)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->draw_hline_vfunc(Glib::wrap((GdkWindowObject*)(window), true)
+, ((Gtk::StateType)(state_type))
+, Glib::wrap(area)
+, Glib::wrap(widget)
+, Glib::convert_const_gchar_ptr_to_ustring(detail)
+, x1
+, x2
+, y
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->draw_hline)
+      (*base->draw_hline)(self, window, state_type, area, widget, detail, x1, x2, y);
+  }
+}
+
+void Style_Class::draw_vline_vfunc_callback(GtkStyle* self, GdkWindow* window, GtkStateType state_type, GdkRectangle* area, GtkWidget* widget, const gchar* detail, gint y1, gint y2, gint x)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->draw_vline_vfunc(Glib::wrap((GdkWindowObject*)(window), true)
+, ((Gtk::StateType)(state_type))
+, Glib::wrap(area)
+, Glib::wrap(widget)
+, Glib::convert_const_gchar_ptr_to_ustring(detail)
+, y1
+, y2
+, x
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->draw_vline)
+      (*base->draw_vline)(self, window, state_type, area, widget, detail, y1, y2, x);
+  }
+}
+
+void Style_Class::draw_shadow_vfunc_callback(GtkStyle* self, GdkWindow* window, GtkStateType state_type, GtkShadowType shadow_type, GdkRectangle* area, GtkWidget* widget, const gchar* detail, gint x, gint y, gint width, gint height)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->draw_shadow_vfunc(Glib::wrap((GdkWindowObject*)(window), true)
+, ((Gtk::StateType)(state_type))
+, ((ShadowType)(shadow_type))
+, Glib::wrap(area)
+, Glib::wrap(widget)
+, Glib::convert_const_gchar_ptr_to_ustring(detail)
+, x
+, y
+, width
+, height
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->draw_shadow)
+      (*base->draw_shadow)(self, window, state_type, shadow_type, area, widget, detail, x, y, width, height);
+  }
+}
+
+void Style_Class::draw_polygon_vfunc_callback(GtkStyle* self, GdkWindow* window, GtkStateType state_type, GtkShadowType shadow_type, GdkRectangle* area, GtkWidget* widget, const gchar* detail, GdkPoint* point, gint npoints, gboolean fill)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->draw_polygon_vfunc(Glib::wrap((GdkWindowObject*)(window), true)
+, ((Gtk::StateType)(state_type))
+, ((ShadowType)(shadow_type))
+, Glib::wrap(area)
+, Glib::wrap(widget)
+, Glib::convert_const_gchar_ptr_to_ustring(detail)
+, point, npoints
+, fill
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->draw_polygon)
+      (*base->draw_polygon)(self, window, state_type, shadow_type, area, widget, detail, point, npoints, fill);
+  }
+}
+
+void Style_Class::draw_arrow_vfunc_callback(GtkStyle* self, GdkWindow* window, GtkStateType state_type, GtkShadowType shadow_type, GdkRectangle* area, GtkWidget* widget, const gchar* detail, GtkArrowType arrow_type, gboolean fill, gint x, gint y, gint width, gint height)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->draw_arrow_vfunc(Glib::wrap((GdkWindowObject*)(window), true)
+, ((Gtk::StateType)(state_type))
+, ((ShadowType)(shadow_type))
+, Glib::wrap(area)
+, Glib::wrap(widget)
+, Glib::convert_const_gchar_ptr_to_ustring(detail)
+, ((Gtk::ArrowType)(arrow_type))
+, fill
+, x
+, y
+, width
+, height
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->draw_arrow)
+      (*base->draw_arrow)(self, window, state_type, shadow_type, area, widget, detail, arrow_type, fill, x, y, width, height);
+  }
+}
+
+void Style_Class::draw_diamond_vfunc_callback(GtkStyle* self, GdkWindow* window, GtkStateType state_type, GtkShadowType shadow_type, GdkRectangle* area, GtkWidget* widget, const gchar* detail, gint x, gint y, gint width, gint height)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->draw_diamond_vfunc(Glib::wrap((GdkWindowObject*)(window), true)
+, ((Gtk::StateType)(state_type))
+, ((ShadowType)(shadow_type))
+, Glib::wrap(area)
+, Glib::wrap(widget)
+, Glib::convert_const_gchar_ptr_to_ustring(detail)
+, x
+, y
+, width
+, height
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->draw_diamond)
+      (*base->draw_diamond)(self, window, state_type, shadow_type, area, widget, detail, x, y, width, height);
+  }
+}
+
+void Style_Class::draw_string_vfunc_callback(GtkStyle* self, GdkWindow* window, GtkStateType state_type, GdkRectangle* area, GtkWidget* widget, const gchar* detail, gint x, gint y, const gchar* string)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->draw_string_vfunc(Glib::wrap((GdkWindowObject*)(window), true)
+, ((Gtk::StateType)(state_type))
+, Glib::wrap(area)
+, Glib::wrap(widget)
+, Glib::convert_const_gchar_ptr_to_ustring(detail)
+, x
+, y
+, Glib::convert_const_gchar_ptr_to_ustring(string)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->draw_string)
+      (*base->draw_string)(self, window, state_type, area, widget, detail, x, y, string);
+  }
+}
+
+void Style_Class::draw_box_vfunc_callback(GtkStyle* self, GdkWindow* window, GtkStateType state_type, GtkShadowType shadow_type, GdkRectangle* area, GtkWidget* widget, const gchar* detail, gint x, gint y, gint width, gint height)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->draw_box_vfunc(Glib::wrap((GdkWindowObject*)(window), true)
+, ((Gtk::StateType)(state_type))
+, ((ShadowType)(shadow_type))
+, Glib::wrap(area)
+, Glib::wrap(widget)
+, Glib::convert_const_gchar_ptr_to_ustring(detail)
+, x
+, y
+, width
+, height
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->draw_box)
+      (*base->draw_box)(self, window, state_type, shadow_type, area, widget, detail, x, y, width, height);
+  }
+}
+
+void Style_Class::draw_flat_box_vfunc_callback(GtkStyle* self, GdkWindow* window, GtkStateType state_type, GtkShadowType shadow_type, GdkRectangle* area, GtkWidget* widget, const gchar* detail, gint x, gint y, gint width, gint height)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->draw_flat_box_vfunc(Glib::wrap((GdkWindowObject*)(window), true)
+, ((Gtk::StateType)(state_type))
+, ((ShadowType)(shadow_type))
+, Glib::wrap(area)
+, Glib::wrap(widget)
+, Glib::convert_const_gchar_ptr_to_ustring(detail)
+, x
+, y
+, width
+, height
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->draw_flat_box)
+      (*base->draw_flat_box)(self, window, state_type, shadow_type, area, widget, detail, x, y, width, height);
+  }
+}
+
+void Style_Class::draw_check_vfunc_callback(GtkStyle* self, GdkWindow* window, GtkStateType state_type, GtkShadowType shadow_type, GdkRectangle* area, GtkWidget* widget, const gchar* detail, gint x, gint y, gint width, gint height)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->draw_check_vfunc(Glib::wrap((GdkWindowObject*)(window), true)
+, ((Gtk::StateType)(state_type))
+, ((ShadowType)(shadow_type))
+, Glib::wrap(area)
+, Glib::wrap(widget)
+, Glib::convert_const_gchar_ptr_to_ustring(detail)
+, x
+, y
+, width
+, height
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->draw_check)
+      (*base->draw_check)(self, window, state_type, shadow_type, area, widget, detail, x, y, width, height);
+  }
+}
+
+void Style_Class::draw_option_vfunc_callback(GtkStyle* self, GdkWindow* window, GtkStateType state_type, GtkShadowType shadow_type, GdkRectangle* area, GtkWidget* widget, const gchar* detail, gint x, gint y, gint width, gint height)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->draw_option_vfunc(Glib::wrap((GdkWindowObject*)(window), true)
+, ((Gtk::StateType)(state_type))
+, ((ShadowType)(shadow_type))
+, Glib::wrap(area)
+, Glib::wrap(widget)
+, Glib::convert_const_gchar_ptr_to_ustring(detail)
+, x
+, y
+, width
+, height
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->draw_option)
+      (*base->draw_option)(self, window, state_type, shadow_type, area, widget, detail, x, y, width, height);
+  }
+}
+
+void Style_Class::draw_tab_vfunc_callback(GtkStyle* self, GdkWindow* window, GtkStateType state_type, GtkShadowType shadow_type, GdkRectangle* area, GtkWidget* widget, const gchar* detail, gint x, gint y, gint width, gint height)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->draw_tab_vfunc(Glib::wrap((GdkWindowObject*)(window), true)
+, ((Gtk::StateType)(state_type))
+, ((ShadowType)(shadow_type))
+, Glib::wrap(area)
+, Glib::wrap(widget)
+, Glib::convert_const_gchar_ptr_to_ustring(detail)
+, x
+, y
+, width
+, height
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->draw_tab)
+      (*base->draw_tab)(self, window, state_type, shadow_type, area, widget, detail, x, y, width, height);
+  }
+}
+
+void Style_Class::draw_shadow_gap_vfunc_callback(GtkStyle* self, GdkWindow* window, GtkStateType state_type, GtkShadowType shadow_type, GdkRectangle* area, GtkWidget* widget, const gchar* detail, gint x, gint y, gint width, gint height, GtkPositionType gap_side, gint gap_x, gint gap_width)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->draw_shadow_gap_vfunc(Glib::wrap((GdkWindowObject*)(window), true)
+, ((Gtk::StateType)(state_type))
+, ((ShadowType)(shadow_type))
+, Glib::wrap(area)
+, Glib::wrap(widget)
+, Glib::convert_const_gchar_ptr_to_ustring(detail)
+, x
+, y
+, width
+, height
+, ((Gtk::PositionType)(gap_side))
+, gap_x
+, gap_width
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->draw_shadow_gap)
+      (*base->draw_shadow_gap)(self, window, state_type, shadow_type, area, widget, detail, x, y, width, height, gap_side, gap_x, gap_width);
+  }
+}
+
+void Style_Class::draw_box_gap_vfunc_callback(GtkStyle* self, GdkWindow* window, GtkStateType state_type, GtkShadowType shadow_type, GdkRectangle* area, GtkWidget* widget, const gchar* detail, gint x, gint y, gint width, gint height, GtkPositionType gap_side, gint gap_x, gint gap_width)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->draw_box_gap_vfunc(Glib::wrap((GdkWindowObject*)(window), true)
+, ((Gtk::StateType)(state_type))
+, ((ShadowType)(shadow_type))
+, Glib::wrap(area)
+, Glib::wrap(widget)
+, Glib::convert_const_gchar_ptr_to_ustring(detail)
+, x
+, y
+, width
+, height
+, ((Gtk::PositionType)(gap_side))
+, gap_x
+, gap_width
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->draw_box_gap)
+      (*base->draw_box_gap)(self, window, state_type, shadow_type, area, widget, detail, x, y, width, height, gap_side, gap_x, gap_width);
+  }
+}
+
+void Style_Class::draw_extension_vfunc_callback(GtkStyle* self, GdkWindow* window, GtkStateType state_type, GtkShadowType shadow_type, GdkRectangle* area, GtkWidget* widget, const gchar* detail, gint x, gint y, gint width, gint height, GtkPositionType gap_side)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->draw_extension_vfunc(Glib::wrap((GdkWindowObject*)(window), true)
+, ((Gtk::StateType)(state_type))
+, ((ShadowType)(shadow_type))
+, Glib::wrap(area)
+, Glib::wrap(widget)
+, Glib::convert_const_gchar_ptr_to_ustring(detail)
+, x
+, y
+, width
+, height
+, ((PositionType)(gap_side))
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->draw_extension)
+      (*base->draw_extension)(self, window, state_type, shadow_type, area, widget, detail, x, y, width, height, gap_side);
+  }
+}
+
+void Style_Class::draw_focus_vfunc_callback(GtkStyle* self, GdkWindow* window, GtkStateType state_type, GdkRectangle* area, GtkWidget* widget, const gchar* detail, gint x, gint y, gint width, gint height)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->draw_focus_vfunc(Glib::wrap((GdkWindowObject*)(window), true)
+, ((Gtk::StateType)(state_type))
+, Glib::wrap(area)
+, Glib::wrap(widget)
+, Glib::convert_const_gchar_ptr_to_ustring(detail)
+, x
+, y
+, width
+, height
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->draw_focus)
+      (*base->draw_focus)(self, window, state_type, area, widget, detail, x, y, width, height);
+  }
+}
+
+void Style_Class::draw_slider_vfunc_callback(GtkStyle* self, GdkWindow* window, GtkStateType state_type, GtkShadowType shadow_type, GdkRectangle* area, GtkWidget* widget, const gchar* detail, gint x, gint y, gint width, gint height, GtkOrientation orientation)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->draw_slider_vfunc(Glib::wrap((GdkWindowObject*)(window), true)
+, ((Gtk::StateType)(state_type))
+, ((ShadowType)(shadow_type))
+, Glib::wrap(area)
+, Glib::wrap(widget)
+, Glib::convert_const_gchar_ptr_to_ustring(detail)
+, x
+, y
+, width
+, height
+, ((Orientation)(orientation))
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->draw_slider)
+      (*base->draw_slider)(self, window, state_type, shadow_type, area, widget, detail, x, y, width, height, orientation);
+  }
+}
+
+void Style_Class::draw_handle_vfunc_callback(GtkStyle* self, GdkWindow* window, GtkStateType state_type, GtkShadowType shadow_type, GdkRectangle* area, GtkWidget* widget, const gchar* detail, gint x, gint y, gint width, gint height, GtkOrientation orientation)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->draw_handle_vfunc(Glib::wrap((GdkWindowObject*)(window), true)
+, ((Gtk::StateType)(state_type))
+, ((ShadowType)(shadow_type))
+, Glib::wrap(area)
+, Glib::wrap(widget)
+, Glib::convert_const_gchar_ptr_to_ustring(detail)
+, x
+, y
+, width
+, height
+, ((Orientation)(orientation))
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->draw_handle)
+      (*base->draw_handle)(self, window, state_type, shadow_type, area, widget, detail, x, y, width, height, orientation);
+  }
+}
+
+void Style_Class::draw_expander_vfunc_callback(GtkStyle* self, GdkWindow* window, GtkStateType state_type, GdkRectangle* area, GtkWidget* widget, const gchar* detail, gint x, gint y, GtkExpanderStyle expander_style)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->draw_expander_vfunc(Glib::wrap((GdkWindowObject*)(window), true)
+, ((Gtk::StateType)(state_type))
+, Glib::wrap(area)
+, Glib::wrap(widget)
+, Glib::convert_const_gchar_ptr_to_ustring(detail)
+, x
+, y
+, ((ExpanderStyle)(expander_style))
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->draw_expander)
+      (*base->draw_expander)(self, window, state_type, area, widget, detail, x, y, expander_style);
+  }
+}
+
+void Style_Class::draw_layout_vfunc_callback(GtkStyle* self, GdkWindow* window, GtkStateType state_type, gboolean use_text, GdkRectangle* area, GtkWidget* widget, const gchar* detail, gint x, gint y, PangoLayout* layout)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->draw_layout_vfunc(Glib::wrap((GdkWindowObject*)(window), true)
+, ((Gtk::StateType)(state_type))
+, use_text
+, Glib::wrap(area)
+, Glib::wrap(widget)
+, Glib::convert_const_gchar_ptr_to_ustring(detail)
+, x
+, y
+, Glib::wrap(layout)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->draw_layout)
+      (*base->draw_layout)(self, window, state_type, use_text, area, widget, detail, x, y, layout);
+  }
+}
+
+void Style_Class::draw_resize_grip_vfunc_callback(GtkStyle* self, GdkWindow* window, GtkStateType state_type, GdkRectangle* area, GtkWidget* widget, const gchar* detail, GdkWindowEdge edge, gint x, gint y, gint width, gint height)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->draw_resize_grip_vfunc(Glib::wrap((GdkWindowObject*)(window), true)
+, ((Gtk::StateType)(state_type))
+, Glib::wrap(area)
+, Glib::wrap(widget)
+, Glib::convert_const_gchar_ptr_to_ustring(detail)
+, ((Gdk::WindowEdge)(edge))
+, x
+, y
+, width
+, height
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->draw_resize_grip)
+      (*base->draw_resize_grip)(self, window, state_type, area, widget, detail, edge, x, y, width, height);
+  }
+}
+
+
+void Style_Class::realize_callback(GtkStyle* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_realize();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->realize)
+      (*base->realize)(self);
+  }
+}
+
+void Style_Class::unrealize_callback(GtkStyle* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_unrealize();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->unrealize)
+      (*base->unrealize)(self);
+  }
+}
+
+
+Glib::ObjectBase* Style_Class::wrap_new(GObject* object)
+{
+  return new Style((GtkStyle*)object);
+}
+
+
+/* The implementation: */
+
+GtkStyle* Style::gobj_copy()
+{
+  reference();
+  return gobj();
+}
+
+Style::Style(const Glib::ConstructParams& construct_params)
+:
+  Glib::Object(construct_params)
+{}
+
+Style::Style(GtkStyle* castitem)
+:
+  Glib::Object((GObject*)(castitem))
+{}
+
+Style::~Style()
+{}
+
+
+Style::CppClassType Style::style_class_; // initialize static member
+
+GType Style::get_type()
+{
+  return style_class_.init().get_type();
+}
+
+GType Style::get_base_type()
+{
+  return gtk_style_get_type();
+}
+
+
+Style::Style()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Glib::Object(Glib::ConstructParams(style_class_.init()))
+{
+  }
+
+Glib::RefPtr<Style> Style::create()
+{
+  return Glib::RefPtr<Style>( new Style() );
+}
+void Style::set_fg(StateType state, const Gdk::Color& color)
+{
+  gobj()->fg[state] = *color.gobj();
+}
+
+Gdk::Color Style::get_fg(StateType state) const
+{
+  return Gdk::Color(const_cast<GdkColor*>(&gobj()->fg[state]), true);
+}
+
+void Style::set_bg(StateType state, const Gdk::Color& color)
+{
+  gobj()->bg[state] = *color.gobj();
+}
+
+Gdk::Color Style::get_bg(StateType state) const
+{
+  return Gdk::Color(const_cast<GdkColor*>(&gobj()->bg[state]), true);
+}
+
+void Style::set_light(StateType state, const Gdk::Color& color)
+{
+  gobj()->light[state] = *color.gobj();
+}
+
+Gdk::Color Style::get_light(StateType state) const
+{
+  return Gdk::Color(const_cast<GdkColor*>(&gobj()->light[state]), true);
+}
+
+void Style::set_dark(StateType state, const Gdk::Color& color)
+{
+  gobj()->dark[state] = *color.gobj();
+}
+
+Gdk::Color Style::get_dark(StateType state) const
+{
+  return Gdk::Color(const_cast<GdkColor*>(&gobj()->dark[state]), true);
+}
+
+void Style::set_mid(StateType state, const Gdk::Color& color)
+{
+  gobj()->mid[state] = *color.gobj();
+}
+
+Gdk::Color Style::get_mid(StateType state) const
+{
+  return Gdk::Color(const_cast<GdkColor*>(&gobj()->mid[state]), true);
+}
+
+void Style::set_text(StateType state, const Gdk::Color& color)
+{
+  gobj()->text[state] = *color.gobj();
+}
+
+Gdk::Color Style::get_text(StateType state) const
+{
+  return Gdk::Color(const_cast<GdkColor*>(&gobj()->text[state]), true);
+}
+
+void Style::set_base(StateType state, const Gdk::Color& color)
+{
+  gobj()->base[state] = *color.gobj();
+}
+
+Gdk::Color Style::get_base(StateType state) const
+{
+  return Gdk::Color(const_cast<GdkColor*>(&gobj()->base[state]), true);
+}
+
+void Style::set_text_aa(StateType state, const Gdk::Color& color)
+{
+  gobj()->text_aa[state] = *color.gobj();
+}
+
+Gdk::Color Style::get_text_aa(StateType state) const
+{
+  return Gdk::Color(const_cast<GdkColor*>(&gobj()->text_aa[state]), true);
+}
+
+void Style::set_black(const Gdk::Color& value)
+{
+  gobj()->black = (*(value).gobj());
+}
+
+Gdk::Color Style::get_black() const
+{
+  return Gdk::Color(const_cast<GdkColor*>(&(gobj()->black)), true);
+}
+
+void Style::set_white(const Gdk::Color& value)
+{
+  gobj()->white = (*(value).gobj());
+}
+
+Gdk::Color Style::get_white() const
+{
+  return Gdk::Color(const_cast<GdkColor*>(&(gobj()->white)), true);
+}
+
+int Style::get_xthickness() const
+{
+  return gobj()->xthickness;
+}
+
+int Style::get_ythickness() const
+{
+  return gobj()->ythickness;
+}
+
+Glib::RefPtr<Gdk::GC> Style::get_black_gc()
+{
+  Glib::RefPtr<Gdk::GC> ref_ptr(Glib::wrap(gobj()->black_gc));
+
+  if(ref_ptr)
+    ref_ptr->reference();
+
+  return ref_ptr;
+}
+
+Glib::RefPtr<const Gdk::GC> Style::get_black_gc() const
+{
+  Glib::RefPtr<const Gdk::GC> ref_ptr(Glib::wrap(gobj()->black_gc));
+
+  if(ref_ptr)
+    ref_ptr->reference();
+
+  return ref_ptr;
+}
+
+Glib::RefPtr<Gdk::GC> Style::get_white_gc()
+{
+  Glib::RefPtr<Gdk::GC> ref_ptr(Glib::wrap(gobj()->white_gc));
+
+  if(ref_ptr)
+    ref_ptr->reference();
+
+  return ref_ptr;
+}
+
+Glib::RefPtr<const Gdk::GC> Style::get_white_gc() const
+{
+  Glib::RefPtr<const Gdk::GC> ref_ptr(Glib::wrap(gobj()->white_gc));
+
+  if(ref_ptr)
+    ref_ptr->reference();
+
+  return ref_ptr;
+}
+
+void Style::paint_arrow(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, ShadowType shadow_type, const Gdk::Rectangle& area, Widget& widget, const Glib::ustring& detail, ArrowType arrow_type, bool fill, int x, int y, int width, int height) const
+{
+  gtk_paint_arrow(const_cast<GtkStyle*>(gobj()), Glib::unwrap(window), ((GtkStateType)(state_type)), ((GtkShadowType)(shadow_type)), const_cast<GdkRectangle*>(area.gobj()), (widget).gobj(), detail.c_str(), ((GtkArrowType)(arrow_type)), static_cast<int>(fill), x, y, width, height);
+}
+
+void Style::paint_box(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, ShadowType shadow_type, const Gdk::Rectangle& area, Widget& widget, const Glib::ustring& detail, int x, int y, int width, int height) const
+{
+  gtk_paint_box(const_cast<GtkStyle*>(gobj()), Glib::unwrap(window), ((GtkStateType)(state_type)), ((GtkShadowType)(shadow_type)), const_cast<GdkRectangle*>(area.gobj()), (widget).gobj(), detail.c_str(), x, y, width, height);
+}
+
+void Style::paint_box_gap(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, ShadowType shadow_type, const Gdk::Rectangle& area, Widget& widget, const Glib::ustring& detail, int x, int y, int width, int height, PositionType gap_side, int gap_x, int gap_width) const
+{
+  gtk_paint_box_gap(const_cast<GtkStyle*>(gobj()), Glib::unwrap(window), ((GtkStateType)(state_type)), ((GtkShadowType)(shadow_type)), const_cast<GdkRectangle*>(area.gobj()), (widget).gobj(), const_cast<gchar*>(detail.c_str()), x, y, width, height, ((GtkPositionType)(gap_side)), gap_x, gap_width);
+}
+
+void Style::paint_check(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, ShadowType shadow_type, const Gdk::Rectangle& area, Widget& widget, const Glib::ustring& detail, int x, int y, int width, int height) const
+{
+  gtk_paint_check(const_cast<GtkStyle*>(gobj()), Glib::unwrap(window), ((GtkStateType)(state_type)), ((GtkShadowType)(shadow_type)), const_cast<GdkRectangle*>(area.gobj()), (widget).gobj(), detail.c_str(), x, y, width, height);
+}
+
+void Style::paint_diamond(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, ShadowType shadow_type, const Gdk::Rectangle& area, Widget& widget, const Glib::ustring& detail, int x, int y, int width, int height) const
+{
+  gtk_paint_diamond(const_cast<GtkStyle*>(gobj()), Glib::unwrap(window), ((GtkStateType)(state_type)), ((GtkShadowType)(shadow_type)), const_cast<GdkRectangle*>(area.gobj()), (widget).gobj(), detail.c_str(), x, y, width, height);
+}
+
+void Style::paint_extension(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, ShadowType shadow_type, const Gdk::Rectangle& area, Widget& widget, const Glib::ustring& detail, int x, int y, int width, int height, PositionType gap_side) const
+{
+  gtk_paint_extension(const_cast<GtkStyle*>(gobj()), Glib::unwrap(window), ((GtkStateType)(state_type)), ((GtkShadowType)(shadow_type)), const_cast<GdkRectangle*>(area.gobj()), (widget).gobj(), const_cast<gchar*>(detail.c_str()), x, y, width, height, ((GtkPositionType)(gap_side)));
+}
+
+void Style::paint_flat_box(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, ShadowType shadow_type, const Gdk::Rectangle& area, Widget& widget, const Glib::ustring& detail, int x, int y, int width, int height) const
+{
+  gtk_paint_flat_box(const_cast<GtkStyle*>(gobj()), Glib::unwrap(window), ((GtkStateType)(state_type)), ((GtkShadowType)(shadow_type)), const_cast<GdkRectangle*>(area.gobj()), (widget).gobj(), detail.c_str(), x, y, width, height);
+}
+
+void Style::paint_focus(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, const Gdk::Rectangle& area, Widget& widget, const Glib::ustring& detail, int x, int y, int width, int height) const
+{
+  gtk_paint_focus(const_cast<GtkStyle*>(gobj()), Glib::unwrap(window), ((GtkStateType)(state_type)), const_cast<GdkRectangle*>(area.gobj()), (widget).gobj(), detail.c_str(), x, y, width, height);
+}
+
+void Style::paint_handle(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, ShadowType shadow_type, const Gdk::Rectangle& area, Widget& widget, const Glib::ustring& detail, int x, int y, int width, int height, Orientation orientation) const
+{
+  gtk_paint_handle(const_cast<GtkStyle*>(gobj()), Glib::unwrap(window), ((GtkStateType)(state_type)), ((GtkShadowType)(shadow_type)), const_cast<GdkRectangle*>(area.gobj()), (widget).gobj(), detail.c_str(), x, y, width, height, ((GtkOrientation)(orientation)));
+}
+
+void Style::paint_hline(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, const Gdk::Rectangle& area, Widget& widget, const Glib::ustring& detail, int x1, int x2, int y) const
+{
+  gtk_paint_hline(const_cast<GtkStyle*>(gobj()), Glib::unwrap(window), ((GtkStateType)(state_type)), const_cast<GdkRectangle*>(area.gobj()), (widget).gobj(), detail.c_str(), x1, x2, y);
+}
+
+void Style::paint_option(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, ShadowType shadow_type, const Gdk::Rectangle& area, Widget& widget, const Glib::ustring& detail, int x, int y, int width, int height) const
+{
+  gtk_paint_option(const_cast<GtkStyle*>(gobj()), Glib::unwrap(window), ((GtkStateType)(state_type)), ((GtkShadowType)(shadow_type)), const_cast<GdkRectangle*>(area.gobj()), (widget).gobj(), detail.c_str(), x, y, width, height);
+}
+
+void Style::paint_shadow(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, ShadowType shadow_type, const Gdk::Rectangle& area, Widget& widget, const Glib::ustring& detail, int x, int y, int width, int height) const
+{
+  gtk_paint_shadow(const_cast<GtkStyle*>(gobj()), Glib::unwrap(window), ((GtkStateType)(state_type)), ((GtkShadowType)(shadow_type)), const_cast<GdkRectangle*>(area.gobj()), (widget).gobj(), detail.c_str(), x, y, width, height);
+}
+
+void Style::paint_shadow_gap(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, ShadowType shadow_type, const Gdk::Rectangle& area, Widget& widget, const Glib::ustring& detail, int x, int y, int width, int height, PositionType gap_side, int gap_x, int gap_width) const
+{
+  gtk_paint_shadow_gap(const_cast<GtkStyle*>(gobj()), Glib::unwrap(window), ((GtkStateType)(state_type)), ((GtkShadowType)(shadow_type)), const_cast<GdkRectangle*>(area.gobj()), (widget).gobj(), const_cast<gchar*>(detail.c_str()), x, y, width, height, ((GtkPositionType)(gap_side)), gap_x, gap_width);
+}
+
+void Style::paint_slider(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, ShadowType shadow_type, const Gdk::Rectangle& area, Widget& widget, const Glib::ustring& detail, int x, int y, int width, int height, Orientation orientation) const
+{
+  gtk_paint_slider(const_cast<GtkStyle*>(gobj()), Glib::unwrap(window), ((GtkStateType)(state_type)), ((GtkShadowType)(shadow_type)), const_cast<GdkRectangle*>(area.gobj()), (widget).gobj(), detail.c_str(), x, y, width, height, ((GtkOrientation)(orientation)));
+}
+
+void Style::paint_tab(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, ShadowType shadow_type, const Gdk::Rectangle& area, Widget& widget, const Glib::ustring& detail, int x, int y, int width, int height) const
+{
+  gtk_paint_tab(const_cast<GtkStyle*>(gobj()), Glib::unwrap(window), ((GtkStateType)(state_type)), ((GtkShadowType)(shadow_type)), const_cast<GdkRectangle*>(area.gobj()), (widget).gobj(), detail.c_str(), x, y, width, height);
+}
+
+void Style::paint_vline(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, const Gdk::Rectangle& area, Widget& widget, const Glib::ustring& detail, int y1, int y2, int x) const
+{
+  gtk_paint_vline(const_cast<GtkStyle*>(gobj()), Glib::unwrap(window), ((GtkStateType)(state_type)), const_cast<GdkRectangle*>(area.gobj()), (widget).gobj(), detail.c_str(), y1, y2, x);
+}
+
+void Style::paint_expander(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, const Gdk::Rectangle& area, Widget& widget, const Glib::ustring& detail, int x, int y, ExpanderStyle expander_style) const
+{
+  gtk_paint_expander(const_cast<GtkStyle*>(gobj()), Glib::unwrap(window), ((GtkStateType)(state_type)), const_cast<GdkRectangle*>(area.gobj()), (widget).gobj(), detail.c_str(), x, y, ((GtkExpanderStyle)(expander_style)));
+}
+
+void Style::paint_layout(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, bool use_text, const Gdk::Rectangle& area, Widget& widget, const Glib::ustring& detail, int x, int y, const Glib::RefPtr<Pango::Layout>& layout) const
+{
+  gtk_paint_layout(const_cast<GtkStyle*>(gobj()), Glib::unwrap(window), ((GtkStateType)(state_type)), static_cast<int>(use_text), const_cast<GdkRectangle*>(area.gobj()), (widget).gobj(), detail.c_str(), x, y, Glib::unwrap(layout));
+}
+
+void Style::paint_resize_grip(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, const Gdk::Rectangle& area, Widget& widget, const Glib::ustring& detail, Gdk::WindowEdge edge, int x, int y, int width, int height) const
+{
+  gtk_paint_resize_grip(const_cast<GtkStyle*>(gobj()), Glib::unwrap(window), ((GtkStateType)(state_type)), const_cast<GdkRectangle*>(area.gobj()), (widget).gobj(), detail.c_str(), ((GdkWindowEdge)(edge)), x, y, width, height);
+}
+
+Glib::RefPtr<Style> Style::copy()
+{
+  return Glib::wrap(gtk_style_copy(gobj()));
+}
+
+void Style::set_background(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type)
+{
+  gtk_style_set_background(gobj(), Glib::unwrap(window), ((GtkStateType)(state_type)));
+}
+
+void Style::apply_default_background(const Glib::RefPtr<Gdk::Window>& window, bool set_bg, Gtk::StateType state_type, const Gdk::Rectangle& area, int x, int y, int width, int height)
+{
+  gtk_style_apply_default_background(gobj(), Glib::unwrap(window), static_cast<int>(set_bg), ((GtkStateType)(state_type)), const_cast<GdkRectangle*>(area.gobj()), x, y, width, height);
+}
+
+IconSet Style::lookup_icon_set(const Gtk::StockID& stock_id)
+{
+  return Glib::wrap(gtk_style_lookup_icon_set(gobj(), (stock_id).get_c_str()));
+}
+
+Glib::RefPtr<Gdk::Pixbuf> Style::render_icon(const IconSource& source, Gtk::TextDirection direction, Gtk::StateType state, Gtk::IconSize size, Gtk::Widget& widget, const Glib::ustring& detail)
+{
+  return Glib::wrap(gtk_style_render_icon(gobj(), (source).gobj(), ((GtkTextDirection)(direction)), ((GtkStateType)(state)), static_cast<GtkIconSize>(int(size)), (widget).gobj(), detail.c_str()));
+}
+
+
+Glib::SignalProxy0< void > Style::signal_realize()
+{
+  return Glib::SignalProxy0< void >(this, &Style_signal_realize_info);
+}
+
+Glib::SignalProxy0< void > Style::signal_unrealize()
+{
+  return Glib::SignalProxy0< void >(this, &Style_signal_unrealize_info);
+}
+
+
+void Gtk::Style::on_realize()
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->realize)
+    (*base->realize)(gobj());
+}
+
+void Gtk::Style::on_unrealize()
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->unrealize)
+    (*base->unrealize)(gobj());
+}
+
+
+void Gtk::Style::realize_vfunc() 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->realize)
+    (*base->realize)(gobj());
+}
+
+void Gtk::Style::unrealize_vfunc() 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->unrealize)
+    (*base->unrealize)(gobj());
+}
+
+void Gtk::Style::copy_vfunc(const Glib::RefPtr<Style>& src) 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->copy)
+    (*base->copy)(gobj(),Glib::unwrap(src));
+}
+
+Glib::RefPtr<Style> Gtk::Style::clone_vfunc() 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->clone)
+    return Glib::wrap((*base->clone)(gobj()));
+
+  typedef Glib::RefPtr<Style> RType;
+  return RType();
+}
+
+void Gtk::Style::init_from_rc_vfunc(const Glib::RefPtr<RcStyle>& rc_style) 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->init_from_rc)
+    (*base->init_from_rc)(gobj(),Glib::unwrap(rc_style));
+}
+
+void Gtk::Style::set_background_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type) 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->set_background)
+    (*base->set_background)(gobj(),Glib::unwrap(window),((GtkStateType)(state_type)));
+}
+
+Glib::RefPtr<Gdk::Pixbuf> Gtk::Style::render_icon_vfunc(const IconSource& source, TextDirection direction, Gtk::StateType state, IconSize size, Widget* widget, const Glib::ustring& detail) 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->render_icon)
+    return Glib::wrap((*base->render_icon)(gobj(),(source).gobj(),((GtkTextDirection)(direction)),((GtkStateType)(state)),static_cast<GtkIconSize>(int(size)),(GtkWidget*)Glib::unwrap(widget),detail.c_str()));
+
+  typedef Glib::RefPtr<Gdk::Pixbuf> RType;
+  return RType();
+}
+
+void Gtk::Style::draw_hline_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, const Gdk::Rectangle& area, Widget* widget, const Glib::ustring& detail, int x1, int x2, int y) 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->draw_hline)
+    (*base->draw_hline)(gobj(),Glib::unwrap(window),((GtkStateType)(state_type)),const_cast<GdkRectangle*>(area.gobj()),(GtkWidget*)Glib::unwrap(widget),detail.c_str(),x1,x2,y);
+}
+
+void Gtk::Style::draw_vline_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, const Gdk::Rectangle& area, Widget* widget, const Glib::ustring& detail, int y1, int y2, int x) 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->draw_vline)
+    (*base->draw_vline)(gobj(),Glib::unwrap(window),((GtkStateType)(state_type)),const_cast<GdkRectangle*>(area.gobj()),(GtkWidget*)Glib::unwrap(widget),detail.c_str(),y1,y2,x);
+}
+
+void Gtk::Style::draw_shadow_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, ShadowType shadow_type, const Gdk::Rectangle& area, Widget* widget, const Glib::ustring& detail, int x, int y, int width, int height) 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->draw_shadow)
+    (*base->draw_shadow)(gobj(),Glib::unwrap(window),((GtkStateType)(state_type)),((GtkShadowType)(shadow_type)),const_cast<GdkRectangle*>(area.gobj()),(GtkWidget*)Glib::unwrap(widget),detail.c_str(),x,y,width,height);
+}
+
+void Gtk::Style::draw_polygon_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, ShadowType shadow_type, const Gdk::Rectangle& area, Widget* widget, const Glib::ustring& detail, GdkPoint* point, int npoints, bool fill) 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->draw_polygon)
+    (*base->draw_polygon)(gobj(),Glib::unwrap(window),((GtkStateType)(state_type)),((GtkShadowType)(shadow_type)),const_cast<GdkRectangle*>(area.gobj()),(GtkWidget*)Glib::unwrap(widget),detail.c_str(),point,npoints,static_cast<int>(fill));
+}
+
+void Gtk::Style::draw_arrow_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, ShadowType shadow_type, const Gdk::Rectangle& area, Widget* widget, const Glib::ustring& detail, Gtk::ArrowType arrow_type, bool fill, int x, int y, int width, int height) 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->draw_arrow)
+    (*base->draw_arrow)(gobj(),Glib::unwrap(window),((GtkStateType)(state_type)),((GtkShadowType)(shadow_type)),const_cast<GdkRectangle*>(area.gobj()),(GtkWidget*)Glib::unwrap(widget),detail.c_str(),((GtkArrowType)(arrow_type)),static_cast<int>(fill),x,y,width,height);
+}
+
+void Gtk::Style::draw_diamond_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, ShadowType shadow_type, const Gdk::Rectangle& area, Widget* widget, const Glib::ustring& detail, int x, int y, int width, int height) 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->draw_diamond)
+    (*base->draw_diamond)(gobj(),Glib::unwrap(window),((GtkStateType)(state_type)),((GtkShadowType)(shadow_type)),const_cast<GdkRectangle*>(area.gobj()),(GtkWidget*)Glib::unwrap(widget),detail.c_str(),x,y,width,height);
+}
+
+void Gtk::Style::draw_string_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, const Gdk::Rectangle& area, Widget* widget, const Glib::ustring& detail, int x, int y, const Glib::ustring& string) 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->draw_string)
+    (*base->draw_string)(gobj(),Glib::unwrap(window),((GtkStateType)(state_type)),const_cast<GdkRectangle*>(area.gobj()),(GtkWidget*)Glib::unwrap(widget),detail.c_str(),x,y,string.c_str());
+}
+
+void Gtk::Style::draw_box_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, ShadowType shadow_type, const Gdk::Rectangle& area, Widget* widget, const Glib::ustring& detail, int x, int y, int width, int height) 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->draw_box)
+    (*base->draw_box)(gobj(),Glib::unwrap(window),((GtkStateType)(state_type)),((GtkShadowType)(shadow_type)),const_cast<GdkRectangle*>(area.gobj()),(GtkWidget*)Glib::unwrap(widget),detail.c_str(),x,y,width,height);
+}
+
+void Gtk::Style::draw_flat_box_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, ShadowType shadow_type, const Gdk::Rectangle& area, Widget* widget, const Glib::ustring& detail, int x, int y, int width, int height) 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->draw_flat_box)
+    (*base->draw_flat_box)(gobj(),Glib::unwrap(window),((GtkStateType)(state_type)),((GtkShadowType)(shadow_type)),const_cast<GdkRectangle*>(area.gobj()),(GtkWidget*)Glib::unwrap(widget),detail.c_str(),x,y,width,height);
+}
+
+void Gtk::Style::draw_check_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, ShadowType shadow_type, const Gdk::Rectangle& area, Widget* widget, const Glib::ustring& detail, int x, int y, int width, int height) 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->draw_check)
+    (*base->draw_check)(gobj(),Glib::unwrap(window),((GtkStateType)(state_type)),((GtkShadowType)(shadow_type)),const_cast<GdkRectangle*>(area.gobj()),(GtkWidget*)Glib::unwrap(widget),detail.c_str(),x,y,width,height);
+}
+
+void Gtk::Style::draw_option_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, ShadowType shadow_type, const Gdk::Rectangle& area, Widget* widget, const Glib::ustring& detail, int x, int y, int width, int height) 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->draw_option)
+    (*base->draw_option)(gobj(),Glib::unwrap(window),((GtkStateType)(state_type)),((GtkShadowType)(shadow_type)),const_cast<GdkRectangle*>(area.gobj()),(GtkWidget*)Glib::unwrap(widget),detail.c_str(),x,y,width,height);
+}
+
+void Gtk::Style::draw_tab_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, ShadowType shadow_type, const Gdk::Rectangle& area, Widget* widget, const Glib::ustring& detail, int x, int y, int width, int height) 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->draw_tab)
+    (*base->draw_tab)(gobj(),Glib::unwrap(window),((GtkStateType)(state_type)),((GtkShadowType)(shadow_type)),const_cast<GdkRectangle*>(area.gobj()),(GtkWidget*)Glib::unwrap(widget),detail.c_str(),x,y,width,height);
+}
+
+void Gtk::Style::draw_shadow_gap_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, ShadowType shadow_type, const Gdk::Rectangle& area, Widget* widget, const Glib::ustring& detail, int x, int y, int width, int height, Gtk::PositionType gap_side, int gap_x, int gap_width) 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->draw_shadow_gap)
+    (*base->draw_shadow_gap)(gobj(),Glib::unwrap(window),((GtkStateType)(state_type)),((GtkShadowType)(shadow_type)),const_cast<GdkRectangle*>(area.gobj()),(GtkWidget*)Glib::unwrap(widget),detail.c_str(),x,y,width,height,((GtkPositionType)(gap_side)),gap_x,gap_width);
+}
+
+void Gtk::Style::draw_box_gap_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, ShadowType shadow_type, const Gdk::Rectangle& area, Widget* widget, const Glib::ustring& detail, int x, int y, int width, int height, Gtk::PositionType gap_side, int gap_x, int gap_width) 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->draw_box_gap)
+    (*base->draw_box_gap)(gobj(),Glib::unwrap(window),((GtkStateType)(state_type)),((GtkShadowType)(shadow_type)),const_cast<GdkRectangle*>(area.gobj()),(GtkWidget*)Glib::unwrap(widget),detail.c_str(),x,y,width,height,((GtkPositionType)(gap_side)),gap_x,gap_width);
+}
+
+void Gtk::Style::draw_extension_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, ShadowType shadow_type, const Gdk::Rectangle& area, Widget* widget, const Glib::ustring& detail, int x, int y, int width, int height, PositionType gap_side) 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->draw_extension)
+    (*base->draw_extension)(gobj(),Glib::unwrap(window),((GtkStateType)(state_type)),((GtkShadowType)(shadow_type)),const_cast<GdkRectangle*>(area.gobj()),(GtkWidget*)Glib::unwrap(widget),detail.c_str(),x,y,width,height,((GtkPositionType)(gap_side)));
+}
+
+void Gtk::Style::draw_focus_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, const Gdk::Rectangle& area, Widget* widget, const Glib::ustring& detail, int x, int y, int width, int height) 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->draw_focus)
+    (*base->draw_focus)(gobj(),Glib::unwrap(window),((GtkStateType)(state_type)),const_cast<GdkRectangle*>(area.gobj()),(GtkWidget*)Glib::unwrap(widget),detail.c_str(),x,y,width,height);
+}
+
+void Gtk::Style::draw_slider_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, ShadowType shadow_type, const Gdk::Rectangle& area, Widget* widget, const Glib::ustring& detail, int x, int y, int width, int height, Orientation orientation) 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->draw_slider)
+    (*base->draw_slider)(gobj(),Glib::unwrap(window),((GtkStateType)(state_type)),((GtkShadowType)(shadow_type)),const_cast<GdkRectangle*>(area.gobj()),(GtkWidget*)Glib::unwrap(widget),detail.c_str(),x,y,width,height,((GtkOrientation)(orientation)));
+}
+
+void Gtk::Style::draw_handle_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, ShadowType shadow_type, const Gdk::Rectangle& area, Widget* widget, const Glib::ustring& detail, int x, int y, int width, int height, Orientation orientation) 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->draw_handle)
+    (*base->draw_handle)(gobj(),Glib::unwrap(window),((GtkStateType)(state_type)),((GtkShadowType)(shadow_type)),const_cast<GdkRectangle*>(area.gobj()),(GtkWidget*)Glib::unwrap(widget),detail.c_str(),x,y,width,height,((GtkOrientation)(orientation)));
+}
+
+void Gtk::Style::draw_expander_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, const Gdk::Rectangle& area, Widget* widget, const Glib::ustring& detail, int x, int y, ExpanderStyle expander_style) 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->draw_expander)
+    (*base->draw_expander)(gobj(),Glib::unwrap(window),((GtkStateType)(state_type)),const_cast<GdkRectangle*>(area.gobj()),(GtkWidget*)Glib::unwrap(widget),detail.c_str(),x,y,((GtkExpanderStyle)(expander_style)));
+}
+
+void Gtk::Style::draw_layout_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, bool use_text, const Gdk::Rectangle& area, Widget* widget, const Glib::ustring& detail, int x, int y, const Glib::RefPtr<Pango::Layout>& layout) 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->draw_layout)
+    (*base->draw_layout)(gobj(),Glib::unwrap(window),((GtkStateType)(state_type)),static_cast<int>(use_text),const_cast<GdkRectangle*>(area.gobj()),(GtkWidget*)Glib::unwrap(widget),detail.c_str(),x,y,Glib::unwrap(layout));
+}
+
+void Gtk::Style::draw_resize_grip_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, const Gdk::Rectangle& area, Widget* widget, const Glib::ustring& detail, Gdk::WindowEdge edge, int x, int y, int width, int height) 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->draw_resize_grip)
+    (*base->draw_resize_grip)(gobj(),Glib::unwrap(window),((GtkStateType)(state_type)),const_cast<GdkRectangle*>(area.gobj()),(GtkWidget*)Glib::unwrap(widget),detail.c_str(),((GdkWindowEdge)(edge)),x,y,width,height);
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/style.h b/libs/gtkmm2/gtk/gtkmm/style.h
new file mode 100644
index 0000000000..d460abdc61
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/style.h
@@ -0,0 +1,786 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_STYLE_H
+#define _GTKMM_STYLE_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* Copyright (C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+
+#include <pangomm/fontdescription.h>
+#include <pangomm/layout.h>
+
+#include <gdkmm/gc.h>
+#include <gdkmm/pixmap.h>
+#include <gdkmm/types.h>
+#include <gdkmm/window.h>
+
+#include <gtkmm/object.h>
+#include <gtkmm/enums.h>
+#include <gtkmm/iconsource.h>
+#include <gtkmm/iconset.h>
+#include <gtkmmconfig.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkStyle GtkStyle;
+typedef struct _GtkStyleClass GtkStyleClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class Style_Class; } // namespace Gtk
+namespace Gtk
+{
+
+class Widget;
+class RcStyle;
+
+
+class Style : public Glib::Object
+{
+  
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+public:
+  typedef Style CppObjectType;
+  typedef Style_Class CppClassType;
+  typedef GtkStyle BaseObjectType;
+  typedef GtkStyleClass BaseClassType;
+
+private:  friend class Style_Class;
+  static CppClassType style_class_;
+
+private:
+  // noncopyable
+  Style(const Style&);
+  Style& operator=(const Style&);
+
+protected:
+  explicit Style(const Glib::ConstructParams& construct_params);
+  explicit Style(GtkStyle* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+  virtual ~Style();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GObject.
+  GtkStyle*       gobj()       { return reinterpret_cast<GtkStyle*>(gobject_); }
+
+  ///Provides access to the underlying C GObject.
+  const GtkStyle* gobj() const { return reinterpret_cast<GtkStyle*>(gobject_); }
+
+  ///Provides access to the underlying C instance. The caller is responsible for unrefing it. Use when directly setting fields in structs.
+  GtkStyle* gobj_copy();
+
+private:
+
+  
+protected:
+  Style();
+
+public:
+  
+  static Glib::RefPtr<Style> create();
+
+  
+  void set_fg(Gtk::StateType state, const Gdk::Color& color);
+  Gdk::Color get_fg(Gtk::StateType state) const;
+
+  void set_bg(Gtk::StateType state, const Gdk::Color& color);
+  Gdk::Color get_bg(Gtk::StateType state) const;
+
+  void set_light(Gtk::StateType state, const Gdk::Color& color);
+  Gdk::Color get_light(Gtk::StateType state) const;
+
+  void set_dark(Gtk::StateType state, const Gdk::Color& color);
+  Gdk::Color get_dark(Gtk::StateType state) const;
+
+  void set_mid(Gtk::StateType state, const Gdk::Color& color);
+  Gdk::Color get_mid(Gtk::StateType state) const;
+
+  void set_text(Gtk::StateType state, const Gdk::Color& color);
+  Gdk::Color get_text(Gtk::StateType state) const;
+
+  void set_base(Gtk::StateType state, const Gdk::Color& color);
+  Gdk::Color get_base(Gtk::StateType state) const;
+
+  void set_text_aa(Gtk::StateType state, const Gdk::Color& color);
+  Gdk::Color get_text_aa(Gtk::StateType state) const;
+
+
+  void set_black(const Gdk::Color& value);
+  Gdk::Color get_black() const;
+  void set_white(const Gdk::Color& value);
+  Gdk::Color get_white() const;
+
+  void set_font(const Pango::FontDescription& font_desc);
+
+  // These are only available after being attached to a window.
+  Pango::FontDescription get_font() const;
+
+  void set_xthickness(int xthickness);
+  int get_xthickness() const;
+
+  void set_ythickness(int ythickness);
+  int get_ythickness() const;
+
+  Glib::RefPtr<Gdk::GC> get_fg_gc(Gtk::StateType state_type);
+  Glib::RefPtr<const Gdk::GC> get_fg_gc(Gtk::StateType state_type) const;
+
+  Glib::RefPtr<Gdk::GC> get_bg_gc(Gtk::StateType state_type);
+  Glib::RefPtr<const Gdk::GC> get_bg_gc(Gtk::StateType state_type) const;
+
+  Glib::RefPtr<Gdk::GC> get_light_gc(Gtk::StateType state_type);
+  Glib::RefPtr<const Gdk::GC> get_light_gc(Gtk::StateType state_type) const;
+
+  Glib::RefPtr<Gdk::GC> get_dark_gc(Gtk::StateType state_type);
+  Glib::RefPtr<const Gdk::GC> get_dark_gc(Gtk::StateType state_type) const;
+
+  Glib::RefPtr<Gdk::GC> get_mid_gc ( Gtk::StateType state_type);
+  Glib::RefPtr<const Gdk::GC> get_mid_gc ( Gtk::StateType state_type) const;
+
+  Glib::RefPtr<Gdk::GC> get_text_gc(Gtk::StateType state_type);
+  Glib::RefPtr<const Gdk::GC> get_text_gc(Gtk::StateType state_type) const;
+
+  Glib::RefPtr<Gdk::GC> get_base_gc(Gtk::StateType state_type);
+  Glib::RefPtr<const Gdk::GC> get_base_gc(Gtk::StateType state_type) const;
+
+  Glib::RefPtr<Gdk::GC> get_black_gc();
+  Glib::RefPtr<const Gdk::GC> get_black_gc() const;
+  Glib::RefPtr<Gdk::GC> get_white_gc();
+  Glib::RefPtr<const Gdk::GC> get_white_gc() const;
+
+  /* Deprecated in gtkmm 2.2 -- use get_bg() instead.
+   * Honestly, I have absolutely no idea why this method was added
+   * in the first place.  It's basically just confusing since it's
+   * absolutely unrelated to set_background().  Sigh.
+   */
+  Gdk::Color get_background(Gtk::StateType state_type) const;
+
+  /* Deprecated in gtkmm 2.2 -- use get_bg_pixmap() instead.
+   */
+  Glib::RefPtr<Gdk::Pixmap> get_background_pixmap(Gtk::StateType state_type);
+
+  void set_bg_pixmap(Gtk::StateType state_type, const Glib::RefPtr<Gdk::Pixmap>& pixmap);
+  Glib::RefPtr<Gdk::Pixmap>       get_bg_pixmap(Gtk::StateType state_type);
+  Glib::RefPtr<const Gdk::Pixmap> get_bg_pixmap(Gtk::StateType state_type) const;
+
+  
+  /** Draws an arrow in the given rectangle on @a window  using the given 
+   * parameters. @a arrow_type  determines the direction of the arrow.
+   * @param window A Gdk::Window.
+   * @param state_type A state.
+   * @param shadow_type The type of shadow to draw.
+   * @param area Clip rectangle.
+   * @param widget The widget.
+   * @param detail A style detail.
+   * @param arrow_type The type of arrow to draw.
+   * @param fill <tt>true</tt> if the arrow tip should be filled.
+   * @param x X origin of the rectangle to draw the arrow in.
+   * @param y Y origin of the rectangle to draw the arrow in.
+   * @param width Width of the rectangle to draw the arrow in.
+   * @param height Height of the rectangle to draw the arrow in.
+   */
+  void paint_arrow(
+                  const Glib::RefPtr<Gdk::Window>&  window,
+                  Gtk::StateType                    state_type,
+                  ShadowType                        shadow_type,
+                  const Gdk::Rectangle&             area,
+                  Widget&                           widget,
+                  const Glib::ustring&              detail,
+                  ArrowType                         arrow_type,
+                  bool                              fill,
+                  int                               x,
+                  int                               y,
+                  int                               width,
+                  int                               height) const;
+
+  
+  /** Draws a box on @a window  with the given parameters.
+   * @param window A Gdk::Window.
+   * @param state_type A state.
+   * @param shadow_type The type of shadow to draw.
+   * @param area Clip rectangle.
+   * @param widget The widget.
+   * @param detail A style detail.
+   * @param x X origin of the box.
+   * @param y Y origin of the box.
+   * @param width The width of the box.
+   * @param height The height of the box.
+   */
+  void paint_box(
+                  const Glib::RefPtr<Gdk::Window>&  window,
+                  Gtk::StateType                    state_type,
+                  ShadowType                        shadow_type,
+                  const Gdk::Rectangle&             area,
+                  Widget&                           widget,
+                  const Glib::ustring&              detail,
+                  int                               x,
+                  int                               y,
+                  int                               width,
+                  int                               height) const;
+
+  
+  /** Draws a box in @a window  using the given style and state and shadow type, 
+   * leaving a gap in one side.
+   * @param window A Gdk::Window.
+   * @param state_type A state.
+   * @param shadow_type Type of shadow to draw.
+   * @param area Clip rectangle.
+   * @param widget The widget.
+   * @param detail A style detail.
+   * @param x X origin of the rectangle.
+   * @param y Y origin of the rectangle.
+   * @param width Width of the rectangle.
+   * @param height Width of the rectangle.
+   * @param gap_side Side in which to leave the gap.
+   * @param gap_x Starting position of the gap.
+   * @param gap_width Width of the gap.
+   */
+  void paint_box_gap(
+                  const Glib::RefPtr<Gdk::Window>&  window,
+                  Gtk::StateType                    state_type,
+                  ShadowType                        shadow_type,
+                  const Gdk::Rectangle&             area,
+                  Widget&                           widget,
+                  const Glib::ustring&              detail,
+                  int                               x,
+                  int                               y,
+                  int                               width,
+                  int                               height,
+                  PositionType                      gap_side,
+                  int                               gap_x,
+                  int                               gap_width) const;
+
+  
+  /** Draws a check button indicator in the given rectangle on @a window  with 
+   * the given parameters.
+   * @param window A Gdk::Window.
+   * @param state_type A state.
+   * @param shadow_type The type of shadow to draw.
+   * @param area Clip rectangle.
+   * @param widget The widget.
+   * @param detail A style detail.
+   * @param x X origin of the rectangle to draw the check in.
+   * @param y Y origin of the rectangle to draw the check in.
+   * @param width The width of the rectangle to draw the check in.
+   * @param height The height of the rectangle to draw the check in.
+   */
+  void paint_check(
+                  const Glib::RefPtr<Gdk::Window>&  window,
+                  Gtk::StateType                    state_type,
+                  ShadowType                        shadow_type,
+                  const Gdk::Rectangle&             area,
+                  Widget&                           widget,
+                  const Glib::ustring&              detail,
+                  int                               x,
+                  int                               y,
+                  int                               width,
+                  int                               height) const;
+
+  
+  /** Draws a diamond in the given rectangle on @a window  using the given
+   * parameters.
+   * @param window A Gdk::Window.
+   * @param state_type A state.
+   * @param shadow_type The type of shadow to draw.
+   * @param area Clip rectangle.
+   * @param widget The widget.
+   * @param detail A style detail.
+   * @param x X origin of the rectangle to draw the diamond in.
+   * @param y Y origin of the rectangle to draw the diamond in.
+   * @param width Width of the rectangle to draw the diamond in.
+   * @param height Height of the rectangle to draw the diamond in.
+   */
+  void paint_diamond(
+                  const Glib::RefPtr<Gdk::Window>&  window,
+                  Gtk::StateType                    state_type,
+                  ShadowType                        shadow_type,
+                  const Gdk::Rectangle&             area,
+                  Widget&                           widget,
+                  const Glib::ustring&              detail,
+                  int                               x,
+                  int                               y,
+                  int                               width,
+                  int                               height) const;
+
+  
+  /** Draws an extension, i.e.\ a notebook tab.
+   * @param window A Gdk::Window.
+   * @param state_type A state.
+   * @param shadow_type Type of shadow to draw.
+   * @param area Clip rectangle.
+   * @param widget The widget.
+   * @param detail A style detail.
+   * @param x X origin of the extension.
+   * @param y Y origin of the extension.
+   * @param width Width of the extension.
+   * @param height Width of the extension.
+   * @param gap_side The side on to which the extension is attached.
+   */
+  void paint_extension(
+                  const Glib::RefPtr<Gdk::Window>&  window,
+                  Gtk::StateType                    state_type,
+                  ShadowType                        shadow_type,
+                  const Gdk::Rectangle&             area,
+                  Widget&                           widget,
+                  const Glib::ustring&              detail,
+                  int                               x,
+                  int                               y,
+                  int                               width,
+                  int                               height,
+                  PositionType                      gap_side) const;
+
+  
+  /** Draws a flat box on @a window  with the given parameters.
+   * @param window A Gdk::Window.
+   * @param state_type A state.
+   * @param shadow_type The type of shadow to draw.
+   * @param area Clip rectangle.
+   * @param widget The widget.
+   * @param detail A style detail.
+   * @param x X origin of the box.
+   * @param y Y origin of the box.
+   * @param width The width of the box.
+   * @param height The height of the box.
+   */
+  void paint_flat_box(
+                  const Glib::RefPtr<Gdk::Window>&  window,
+                  Gtk::StateType                    state_type,
+                  ShadowType                        shadow_type,
+                  const Gdk::Rectangle&             area,
+                  Widget&                           widget,
+                  const Glib::ustring&              detail,
+                  int                               x,
+                  int                               y,
+                  int                               width,
+                  int                               height) const;
+
+  
+  /** Draws a focus indicator around the given rectangle on @a window  using the
+   * given style.
+   * @param window A Gdk::Window.
+   * @param state_type A state.
+   * @param area Clip rectangle.
+   * @param widget The widget.
+   * @param detail A style detail.
+   * @param x The x origin of the rectangle around which to draw a focus indicator.
+   * @param y The y origin of the rectangle around which to draw a focus indicator.
+   * @param width The width of the rectangle around which to draw a focus indicator.
+   * @param height The height of the rectangle around which to draw a focus indicator.
+   */
+  void paint_focus(
+                  const Glib::RefPtr<Gdk::Window>&  window,
+                  Gtk::StateType                    state_type,
+                  const Gdk::Rectangle&             area,
+                  Widget&                           widget,
+                  const Glib::ustring&              detail,
+                  int                               x,
+                  int                               y,
+                  int                               width,
+                  int                               height) const;
+
+  
+  /** Draws a handle as used in Gtk::HandleBox and Gtk::Paned.
+   * @param window A Gdk::Window.
+   * @param state_type A state.
+   * @param shadow_type Type of shadow to draw.
+   * @param area Clip rectangle.
+   * @param widget The widget.
+   * @param detail A style detail.
+   * @param x X origin of the handle.
+   * @param y Y origin of the handle.
+   * @param width With of the handle.
+   * @param height Height of the handle.
+   * @param orientation The orientation of the handle.
+   */
+  void paint_handle(
+                  const Glib::RefPtr<Gdk::Window>&  window,
+                  Gtk::StateType                    state_type,
+                  ShadowType                        shadow_type,
+                  const Gdk::Rectangle&             area,
+                  Widget&                           widget,
+                  const Glib::ustring&              detail,
+                  int                               x,
+                  int                               y,
+                  int                               width,
+                  int                               height,
+                  Orientation                       orientation) const;
+
+  
+  /** Draws a horizontal line from ( @a x1 , @a y ) to ( @a x2 , @a y ) in @a window 
+   * using the given style and state.
+   * @param window A Gdk::Window.
+   * @param state_type A state.
+   * @param area Rectangle to which the output is clipped.
+   * @param widget The widget.
+   * @param detail A style detail.
+   * @param x1 The starting x coordinate.
+   * @param x2 The ending x coordinate.
+   * @param y The y coordinate.
+   */
+  void paint_hline(
+                  const Glib::RefPtr<Gdk::Window>&  window,
+                  Gtk::StateType                    state_type,
+                  const Gdk::Rectangle&             area,
+                  Widget&                           widget,
+                  const Glib::ustring&              detail,
+                  int                               x1,
+                  int                               x2,
+                  int                               y) const;
+
+  
+  /** Draws a radio button indicator in the given rectangle on @a window  with 
+   * the given parameters.
+   * @param window A Gdk::Window.
+   * @param state_type A state.
+   * @param shadow_type The type of shadow to draw.
+   * @param area Clip rectangle.
+   * @param widget The widget.
+   * @param detail A style detail.
+   * @param x X origin of the rectangle to draw the option in.
+   * @param y Y origin of the rectangle to draw the option in.
+   * @param width The width of the rectangle to draw the option in.
+   * @param height The height of the rectangle to draw the option in.
+   */
+  void paint_option(
+                  const Glib::RefPtr<Gdk::Window>&  window,
+                  Gtk::StateType                    state_type,
+                  ShadowType                        shadow_type,
+                  const Gdk::Rectangle&             area,
+                  Widget&                           widget,
+                  const Glib::ustring&              detail,
+                  int                               x,
+                  int                               y,
+                  int                               width,
+                  int                               height) const;
+
+  void paint_polygon(
+                  const Glib::RefPtr<Gdk::Window>&      window,
+                  Gtk::StateType                        state_type,
+                  ShadowType                            shadow_type,
+                  const Gdk::Rectangle&                 area,
+                  Widget&                               widget,
+                  const Glib::ustring&                  detail,
+                  const Glib::ArrayHandle<Gdk::Point>&  points,
+                  bool                                  fill) const;
+
+  
+  /** Draws a shadow around the given rectangle in @a window  
+   * using the given style and state and shadow type.
+   * @param window A Gdk::Window.
+   * @param state_type A state.
+   * @param shadow_type Type of shadow to draw.
+   * @param area Clip rectangle.
+   * @param widget The widget.
+   * @param detail A style detail.
+   * @param x X origin of the rectangle.
+   * @param y Y origin of the rectangle.
+   * @param width Width of the rectangle.
+   * @param height Width of the rectangle.
+   */
+  void paint_shadow(
+                  const Glib::RefPtr<Gdk::Window>&  window,
+                  Gtk::StateType                    state_type,
+                  ShadowType                        shadow_type,
+                  const Gdk::Rectangle&             area,
+                  Widget&                           widget,
+                  const Glib::ustring&              detail,
+                  int                               x,
+                  int                               y,
+                  int                               width,
+                  int                               height) const;
+
+  
+  /** Draws a shadow around the given rectangle in @a window  
+   * using the given style and state and shadow type, leaving a 
+   * gap in one side.
+   * @param window A Gdk::Window.
+   * @param state_type A state.
+   * @param shadow_type Type of shadow to draw.
+   * @param area Clip rectangle.
+   * @param widget The widget.
+   * @param detail A style detail.
+   * @param x X origin of the rectangle.
+   * @param y Y origin of the rectangle.
+   * @param width Width of the rectangle.
+   * @param height Width of the rectangle.
+   * @param gap_side Side in which to leave the gap.
+   * @param gap_x Starting position of the gap.
+   * @param gap_width Width of the gap.
+   */
+  void paint_shadow_gap(
+                  const Glib::RefPtr<Gdk::Window>&  window,
+                  Gtk::StateType                    state_type,
+                  ShadowType                        shadow_type,
+                  const Gdk::Rectangle&             area,
+                  Widget&                           widget,
+                  const Glib::ustring&              detail,
+                  int                               x,
+                  int                               y,
+                  int                               width,
+                  int                               height,
+                  PositionType                      gap_side,
+                  int                               gap_x,
+                  int                               gap_width) const;
+
+  
+  /** 
+   */
+  void paint_slider(
+                  const Glib::RefPtr<Gdk::Window>&  window,
+                  Gtk::StateType                    state_type,
+                  ShadowType                        shadow_type,
+                  const Gdk::Rectangle&             area,
+                  Widget&                           widget,
+                  const Glib::ustring&              detail,
+                  int                               x,
+                  int                               y,
+                  int                               width,
+                  int                               height,
+                  Orientation                       orientation) const;
+
+  
+  /** Draws an option menu tab (i.e.\ the up and down pointing arrows)
+   * in the given rectangle on @a window  using the given parameters.
+   * @param window A Gdk::Window.
+   * @param state_type A state.
+   * @param shadow_type The type of shadow to draw.
+   * @param area Clip rectangle.
+   * @param widget The widget.
+   * @param detail A style detail.
+   * @param x X origin of the rectangle to draw the tab in.
+   * @param y Y origin of the rectangle to draw the tab in.
+   * @param width The width of the rectangle to draw the tab in.
+   * @param height The height of the rectangle to draw the tab in.
+   */
+  void paint_tab(
+                  const Glib::RefPtr<Gdk::Window>&  window,
+                  Gtk::StateType                    state_type,
+                  ShadowType                        shadow_type,
+                  const Gdk::Rectangle&             area,
+                  Widget&                           widget,
+                  const Glib::ustring&              detail,
+                  int                               x,
+                  int                               y,
+                  int                               width,
+                  int                               height) const;
+
+                  
+  /** Draws a vertical line from ( @a x , @a y1 ) to ( @a x , @a y2 ) in @a window 
+   * using the given style and state.
+   * @param window A Gdk::Window.
+   * @param state_type A state.
+   * @param area Rectangle to which the output is clipped.
+   * @param widget The widget.
+   * @param detail A style detail.
+   * @param y1 The starting y coordinate.
+   * @param y2 The ending y coordinate.
+   * @param x The x coordinate.
+   */
+  void paint_vline(
+                  const Glib::RefPtr<Gdk::Window>&  window,
+                  Gtk::StateType                    state_type,
+                  const Gdk::Rectangle&             area,
+                  Widget&                           widget,
+                  const Glib::ustring&              detail,
+                  int                               y1,
+                  int                               y2,
+                  int                               x) const;
+
+  
+  /** Draws an expander as used in Gtk::TreeView.
+   * @param window A Gdk::Window.
+   * @param state_type A state.
+   * @param area Clip rectangle.
+   * @param widget The widget.
+   * @param detail A style detail.
+   * @param x The x position to draw the expander at.
+   * @param y The y position to draw the expander at.
+   * @param expander_style The style to draw the expander in.
+   */
+  void paint_expander(
+                  const Glib::RefPtr<Gdk::Window>&  window,
+                  Gtk::StateType                    state_type,
+                  const Gdk::Rectangle&             area,
+                  Widget&                           widget,
+                  const Glib::ustring&              detail,
+                  int                               x,
+                  int                               y,
+                  ExpanderStyle                     expander_style) const;
+
+  
+  /** 
+   */
+  void paint_layout(
+                  const Glib::RefPtr<Gdk::Window>&    window,
+                  Gtk::StateType                      state_type,
+                  bool                                use_text,
+                  const Gdk::Rectangle&               area,
+                  Widget&                             widget,
+                  const Glib::ustring&                detail,
+                  int                                 x,
+                  int                                 y,
+                  const Glib::RefPtr<Pango::Layout>&  layout) const;
+
+  
+  /** Draws a resize grip in the given rectangle on @a window  using the given
+   * parameters.
+   * @param window A Gdk::Window.
+   * @param state_type A state.
+   * @param area Clip rectangle.
+   * @param widget The widget.
+   * @param detail A style detail.
+   * @param edge The edge in which to draw the resize grip.
+   * @param x The x origin of the rectangle in which to draw the resize grip.
+   * @param y The y origin of the rectangle in which to draw the resize grip.
+   * @param width The width of the rectangle in which to draw the resize grip.
+   * @param height The height of the rectangle in which to draw the resize grip.
+   */
+  void paint_resize_grip(
+                  const Glib::RefPtr<Gdk::Window>&  window,
+                  Gtk::StateType                    state_type,
+                  const Gdk::Rectangle&             area,
+                  Widget&                           widget,
+                  const Glib::ustring&              detail,
+                  Gdk::WindowEdge                   edge,
+                  int                               x,
+                  int                               y,
+                  int                               width,
+                  int                               height) const;
+
+
+  Glib::RefPtr<Style> copy();
+
+  // These are worthless to the users - they should use set_style instead.
+  
+  //_WRAP_METHOD(Glib::RefPtr<Style> attach(const Glib::RefPtr<Gdk::Window>& window), gtk_style_attach)
+  //_WRAP_METHOD(void detach(), gtk_style_detach)
+
+  
+  /** Sets the background of @a window  to the background color or pixmap
+   * specified by @a style  for the given state.
+   * @param window A Gdk::Window.
+   * @param state_type A state.
+   */
+  void set_background(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type);
+
+  
+  void apply_default_background(const Glib::RefPtr<Gdk::Window>& window, bool set_bg,
+	              Gtk::StateType state_type, const Gdk::Rectangle& area,
+	              int x, int y, int width, int height);
+
+  
+  IconSet lookup_icon_set(const Gtk::StockID& stock_id);
+
+  
+  /** Renders the icon specified by @a source  at the given @a size  
+   * according to the given parameters and returns the result in a 
+   * pixbuf.
+   * @param source The Gtk::IconSource specifying the icon to render.
+   * @param direction A text direction.
+   * @param state A state.
+   * @param size The size to render the icon at. A size of (GtkIconSize)-1
+   * means render at the size of the source and don't scale.
+   * @param widget The widget.
+   * @param detail A style detail.
+   * @return A newly-created Gdk::Pixbuf containing the rendered icon.
+   */
+  Glib::RefPtr<Gdk::Pixbuf> render_icon(const IconSource& source,
+                                       Gtk::TextDirection direction, Gtk::StateType state, Gtk::IconSize size,
+                                       Gtk::Widget& widget, const Glib::ustring& detail);
+
+protected:
+    virtual void realize_vfunc();
+    virtual void unrealize_vfunc();
+    virtual void copy_vfunc(const Glib::RefPtr<Style>& src);
+    virtual Glib::RefPtr<Style> clone_vfunc();
+    virtual void init_from_rc_vfunc(const Glib::RefPtr<RcStyle>& rc_style);
+    virtual void set_background_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type);
+
+    virtual Glib::RefPtr<Gdk::Pixbuf> render_icon_vfunc(const IconSource& source, TextDirection direction, Gtk::StateType state, IconSize size, Widget* widget, const Glib::ustring& detail);
+    virtual void draw_hline_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, const Gdk::Rectangle& area, Widget* widget, const Glib::ustring& detail, int x1, int x2, int y);
+    virtual void draw_vline_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, const Gdk::Rectangle& area, Widget* widget, const Glib::ustring& detail, int y1, int y2, int x);
+    virtual void draw_shadow_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, ShadowType shadow_type, const Gdk::Rectangle& area, Widget* widget, const Glib::ustring& detail, int x, int y, int width, int height);
+    virtual void draw_polygon_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, ShadowType shadow_type, const Gdk::Rectangle& area, Widget* widget, const Glib::ustring& detail, GdkPoint* point, int npoints, bool fill);
+    virtual void draw_arrow_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, ShadowType shadow_type, const Gdk::Rectangle& area, Widget* widget, const Glib::ustring& detail, Gtk::ArrowType arrow_type, bool fill, int x, int y, int width, int height);
+    virtual void draw_diamond_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, ShadowType shadow_type, const Gdk::Rectangle& area, Widget* widget, const Glib::ustring& detail, int x, int y, int width, int height);
+    virtual void draw_string_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, const Gdk::Rectangle& area, Widget* widget, const Glib::ustring& detail, int x, int y, const Glib::ustring& string);
+    virtual void draw_box_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, ShadowType shadow_type, const Gdk::Rectangle& area, Widget* widget, const Glib::ustring& detail, int x, int y, int width, int height);
+    virtual void draw_flat_box_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, ShadowType shadow_type, const Gdk::Rectangle& area, Widget* widget, const Glib::ustring& detail, int x, int y, int width, int height);
+    virtual void draw_check_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, ShadowType shadow_type, const Gdk::Rectangle& area, Widget* widget, const Glib::ustring& detail, int x, int y, int width, int height);
+    virtual void draw_option_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, ShadowType shadow_type, const Gdk::Rectangle& area, Widget* widget, const Glib::ustring& detail, int x, int y, int width, int height);
+    virtual void draw_tab_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, ShadowType shadow_type, const Gdk::Rectangle& area, Widget* widget, const Glib::ustring& detail, int x, int y, int width, int height);
+    virtual void draw_shadow_gap_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, ShadowType shadow_type, const Gdk::Rectangle& area, Widget* widget, const Glib::ustring& detail, int x, int y, int width, int height, Gtk::PositionType gap_side, int gap_x, int gap_width);
+    virtual void draw_box_gap_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, ShadowType shadow_type, const Gdk::Rectangle& area, Widget* widget, const Glib::ustring& detail, int x, int y, int width, int height, Gtk::PositionType gap_side, int gap_x, int gap_width);
+    virtual void draw_extension_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, ShadowType shadow_type, const Gdk::Rectangle& area, Widget* widget, const Glib::ustring& detail, int x, int y, int width, int height, PositionType gap_side);
+    virtual void draw_focus_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, const Gdk::Rectangle& area, Widget* widget, const Glib::ustring& detail, int x, int y, int width, int height);
+    virtual void draw_slider_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, ShadowType shadow_type, const Gdk::Rectangle& area, Widget* widget, const Glib::ustring& detail, int x, int y, int width, int height, Orientation orientation);
+    virtual void draw_handle_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, ShadowType shadow_type, const Gdk::Rectangle& area, Widget* widget, const Glib::ustring& detail, int x, int y, int width, int height, Orientation orientation);
+    virtual void draw_expander_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, const Gdk::Rectangle& area, Widget* widget, const Glib::ustring& detail, int x, int y, ExpanderStyle expander_style);
+    virtual void draw_layout_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, bool use_text, const Gdk::Rectangle& area, Widget* widget, const Glib::ustring& detail, int x, int y, const Glib::RefPtr<Pango::Layout>& layout);
+    virtual void draw_resize_grip_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, const Gdk::Rectangle& area, Widget* widget, const Glib::ustring& detail, Gdk::WindowEdge edge, int x, int y, int width, int height);
+
+  
+  Glib::SignalProxy0< void > signal_realize();
+
+  
+  Glib::SignalProxy0< void > signal_unrealize();
+
+
+public:
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+  virtual void on_realize();
+  virtual void on_unrealize();
+
+
+};
+
+} // namespace Gtk
+
+
+namespace Glib
+{
+  /** @relates Gtk::Style
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Glib::RefPtr<Gtk::Style> wrap(GtkStyle* object, bool take_copy = false);
+}
+
+
+#endif /* _GTKMM_STYLE_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/table.cc b/libs/gtkmm2/gtk/gtkmm/table.cc
new file mode 100644
index 0000000000..7fd5cb8292
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/table.cc
@@ -0,0 +1,406 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/table.h>
+#include <gtkmm/private/table_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* 
+ *
+ * Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtk/gtktable.h>
+
+namespace Gtk
+{
+
+namespace Table_Helpers
+{
+
+Widget* Child::get_widget() const
+{
+  return Glib::wrap(gobj()->widget);
+}
+
+guint16 Child::get_left_attach() const
+{
+  return gobj()->left_attach;
+}
+
+
+guint16 Child::get_right_attach() const
+{
+  return gobj()->right_attach;
+}
+
+guint16 Child::get_top_attach() const
+{
+  return gobj()->top_attach;
+}
+
+guint16 Child::get_bottom_attach() const
+{
+  return gobj()->bottom_attach;
+}
+
+guint16 Child::get_xpadding() const
+{
+  return gobj()->xpadding;
+}
+
+guint16 Child::get_ypadding() const
+{
+  return gobj()->ypadding;
+}
+
+bool Child::get_xexpand() const
+{
+  return (bool)gobj()->xexpand;
+}
+
+bool Child::get_yexpand() const
+{
+  return (bool)gobj()->yexpand;
+}
+
+bool Child::get_xshrink() const
+{
+  return (bool)gobj()->xshrink;
+}
+bool Child::get_yshrink() const
+{
+  return (bool)gobj()->yshrink;
+}
+
+bool Child::get_xfill() const
+{
+  return (bool)gobj()->xfill;
+}
+
+bool Child::get_yfill() const
+{
+  return (bool)gobj()->yfill;
+}
+
+
+} //namespace Table_Helpers
+
+
+void Table::set_spacings(guint spacing)
+{
+  set_row_spacings(spacing);
+  set_col_spacings(spacing);
+}
+
+Table::TableList& Table::children()
+{
+  children_proxy_ = TableList(gobj());
+  return children_proxy_;
+}
+
+const Table::TableList& Table::children() const
+{
+  children_proxy_ = TableList(const_cast<GtkTable*>(gobj()));
+  return children_proxy_;
+}
+
+
+} /* namespace Gtk */
+
+
+namespace
+{
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Gtk::Table* wrap(GtkTable* object, bool take_copy)
+{
+  return dynamic_cast<Gtk::Table *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& Table_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &Table_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_table_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void Table_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+}
+
+
+Glib::ObjectBase* Table_Class::wrap_new(GObject* o)
+{
+  return manage(new Table((GtkTable*)(o)));
+
+}
+
+
+/* The implementation: */
+
+Table::Table(const Glib::ConstructParams& construct_params)
+:
+  Gtk::Container(construct_params)
+{
+  }
+
+Table::Table(GtkTable* castitem)
+:
+  Gtk::Container((GtkContainer*)(castitem))
+{
+  }
+
+Table::~Table()
+{
+  destroy_();
+}
+
+Table::CppClassType Table::table_class_; // initialize static member
+
+GType Table::get_type()
+{
+  return table_class_.init().get_type();
+}
+
+GType Table::get_base_type()
+{
+  return gtk_table_get_type();
+}
+
+
+namespace Table_Helpers
+{
+
+void TableList::remove(const_reference child)
+{
+  gtk_container_remove(GTK_CONTAINER(gparent_),
+                       (GtkWidget*)(child.gobj()));
+}
+
+void TableList::remove(Widget& widget)
+{
+  gtk_container_remove(GTK_CONTAINER(gparent_), (GtkWidget*)(widget.gobj()));
+}
+
+TableList::iterator TableList::erase(iterator position)
+{
+  //Check that it is a valid iterator, to a real item:
+  if ( !position.node_|| (position == end()) )
+    return end();
+
+  //Get an iterator the the next item, to return:
+  iterator next = position;
+  next++;
+
+  //Use GTK+ C function to remove it, by providing the GtkWidget*:
+  gtk_container_remove( GTK_CONTAINER(gparent_), (GtkWidget*)(position->gobj()) );
+  return next;
+}
+
+} /* namespace Table_Helpers */
+
+
+namespace Table_Helpers
+{
+
+TableList::TableList()
+{}
+
+TableList::TableList(GtkTable* gparent)
+: type_base((GObject*)gparent)
+{}
+
+TableList::TableList(const TableList& src)
+:
+  type_base(src)
+{}
+
+TableList& TableList::operator=(const TableList& src)
+{
+  type_base::operator=(src);
+  return *this;
+}
+
+GList*& TableList::glist() const
+{
+  return ((GtkTable*)gparent_)->children;
+}
+
+void TableList::erase(iterator start, iterator stop)
+{
+  type_base::erase(start, stop);
+}
+
+GtkTable* TableList::gparent()
+{
+  return (GtkTable*)type_base::gparent();
+}
+
+const GtkTable* TableList::gparent() const
+{
+  return (GtkTable*)type_base::gparent();
+}
+
+TableList::reference TableList::operator[](size_type l) const
+{
+  return type_base::operator[](l);
+}
+
+} /* namespace Table_Helpers */
+
+Table::Table(guint n_rows, guint n_columns, bool homogeneous)
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Container(Glib::ConstructParams(table_class_.init(), "n_rows", n_rows, "n_columns", n_columns, "homogeneous", static_cast<int>(homogeneous), (char*) 0))
+{
+  }
+
+void Table::attach(Widget& child, guint left_attach, guint right_attach, guint top_attach, guint bottom_attach, AttachOptions xoptions, AttachOptions yoptions, guint xpadding, guint ypadding)
+{
+  gtk_table_attach(gobj(), (child).gobj(), left_attach, right_attach, top_attach, bottom_attach, ((GtkAttachOptions)(xoptions)), ((GtkAttachOptions)(yoptions)), xpadding, ypadding);
+}
+
+void Table::resize(guint rows, guint columns)
+{
+  gtk_table_resize(gobj(), rows, columns);
+}
+
+void Table::set_row_spacing(guint row, guint spacing)
+{
+  gtk_table_set_row_spacing(gobj(), row, spacing);
+}
+
+guint Table::get_row_spacing(guint row) const
+{
+  return gtk_table_get_row_spacing(const_cast<GtkTable*>(gobj()), row);
+}
+
+void Table::set_col_spacing(guint column, guint spacing)
+{
+  gtk_table_set_col_spacing(gobj(), column, spacing);
+}
+
+guint Table::get_col_spacing(guint column) const
+{
+  return gtk_table_get_col_spacing(const_cast<GtkTable*>(gobj()), column);
+}
+
+void Table::set_row_spacings(guint spacing)
+{
+  gtk_table_set_row_spacings(gobj(), spacing);
+}
+
+void Table::set_col_spacings(guint spacing)
+{
+  gtk_table_set_col_spacings(gobj(), spacing);
+}
+
+guint Table::get_default_row_spacing()
+{
+  return gtk_table_get_default_row_spacing(gobj());
+}
+
+guint Table::get_default_col_spacing()
+{
+  return gtk_table_get_default_col_spacing(gobj());
+}
+
+void Table::set_homogeneous(bool homogeneous)
+{
+  gtk_table_set_homogeneous(gobj(), static_cast<int>(homogeneous));
+}
+
+bool Table::get_homogeneous() const
+{
+  return gtk_table_get_homogeneous(const_cast<GtkTable*>(gobj()));
+}
+
+
+Glib::PropertyProxy<guint> Table::property_n_rows() 
+{
+  return Glib::PropertyProxy<guint>(this, "n-rows");
+}
+
+Glib::PropertyProxy_ReadOnly<guint> Table::property_n_rows() const
+{
+  return Glib::PropertyProxy_ReadOnly<guint>(this, "n-rows");
+}
+
+Glib::PropertyProxy<guint> Table::property_n_columns() 
+{
+  return Glib::PropertyProxy<guint>(this, "n-columns");
+}
+
+Glib::PropertyProxy_ReadOnly<guint> Table::property_n_columns() const
+{
+  return Glib::PropertyProxy_ReadOnly<guint>(this, "n-columns");
+}
+
+Glib::PropertyProxy<guint> Table::property_column_spacing() 
+{
+  return Glib::PropertyProxy<guint>(this, "column-spacing");
+}
+
+Glib::PropertyProxy_ReadOnly<guint> Table::property_column_spacing() const
+{
+  return Glib::PropertyProxy_ReadOnly<guint>(this, "column-spacing");
+}
+
+Glib::PropertyProxy<guint> Table::property_row_spacing() 
+{
+  return Glib::PropertyProxy<guint>(this, "row-spacing");
+}
+
+Glib::PropertyProxy_ReadOnly<guint> Table::property_row_spacing() const
+{
+  return Glib::PropertyProxy_ReadOnly<guint>(this, "row-spacing");
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/table.h b/libs/gtkmm2/gtk/gtkmm/table.h
new file mode 100644
index 0000000000..5dd6a8987e
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/table.h
@@ -0,0 +1,379 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_TABLE_H
+#define _GTKMM_TABLE_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* Copyright (C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <glibmm/helperlist.h>
+#include <gtkmm/container.h>
+#include <gtkmm/enums.h>
+#include <gtk/gtktable.h> /* for GtkTableChild */
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkTable GtkTable;
+typedef struct _GtkTableClass GtkTableClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class Table_Class; } // namespace Gtk
+namespace Gtk
+{
+
+class Table;
+
+namespace Table_Helpers
+{
+
+class Child : protected _GtkTableChild
+{
+private:
+  Child& operator=(const Child&); //Not implemented.
+  Child(const Child&); //Not implemented.
+
+public:
+  inline _GtkTableChild* gobj() {return (this);}
+  inline const _GtkTableChild* gobj() const {return (this);}
+
+  Widget* get_widget() const;
+
+  //TODO: Which of the GtkTableChild's fields are public API?
+  //Maybe we should remove some of these get()s or add some set()s.
+  //If get_widget() is the only accessor, then we should probably make
+  //the STL-style Table list contain Widgets instead of Childs.
+
+  guint16 get_left_attach() const;
+  guint16 get_right_attach() const;
+  guint16 get_top_attach() const;
+  guint16 get_bottom_attach() const;
+  guint16 get_xpadding() const;
+  guint16 get_ypadding() const;
+  bool get_xexpand() const;
+  bool get_yexpand() const;
+  bool get_xshrink() const;
+  bool get_yshrink() const;
+  bool get_xfill() const;
+  bool get_yfill() const;
+
+protected:
+  inline GtkTable* parent()
+    { return (GtkTable*) (gobj()->widget->parent); }
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  friend class Dummy_; // silence the compiler (Child has only private ctors)
+#endif
+};
+
+
+class TableList : public Glib::HelperList< Child, Widget, Glib::List_Iterator< Child > >
+{
+public:
+  TableList();
+  explicit TableList(GtkTable* gparent);
+  TableList(const TableList& src);
+  virtual ~TableList() {}
+
+  TableList& operator=(const TableList& src);
+
+  typedef Glib::HelperList< Child, Widget,  Glib::List_Iterator< Child > > type_base;
+
+  GtkTable* gparent();
+  const GtkTable* gparent() const;
+
+  virtual GList*& glist() const;      // front of list
+
+  virtual void erase(iterator start, iterator stop);
+  virtual iterator erase(iterator);  //Implented as custom or by LIST_CONTAINER_REMOVE
+  virtual void remove(const_reference); //Implented as custom or by LIST_CONTAINER_REMOVE
+
+  /// This is order n. (use at own risk)
+  reference operator[](size_type l) const;
+
+protected:
+  //Hide these because its read-only:
+  iterator insert(iterator position, element_type& e);
+
+  inline void pop_front();
+  inline void pop_back();
+
+
+  //The standard iterator, instead of List_Cpp_Iterator,
+  //only works because Child is derived from _GtkTableChild.
+
+  
+virtual void remove(Widget& w); //Implented as custom or by LIST_CONTAINER_REMOVE
+
+  };
+
+
+} // namespace Table_Helpers
+
+
+/** Pack widgets in regular patterns.
+ * @ingroup Widgets
+ * @ingroup Containers
+ * Gtk::Table is one of the primary ways of grouping widgets together.  It
+ * consists of a set of lattice points to to which widgets can be attached.
+ * There are <em>rows</em>&nbsp;+&nbsp;1 lattice points vertically and
+ * <em>columns</em>&nbsp;+&nbsp;1 lattice points horizontally.  Lattice points
+ * start counting from 0.  Lattice points can either be specified to be
+ * <em>homogeneous</em>, meaning equally spaced, or not <em>homogeneous</em>,
+ * meaning each cell should be calculated based on the widgets contained in the
+ * row and column. The <em>homogeneous</em> property defaults to false.
+ *
+ * Widgets can be attached to the table by specifying the top, bottom, left and
+ * right points corresponding to upper, lefthand lattice point and the lower,
+ * righthand lattice point which the widget should span.  Widgets can either be
+ * contained in a cell or may span cells.  A number of options control the
+ * resizing behavior of widgets contained in the table.
+ *
+ * @par Packing options:
+ * There are a number of packing options that can be specified when adding a
+ * widget.  With <tt>Gtk::EXPAND</tt>, the lattice is allowed to grow to fill
+ * space.  With <tt>Gtk::SHRINK</tt>, the lattice is allowed to shrink when
+ * resized.  It is also possible to specify the behaviour of the widgets
+ * allocation within the table.  The flag <tt>Gtk::FILL</tt> declares the
+ * widget should grow to fill lattice.  If this is not set any extra space is
+ * used as padding.  The default is <tt>(Gtk::FILL&nbsp;|&nbsp;Gtk::EXPAND)</tt>.
+ *
+ * @par Table sizing:
+ * The table size is calculated based on the size of the widgets contained
+ * within and the restrictions imposed by specified options.  Padding and
+ * spacing can be used in the table.  Padding is added on either side of a
+ * widget, while spacing is placed between widgets.
+ *
+ * @see Gtk::HBox, Gtk::VBox
+ */
+
+class Table : public Container
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Table CppObjectType;
+  typedef Table_Class CppClassType;
+  typedef GtkTable BaseObjectType;
+  typedef GtkTableClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~Table();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class Table_Class;
+  static CppClassType table_class_;
+
+  // noncopyable
+  Table(const Table&);
+  Table& operator=(const Table&);
+
+protected:
+  explicit Table(const Glib::ConstructParams& construct_params);
+  explicit Table(GtkTable* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GtkTable*       gobj()       { return reinterpret_cast<GtkTable*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GtkTable* gobj() const { return reinterpret_cast<GtkTable*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+private:
+
+  
+public:
+  explicit Table(guint n_rows = 1, guint n_columns = 1, bool homogeneous = false);
+
+  
+        void attach(Widget& child,
+                    guint left_attach, guint right_attach,
+                    guint top_attach, guint bottom_attach,
+                    AttachOptions xoptions = FILL | EXPAND, AttachOptions yoptions = FILL | EXPAND,
+                    guint xpadding = 0, guint ypadding = 0);
+
+
+  void resize(guint rows, guint columns);
+
+
+  void set_row_spacing(guint row, guint spacing);
+  
+  /** Gets the amount of space between row @a row , and
+   * row @a row  + 1. See set_row_spacing().
+   * @param row A row in the table, 0 indicates the first row.
+   * @return The row spacing.
+   */
+  guint get_row_spacing(guint row) const;
+
+  
+  void set_col_spacing(guint column, guint spacing);
+  
+  /** Gets the amount of space between column @a col , and
+   * column @a col  + 1. See set_col_spacing().
+   * @param column A column in the table, 0 indicates the first column.
+   * @return The column spacing.
+   */
+  guint get_col_spacing(guint column) const;
+
+  
+  void set_row_spacings(guint spacing);
+
+  
+  void set_col_spacings(guint spacing);
+
+  void set_spacings(guint spacing);
+
+  
+  /** Gets the default row spacing for the table. This is
+   * the spacing that will be used for newly added rows.
+   * (See set_row_spacings())
+   * @return Value: the default row spacing.
+   */
+  guint get_default_row_spacing();
+  
+  /** Gets the default column spacing for the table. This is
+   * the spacing that will be used for newly added columns.
+   * (See set_col_spacings())
+   * @return Value: the default column spacing.
+   */
+  guint get_default_col_spacing();
+
+  
+  void set_homogeneous(bool homogeneous = true);
+  
+  /** Returns whether the table cells are all constrained to the same
+   * width and height. (See gtk_table_set_homogenous())
+   * @return <tt>true</tt> if the cells are all constrained to the same size.
+   */
+  bool get_homogeneous() const;
+
+  typedef Table_Helpers::TableList TableList;
+
+
+  TableList& children();
+  const TableList& children() const;
+
+  /** The number of rows in the table.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<guint> property_n_rows() ;
+
+/** The number of rows in the table.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<guint> property_n_rows() const;
+
+  /** The number of columns in the table.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<guint> property_n_columns() ;
+
+/** The number of columns in the table.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<guint> property_n_columns() const;
+
+  /** The amount of space between two consecutive columns.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<guint> property_column_spacing() ;
+
+/** The amount of space between two consecutive columns.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<guint> property_column_spacing() const;
+
+  /** The amount of space between two consecutive rows.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<guint> property_row_spacing() ;
+
+/** The amount of space between two consecutive rows.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<guint> property_row_spacing() const;
+
+
+protected:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  mutable TableList children_proxy_;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+};
+
+} // namespace Gtk
+
+
+namespace Glib
+{
+  /** @relates Gtk::Table
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gtk::Table* wrap(GtkTable* object, bool take_copy = false);
+}
+#endif /* _GTKMM_TABLE_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/targetentry.cc b/libs/gtkmm2/gtk/gtkmm/targetentry.cc
new file mode 100644
index 0000000000..e97e8438f5
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/targetentry.cc
@@ -0,0 +1,113 @@
+// -*- c++ -*-
+/* $Id$ */
+
+/* targetentry.cc
+ *
+ * Copyright (C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/targetentry.h>
+
+
+namespace Gtk
+{
+
+TargetEntry::TargetEntry()
+{
+  memset(&gobject_, 0, sizeof(gobject_));
+}
+
+TargetEntry::TargetEntry(const Glib::ustring& target, Gtk::TargetFlags flags, guint info)
+{
+  set_target(target);
+  set_flags(flags);
+  set_info(info);
+}
+
+TargetEntry::TargetEntry(const GtkTargetEntry& gobject)
+{
+  set_target(gobject.target);
+  set_info(gobject.info);
+  set_flags(TargetFlags(gobject.flags));
+}
+
+TargetEntry::TargetEntry(const TargetEntry& src)
+{
+  set_target(src.get_target());
+  set_info(src.get_info());
+  set_flags(src.get_flags());
+}
+
+TargetEntry::~TargetEntry()
+{
+  g_free(gobject_.target);
+}
+
+TargetEntry& TargetEntry::operator=(const TargetEntry& src)
+{
+  if(&src != this)
+  {
+    set_target(src.get_target());
+    set_info(src.get_info());
+    set_flags(src.get_flags());
+  }
+
+  return *this;
+}
+
+Glib::ustring TargetEntry::get_target() const
+{
+  return gobject_.target;
+}
+
+void TargetEntry::set_target(const Glib::ustring& target)
+{
+  gobject_.target = g_strdup(target.c_str());
+}
+
+Gtk::TargetFlags TargetEntry::get_flags() const
+{
+  return (Gtk::TargetFlags)(gobject_.flags);
+}
+
+void TargetEntry::set_flags(Gtk::TargetFlags flags)
+{
+  gobject_.flags = (guint)(flags);
+}
+
+guint TargetEntry::get_info() const
+{
+  return gobject_.info;
+}
+
+void TargetEntry::set_info(guint info)
+{
+  gobject_.info = info;
+}
+
+GtkTargetEntry* TargetEntry::gobj()
+{
+  return &gobject_;
+}
+
+const GtkTargetEntry* TargetEntry::gobj() const
+{
+  return &gobject_;
+}
+
+} /* namespace Gtk */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/targetentry.h b/libs/gtkmm2/gtk/gtkmm/targetentry.h
new file mode 100644
index 0000000000..6b00623adc
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/targetentry.h
@@ -0,0 +1,97 @@
+// -*- c++ -*-
+#ifndef _GTKMM_TARGETENTRY_H
+#define _GTKMM_TARGETENTRY_H
+
+/* $Id$ */
+
+/* targetentry.h
+ *
+ * Copyright (C) 2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <glibmm/utility.h>
+#include <glibmm/ustring.h>
+#include <glibmm/arrayhandle.h>
+#include <gtkmm/enums.h>
+#include <gtk/gtkselection.h> //For GtkTargetEntry.
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+extern "C"
+{
+  typedef struct _GtkTargetEntry GtkTargetEntry;
+}
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+namespace Gtk
+{
+
+class TargetEntry
+{
+public:
+  TargetEntry();
+  explicit TargetEntry(const Glib::ustring& target, Gtk::TargetFlags flags = Gtk::TargetFlags(0), guint info = 0);
+  explicit TargetEntry(const GtkTargetEntry& gobject);
+  TargetEntry(const TargetEntry& src);
+  virtual ~TargetEntry();
+
+  TargetEntry& operator=(const TargetEntry& src);
+
+  Glib::ustring get_target() const;
+  void set_target(const Glib::ustring& target);
+
+  Gtk::TargetFlags get_flags() const;
+  void set_flags(Gtk::TargetFlags flags);
+
+  guint get_info() const;
+  void set_info(guint info);
+
+  //Use this when you have to use an array of GdkTargetEntrys
+  //This TargetEntry will still own the string memory.
+  GtkTargetEntry* gobj();
+  const GtkTargetEntry* gobj() const;
+
+protected:
+  GtkTargetEntry gobject_;
+};
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+struct TargetEntry_Traits
+{
+  typedef TargetEntry CppType;
+  typedef GtkTargetEntry CType;
+  typedef GtkTargetEntry CTypeNonConst;
+
+  static const CType& to_c_type(const CppType& item)
+    { return *item.gobj(); }
+
+  static const CType& to_c_type(const CType& item)
+    { return item; }
+
+  static CppType to_cpp_type(const CType& item)
+    { return TargetEntry(item); /* copies string */}
+
+  static void release_c_type(const CType&) {}
+};
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+typedef Glib::ArrayHandle< TargetEntry, TargetEntry_Traits > ArrayHandle_TargetEntry;
+
+} /* namespace Gtk */
+
+
+#endif /* _GTKMM_TARGETENTRY_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/targetlist.cc b/libs/gtkmm2/gtk/gtkmm/targetlist.cc
new file mode 100644
index 0000000000..8629b4f1a9
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/targetlist.cc
@@ -0,0 +1,129 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/targetlist.h>
+#include <gtkmm/private/targetlist_p.h>
+
+#include <gtk/gtkselection.h>
+/* Copyright 2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+namespace Gtk
+{
+
+Glib::RefPtr<Gtk::TargetList> TargetList::create(const ArrayHandle_TargetEntry& targets)
+{
+  return Glib::wrap(gtk_target_list_new(targets.data(), targets.size()));
+}
+
+void TargetList::add(const ArrayHandle_TargetEntry& targets)
+{
+  gtk_target_list_add_table(gobj(), targets.data(), targets.size());
+}
+
+} // namespace Gtk
+
+
+namespace
+{
+} // anonymous namespace
+
+
+/* Why reinterpret_cast<TargetList*>(gobject) is needed:
+ *
+ * A TargetList instance is in fact always a GtkTargetList instance.
+ * Unfortunately, GtkTargetList cannot be a member of TargetList,
+ * because it is an opaque struct.  Also, the C interface does not provide
+ * any hooks to install a destroy notification handler, thus we cannot
+ * wrap it dynamically either.
+ *
+ * The cast works because TargetList does not have any member data, and
+ * it is impossible to derive from it.  This is ensured by not implementing
+ * the (protected) default constructor.  The ctor is protected rather than
+ * private just to avoid a compile warning.
+ */
+
+namespace Glib
+{
+
+Glib::RefPtr<Gtk::TargetList> wrap(GtkTargetList* object, bool take_copy)
+{
+  if(take_copy && object)
+    gtk_target_list_ref(object);
+
+  // See the comment at the top of this file, if you want to know why the cast works.
+  return Glib::RefPtr<Gtk::TargetList>(reinterpret_cast<Gtk::TargetList*>(object));
+}
+
+} // namespace Glib
+
+
+namespace Gtk
+{
+
+
+void TargetList::reference() const
+{
+  // See the comment at the top of this file, if you want to know why the cast works.
+  gtk_target_list_ref(reinterpret_cast<GtkTargetList*>(const_cast<TargetList*>(this)));
+}
+
+void TargetList::unreference() const
+{
+  // See the comment at the top of this file, if you want to know why the cast works.
+  gtk_target_list_unref(reinterpret_cast<GtkTargetList*>(const_cast<TargetList*>(this)));
+}
+
+GtkTargetList* TargetList::gobj()
+{
+  // See the comment at the top of this file, if you want to know why the cast works.
+  return reinterpret_cast<GtkTargetList*>(this);
+}
+
+const GtkTargetList* TargetList::gobj() const
+{
+  // See the comment at the top of this file, if you want to know why the cast works.
+  return reinterpret_cast<const GtkTargetList*>(this);
+}
+
+GtkTargetList* TargetList::gobj_copy() const
+{
+  // See the comment at the top of this file, if you want to know why the cast works.
+  GtkTargetList *const gobject = reinterpret_cast<GtkTargetList*>(const_cast<TargetList*>(this));
+  gtk_target_list_ref(gobject);
+  return gobject;
+}
+
+
+void TargetList::add(const Glib::ustring& target, TargetFlags flags, guint info)
+{
+  gtk_target_list_add(gobj(), Gdk::AtomString::to_c_type(target), (guint)(flags), info);
+}
+
+void TargetList::remove(const Glib::ustring& target)
+{
+  gtk_target_list_remove(gobj(), Gdk::AtomString::to_c_type(target));
+}
+
+bool TargetList::find(const Glib::ustring& target, guint* info) const
+{
+  return gtk_target_list_find(const_cast<GtkTargetList*>(gobj()), Gdk::AtomString::to_c_type(target), info);
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/targetlist.h b/libs/gtkmm2/gtk/gtkmm/targetlist.h
new file mode 100644
index 0000000000..286d533ee1
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/targetlist.h
@@ -0,0 +1,97 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_TARGETLIST_H
+#define _GTKMM_TARGETLIST_H
+
+#include <glibmm.h>
+
+/* Copyright(C) 2002 The gtkmm Development Team
+ *
+ * This library is free software, ) you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library, ) if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+
+#include <gtkmm/enums.h>
+#include <gtkmm/targetentry.h>
+#include <gdkmm/types.h>
+
+
+namespace Gtk
+{
+
+class TargetList
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef TargetList CppObjectType;
+  typedef GtkTargetList BaseObjectType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+  // For use with Glib::RefPtr<> only.
+  void reference()   const;
+  void unreference() const;
+
+  ///Provides access to the underlying C instance.
+  GtkTargetList*       gobj();
+
+  ///Provides access to the underlying C instance.
+  const GtkTargetList* gobj() const;
+
+  ///Provides access to the underlying C instance. The caller is responsible for unrefing it. Use when directly setting fields in structs.
+  GtkTargetList* gobj_copy() const;
+
+protected:
+  // Do not derive this.  Gtk::TargetList can neither be constructed nor deleted.
+  TargetList();
+  void operator delete(void*, size_t);
+
+private:
+  // noncopyable
+  TargetList(const TargetList&);
+  TargetList& operator=(const TargetList&);
+
+
+public:
+  static Glib::RefPtr<Gtk::TargetList> create(const ArrayHandle_TargetEntry& targets);
+  
+ 
+  void add(const Glib::ustring& target, TargetFlags flags = TargetFlags(0), guint info = 0);
+  void add(const ArrayHandle_TargetEntry& targets);
+  
+  void remove(const Glib::ustring& target);
+  
+  bool find(const Glib::ustring& target, guint* info) const;
+
+
+};
+
+} // namespace Gtk
+
+
+namespace Glib
+{
+
+  /** @relates Gtk::TargetList
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Glib::RefPtr<Gtk::TargetList> wrap(GtkTargetList* object, bool take_copy = false);
+
+} // namespace Glib
+
+#endif /* _GTKMM_TARGETLIST_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/tearoffmenuitem.cc b/libs/gtkmm2/gtk/gtkmm/tearoffmenuitem.cc
new file mode 100644
index 0000000000..fbcc26f2cd
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/tearoffmenuitem.cc
@@ -0,0 +1,138 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/tearoffmenuitem.h>
+#include <gtkmm/private/tearoffmenuitem_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* 
+ *
+ * Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtk/gtktearoffmenuitem.h>
+
+namespace Gtk
+{
+
+bool TearoffMenuItem::is_torn_off() const
+{
+  return gobj()->torn_off;
+}
+
+} /* namespace Gtk */
+
+namespace
+{
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Gtk::TearoffMenuItem* wrap(GtkTearoffMenuItem* object, bool take_copy)
+{
+  return dynamic_cast<Gtk::TearoffMenuItem *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& TearoffMenuItem_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &TearoffMenuItem_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_tearoff_menu_item_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void TearoffMenuItem_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+}
+
+
+Glib::ObjectBase* TearoffMenuItem_Class::wrap_new(GObject* o)
+{
+  return manage(new TearoffMenuItem((GtkTearoffMenuItem*)(o)));
+
+}
+
+
+/* The implementation: */
+
+TearoffMenuItem::TearoffMenuItem(const Glib::ConstructParams& construct_params)
+:
+  Gtk::MenuItem(construct_params)
+{
+  }
+
+TearoffMenuItem::TearoffMenuItem(GtkTearoffMenuItem* castitem)
+:
+  Gtk::MenuItem((GtkMenuItem*)(castitem))
+{
+  }
+
+TearoffMenuItem::~TearoffMenuItem()
+{
+  destroy_();
+}
+
+TearoffMenuItem::CppClassType TearoffMenuItem::tearoffmenuitem_class_; // initialize static member
+
+GType TearoffMenuItem::get_type()
+{
+  return tearoffmenuitem_class_.init().get_type();
+}
+
+GType TearoffMenuItem::get_base_type()
+{
+  return gtk_tearoff_menu_item_get_type();
+}
+
+
+TearoffMenuItem::TearoffMenuItem()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::MenuItem(Glib::ConstructParams(tearoffmenuitem_class_.init()))
+{
+  }
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/tearoffmenuitem.h b/libs/gtkmm2/gtk/gtkmm/tearoffmenuitem.h
new file mode 100644
index 0000000000..f2c619c0ee
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/tearoffmenuitem.h
@@ -0,0 +1,124 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_TEAROFFMENUITEM_H
+#define _GTKMM_TEAROFFMENUITEM_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+
+/* tearoffmenuitem.h
+ * 
+ * Copyright (C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/menuitem.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkTearoffMenuItem GtkTearoffMenuItem;
+typedef struct _GtkTearoffMenuItemClass GtkTearoffMenuItemClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class TearoffMenuItem_Class; } // namespace Gtk
+namespace Gtk
+{
+
+/** A special Gtk::MenuItem which is used to tear off and reattach its menu.
+ * When its menu is shown normally, the Gtk::TearoffMenuItem is drawn as a dotted line indicating that the menu can be torn off. Activating it causes its menu to be torn off and displayed in its own window.
+ * When its menu is shown as a tearoff menu, the Gtk::TearoffMenuItem is drawn as a dotted line which has a left pointing arrow graphic indicating that the tearoff menu can be reattached. Activating it will erase the tearoff menu window.
+ * @ingroup Widgets
+ * @ingroup Menus
+ */
+
+class TearoffMenuItem : public MenuItem
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef TearoffMenuItem CppObjectType;
+  typedef TearoffMenuItem_Class CppClassType;
+  typedef GtkTearoffMenuItem BaseObjectType;
+  typedef GtkTearoffMenuItemClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~TearoffMenuItem();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class TearoffMenuItem_Class;
+  static CppClassType tearoffmenuitem_class_;
+
+  // noncopyable
+  TearoffMenuItem(const TearoffMenuItem&);
+  TearoffMenuItem& operator=(const TearoffMenuItem&);
+
+protected:
+  explicit TearoffMenuItem(const Glib::ConstructParams& construct_params);
+  explicit TearoffMenuItem(GtkTearoffMenuItem* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GtkTearoffMenuItem*       gobj()       { return reinterpret_cast<GtkTearoffMenuItem*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GtkTearoffMenuItem* gobj() const { return reinterpret_cast<GtkTearoffMenuItem*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+private:
+
+public:
+  TearoffMenuItem();
+
+  bool is_torn_off() const;
+
+
+};
+
+} /* namespace Gtk */
+
+
+namespace Glib
+{
+  /** @relates Gtk::TearoffMenuItem
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gtk::TearoffMenuItem* wrap(GtkTearoffMenuItem* object, bool take_copy = false);
+}
+#endif /* _GTKMM_TEAROFFMENUITEM_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/textattributes.cc b/libs/gtkmm2/gtk/gtkmm/textattributes.cc
new file mode 100644
index 0000000000..ff1e647a08
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/textattributes.cc
@@ -0,0 +1,103 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/textattributes.h>
+#include <gtkmm/private/textattributes_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/*
+ *
+ * Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtk/gtktexttag.h>
+
+
+namespace
+{
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Gtk::TextAttributes wrap(GtkTextAttributes* object, bool take_copy)
+{
+  return Gtk::TextAttributes(object, take_copy);
+}
+
+} // namespace Glib
+
+
+namespace Gtk
+{
+
+
+// static
+GType TextAttributes::get_type()
+{
+  return gtk_text_attributes_get_type();
+}
+
+TextAttributes::TextAttributes()
+:
+  gobject_ (gtk_text_attributes_new())
+{}
+
+TextAttributes::TextAttributes(const TextAttributes& other)
+:
+  gobject_ ((other.gobject_) ? gtk_text_attributes_copy(other.gobject_) : 0)
+{}
+
+TextAttributes::TextAttributes(GtkTextAttributes* gobject, bool make_a_copy)
+:
+  // For BoxedType wrappers, make_a_copy is true by default.  The static
+  // BoxedType wrappers must always take a copy, thus make_a_copy = true
+  // ensures identical behaviour if the default argument is used.
+  gobject_ ((make_a_copy && gobject) ? gtk_text_attributes_copy(gobject) : gobject)
+{}
+
+TextAttributes& TextAttributes::operator=(const TextAttributes& other)
+{
+  TextAttributes temp (other);
+  swap(temp);
+  return *this;
+}
+
+TextAttributes::~TextAttributes()
+{
+  if(gobject_)
+    gtk_text_attributes_unref(gobject_);
+}
+
+void TextAttributes::swap(TextAttributes& other)
+{
+  GtkTextAttributes *const temp = gobject_;
+  gobject_ = other.gobject_;
+  other.gobject_ = temp;
+}
+
+GtkTextAttributes* TextAttributes::gobj_copy() const
+{
+  return gtk_text_attributes_copy(gobject_);
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/textattributes.h b/libs/gtkmm2/gtk/gtkmm/textattributes.h
new file mode 100644
index 0000000000..6deef34cab
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/textattributes.h
@@ -0,0 +1,114 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_TEXTATTRIBUTES_H
+#define _GTKMM_TEXTATTRIBUTES_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* textattributes.h
+ *
+ * Copyright(C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software, ) you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library, ) if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+extern "C" { typedef struct _GtkTextAttributes GtkTextAttributes; }
+#endif
+
+namespace Gtk
+{
+
+/**
+ * @ingroup TextView
+ */
+class TextAttributes
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef TextAttributes CppObjectType;
+  typedef GtkTextAttributes BaseObjectType;
+
+  static GType get_type() G_GNUC_CONST;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  TextAttributes();
+
+  explicit TextAttributes(GtkTextAttributes* gobject, bool make_a_copy = true);
+
+  TextAttributes(const TextAttributes& other);
+  TextAttributes& operator=(const TextAttributes& other);
+
+  ~TextAttributes();
+
+  void swap(TextAttributes& other);
+
+  ///Provides access to the underlying C instance.
+  GtkTextAttributes*       gobj()       { return gobject_; }
+
+  ///Provides access to the underlying C instance.
+  const GtkTextAttributes* gobj() const { return gobject_; }
+
+  ///Provides access to the underlying C instance. The caller is responsible for freeing it. Use when directly setting fields in structs.
+  GtkTextAttributes* gobj_copy() const;
+
+protected:
+  GtkTextAttributes* gobject_;
+
+private:
+
+public:
+
+
+};
+
+} //namespace Gtk
+
+
+namespace Gtk
+{
+
+/** @relates Gtk::TextAttributes
+ * @param lhs The left-hand side
+ * @param rhs The right-hand side
+ */
+inline void swap(TextAttributes& lhs, TextAttributes& rhs)
+  { lhs.swap(rhs); }
+
+} // namespace Gtk
+
+namespace Glib
+{
+
+/** @relates Gtk::TextAttributes
+ * @param object The C instance
+ * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+ * @result A C++ instance that wraps this C instance.
+ */
+Gtk::TextAttributes wrap(GtkTextAttributes* object, bool take_copy = false);
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+template <>
+class Value<Gtk::TextAttributes> : public Glib::Value_Boxed<Gtk::TextAttributes>
+{};
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+} // namespace Glib
+
+#endif /* _GTKMM_TEXTATTRIBUTES_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/textbuffer.cc b/libs/gtkmm2/gtk/gtkmm/textbuffer.cc
new file mode 100644
index 0000000000..ab66089ba8
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/textbuffer.cc
@@ -0,0 +1,1664 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/textbuffer.h>
+#include <gtkmm/private/textbuffer_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* Copyright(C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtk/gtktextbuffer.h>
+#include <glib/gslist.h>
+#include <gtkmm/textmark.h>
+#include <gtkmm/textiter.h>
+
+
+namespace Gtk
+{
+
+typedef TextChildAnchor ChildAnchor; //Help the code-generator so that it does not have to fully qualify this type in the .cc file.
+
+TextBuffer::TextBuffer(const Glib::RefPtr<TagTable>& tag_table)
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Glib::Object(Glib::ConstructParams(textbuffer_class_.init(), "tag_table",Glib::unwrap(tag_table), (char*) 0))
+{}
+
+Glib::RefPtr<TextBuffer::Tag> TextBuffer::create_tag(const Glib::ustring& tag_name)
+{
+  //gtk_text_buffer_create_tag takes a varargs list of property names and values.
+  //gtkmm coders should use the Tag.set_* method instead.
+  return Glib::wrap(gtk_text_buffer_create_tag(gobj(), tag_name.c_str(), (char*)0), true); //true = take_copy.
+  //We have to take a copy because gtk_text_buffer_create_tag() doesn't ref for us, for no real reason.
+}
+
+Glib::RefPtr<TextBuffer::Tag> TextBuffer::create_tag()
+{
+  //gtk_text_buffer_create_tag takes a varargs list of property names and values.
+  //gtkmm coders should use the Tag.set_* method instead.
+  return Glib::wrap(gtk_text_buffer_create_tag(gobj(), (const char*)0, (char*)0), true); //true = take_copy.
+  //We have to take a copy because gtk_text_buffer_create_tag() doesn't ref for us, for no real reason.
+}
+
+Glib::RefPtr<TextBuffer::Mark>
+TextBuffer::create_mark(const TextBuffer::iterator& where, bool left_gravity)
+{
+  return Glib::wrap(gtk_text_buffer_create_mark(
+      gobj(), 0, const_cast<GtkTextIter*>(where.gobj()), left_gravity),
+      true); // acquire reference
+}
+
+TextBuffer::iterator TextBuffer::get_iter_at_line_offset(int line_number, int char_offset)
+{
+  iterator iter;
+  gtk_text_buffer_get_iter_at_line_offset(gobj(), iter.gobj(), line_number, char_offset);
+  return iter;
+}
+
+TextBuffer::iterator TextBuffer::get_iter_at_line_index(int line_number, int byte_index)
+{
+  iterator iter;
+  gtk_text_buffer_get_iter_at_line_index(gobj(), iter.gobj(), line_number, byte_index);
+  return iter;
+}
+
+TextBuffer::iterator TextBuffer::get_iter_at_offset(int char_offset)
+{
+  iterator iter;
+  gtk_text_buffer_get_iter_at_offset(gobj(), iter.gobj(), char_offset);
+  return iter;
+}
+
+TextBuffer::iterator TextBuffer::get_iter_at_line(int line_number)
+{
+  iterator iter;
+  gtk_text_buffer_get_iter_at_line(gobj(), iter.gobj(), line_number);
+  return iter;
+}
+
+TextBuffer::iterator TextBuffer::begin()
+{
+  iterator iter;
+  gtk_text_buffer_get_start_iter(gobj(), iter.gobj());
+  return iter;
+}
+
+TextBuffer::iterator TextBuffer::end()
+{
+  iterator iter;
+  gtk_text_buffer_get_end_iter(gobj(), iter.gobj());
+  return iter;
+}
+
+void TextBuffer::get_bounds(iterator& range_begin, iterator& range_end)
+{
+  gtk_text_buffer_get_bounds(gobj(), range_begin.gobj(), range_end.gobj());
+}
+
+TextBuffer::iterator TextBuffer::get_iter_at_mark(const Glib::RefPtr<Mark>& mark)
+{
+  iterator iter;
+  gtk_text_buffer_get_iter_at_mark(gobj(), iter.gobj(), mark->gobj());
+  return iter;
+}
+
+void TextBuffer::set_text(const Glib::ustring& text)
+{
+  gtk_text_buffer_set_text(gobj(), text.data(), text.bytes());
+}
+
+void TextBuffer::set_text(const char* text_begin, const char* text_end)
+{
+  gtk_text_buffer_set_text(gobj(), text_begin, text_end - text_begin);
+}
+
+//deprecated:
+void TextBuffer::assign(const Glib::ustring& text)
+{
+  gtk_text_buffer_set_text(gobj(), text.data(), text.bytes());
+}
+
+//deprecated:
+void TextBuffer::assign(const char* text_begin, const char* text_end)
+{
+  gtk_text_buffer_set_text(gobj(), text_begin, text_end - text_begin);
+}
+
+TextBuffer::iterator TextBuffer::insert(const iterator& pos, const Glib::ustring& text)
+{
+  // gtk_text_buffer_insert() modifies the iterator, but that's not the
+  // STL way so we give it something that we don't mind it modifying.
+  iterator iterCopy (pos);
+  gtk_text_buffer_insert(gobj(), iterCopy.gobj(), text.data(), text.bytes());
+
+  // According to the gtk_text_buffer_insert() docs, the "default signal handler
+  // revalidates it to point to the end of the inserted text".
+  return iterCopy;
+}
+
+TextBuffer::iterator TextBuffer::insert(const iterator& pos, const char* text_begin, const char* text_end)
+{
+  // gtk_text_buffer_insert() modifies the iterator, but that's not the
+  // STL way so we give it something that we don't mind it modifying.
+  iterator iterCopy (pos);
+  gtk_text_buffer_insert(gobj(), iterCopy.gobj(), text_begin, text_end - text_begin);
+
+  // According to the gtk_text_buffer_insert() docs, the "default signal handler
+  // revalidates it to point to the end of the inserted text".
+  return iterCopy;
+}
+
+TextBuffer::iterator TextBuffer::insert_pixbuf(const iterator& pos, const Glib::RefPtr<Gdk::Pixbuf>& pixbuf)
+{
+  iterator iterCopy (pos);
+  gtk_text_buffer_insert_pixbuf(gobj(), iterCopy.gobj(), pixbuf->gobj());
+  return iterCopy;
+}
+
+TextBuffer::iterator TextBuffer::insert_child_anchor(const iterator& pos,
+                                                     const Glib::RefPtr<ChildAnchor>& anchor)
+{
+  // Copy the iterator. It might be changed because it is used as a signal parameter internally.
+  iterator iterCopy (pos);
+  gtk_text_buffer_insert_child_anchor(gobj(), iterCopy.gobj(), Glib::unwrap(anchor));
+  return iterCopy;
+}
+
+Glib::RefPtr<ChildAnchor> TextBuffer::create_child_anchor(const iterator& pos)
+{
+  // Copy the iterator. It might be changed because it is used as a signal parameter internally.
+  iterator iterCopy (pos);
+  return Glib::wrap(gtk_text_buffer_create_child_anchor(gobj(), iterCopy.gobj()),
+                    true); // The function does not do a ref for us.
+}
+
+void TextBuffer::insert_at_cursor(const Glib::ustring& text)
+{
+  gtk_text_buffer_insert_at_cursor(gobj(), text.data(), text.bytes());
+}
+
+void TextBuffer::insert_at_cursor(const char* text_begin, const char* text_end)
+{
+  gtk_text_buffer_insert_at_cursor(gobj(), text_begin, text_end - text_begin);
+}
+
+std::pair<TextBuffer::iterator,bool>
+TextBuffer::insert_interactive(const iterator& pos, const Glib::ustring& text, bool default_editable)
+{
+  // Since we have to copy the iterator anyway we can as well create the
+  // std::pair now.  That saves another copy later (mind you, TextIter is
+  // a heavy struct), and allows modern compilers to apply the return value
+  // optimization.
+  std::pair<iterator,bool> pair_iter_success (pos, false);
+
+  pair_iter_success.second = gtk_text_buffer_insert_interactive(
+      gobj(), pair_iter_success.first.gobj(), text.data(), text.bytes(), default_editable);
+
+  return pair_iter_success;
+}
+
+std::pair<TextBuffer::iterator,bool>
+TextBuffer::insert_interactive(const iterator& pos, const char* text_begin, const char* text_end,
+                               bool default_editable)
+{
+  // Since we have to copy the iterator anyway we can as well create the
+  // std::pair now.  That saves another copy later (mind you, TextIter is
+  // a heavy struct), and allows modern compilers to apply the return value
+  // optimization.
+  std::pair<iterator,bool> pair_iter_success (pos, false);
+
+  pair_iter_success.second =  gtk_text_buffer_insert_interactive(
+      gobj(), pair_iter_success.first.gobj(), text_begin, text_end - text_begin, default_editable);
+
+  return pair_iter_success;
+}
+
+bool TextBuffer::insert_interactive_at_cursor(const Glib::ustring& text, bool default_editable)
+{
+  return gtk_text_buffer_insert_interactive_at_cursor(
+      gobj(), text.data(), text.bytes(), default_editable);
+}
+
+bool TextBuffer::insert_interactive_at_cursor(const char* text_begin, const char* text_end,
+                                              bool default_editable)
+{
+  return gtk_text_buffer_insert_interactive_at_cursor(
+      gobj(), text_begin, text_end - text_begin, default_editable);
+}
+
+TextBuffer::iterator TextBuffer::insert_with_tag(const iterator& pos, const Glib::ustring& text,
+                                                 const Glib::RefPtr<Tag>& tag)
+{
+  // gtk_text_buffer_insert_with_tags() invalidates the iterator, but this lets us recreate it later.
+  const int offset = pos.get_offset();
+
+  iterator iterCopy (pos);
+  gtk_text_buffer_insert_with_tags(
+      gobj(), iterCopy.gobj(), text.data(), text.bytes(), tag->gobj(), (GtkTextTag*)0);
+
+  return get_iter_at_offset(offset + text.size());
+}
+
+TextBuffer::iterator TextBuffer::insert_with_tag(const iterator& pos,
+                                                 const char* text_begin, const char* text_end,
+                                                 const Glib::RefPtr<Tag>& tag)
+{
+  // gtk_text_buffer_insert_with_tags() invalidates the iterator, but this lets us recreate it later.
+  const int offset = pos.get_offset();
+
+  iterator iterCopy (pos);
+  gtk_text_buffer_insert_with_tags(
+      gobj(), iterCopy.gobj(), text_begin, text_end - text_begin, tag->gobj(), (GtkTextTag*)0);
+
+  return get_iter_at_offset(offset + (text_end - text_begin));
+}
+
+TextBuffer::iterator TextBuffer::insert_with_tag(const iterator& pos, const Glib::ustring& text,
+                                                 const Glib::ustring& tag_name)
+{
+  // gtk_text_buffer_insert_with_tags() invalidates the iterator, but this lets us recreate it later.
+  const int offset = pos.get_offset();
+
+  iterator iterCopy (pos);
+  gtk_text_buffer_insert_with_tags_by_name(
+      gobj(), iterCopy.gobj(), text.data(), text.bytes(), tag_name.c_str(), (char*)0);
+
+  return get_iter_at_offset(offset + text.size());
+}
+
+TextBuffer::iterator TextBuffer::insert_with_tag(const iterator& pos,
+                                                 const char* text_begin, const char* text_end,
+                                                 const Glib::ustring& tag_name)
+{
+  // gtk_text_buffer_insert_with_tags() invalidates the iterator, but this lets us recreate it later.
+  const int offset = pos.get_offset();
+
+  iterator iterCopy (pos);
+  gtk_text_buffer_insert_with_tags_by_name(
+      gobj(), iterCopy.gobj(), text_begin, text_end - text_begin, tag_name.c_str(), (char*)0);
+
+  return get_iter_at_offset(offset + (text_end - text_begin));
+}
+
+TextBuffer::iterator TextBuffer::insert_with_tags(const iterator& pos, const Glib::ustring& text,
+                                                  const Glib::ArrayHandle< Glib::RefPtr<Tag> >& tags)
+{
+  const char *const text_begin = text.data();
+  return insert_with_tags(pos, text_begin, text_begin + text.bytes(), tags);
+}
+
+TextBuffer::iterator TextBuffer::insert_with_tags(const iterator& pos,
+                                                  const char* text_begin, const char* text_end,
+                                                  const Glib::ArrayHandle< Glib::RefPtr<Tag> >& tags)
+{
+  const int start_offset = pos.get_offset();
+  iterator range_end (insert(pos, text_begin, text_end));
+
+  GtkTextIter range_begin;
+  gtk_text_buffer_get_iter_at_offset(gobj(), &range_begin, start_offset);
+
+  //This was GtkTextTag* const * const, but the SUN Forte compiler said that it couldn't convert to that. murrayc
+  const GtkTextTag* const* tags_begin = tags.data();
+  const GtkTextTag* const* tags_end   = tags_begin + tags.size();
+
+  //TODO: Investigate if this const_cast<> is really necessary.
+  //I added it for the SUN Forte compiler. murrayc.
+  for(GtkTextTag *const * ptag = const_cast<GtkTextTag* const *>(tags_begin); ptag != const_cast<GtkTextTag* const *>(tags_end); 
+++ptag)
+  {
+    gtk_text_buffer_apply_tag(gobj(), *ptag, &range_begin, range_end.gobj());
+  }
+
+  return range_end;
+}
+
+TextBuffer::iterator TextBuffer::insert_with_tags_by_name(const iterator& pos, const Glib::ustring& text,
+                                                          const Glib::ArrayHandle<Glib::ustring>& tag_names)
+{
+  const char *const text_begin = text.data();
+  return insert_with_tags_by_name(pos, text_begin, text_begin + text.bytes(), tag_names);
+}
+
+TextBuffer::iterator TextBuffer::insert_with_tags_by_name(const iterator& pos,
+                                                          const char* text_begin, const char* text_end,
+                                                          const Glib::ArrayHandle<Glib::ustring>& tag_names)
+{
+  // gtk_buffer_insert_with_tags_by_name() is a convenience wrapper, so it's kind of OK to reimplement it:
+
+  const int start_offset = pos.get_offset();
+  iterator range_end (insert(pos, text_begin, text_end));
+
+  GtkTextIter range_begin;
+  gtk_text_buffer_get_iter_at_offset(gobj(), &range_begin, start_offset);
+
+  GtkTextTagTable *const tag_table = gtk_text_buffer_get_tag_table(gobj());
+
+  const char *const *const names_begin = tag_names.data();
+  const char *const *const names_end   = names_begin + tag_names.size();
+
+  for(const char *const * pname = names_begin; pname != names_end; ++pname)
+  {
+    if(GtkTextTag *const tag = gtk_text_tag_table_lookup(tag_table, *pname))
+    {
+      gtk_text_buffer_apply_tag(gobj(), tag, &range_begin, range_end.gobj());
+    }
+    else
+    {
+      g_warning("Gtk::TextBuffer::insert_with_tags_by_name(): no tag with name '%s'!", *pname);
+    }
+  }
+
+  return range_end;
+}
+
+TextBuffer::iterator TextBuffer::insert(const iterator& pos,
+                                        const iterator& range_begin, const iterator& range_end)
+{
+  iterator iterCopy (pos);
+  gtk_text_buffer_insert_range(gobj(), iterCopy.gobj(), range_begin.gobj(), range_end.gobj());
+  return iterCopy;
+}
+
+std::pair<TextBuffer::iterator,bool>
+TextBuffer::insert_interactive(const iterator& pos, const iterator& range_begin,
+                               const iterator& range_end, bool default_editable)
+{
+  // Since we have to copy the iterator anyway we can as well create the
+  // std::pair now.  That saves another copy later (mind you, TextIter is
+  // a heavy struct), and allows modern compilers to apply the return value
+  // optimization.
+  std::pair<iterator,bool> pair_iter_success (pos, false);
+
+  pair_iter_success.second = gtk_text_buffer_insert_range_interactive(
+      gobj(), pair_iter_success.first.gobj(), range_begin.gobj(), range_end.gobj(), default_editable);
+
+  return pair_iter_success;
+}
+
+TextBuffer::iterator TextBuffer::erase(const iterator& range_begin, const iterator& range_end)
+{
+  // GTK+ sets the iterators to where the deletion occured. We do it the STL way and therefore need copies.
+  iterator beginCopy (range_begin);
+  iterator endCopy   (range_end);
+  gtk_text_buffer_delete(gobj(), beginCopy.gobj(), endCopy.gobj());
+  return beginCopy;
+}
+
+TextBuffer::iterator TextBuffer::backspace(const iterator& iter, bool interactive, bool default_editable)
+{
+  // GTK+ sets the iterators to where the deletion occured. We do it the STL way and therefore need copies.
+  iterator copy(iter);
+  gtk_text_buffer_backspace(gobj(), copy.gobj(), interactive, default_editable);
+  return copy;
+}
+
+
+std::pair<TextBuffer::iterator,bool>
+TextBuffer::erase_interactive(const iterator& range_begin, const iterator& range_end,
+                              bool default_editable)
+{
+  // Since we have to copy the iterator anyway we can as well create the
+  // std::pair now.  That saves another copy later (mind you, TextIter is
+  // a heavy struct), and allows modern compilers to apply the return value
+  // optimization.
+  std::pair<iterator,bool> pair_iter_success (range_begin, false);
+
+  // GTK+ sets the iterators to where the deletion occured.
+  // We do it the STL way and therefore need copies.
+  iterator endCopy (range_end);
+
+  pair_iter_success.second = gtk_text_buffer_delete_interactive(
+      gobj(), pair_iter_success.first.gobj(), endCopy.gobj(), default_editable);
+
+  return pair_iter_success;
+}
+
+void TextBuffer::paste_clipboard(const Glib::RefPtr<Clipboard>& clipboard, const iterator& override_location,
+                                 bool default_editable)
+{
+  gtk_text_buffer_paste_clipboard(gobj(), clipboard->gobj(),
+      const_cast<GtkTextIter*>(override_location.gobj()), default_editable);
+}
+
+void TextBuffer::paste_clipboard(const Glib::RefPtr<Clipboard>& clipboard, bool default_editable)
+{
+  gtk_text_buffer_paste_clipboard(gobj(), clipboard->gobj(), 0, default_editable);
+}
+
+TextBuffer::iterator TextBuffer::get_iter_at_child_anchor(const Glib::RefPtr<ChildAnchor>& anchor)
+{
+  iterator iter;
+  gtk_text_buffer_get_iter_at_child_anchor(gobj(), iter.gobj(), anchor->gobj());
+  return iter;
+}
+
+int TextBuffer::size() const
+{
+  return get_char_count();
+}
+
+Glib::ustring TextBuffer::get_text(bool include_hidden_chars)
+{
+  return get_text(begin(), end(), include_hidden_chars);
+}
+
+} // namespace Gtk
+
+
+namespace
+{
+
+void TextBuffer_signal_insert_callback(GtkTextBuffer* self, GtkTextIter* p0,const gchar* p1,gint p2,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,const TextBuffer::iterator&,const Glib::ustring&,int > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(Glib::wrap(p0)
+, Glib::ustring(p1, p1 + p2)
+, p2
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+}
+
+const Glib::SignalProxyInfo TextBuffer_signal_insert_info =
+{
+  "insert_text",
+  (GCallback) &TextBuffer_signal_insert_callback,
+  (GCallback) &TextBuffer_signal_insert_callback
+};
+
+
+void TextBuffer_signal_insert_pixbuf_callback(GtkTextBuffer* self, GtkTextIter* p0,GdkPixbuf* p1,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,const TextBuffer::iterator&,const Glib::RefPtr<Gdk::Pixbuf>& > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(Glib::wrap(p0)
+, Glib::wrap(p1, true)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+}
+
+const Glib::SignalProxyInfo TextBuffer_signal_insert_pixbuf_info =
+{
+  "insert_pixbuf",
+  (GCallback) &TextBuffer_signal_insert_pixbuf_callback,
+  (GCallback) &TextBuffer_signal_insert_pixbuf_callback
+};
+
+
+void TextBuffer_signal_insert_child_anchor_callback(GtkTextBuffer* self, GtkTextIter* p0,GtkTextChildAnchor* p1,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,const TextBuffer::iterator&,const Glib::RefPtr<ChildAnchor>& > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(Glib::wrap(p0)
+, Glib::wrap(p1, true)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+}
+
+const Glib::SignalProxyInfo TextBuffer_signal_insert_child_anchor_info =
+{
+  "insert_child_anchor",
+  (GCallback) &TextBuffer_signal_insert_child_anchor_callback,
+  (GCallback) &TextBuffer_signal_insert_child_anchor_callback
+};
+
+
+void TextBuffer_signal_erase_callback(GtkTextBuffer* self, GtkTextIter* p0,GtkTextIter* p1,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,const TextBuffer::iterator&,const TextBuffer::iterator& > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(Glib::wrap(p0)
+, Glib::wrap(p1)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+}
+
+const Glib::SignalProxyInfo TextBuffer_signal_erase_info =
+{
+  "delete_range",
+  (GCallback) &TextBuffer_signal_erase_callback,
+  (GCallback) &TextBuffer_signal_erase_callback
+};
+
+
+const Glib::SignalProxyInfo TextBuffer_signal_changed_info =
+{
+  "changed",
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
+};
+
+
+const Glib::SignalProxyInfo TextBuffer_signal_modified_changed_info =
+{
+  "modified_changed",
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
+};
+
+
+void TextBuffer_signal_mark_set_callback(GtkTextBuffer* self, const GtkTextIter* p0,GtkTextMark* p1,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,const TextBuffer::iterator&,const Glib::RefPtr<TextBuffer::Mark>& > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(Glib::wrap(p0)
+, Glib::wrap(p1, true)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+}
+
+const Glib::SignalProxyInfo TextBuffer_signal_mark_set_info =
+{
+  "mark_set",
+  (GCallback) &TextBuffer_signal_mark_set_callback,
+  (GCallback) &TextBuffer_signal_mark_set_callback
+};
+
+
+void TextBuffer_signal_mark_deleted_callback(GtkTextBuffer* self, GtkTextMark* p0,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,const Glib::RefPtr<TextBuffer::Mark>& > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(Glib::wrap(p0, true)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+}
+
+const Glib::SignalProxyInfo TextBuffer_signal_mark_deleted_info =
+{
+  "mark_deleted",
+  (GCallback) &TextBuffer_signal_mark_deleted_callback,
+  (GCallback) &TextBuffer_signal_mark_deleted_callback
+};
+
+
+void TextBuffer_signal_apply_tag_callback(GtkTextBuffer* self, GtkTextTag* p0,const GtkTextIter* p1,const GtkTextIter* p2,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,const Glib::RefPtr<TextBuffer::Tag>&,const TextBuffer::iterator&,const TextBuffer::iterator& > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(Glib::wrap(p0, true)
+, Glib::wrap(p1)
+, Glib::wrap(p2)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+}
+
+const Glib::SignalProxyInfo TextBuffer_signal_apply_tag_info =
+{
+  "apply_tag",
+  (GCallback) &TextBuffer_signal_apply_tag_callback,
+  (GCallback) &TextBuffer_signal_apply_tag_callback
+};
+
+
+void TextBuffer_signal_remove_tag_callback(GtkTextBuffer* self, GtkTextTag* p0,const GtkTextIter* p1,const GtkTextIter* p2,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,const Glib::RefPtr<TextBuffer::Tag>&,const TextBuffer::iterator&,const TextBuffer::iterator& > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(Glib::wrap(p0, true)
+, Glib::wrap(p1)
+, Glib::wrap(p2)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+}
+
+const Glib::SignalProxyInfo TextBuffer_signal_remove_tag_info =
+{
+  "remove_tag",
+  (GCallback) &TextBuffer_signal_remove_tag_callback,
+  (GCallback) &TextBuffer_signal_remove_tag_callback
+};
+
+
+const Glib::SignalProxyInfo TextBuffer_signal_begin_user_action_info =
+{
+  "begin_user_action",
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
+};
+
+
+const Glib::SignalProxyInfo TextBuffer_signal_end_user_action_info =
+{
+  "end_user_action",
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
+};
+
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Glib::RefPtr<Gtk::TextBuffer> wrap(GtkTextBuffer* object, bool take_copy)
+{
+  return Glib::RefPtr<Gtk::TextBuffer>( dynamic_cast<Gtk::TextBuffer*> (Glib::wrap_auto ((GObject*)(object), take_copy)) );
+  //We use dynamic_cast<> in case of multiple inheritance.
+}
+
+} /* namespace Glib */
+
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& TextBuffer_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &TextBuffer_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_text_buffer_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void TextBuffer_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+  klass->insert_text = &insert_text_callback;
+  klass->insert_pixbuf = &insert_pixbuf_callback;
+  klass->insert_child_anchor = &insert_child_anchor_callback;
+  klass->delete_range = &delete_range_callback;
+  klass->changed = &changed_callback;
+  klass->modified_changed = &modified_changed_callback;
+  klass->mark_set = &mark_set_callback;
+  klass->mark_deleted = &mark_deleted_callback;
+  klass->apply_tag = &apply_tag_callback;
+  klass->remove_tag = &remove_tag_callback;
+  klass->begin_user_action = &begin_user_action_callback;
+  klass->end_user_action = &end_user_action_callback;
+}
+
+
+void TextBuffer_Class::insert_text_callback(GtkTextBuffer* self, GtkTextIter* p0, const gchar* p1, gint p2)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_insert(Glib::wrap(p0)
+, Glib::ustring(p1, p1 + p2)
+, p2
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->insert_text)
+      (*base->insert_text)(self, p0, p1, p2);
+  }
+}
+
+void TextBuffer_Class::insert_pixbuf_callback(GtkTextBuffer* self, GtkTextIter* p0, GdkPixbuf* p1)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_insert_pixbuf(Glib::wrap(p0)
+, Glib::wrap(p1, true)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->insert_pixbuf)
+      (*base->insert_pixbuf)(self, p0, p1);
+  }
+}
+
+void TextBuffer_Class::insert_child_anchor_callback(GtkTextBuffer* self, GtkTextIter* p0, GtkTextChildAnchor* p1)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_insert_child_anchor(Glib::wrap(p0)
+, Glib::wrap(p1, true)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->insert_child_anchor)
+      (*base->insert_child_anchor)(self, p0, p1);
+  }
+}
+
+void TextBuffer_Class::delete_range_callback(GtkTextBuffer* self, GtkTextIter* p0, GtkTextIter* p1)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_erase(Glib::wrap(p0)
+, Glib::wrap(p1)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->delete_range)
+      (*base->delete_range)(self, p0, p1);
+  }
+}
+
+void TextBuffer_Class::changed_callback(GtkTextBuffer* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_changed();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->changed)
+      (*base->changed)(self);
+  }
+}
+
+void TextBuffer_Class::modified_changed_callback(GtkTextBuffer* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_modified_changed();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->modified_changed)
+      (*base->modified_changed)(self);
+  }
+}
+
+void TextBuffer_Class::mark_set_callback(GtkTextBuffer* self, const GtkTextIter* p0, GtkTextMark* p1)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_mark_set(Glib::wrap(p0)
+, Glib::wrap(p1, true)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->mark_set)
+      (*base->mark_set)(self, p0, p1);
+  }
+}
+
+void TextBuffer_Class::mark_deleted_callback(GtkTextBuffer* self, GtkTextMark* p0)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_mark_deleted(Glib::wrap(p0, true)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->mark_deleted)
+      (*base->mark_deleted)(self, p0);
+  }
+}
+
+void TextBuffer_Class::apply_tag_callback(GtkTextBuffer* self, GtkTextTag* p0, const GtkTextIter* p1, const GtkTextIter* p2)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_apply_tag(Glib::wrap(p0, true)
+, Glib::wrap(p1)
+, Glib::wrap(p2)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->apply_tag)
+      (*base->apply_tag)(self, p0, p1, p2);
+  }
+}
+
+void TextBuffer_Class::remove_tag_callback(GtkTextBuffer* self, GtkTextTag* p0, const GtkTextIter* p1, const GtkTextIter* p2)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_remove_tag(Glib::wrap(p0, true)
+, Glib::wrap(p1)
+, Glib::wrap(p2)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->remove_tag)
+      (*base->remove_tag)(self, p0, p1, p2);
+  }
+}
+
+void TextBuffer_Class::begin_user_action_callback(GtkTextBuffer* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_begin_user_action();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->begin_user_action)
+      (*base->begin_user_action)(self);
+  }
+}
+
+void TextBuffer_Class::end_user_action_callback(GtkTextBuffer* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_end_user_action();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->end_user_action)
+      (*base->end_user_action)(self);
+  }
+}
+
+
+Glib::ObjectBase* TextBuffer_Class::wrap_new(GObject* object)
+{
+  return new TextBuffer((GtkTextBuffer*)object);
+}
+
+
+/* The implementation: */
+
+GtkTextBuffer* TextBuffer::gobj_copy()
+{
+  reference();
+  return gobj();
+}
+
+TextBuffer::TextBuffer(const Glib::ConstructParams& construct_params)
+:
+  Glib::Object(construct_params)
+{}
+
+TextBuffer::TextBuffer(GtkTextBuffer* castitem)
+:
+  Glib::Object((GObject*)(castitem))
+{}
+
+TextBuffer::~TextBuffer()
+{}
+
+
+TextBuffer::CppClassType TextBuffer::textbuffer_class_; // initialize static member
+
+GType TextBuffer::get_type()
+{
+  return textbuffer_class_.init().get_type();
+}
+
+GType TextBuffer::get_base_type()
+{
+  return gtk_text_buffer_get_type();
+}
+
+
+TextBuffer::TextBuffer()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Glib::Object(Glib::ConstructParams(textbuffer_class_.init()))
+{
+  }
+
+Glib::RefPtr<TextBuffer> TextBuffer::create()
+{
+  return Glib::RefPtr<TextBuffer>( new TextBuffer() );
+}
+Glib::RefPtr<TextBuffer> TextBuffer::create(const Glib::RefPtr<TagTable>& tag_table)
+{
+  return Glib::RefPtr<TextBuffer>( new TextBuffer(tag_table) );
+}
+int TextBuffer::get_line_count() const
+{
+  return gtk_text_buffer_get_line_count(const_cast<GtkTextBuffer*>(gobj()));
+}
+
+int TextBuffer::get_char_count() const
+{
+  return gtk_text_buffer_get_char_count(const_cast<GtkTextBuffer*>(gobj()));
+}
+
+Glib::RefPtr<TextBuffer::TagTable> TextBuffer::get_tag_table()
+{
+
+  Glib::RefPtr<TextBuffer::TagTable> retvalue = Glib::wrap(gtk_text_buffer_get_tag_table(gobj()));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::RefPtr<const TextBuffer::TagTable> TextBuffer::get_tag_table() const
+{
+
+  Glib::RefPtr<const TextBuffer::TagTable> retvalue = Glib::wrap(gtk_text_buffer_get_tag_table(const_cast<GtkTextBuffer*>(gobj())));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::ustring TextBuffer::get_text(const iterator& start, const iterator& end, bool include_hidden_chars)
+{
+  return Glib::convert_return_gchar_ptr_to_ustring(gtk_text_buffer_get_text(gobj(), (start).gobj(), (end).gobj(), static_cast<int>(include_hidden_chars)));
+}
+
+Glib::ustring TextBuffer::get_slice(const iterator& start, const iterator& end, bool include_hidden_chars)
+{
+  return Glib::convert_return_gchar_ptr_to_ustring(gtk_text_buffer_get_slice(gobj(), (start).gobj(), (end).gobj(), static_cast<int>(include_hidden_chars)));
+}
+
+Glib::RefPtr<TextBuffer::Mark> TextBuffer::create_mark(const Glib::ustring& mark_name, const iterator& where, bool left_gravity)
+{
+
+  Glib::RefPtr<TextBuffer::Mark> retvalue = Glib::wrap(gtk_text_buffer_create_mark(gobj(), mark_name.c_str(), (where).gobj(), static_cast<int>(left_gravity)));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+void TextBuffer::move_mark(const Glib::RefPtr<Mark>& mark, const iterator& where)
+{
+  gtk_text_buffer_move_mark(gobj(), Glib::unwrap(mark), (where).gobj());
+}
+
+void TextBuffer::delete_mark(const Glib::RefPtr<Mark>& mark)
+{
+  gtk_text_buffer_delete_mark(gobj(), Glib::unwrap(mark));
+}
+
+Glib::RefPtr<TextBuffer::Mark> TextBuffer::get_mark(const Glib::ustring& name)
+{
+
+  Glib::RefPtr<TextBuffer::Mark> retvalue = Glib::wrap(gtk_text_buffer_get_mark(gobj(), name.c_str()));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::RefPtr<const TextBuffer::Mark> TextBuffer::get_mark(const Glib::ustring& name) const
+{
+
+  Glib::RefPtr<const TextBuffer::Mark> retvalue = Glib::wrap(gtk_text_buffer_get_mark(const_cast<GtkTextBuffer*>(gobj()), name.c_str()));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+void TextBuffer::move_mark_by_name(const Glib::ustring& name, const iterator& where)
+{
+  gtk_text_buffer_move_mark_by_name(gobj(), name.c_str(), (where).gobj());
+}
+
+void TextBuffer::delete_mark_by_name(const Glib::ustring& name)
+{
+  gtk_text_buffer_delete_mark_by_name(gobj(), name.c_str());
+}
+
+Glib::RefPtr<TextBuffer::Mark> TextBuffer::get_insert()
+{
+
+  Glib::RefPtr<TextBuffer::Mark> retvalue = Glib::wrap(gtk_text_buffer_get_insert(gobj()));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::RefPtr<TextBuffer::Mark> TextBuffer::get_selection_bound()
+{
+
+  Glib::RefPtr<TextBuffer::Mark> retvalue = Glib::wrap(gtk_text_buffer_get_selection_bound(gobj()));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+void TextBuffer::place_cursor(const iterator& where)
+{
+  gtk_text_buffer_place_cursor(gobj(), (where).gobj());
+}
+
+void TextBuffer::apply_tag(const Glib::RefPtr<Tag>& tag, const iterator& start, const iterator& end)
+{
+  gtk_text_buffer_apply_tag(gobj(), Glib::unwrap(tag), (start).gobj(), (end).gobj());
+}
+
+void TextBuffer::remove_tag(const Glib::RefPtr<Tag>& tag, const iterator& start, const iterator& end)
+{
+  gtk_text_buffer_remove_tag(gobj(), Glib::unwrap(tag), (start).gobj(), (end).gobj());
+}
+
+void TextBuffer::apply_tag_by_name(const Glib::ustring& name, const iterator& start, const iterator& end)
+{
+  gtk_text_buffer_apply_tag_by_name(gobj(), name.c_str(), (start).gobj(), (end).gobj());
+}
+
+void TextBuffer::remove_tag_by_name(const Glib::ustring& name, const iterator& start, const iterator& end)
+{
+  gtk_text_buffer_remove_tag_by_name(gobj(), name.c_str(), (start).gobj(), (end).gobj());
+}
+
+void TextBuffer::remove_all_tags(const iterator& start, const iterator& end)
+{
+  gtk_text_buffer_remove_all_tags(gobj(), (start).gobj(), (end).gobj());
+}
+
+bool TextBuffer::get_modified() const
+{
+  return gtk_text_buffer_get_modified(const_cast<GtkTextBuffer*>(gobj()));
+}
+
+void TextBuffer::set_modified(bool setting)
+{
+  gtk_text_buffer_set_modified(gobj(), static_cast<int>(setting));
+}
+
+void TextBuffer::add_selection_clipboard(const Glib::RefPtr<Clipboard>& clipboard)
+{
+  gtk_text_buffer_add_selection_clipboard(gobj(), Glib::unwrap(clipboard));
+}
+
+void TextBuffer::remove_selection_clipboard(const Glib::RefPtr<Clipboard>& clipboard)
+{
+  gtk_text_buffer_remove_selection_clipboard(gobj(), Glib::unwrap(clipboard));
+}
+
+void TextBuffer::cut_clipboard(const Glib::RefPtr<Clipboard>& clipboard, bool default_editable)
+{
+  gtk_text_buffer_cut_clipboard(gobj(), Glib::unwrap(clipboard), static_cast<int>(default_editable));
+}
+
+void TextBuffer::copy_clipboard(const Glib::RefPtr<Clipboard>& clipboard)
+{
+  gtk_text_buffer_copy_clipboard(gobj(), Glib::unwrap(clipboard));
+}
+
+bool TextBuffer::get_selection_bounds(iterator& start, iterator& end) const
+{
+  return gtk_text_buffer_get_selection_bounds(const_cast<GtkTextBuffer*>(gobj()), (start).gobj(), (end).gobj());
+}
+
+bool TextBuffer::erase_selection(bool interactive, bool default_editable)
+{
+  return gtk_text_buffer_delete_selection(gobj(), static_cast<int>(interactive), static_cast<int>(default_editable));
+}
+
+void TextBuffer::select_range(const iterator& ins, const iterator& bound)
+{
+  gtk_text_buffer_select_range(gobj(), (ins).gobj(), (bound).gobj());
+}
+
+void TextBuffer::begin_user_action()
+{
+  gtk_text_buffer_begin_user_action(gobj());
+}
+
+void TextBuffer::end_user_action()
+{
+  gtk_text_buffer_end_user_action(gobj());
+}
+
+
+Glib::SignalProxy3< void,const TextBuffer::iterator&,const Glib::ustring&,int > TextBuffer::signal_insert()
+{
+  return Glib::SignalProxy3< void,const TextBuffer::iterator&,const Glib::ustring&,int >(this, &TextBuffer_signal_insert_info);
+}
+
+Glib::SignalProxy2< void,const TextBuffer::iterator&,const Glib::RefPtr<Gdk::Pixbuf>& > TextBuffer::signal_insert_pixbuf()
+{
+  return Glib::SignalProxy2< void,const TextBuffer::iterator&,const Glib::RefPtr<Gdk::Pixbuf>& >(this, &TextBuffer_signal_insert_pixbuf_info);
+}
+
+Glib::SignalProxy2< void,const TextBuffer::iterator&,const Glib::RefPtr<ChildAnchor>& > TextBuffer::signal_insert_child_anchor()
+{
+  return Glib::SignalProxy2< void,const TextBuffer::iterator&,const Glib::RefPtr<ChildAnchor>& >(this, &TextBuffer_signal_insert_child_anchor_info);
+}
+
+Glib::SignalProxy2< void,const TextBuffer::iterator&,const TextBuffer::iterator& > TextBuffer::signal_erase()
+{
+  return Glib::SignalProxy2< void,const TextBuffer::iterator&,const TextBuffer::iterator& >(this, &TextBuffer_signal_erase_info);
+}
+
+Glib::SignalProxy0< void > TextBuffer::signal_changed()
+{
+  return Glib::SignalProxy0< void >(this, &TextBuffer_signal_changed_info);
+}
+
+Glib::SignalProxy0< void > TextBuffer::signal_modified_changed()
+{
+  return Glib::SignalProxy0< void >(this, &TextBuffer_signal_modified_changed_info);
+}
+
+Glib::SignalProxy2< void,const TextBuffer::iterator&,const Glib::RefPtr<TextBuffer::Mark>& > TextBuffer::signal_mark_set()
+{
+  return Glib::SignalProxy2< void,const TextBuffer::iterator&,const Glib::RefPtr<TextBuffer::Mark>& >(this, &TextBuffer_signal_mark_set_info);
+}
+
+Glib::SignalProxy1< void,const Glib::RefPtr<TextBuffer::Mark>& > TextBuffer::signal_mark_deleted()
+{
+  return Glib::SignalProxy1< void,const Glib::RefPtr<TextBuffer::Mark>& >(this, &TextBuffer_signal_mark_deleted_info);
+}
+
+Glib::SignalProxy3< void,const Glib::RefPtr<TextBuffer::Tag>&,const TextBuffer::iterator&,const TextBuffer::iterator& > TextBuffer::signal_apply_tag()
+{
+  return Glib::SignalProxy3< void,const Glib::RefPtr<TextBuffer::Tag>&,const TextBuffer::iterator&,const TextBuffer::iterator& >(this, &TextBuffer_signal_apply_tag_info);
+}
+
+Glib::SignalProxy3< void,const Glib::RefPtr<TextBuffer::Tag>&,const TextBuffer::iterator&,const TextBuffer::iterator& > TextBuffer::signal_remove_tag()
+{
+  return Glib::SignalProxy3< void,const Glib::RefPtr<TextBuffer::Tag>&,const TextBuffer::iterator&,const TextBuffer::iterator& >(this, &TextBuffer_signal_remove_tag_info);
+}
+
+Glib::SignalProxy0< void > TextBuffer::signal_begin_user_action()
+{
+  return Glib::SignalProxy0< void >(this, &TextBuffer_signal_begin_user_action_info);
+}
+
+Glib::SignalProxy0< void > TextBuffer::signal_end_user_action()
+{
+  return Glib::SignalProxy0< void >(this, &TextBuffer_signal_end_user_action_info);
+}
+
+
+void Gtk::TextBuffer::on_insert(const TextBuffer::iterator& pos, const Glib::ustring& text, int bytes)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->insert_text)
+    (*base->insert_text)(gobj(),const_cast<GtkTextIter*>((pos).gobj()),text.c_str(),bytes);
+}
+
+void Gtk::TextBuffer::on_insert_pixbuf(const TextBuffer::iterator& pos, const Glib::RefPtr<Gdk::Pixbuf>& pixbuf)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->insert_pixbuf)
+    (*base->insert_pixbuf)(gobj(),const_cast<GtkTextIter*>((pos).gobj()),Glib::unwrap(pixbuf));
+}
+
+void Gtk::TextBuffer::on_insert_child_anchor(const TextBuffer::iterator& pos, const Glib::RefPtr<ChildAnchor>& anchor)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->insert_child_anchor)
+    (*base->insert_child_anchor)(gobj(),const_cast<GtkTextIter*>((pos).gobj()),Glib::unwrap(anchor));
+}
+
+void Gtk::TextBuffer::on_erase(const TextBuffer::iterator& range_begin, const TextBuffer::iterator& range_end)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->delete_range)
+    (*base->delete_range)(gobj(),const_cast<GtkTextIter*>((range_begin).gobj()),const_cast<GtkTextIter*>((range_end).gobj()));
+}
+
+void Gtk::TextBuffer::on_changed()
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->changed)
+    (*base->changed)(gobj());
+}
+
+void Gtk::TextBuffer::on_modified_changed()
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->modified_changed)
+    (*base->modified_changed)(gobj());
+}
+
+void Gtk::TextBuffer::on_mark_set(const TextBuffer::iterator& location, const Glib::RefPtr<TextBuffer::Mark>& mark)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->mark_set)
+    (*base->mark_set)(gobj(),(location).gobj(),Glib::unwrap(mark));
+}
+
+void Gtk::TextBuffer::on_mark_deleted(const Glib::RefPtr<TextBuffer::Mark>& mark)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->mark_deleted)
+    (*base->mark_deleted)(gobj(),Glib::unwrap(mark));
+}
+
+void Gtk::TextBuffer::on_apply_tag(const Glib::RefPtr<TextBuffer::Tag>& tag, const TextBuffer::iterator& range_begin, const TextBuffer::iterator& range_end)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->apply_tag)
+    (*base->apply_tag)(gobj(),Glib::unwrap(tag),(range_begin).gobj(),(range_end).gobj());
+}
+
+void Gtk::TextBuffer::on_remove_tag(const Glib::RefPtr<TextBuffer::Tag>& tag, const TextBuffer::iterator& range_begin, const TextBuffer::iterator& range_end)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->remove_tag)
+    (*base->remove_tag)(gobj(),Glib::unwrap(tag),(range_begin).gobj(),(range_end).gobj());
+}
+
+void Gtk::TextBuffer::on_begin_user_action()
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->begin_user_action)
+    (*base->begin_user_action)(gobj());
+}
+
+void Gtk::TextBuffer::on_end_user_action()
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->end_user_action)
+    (*base->end_user_action)(gobj());
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/textbuffer.h b/libs/gtkmm2/gtk/gtkmm/textbuffer.h
new file mode 100644
index 0000000000..7a40dd9526
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/textbuffer.h
@@ -0,0 +1,844 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_TEXTBUFFER_H
+#define _GTKMM_TEXTBUFFER_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* Copyright(C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+
+#include <gtkmm/object.h>
+#include <gtkmm/texttagtable.h>
+#include <gtkmm/textchildanchor.h>
+#include <gtkmm/textmark.h>
+#include <gtkmm/textiter.h>
+#include <gtkmm/clipboard.h>
+#include <gdkmm/pixbuf.h>
+#include <gtkmmconfig.h>
+#include <utility>
+
+GLIBMM_USING_STD(pair)
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkTextBuffer GtkTextBuffer;
+typedef struct _GtkTextBufferClass GtkTextBufferClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class TextBuffer_Class; } // namespace Gtk
+namespace Gtk
+{
+
+class TextMark;
+class TextIter;
+
+/** Multi-line attributed text that can be displayed by one or more Gtk::TextView widgets.
+ *
+ * Text in a buffer can be marked with tags. A @link Gtk::TextTag Gtk::TextBuffer::Tag@endlink is an attribute that can be applied to some range of text. For example, a tag
+ * might be called "bold" and make the text inside the tag bold. However, the tag concept is more general than that; tags don't
+ * have to affect appearance. They can instead affect the behavior of mouse and key presses, "lock" a range of text so the user
+ * can't edit it, or countless other things. A tag is represented by a @link Gtk::TextTag Gtk::TextBuffer::Tag@endlink object.
+ * One @link Gtk::TextTag Gtk::TextBuffer::Tag@endlink can be applied to any number of text ranges in any number of @link Gtk::TextBuffer Gtk::TextBuffers@endlink.
+ *
+ * Each tag is stored in a @link Gtk::TextTagTable Gtk::TextBuffer::TagTable@endlink. A tag table defines a set of tags that can be used together. Each buffer has one tag
+ * table associated with it; only tags from that tag table can be used with the buffer. A single tag table can be shared between
+ * multiple buffers, however.
+ *
+ * Most text manipulation is accomplished with iterators, represented by an @link Gtk::TextIter iterator@endlink. The iterator can
+ * be used to navigate over characters, words, lines, and sentences.
+ *
+ * But iterators can't be used to preserve positions across buffer modifications. To preserve a position, the
+ * @link Gtk::TextMark Gtk::TextBuffer::Mark@endlink object is ideal. There are two marks built-in to GtkTextBuffer; these are
+ * named "insert" and "selection_bound" and refer to the insertion point and the boundary of the selection which is not the
+ * insertion point. If no text is selected, these two marks will be in the same position. You can manipulate what is selected and
+ * where the cursor appears by moving these marks around.
+ *
+ * Text buffers always contain at least one line, but may be empty (that is, buffers can contain zero characters). The last line
+ * in the text buffer never ends in a line separator (such as newline); the other lines in the buffer always end in a line
+ * separator. Line separators count as characters when computing character counts and character offsets. Note that some Unicode
+ * line separators are represented with multiple bytes in UTF-8, and the two-character sequence "\r\n" is also considered a line
+ * separator.
+ *
+ * @ingroup TextView
+ */
+
+class TextBuffer : public Glib::Object
+{
+   
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+public:
+  typedef TextBuffer CppObjectType;
+  typedef TextBuffer_Class CppClassType;
+  typedef GtkTextBuffer BaseObjectType;
+  typedef GtkTextBufferClass BaseClassType;
+
+private:  friend class TextBuffer_Class;
+  static CppClassType textbuffer_class_;
+
+private:
+  // noncopyable
+  TextBuffer(const TextBuffer&);
+  TextBuffer& operator=(const TextBuffer&);
+
+protected:
+  explicit TextBuffer(const Glib::ConstructParams& construct_params);
+  explicit TextBuffer(GtkTextBuffer* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+  virtual ~TextBuffer();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GObject.
+  GtkTextBuffer*       gobj()       { return reinterpret_cast<GtkTextBuffer*>(gobject_); }
+
+  ///Provides access to the underlying C GObject.
+  const GtkTextBuffer* gobj() const { return reinterpret_cast<GtkTextBuffer*>(gobject_); }
+
+  ///Provides access to the underlying C instance. The caller is responsible for unrefing it. Use when directly setting fields in structs.
+  GtkTextBuffer* gobj_copy();
+
+private:
+
+   
+public:
+  typedef TextIter iterator;
+  typedef TextTag Tag;
+  typedef TextTagTable TagTable;
+  typedef TextMark Mark;
+  typedef TextChildAnchor ChildAnchor;
+
+protected:
+  TextBuffer();
+  explicit TextBuffer(const Glib::RefPtr<TagTable>& tag_table);
+
+public:
+  
+  static Glib::RefPtr<TextBuffer> create();
+
+  
+  static Glib::RefPtr<TextBuffer> create(const Glib::RefPtr<TagTable>& tag_table);
+
+
+  /** Obtains the number of lines in the buffer. This value is cached, so
+   * the function is very fast.
+   * @return Number of lines in the buffer.
+   */
+  int get_line_count() const;
+  
+  /** Gets the number of characters in the buffer; note that characters
+   * and bytes are not the same, you can't e.g.\ expect the contents of
+   * the buffer in string form to be this many bytes long. The character
+   * count is cached, so this function is very fast.
+   * @return Number of characters in the buffer.
+   */
+  int get_char_count() const;
+
+  /// See get_char_count().
+  int size() const;
+
+  
+  /** Get the Gtk::TextTagTable associated with this buffer.
+   * @return The buffer's tag table.
+   */
+  Glib::RefPtr<TextBuffer::TagTable> get_tag_table();
+  
+  /** Get the Gtk::TextTagTable associated with this buffer.
+   * @return The buffer's tag table.
+   */
+  Glib::RefPtr<const TextBuffer::TagTable> get_tag_table() const;
+
+  /** Removes the current contents of the buffer, and inserts @a text instead.
+   * @param text The text to put in the buffer.
+   */
+  void set_text(const Glib::ustring& text);
+
+  /** Removes the current contents of the buffer, and inserts @a text instead.
+   * @param text_begin The start of a UTF8 character array.
+   * @param text_end The end of the UTF8 character array.
+   */
+  void set_text(const char* text_begin, const char* text_end);
+  
+
+  #ifndef GTKMM_DISABLE_DEPRECATED
+  /** @deprecated Use set_text()
+   */
+  void assign(const Glib::ustring& text);
+  
+  /** @deprecated Use set_text()
+   */
+  void assign(const char* text_begin, const char* text_end);
+  #endif //GTKMM_DISABLE_DEPRECATED
+
+  //TODO: Make all insert() methods have the same return type:
+  
+  /** Inserts @a text at position @a pos.
+   * Emits the "insert_text" signal; insertion actually occurs in the default handler for the signal.
+   * The @a pos iterator is invalidated when insertion occurs (because the buffer contents change).
+   *
+   * @param pos An iterator pointing to the position at which the text should be inserted.
+   * @param text The text to be inserted in the buffer.
+   * @result An iterator that points to the end of the inserted text.
+   */
+  iterator insert(const iterator& pos, const Glib::ustring& text);
+
+  /** Inserts text at position @a pos.
+   * Emits the "insert_text" signal; insertion actually occurs in the default handler for the signal.
+   * The @a pos iterator is invalidated when insertion occurs (because the buffer contents change).
+   *
+   * @param pos An iterator pointing to the position at which the text should be inserted.
+   * @param text_begin The start of a UTF8 character array.
+   * @param text_end The end of the UTF8 character array.
+   * @result An iterator that points to the end of the inserted text.
+   */
+  iterator insert(const iterator& pos, const char* text_begin, const char* text_end);
+
+  /** Inserts @a text, using the current cursor position as the insertion point.
+   * Emits the "insert_text" signal; insertion actually occurs in the default handler for the signal.
+   *
+   * @param text The text to be inserted in the buffer.
+   * @result An iterator that points to the end of the inserted text.
+   */
+  void insert_at_cursor(const Glib::ustring& text);
+
+  /** Inserts text, using the current cursor position as the insertion point.
+   * Emits the "insert_text" signal; insertion actually occurs in the default handler for the signal.
+   *
+   * @param text_begin The start of a UTF8 character array.
+   * @param text_end The end of the UTF8 character array.
+   * @result An iterator that points to the end of the inserted text.
+   */
+  void insert_at_cursor(const char* text_begin, const char* text_end);
+
+  /** Like insert(), but the insertion will not occur if @a iter is at a non-editable location in the buffer.
+   * Usually you want to prevent insertions at ineditable locations if the insertion results from a user action (is interactive).
+   *
+   * @a default_editable indicates the editability of text that doesn't have a tag affecting editability applied to it.
+   * Typically the result of Gtk::TextView::get_editable() is appropriate here.
+   *
+   * @param pos An iterator pointing to the position at which the text should be inserted.
+   * @param text The text to be inserted in the buffer.
+   * @param default_editable Default editability of buffer
+   * @result Whether text was actually inserted
+   */
+  std::pair<iterator,bool> insert_interactive(
+      const iterator& pos, const Glib::ustring& text, bool default_editable = true);
+
+  /** Like insert(), but the insertion will not occur if @a pos is at a non-editable location in the buffer.
+   * Usually you want to prevent insertions at ineditable locations if the insertion results from a user action (is interactive).
+   *
+   * @a default_editable indicates the editability of text that doesn't have a tag affecting editability applied to it.
+   * Typically the result of Gtk::TextView::get_editable() is appropriate here.
+   *
+   * @param pos An iterator pointing to the position at which the text should be inserted.
+   * @param text_begin The start of a UTF8 character array.
+   * @param text_end The end of the UTF8 character array.
+   * @param default_editable Default editability of buffer.
+   * @result Whether text was actually inserted
+   */
+  std::pair<iterator,bool> insert_interactive(
+      const iterator& pos, const char* text_begin, const char* text_end, bool default_editable = true);
+
+  /** Calls insert_interactive() at the cursor position.
+   *
+   * @a default_editable indicates the editability of text that doesn't have a tag affecting editability applied to it.
+   * Typically the result of Gtk::TextView::get_editable() is appropriate here.
+   *
+   * @param text The text to be inserted in the buffer.
+   * @param default_editable Default editability of buffer
+   * @result Whether text was actually inserted
+   */
+  bool insert_interactive_at_cursor(const Glib::ustring& text, bool default_editable = true);
+
+  /** Calls insert_interactive() at the cursor position.
+   *
+   * @a default_editable indicates the editability of text that doesn't have a tag affecting editability applied to it.
+   * Typically the result of Gtk::TextView::get_editable() is appropriate here.
+   *
+   * @param text_begin The start of a UTF8 character array.
+   * @param text_end The end of the UTF8 character array.
+   * @param default_editable Default editability of buffer
+   * @result Whether text was actually inserted
+   */
+  bool insert_interactive_at_cursor(const char* text_begin, const char* text_end,
+                                    bool default_editable = true);
+
+  /** Copies text, tags, and pixbufs between @a range_begin and @a range_end (the order of range_begin and range_begin doesn't
+   * matter) and inserts the copy at @a pos. Used instead of simply getting/inserting text because it preserves images and tags.
+   * If range_begin and range_end are in a different buffer, the two buffers must share the same tag table.
+   *
+   * Implemented via emissions of the insert_text and apply_tag signals, so expect those.
+   *
+   * @param pos An iterator pointing to the position at which the text should be inserted.
+   * @param range_begin A position in a buffer.
+   * @param range_end Another position in the same buffer as @a range_begin.
+   * @result Whether text was actually inserted
+   */
+  iterator insert(const iterator& pos, const iterator& range_begin, const iterator& range_end);
+  
+ 
+  /** Same as insert_range(), but does nothing if the insertion point isn't editable.
+   *
+   * The @a default_editable parameter indicates whether the text is editable at @a pos if no tags enclosing @a pos affect editability.
+   * Typically the result of Gtk::TextView::get_editable() is appropriate here.
+   *
+   * @param pos An iterator pointing to the position at which the text should be inserted.
+   * @param range_begin A position in a buffer.
+   * @param range_end Another position in the same buffer as @a range_begin.
+   * @param default_editable Default editability of buffer.
+   * @result Whether text was actually inserted
+   */
+  std::pair<iterator,bool> insert_interactive(const iterator& pos, const iterator& range_begin, const iterator& range_end, bool default_editable = true);
+  
+
+  iterator insert_with_tag(const iterator& pos, const Glib::ustring& text, const Glib::RefPtr<Tag>& tag);
+  iterator insert_with_tag(const iterator& pos, const char* text_begin, const char* text_end, const Glib::RefPtr<Tag>& tag);
+
+  iterator insert_with_tag(const iterator& pos, const Glib::ustring& text, const Glib::ustring& tag_name);
+  iterator insert_with_tag(const iterator& pos, const char* text_begin, const char* text_end, const Glib::ustring& tag_name);
+
+  /** Inserts text into buffer at @a pos, applying the list of tags to the newly-inserted text.
+   * Equivalent to calling insert(), then apply_tag() on the inserted text; This is just a convenience function.
+   *
+   * @param pos An iterator pointing to the position at which the text should be inserted.
+   * @param text The text to be inserted in the buffer.
+   * @param tags A standard C++ container of @link Gtk::TextTag Gtk::TextBuffer::Tags@endlink.
+   * @result Whether text was actually inserted
+   */
+  iterator insert_with_tags(const iterator& pos, const Glib::ustring& text,
+                            const Glib::ArrayHandle< Glib::RefPtr<Tag> >& tags);
+
+  /** Inserts text into buffer at @a pos, applying the list of tags to the newly-inserted text.
+   * Equivalent to calling insert(), then apply_tag() on the inserted text; This is just a convenience function.
+   *
+   * @param pos An iterator pointing to the position at which the text should be inserted.
+   * @param text_begin The start of a UTF8 character array.
+   * @param text_end The end of the UTF8 character array.
+   * @param tags A standard C++ container of @link Gtk::TextTag Gtk::TextBuffer::Tags@endlink.
+   * @result Whether text was actually inserted
+   */                          
+  iterator insert_with_tags(const iterator& pos, const char* text_begin, const char* text_end,
+                            const Glib::ArrayHandle< Glib::RefPtr<Tag> >& tags);
+
+  /** Inserts text into buffer at @a pos, applying the list of tags to the newly-inserted text.
+   * Equivalent to calling insert(), then apply_tag() on the inserted text; This is just a convenience function.
+   *
+   * @param pos An iterator pointing to the position at which the text should be inserted.
+   * @param text The text to be inserted in the buffer.
+   * @param tag_names A standard C++ container of tag names.
+   * @result Whether text was actually inserted
+   */
+  iterator insert_with_tags_by_name(const iterator& pos, const Glib::ustring& text,
+                                    const Glib::StringArrayHandle& tag_names);
+
+
+  /** Equivalent to calling insert(), then apply_tag() on the inserted text; This is just a convenience function.
+   *
+   * @param pos An iterator pointing to the position at which the text should be inserted.
+   * @param text_begin The start of a UTF8 character array.
+   * @param text_end The end of the UTF8 character array.
+   * @param tag_names A standard C++ container of tag names.
+   * @result Whether text was actually inserted
+   */                                   
+  iterator insert_with_tags_by_name(const iterator& pos, const char* text_begin, const char* text_end,
+                                    const Glib::StringArrayHandle& tag_names);
+
+  /* Deletes all text between @a range_begin and @a range_end. The order of range_begin and range_end is not actually relevant.
+   * This function actually emits the "delete_range" signal, and the default handler of that signal deletes the text.
+   * Because the buffer is modified, all outstanding iterators become invalid after calling this function.
+   * @param range_begin
+   * @param range_end
+   * @result An iterator that points to the location where text was deleted.
+   */
+  iterator erase(const iterator& range_begin, const iterator& range_end);
+  
+
+   /* Deletes all editable text between @a range_begin and @a range_end. The order of range_begin and range_end is not actually relevant.
+   * This function actually emits the "delete_range" signal, and the default handler of that signal deletes the text.
+   * Because the buffer is modified, all outstanding iterators become invalid after calling this function.
+   *
+   * @a default_editable indicates the editability of text that doesn't have a tag affecting editability applied to it.
+   * Typically the result of Gtk::TextView::get_editable() is appropriate here.
+   *
+   * @param range_begin
+   * @param range_end
+   * @param default_editable Default editability of buffer
+   * @result An iterator that points to the location where text was deleted, or end() is no text was deleted.
+   */
+  std::pair<iterator,bool> erase_interactive(const iterator& range_begin, const iterator& range_end, bool default_editable = true);
+  
+  
+  //TODO: Document this:
+  iterator backspace(const iterator& iter, bool interactive = true, bool default_editable = true);
+  
+
+  /** Returns the text in the range [ @a start , @a end ). Excludes undisplayed
+   * text (text marked with tags that set the invisibility attribute) if
+   *  @a include_hidden_chars  is <tt>false</tt>. Does not include characters
+   * representing embedded images, so byte and character indexes into
+   * the returned string do <em>not</em> correspond to byte
+   * and character indexes into the buffer. Contrast with
+   * get_slice().
+   * @param start Start of a range.
+   * @param end End of a range.
+   * @param include_hidden_chars Whether to include invisible text.
+   * @return An allocated UTF-8 string.
+   */
+  Glib::ustring get_text(const iterator& start, const iterator& end, bool include_hidden_chars = true);
+
+  /** Returns all the text in the buffer. Excludes undisplayed
+   * text (text marked with tags that set the invisibility attribute) if
+   *  @a include_hidden_chars  is <tt>false</tt>. Does not include characters
+   * representing embedded images, so byte and character indexes into
+   * the returned string do <em>not</em> correspond to byte
+   * and character indexes into the buffer. Contrast with
+   * get_slice().
+   *
+   * @param include_hidden_chars Whether to include invisible text.
+   * @return An allocated UTF-8 string.
+   */
+  Glib::ustring get_text(bool include_hidden_chars = true);
+
+  
+  /** Returns the text in the range [ @a start , @a end ). Excludes undisplayed
+   * text (text marked with tags that set the invisibility attribute) if
+   *  @a include_hidden_chars  is <tt>false</tt>. The returned string includes a
+   * 0xFFFC character whenever the buffer contains
+   * embedded images, so byte and character indexes into
+   * the returned string <em>do</em> correspond to byte
+   * and character indexes into the buffer. Contrast with
+   * get_text(). Note that 0xFFFC can occur in normal
+   * text as well, so it is not a reliable indicator that a pixbuf or
+   * widget is in the buffer.
+   * @param start Start of a range.
+   * @param end End of a range.
+   * @param include_hidden_chars Whether to include invisible text.
+   * @return An allocated UTF-8 string.
+   */
+  Glib::ustring get_slice(const iterator& start, const iterator& end, bool include_hidden_chars = true);
+
+  iterator insert_pixbuf(const iterator& pos, const Glib::RefPtr<Gdk::Pixbuf>& pixbuf);
+  
+
+  iterator insert_child_anchor(const iterator& pos, const Glib::RefPtr<ChildAnchor>& anchor);
+  
+
+  Glib::RefPtr<ChildAnchor> create_child_anchor(const iterator& pos);
+  
+
+  /** Creates a mark at position @a where . The mark can be retrieved by name using
+   * get_mark(). If a mark has left gravity, and text is
+   * inserted at the mark's current location, the mark will be moved to
+   * the left of the newly-inserted text. If the mark has right gravity
+   * ( @a left_gravity  = <tt>false</tt>), the mark will end up on the right of
+   * newly-inserted text. The standard left-to-right cursor is a mark
+   * with right gravity (when you type, the cursor stays on the right
+   * side of the text you're typing).
+   * 
+   * Emits the "mark_set" signal as notification of the mark's initial
+   * placement.
+   * @param mark_name Name for mark, or <tt>0</tt>.
+   * @param where Location to place mark.
+   * @param left_gravity Whether the mark has left gravity.
+   * @return The new Gtk::TextMark object.
+   */
+  Glib::RefPtr<TextBuffer::Mark> create_mark(const Glib::ustring& mark_name, const iterator& where, bool left_gravity = true);
+
+  /** Create an anonymous mark. */
+  /** Creates an anonymous mark at position @a where.
+   *
+   * If a mark has left gravity, and text is
+   * inserted at the mark's current location, the mark will be moved to
+   * the left of the newly-inserted text. If the mark has right gravity
+   * ( @a left_gravity  = <tt>false</tt>), the mark will end up on the right of
+   * newly-inserted text. The standard left-to-right cursor is a mark
+   * with right gravity (when you type, the cursor stays on the right
+   * side of the text you're typing).
+   *
+   * Emits the "mark_set" signal as notification of the mark's initial
+   * placement.
+   * @param where Location to place mark.
+   * @param left_gravity Whether the mark has left gravity.
+   * @return The new Gtk::TextMark object.
+   */ 
+  Glib::RefPtr<Mark> create_mark(const iterator& where, bool left_gravity = true);
+
+  
+  /** Moves @a mark  to the new location @a where . Emits the "mark_set" signal
+   * as notification of the move.
+   * @param mark A Gtk::TextMark.
+   * @param where New location for @a mark  in @a buffer .
+   */
+  void move_mark(const Glib::RefPtr<Mark>& mark, const iterator& where);
+  
+  /** Deletes @a mark , so that it's no longer located anywhere in the
+   * buffer. Removes the reference the buffer holds to the mark, so if
+   * you don't keep a Glib::RefPtr to the mark, it will be freed. Even
+   * if the mark isn't freed, most operations on @a mark  become
+   * invalid. There is no way to undelete a
+   * mark. Gtk::TextMark::get_deleted() will return <tt>true</tt> after this
+   * function has been called on a mark; Gtk::TextMark::get_deleted()
+   * indicates that a mark no longer belongs to a buffer. The "mark_deleted"
+   * signal will be emitted as notification after the mark is deleted.
+   * @param mark A Gtk::TextMark in @a buffer .
+   */
+  void delete_mark(const Glib::RefPtr<Mark>& mark);
+  
+  /** Returns the mark named @a name  in buffer @a buffer , or <tt>0</tt> if no such
+   * mark exists in the buffer.
+   * @param name A mark name.
+   * @return A Gtk::TextMark, or <tt>0</tt>.
+   */
+  Glib::RefPtr<TextBuffer::Mark> get_mark(const Glib::ustring& name);
+  
+  /** Returns the mark named @a name  in buffer @a buffer , or <tt>0</tt> if no such
+   * mark exists in the buffer.
+   * @param name A mark name.
+   * @return A Gtk::TextMark, or <tt>0</tt>.
+   */
+  Glib::RefPtr<const TextBuffer::Mark> get_mark(const Glib::ustring& name) const;
+
+  
+  /** Moves the mark named @a name  (which must exist) to location @a where .
+   * See move_mark() for details.
+   * @param name Name of a mark.
+   * @param where New location for mark.
+   */
+  void move_mark_by_name(const Glib::ustring& name, const iterator& where);
+  
+  /** Deletes the mark named @a name ; the mark must exist. See
+   * delete_mark() for details.
+   * @param name Name of a mark in @a buffer .
+   */
+  void delete_mark_by_name(const Glib::ustring& name);
+
+  
+  /** Returns the mark that represents the cursor (insertion point).
+   * Equivalent to calling get_mark() to get the mark
+   * named "insert", but very slightly more efficient, and involves less
+   * typing.
+   * @return Insertion point mark.
+   */
+  Glib::RefPtr<TextBuffer::Mark> get_insert();
+  
+  /** Returns the mark that represents the selection bound.  Equivalent
+   * to calling get_mark() to get the mark named
+   * "selection_bound", but very slightly more efficient, and involves
+   * less typing.
+   * 
+   * The currently-selected text in @a buffer  is the region between the
+   * "selection_bound" and "insert" marks. If "selection_bound" and
+   * "insert" are in the same place, then there is no current selection.
+   * get_selection_bounds() is another convenient function
+   * for handling the selection, if you just want to know whether there's a
+   * selection and what its bounds are.
+   * @return Selection bound mark.
+   */
+  Glib::RefPtr<TextBuffer::Mark> get_selection_bound();
+
+  
+  /** This function moves the "insert" and "selection_bound" marks
+   * simultaneously.  If you move them to the same place in two steps
+   * with move_mark(), you will temporarily select a
+   * region in between their old and new locations, which can be pretty
+   * inefficient since the temporarily-selected region will force stuff
+   * to be recalculated. This function moves them as a unit, which can
+   * be optimized.
+   * @param where Where to put the cursor.
+   */
+  void place_cursor(const iterator& where);
+  
+  /** Emits the "apply_tag" signal on @a buffer . The default
+   * handler for the signal applies @a tag  to the given range.
+   *  @a start  and @a end  do not have to be in order.
+   * @param tag A Gtk::TextTag.
+   * @param start One bound of range to be tagged.
+   * @param end Other bound of range to be tagged.
+   */
+  void apply_tag(const Glib::RefPtr<Tag>& tag, const iterator& start, const iterator& end);
+  
+  /** Emits the "remove_tag" signal. The default handler for the signal
+   * removes all occurrences of @a tag  from the given range. @a start  and
+   *  @a end  don't have to be in order.
+   * @param tag A Gtk::TextTag.
+   * @param start One bound of range to be untagged.
+   * @param end Other bound of range to be untagged.
+   */
+  void remove_tag(const Glib::RefPtr<Tag>& tag, const iterator& start, const iterator& end);
+  
+  /** Calls Gtk::TextTagTable::lookup() on the buffer's tag table to
+   * get a Gtk::TextTag, then calls apply_tag().
+   * @param name Name of a named Gtk::TextTag.
+   * @param start One bound of range to be tagged.
+   * @param end Other bound of range to be tagged.
+   */
+  void apply_tag_by_name(const Glib::ustring& name, const iterator& start, const iterator& end);
+  
+  /** Calls Gtk::TextTagTable::lookup() on the buffer's tag table to
+   * get a Gtk::TextTag, then calls remove_tag().
+   * @param name Name of a Gtk::TextTag.
+   * @param start One bound of range to be untagged.
+   * @param end Other bound of range to be untagged.
+   */
+  void remove_tag_by_name(const Glib::ustring& name, const iterator& start, const iterator& end);
+  
+  /** Removes all tags in the range between @a start  and @a end .  Be careful
+   * with this function; it could remove tags added in code unrelated to
+   * the code you're currently writing. That is, using this function is
+   * probably a bad idea if you have two or more unrelated code sections
+   * that add tags.
+   * @param start One bound of range to be untagged.
+   * @param end Other bound of range to be untagged.
+   */
+  void remove_all_tags(const iterator& start, const iterator& end);
+
+  /** Creates a tag and adds it to the tag table for buffer. Equivalent to calling Gtk::TextBuffer::Tag::create() and then adding
+   * the tag to the buffer's tag table.
+   * A tag called @a tag_name must not already exist in the tag table for this buffer.
+   *
+   * @param tag_name The name for the new tag.
+   * @result The new tag.
+   */
+  Glib::RefPtr<Tag> create_tag(const Glib::ustring& tag_name);
+  
+
+  /** Creates an anoymous tag and adds it to the tag table for buffer. Equivalent to calling Gtk::TextBuffer::Tag::create() and then adding
+   * the tag to the buffer's tag table.
+   *
+   * @result The new tag.
+   */
+  Glib::RefPtr<Tag> create_tag();
+
+  iterator get_iter_at_line_offset(int line_number, int char_offset);
+  iterator get_iter_at_line_index(int line_number, int byte_index);
+  iterator get_iter_at_offset(int char_offset);
+  iterator get_iter_at_line(int line_number);
+  iterator begin();
+  iterator end();
+  void get_bounds(iterator& range_begin, iterator& range_end);
+
+  /** Get the current position of a mark.
+   * @param mark The @link Gtk::TextMark Gtk::TextBuffer::Mark@endlink
+   * @result An iterator that points to the position of the @a mark.
+   */
+  iterator get_iter_at_mark(const Glib::RefPtr<Mark>& mark);
+
+  /** Get the current position of an anchor.
+   * @param anchor A @link Gtk::TextChildAnchor Gtk::TextBuffer::Anchor@endlink that appears in the buffer.
+   * @result An iterator that points to the position of the @a anchor.
+   */
+  iterator get_iter_at_child_anchor(const Glib::RefPtr<ChildAnchor>& anchor);
+
+  
+  /** Indicates whether the buffer has been modified since the last call
+   * to set_modified() set the modification flag to
+   * <tt>false</tt>. Used for example to enable a "save" function in a text
+   * editor.
+   * @return <tt>true</tt> if the buffer has been modified.
+   */
+  bool get_modified() const;
+  
+  /** Used to keep track of whether the buffer has been modified since the
+   * last time it was saved. Whenever the buffer is saved to disk, call
+   * gtk_text_buffer_set_modified ( @a buffer , <tt>false</tt>). When the buffer is modified,
+   * it will automatically toggled on the modified bit again. When the modified
+   * bit flips, the buffer emits a "modified_changed" signal.
+   * @param setting Modification flag setting.
+   */
+  void set_modified(bool setting = true);
+
+  
+  /** Adds @a clipboard  to the list of clipboards in which the selection contents
+   * of @a buffer  are available. In most cases, @a clipboard  will be the Gtk::Clipboard
+   * of type Gdk::SELECTION_PRIMARY for a view of @a buffer .
+   * @param clipboard A Gtk::Clipboard.
+   */
+  void add_selection_clipboard(const Glib::RefPtr<Clipboard>& clipboard);
+  
+  /** Removes a Gtk::Clipboard added with add_selection_clipboard()
+   * @param clipboard A Gtk::Clipboard added to @a buffer  by add_selection_clipboard().
+   */
+  void remove_selection_clipboard(const Glib::RefPtr<Clipboard>& clipboard);
+  
+  /** Copies the currently-selected text to a clipboard, then deletes
+   * said text if it's editable.
+   * @param clipboard The Gtk::Clipboard object to cut to.
+   * @param default_editable Default editability of the buffer.
+   */
+  void cut_clipboard(const Glib::RefPtr<Clipboard>& clipboard, bool default_editable = true);
+  
+  /** Copies the currently-selected text to a clipboard.
+   * @param clipboard The Gtk::Clipboard object to copy to.
+   */
+  void copy_clipboard(const Glib::RefPtr<Clipboard>& clipboard);
+  void paste_clipboard(const Glib::RefPtr<Clipboard>& clipboard, const iterator& override_location, bool default_editable = true);
+  void paste_clipboard(const Glib::RefPtr<Clipboard>& clipboard, bool default_editable = true);
+  
+
+  /** Returns <tt>true</tt> if some text is selected; places the bounds
+   * of the selection in @a start  and @a end  (if the selection has length 0,
+   * then @a start  and @a end  are filled in with the same value).
+   *  @a start  and @a end  will be in ascending order. If @a start  and @a end  are
+   * <tt>0</tt>, then they are not filled in, but the return value still indicates
+   * whether text is selected.
+   * @param start Iterator to initialize with selection start.
+   * @param end Iterator to initialize with selection end.
+   * @return Whether the selection has nonzero length.
+   */
+  bool get_selection_bounds(iterator& start, iterator& end) const;
+  
+  /** Deletes the range between the "insert" and "selection_bound" marks,
+   * that is, the currently-selected text. If @a interactive  is <tt>true</tt>,
+   * the editability of the selection will be considered (users can't delete
+   * uneditable text).
+   * @param interactive Whether the deletion is caused by user interaction.
+   * @param default_editable Whether the buffer is editable by default.
+   * @return Whether there was a non-empty selection to delete.
+   */
+  bool erase_selection(bool interactive = true, bool default_editable = true);
+
+  
+  /** This function moves the "insert" and "selection_bound" marks
+   * simultaneously.  If you move them in two steps
+   * with move_mark(), you will temporarily select a
+   * region in between their old and new locations, which can be pretty
+   * inefficient since the temporarily-selected region will force stuff
+   * to be recalculated. This function moves them as a unit, which can
+   * be optimized.
+   * 
+   * Since: 2.4
+   * @param ins Where to put the "insert" mark.
+   * @param bound Where to put the "selection_bound" mark.
+   */
+  void select_range(const iterator& ins, const iterator& bound);
+  
+/* Called to specify atomic user actions, used to implement undo */
+  
+  /** Called to indicate that the buffer operations between here and a
+   * call to end_user_action() are part of a single
+   * user-visible operation. The operations between
+   * begin_user_action() and
+   * end_user_action() can then be grouped when creating
+   * an undo stack. Gtk::TextBuffer maintains a count of calls to
+   * begin_user_action() that have not been closed with
+   * a call to end_user_action(), and emits the "begin_user_action"
+   * and "end_user_action" signals only for the outermost pair of calls.
+   * This allows you to build user actions from other user actions.
+   * 
+   * The "interactive" buffer mutation functions, such as
+   * insert_interactive(), automatically call begin/end
+   * user action around the buffer operations they perform, so there's
+   * no need to add extra calls if you user action consists solely of a
+   * single call to one of those functions.
+   */
+  void begin_user_action();
+  
+  /** Should be paired with a call to begin_user_action().
+   * See that function for a full explanation.
+   */
+  void end_user_action();
+
+
+  Glib::SignalProxy3< void,const TextBuffer::iterator&,const Glib::ustring&,int > signal_insert();
+
+  
+  Glib::SignalProxy2< void,const TextBuffer::iterator&,const Glib::RefPtr<Gdk::Pixbuf>& > signal_insert_pixbuf();
+
+  
+  Glib::SignalProxy2< void,const TextBuffer::iterator&,const Glib::RefPtr<ChildAnchor>& > signal_insert_child_anchor();
+
+  
+  Glib::SignalProxy2< void,const TextBuffer::iterator&,const TextBuffer::iterator& > signal_erase();
+
+  
+  Glib::SignalProxy0< void > signal_changed();
+
+  
+  Glib::SignalProxy0< void > signal_modified_changed();
+
+  
+  Glib::SignalProxy2< void,const TextBuffer::iterator&,const Glib::RefPtr<TextBuffer::Mark>& > signal_mark_set();
+
+  
+  Glib::SignalProxy1< void,const Glib::RefPtr<TextBuffer::Mark>& > signal_mark_deleted();
+
+  
+  Glib::SignalProxy3< void,const Glib::RefPtr<TextBuffer::Tag>&,const TextBuffer::iterator&,const TextBuffer::iterator& > signal_apply_tag();
+
+  
+  Glib::SignalProxy3< void,const Glib::RefPtr<TextBuffer::Tag>&,const TextBuffer::iterator&,const TextBuffer::iterator& > signal_remove_tag();
+
+  
+  Glib::SignalProxy0< void > signal_begin_user_action();
+
+  
+  Glib::SignalProxy0< void > signal_end_user_action();
+
+
+public:
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+  virtual void on_insert(const TextBuffer::iterator& pos, const Glib::ustring& text, int bytes);
+  virtual void on_insert_pixbuf(const TextBuffer::iterator& pos, const Glib::RefPtr<Gdk::Pixbuf>& pixbuf);
+  virtual void on_insert_child_anchor(const TextBuffer::iterator& pos, const Glib::RefPtr<ChildAnchor>& anchor);
+  virtual void on_erase(const TextBuffer::iterator& range_begin, const TextBuffer::iterator& range_end);
+  virtual void on_changed();
+  virtual void on_modified_changed();
+  virtual void on_mark_set(const TextBuffer::iterator& location, const Glib::RefPtr<TextBuffer::Mark>& mark);
+  virtual void on_mark_deleted(const Glib::RefPtr<TextBuffer::Mark>& mark);
+  virtual void on_apply_tag(const Glib::RefPtr<TextBuffer::Tag>& tag, const TextBuffer::iterator& range_begin, const TextBuffer::iterator& range_end);
+  virtual void on_remove_tag(const Glib::RefPtr<TextBuffer::Tag>& tag, const TextBuffer::iterator& range_begin, const TextBuffer::iterator& range_end);
+  virtual void on_begin_user_action();
+  virtual void on_end_user_action();
+
+
+};
+
+} // namespace Gtk
+
+
+namespace Glib
+{
+  /** @relates Gtk::TextBuffer
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Glib::RefPtr<Gtk::TextBuffer> wrap(GtkTextBuffer* object, bool take_copy = false);
+}
+
+
+#endif /* _GTKMM_TEXTBUFFER_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/textchildanchor.cc b/libs/gtkmm2/gtk/gtkmm/textchildanchor.cc
new file mode 100644
index 0000000000..e44a5050c3
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/textchildanchor.cc
@@ -0,0 +1,151 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/textchildanchor.h>
+#include <gtkmm/private/textchildanchor_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* 
+ *
+ * Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtk/gtktextchild.h>
+
+namespace
+{
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Glib::RefPtr<Gtk::TextChildAnchor> wrap(GtkTextChildAnchor* object, bool take_copy)
+{
+  return Glib::RefPtr<Gtk::TextChildAnchor>( dynamic_cast<Gtk::TextChildAnchor*> (Glib::wrap_auto ((GObject*)(object), take_copy)) );
+  //We use dynamic_cast<> in case of multiple inheritance.
+}
+
+} /* namespace Glib */
+
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& TextChildAnchor_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &TextChildAnchor_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_text_child_anchor_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void TextChildAnchor_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+}
+
+
+Glib::ObjectBase* TextChildAnchor_Class::wrap_new(GObject* object)
+{
+  return new TextChildAnchor((GtkTextChildAnchor*)object);
+}
+
+
+/* The implementation: */
+
+GtkTextChildAnchor* TextChildAnchor::gobj_copy()
+{
+  reference();
+  return gobj();
+}
+
+TextChildAnchor::TextChildAnchor(const Glib::ConstructParams& construct_params)
+:
+  Glib::Object(construct_params)
+{}
+
+TextChildAnchor::TextChildAnchor(GtkTextChildAnchor* castitem)
+:
+  Glib::Object((GObject*)(castitem))
+{}
+
+TextChildAnchor::~TextChildAnchor()
+{}
+
+
+TextChildAnchor::CppClassType TextChildAnchor::textchildanchor_class_; // initialize static member
+
+GType TextChildAnchor::get_type()
+{
+  return textchildanchor_class_.init().get_type();
+}
+
+GType TextChildAnchor::get_base_type()
+{
+  return gtk_text_child_anchor_get_type();
+}
+
+
+TextChildAnchor::TextChildAnchor()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Glib::Object(Glib::ConstructParams(textchildanchor_class_.init()))
+{
+  }
+
+Glib::RefPtr<TextChildAnchor> TextChildAnchor::create()
+{
+  return Glib::RefPtr<TextChildAnchor>( new TextChildAnchor() );
+}
+Glib::ListHandle<Widget*> TextChildAnchor::get_widgets()
+{
+  return Glib::ListHandle<Widget*>(gtk_text_child_anchor_get_widgets(gobj()), Glib::OWNERSHIP_SHALLOW);
+}
+
+Glib::ListHandle<const Widget*> TextChildAnchor::get_widgets() const
+{
+  return Glib::ListHandle<const Widget*>(gtk_text_child_anchor_get_widgets(const_cast<GtkTextChildAnchor*>(gobj())), Glib::OWNERSHIP_SHALLOW);
+}
+
+bool TextChildAnchor::get_deleted() const
+{
+  return gtk_text_child_anchor_get_deleted(const_cast<GtkTextChildAnchor*>(gobj()));
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/textchildanchor.h b/libs/gtkmm2/gtk/gtkmm/textchildanchor.h
new file mode 100644
index 0000000000..0ee3f68bd0
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/textchildanchor.h
@@ -0,0 +1,159 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_TEXTCHILDANCHOR_H
+#define _GTKMM_TEXTCHILDANCHOR_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* textchildanchor.h
+ * 
+ * Copyright (C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+
+#include <gtkmm/object.h>
+#include <gtkmm/widget.h>
+#include <glibmm/listhandle.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkTextChildAnchor GtkTextChildAnchor;
+typedef struct _GtkTextChildAnchorClass GtkTextChildAnchorClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class TextChildAnchor_Class; } // namespace Gtk
+namespace Gtk
+{
+
+//TODO: Add a real class description.
+
+/** Typedefed as Gtk::TextBuffer::ChildAnchor.
+ * @ingroup TextView
+ */
+
+class TextChildAnchor : public Glib::Object
+{
+   
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+public:
+  typedef TextChildAnchor CppObjectType;
+  typedef TextChildAnchor_Class CppClassType;
+  typedef GtkTextChildAnchor BaseObjectType;
+  typedef GtkTextChildAnchorClass BaseClassType;
+
+private:  friend class TextChildAnchor_Class;
+  static CppClassType textchildanchor_class_;
+
+private:
+  // noncopyable
+  TextChildAnchor(const TextChildAnchor&);
+  TextChildAnchor& operator=(const TextChildAnchor&);
+
+protected:
+  explicit TextChildAnchor(const Glib::ConstructParams& construct_params);
+  explicit TextChildAnchor(GtkTextChildAnchor* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+  virtual ~TextChildAnchor();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GObject.
+  GtkTextChildAnchor*       gobj()       { return reinterpret_cast<GtkTextChildAnchor*>(gobject_); }
+
+  ///Provides access to the underlying C GObject.
+  const GtkTextChildAnchor* gobj() const { return reinterpret_cast<GtkTextChildAnchor*>(gobject_); }
+
+  ///Provides access to the underlying C instance. The caller is responsible for unrefing it. Use when directly setting fields in structs.
+  GtkTextChildAnchor* gobj_copy();
+
+private:
+
+protected:
+  TextChildAnchor();
+
+public:
+  
+  static Glib::RefPtr<TextChildAnchor> create();
+
+
+  /** Gets a list of all widgets anchored at this child anchor.
+   * @return List of widgets anchored at @a anchor .
+   */
+  Glib::ListHandle<Widget*> get_widgets();
+  
+  /** Gets a list of all widgets anchored at this child anchor.
+   * @return List of widgets anchored at @a anchor .
+   */
+  Glib::ListHandle<const Widget*> get_widgets() const;
+  
+  /** Determines whether a child anchor has been deleted from
+   * the buffer. Keep in mind that the child anchor will be
+   * unreferenced when removed from the buffer, so you need to
+   * hold your own reference (with Glib::object_ref()) if you plan
+   * to use this function  @htmlonly&mdash;@endhtmlonly  otherwise all deleted child anchors
+   * will also be finalized.
+   * @return <tt>true</tt> if the child anchor has been deleted from its buffer.
+   */
+  bool get_deleted() const;
+
+  //These methods, and GtkTextLayout are semi-private:
+  
+  //_WRAP_METHOD(void Register_child(TextLayout& layout), gtk_text_child_anchor_register_child)
+  //_WRAP_METHOD(void unregister_child(Widget& child), gtk_text_child_anchor_unregister_child)
+  //_WRAP_METHOD(void queue_resize(TextLayout& layout), gtk_text_child_anchor_queue_resize)
+
+
+public:
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+};
+
+} /* namespace Gtk */
+
+
+namespace Glib
+{
+  /** @relates Gtk::TextChildAnchor
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Glib::RefPtr<Gtk::TextChildAnchor> wrap(GtkTextChildAnchor* object, bool take_copy = false);
+}
+
+
+#endif /* _GTKMM_TEXTCHILDANCHOR_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/textiter.cc b/libs/gtkmm2/gtk/gtkmm/textiter.cc
new file mode 100644
index 0000000000..1881fa5574
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/textiter.cc
@@ -0,0 +1,617 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/textiter.h>
+#include <gtkmm/private/textiter_p.h>
+
+#include <gtk/gtktypebuiltins.h>
+// -*- c++ -*-
+/* $Id$ */
+
+/* Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/texttag.h>
+#include <gtkmm/textbuffer.h>
+
+namespace Gtk
+{
+
+/**** Gtk::TextIter ********************************************************/
+
+
+bool TextIter::get_attributes(TextAttributes& values) const
+{
+  // The initialization is not strictly necessary and omitting it
+  // prevents a gcc-3.2 warning since { 0, } doesn't specifically
+  // initialize all members.
+  GtkTextAttributes gattributes; // = { 0, }
+
+  const bool result = gtk_text_iter_get_attributes(gobj(), &gattributes);
+  values = TextAttributes(&gattributes, true); //true = take_copy.
+  return result;
+}
+
+bool TextIter::begins_tag() const
+{
+  return gtk_text_iter_begins_tag(const_cast<GtkTextIter*>(gobj()), 0 /* see C docs */);
+}
+
+bool TextIter::ends_tag() const
+{
+  return gtk_text_iter_ends_tag(const_cast<GtkTextIter*>(gobj()), 0 /* see C docs */);
+}
+
+bool TextIter::toggles_tag() const
+{
+  return gtk_text_iter_toggles_tag(const_cast<GtkTextIter*>(gobj()), 0 /* see C docs */);
+}
+
+bool TextIter::has_tag() const
+{
+  return gtk_text_iter_has_tag(const_cast<GtkTextIter*>(gobj()), 0 /* see C docs */);
+}
+
+bool TextIter::forward_search(const Glib::ustring& str, TextSearchFlags flags, TextIter& match_start, TextIter& match_end) const
+{
+  return gtk_text_iter_forward_search(const_cast<GtkTextIter*>(gobj()), str.c_str(), ((GtkTextSearchFlags)(flags)), (match_start).gobj(), (match_end).gobj(), 0 /* means end() - see C docs */);
+}
+
+bool TextIter::backward_search(const Glib::ustring& str, TextSearchFlags flags, TextIter& match_start, TextIter& match_end) const
+{
+  return gtk_text_iter_backward_search(const_cast<GtkTextIter*>(gobj()), str.c_str(), ((GtkTextSearchFlags)(flags)), (match_start).gobj(), (match_end).gobj(), 0 /* means end - see C docs */);
+}
+  
+
+} // namespace Gtk
+
+
+namespace
+{
+} // anonymous namespace
+
+// static
+GType Glib::Value<Gtk::TextSearchFlags>::value_type()
+{
+  return gtk_text_search_flags_get_type();
+}
+
+
+namespace Glib
+{
+
+Gtk::TextIter& wrap(GtkTextIter* object)
+{
+  return *reinterpret_cast<Gtk::TextIter*>(object);
+}
+
+const Gtk::TextIter& wrap(const GtkTextIter* object)
+{
+  return *reinterpret_cast<const Gtk::TextIter*>(object);
+}
+
+} // namespace Glib
+
+
+namespace Gtk
+{
+
+
+// static
+GType TextIter::get_type()
+{
+  return gtk_text_iter_get_type();
+}
+
+TextIter::TextIter()
+{
+  GLIBMM_INITIALIZE_STRUCT(gobject_, GtkTextIter);
+}
+
+TextIter::TextIter(const GtkTextIter* gobject)
+{
+  if(gobject)
+    gobject_ = *gobject;
+  else
+    GLIBMM_INITIALIZE_STRUCT(gobject_, GtkTextIter);
+}
+
+
+bool TextIter::forward_find_char_impl(GtkTextCharPredicate predicate, void* user_data, const GtkTextIter* limit)
+{
+  return gtk_text_iter_forward_find_char(gobj(), predicate, user_data, limit);
+}
+
+bool TextIter::backward_find_char_impl(GtkTextCharPredicate predicate, void* user_data, const GtkTextIter* limit)
+{
+  return gtk_text_iter_backward_find_char(gobj(), predicate, user_data, limit);
+}
+
+Glib::RefPtr<TextBuffer> TextIter::get_buffer() const
+{
+
+  Glib::RefPtr<TextBuffer> retvalue = Glib::wrap(gtk_text_iter_get_buffer(const_cast<GtkTextIter*>(gobj())));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+int TextIter::get_offset() const
+{
+  return gtk_text_iter_get_offset(const_cast<GtkTextIter*>(gobj()));
+}
+
+int TextIter::get_line() const
+{
+  return gtk_text_iter_get_line(const_cast<GtkTextIter*>(gobj()));
+}
+
+int TextIter::get_line_offset() const
+{
+  return gtk_text_iter_get_line_offset(const_cast<GtkTextIter*>(gobj()));
+}
+
+int TextIter::get_line_index() const
+{
+  return gtk_text_iter_get_line_index(const_cast<GtkTextIter*>(gobj()));
+}
+
+int TextIter::get_visible_line_offset() const
+{
+  return gtk_text_iter_get_visible_line_offset(const_cast<GtkTextIter*>(gobj()));
+}
+
+int TextIter::get_visible_line_index() const
+{
+  return gtk_text_iter_get_visible_line_index(const_cast<GtkTextIter*>(gobj()));
+}
+
+gunichar TextIter::get_char() const
+{
+  return gtk_text_iter_get_char(const_cast<GtkTextIter*>(gobj()));
+}
+
+Glib::ustring TextIter::get_slice(const TextIter& end) const
+{
+  return Glib::convert_return_gchar_ptr_to_ustring(gtk_text_iter_get_slice(const_cast<GtkTextIter*>(gobj()), (end).gobj()));
+}
+
+Glib::ustring TextIter::get_text(const TextIter& end) const
+{
+  return Glib::convert_return_gchar_ptr_to_ustring(gtk_text_iter_get_text(const_cast<GtkTextIter*>(gobj()), (end).gobj()));
+}
+
+Glib::ustring TextIter::get_visible_slice(const TextIter& end) const
+{
+  return Glib::convert_return_gchar_ptr_to_ustring(gtk_text_iter_get_visible_slice(const_cast<GtkTextIter*>(gobj()), (end).gobj()));
+}
+
+Glib::ustring TextIter::get_visible_text(const TextIter& end) const
+{
+  return Glib::convert_return_gchar_ptr_to_ustring(gtk_text_iter_get_visible_text(const_cast<GtkTextIter*>(gobj()), (end).gobj()));
+}
+
+Glib::RefPtr<Gdk::Pixbuf> TextIter::get_pixbuf() const
+{
+
+  Glib::RefPtr<Gdk::Pixbuf> retvalue = Glib::wrap(gtk_text_iter_get_pixbuf(const_cast<GtkTextIter*>(gobj())));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::SListHandle< Glib::RefPtr<TextMark> > TextIter::get_marks()
+{
+  return Glib::SListHandle< Glib::RefPtr<TextMark> >(gtk_text_iter_get_marks(gobj()), Glib::OWNERSHIP_SHALLOW);
+}
+
+Glib::SListHandle< Glib::RefPtr<const TextMark> > TextIter::get_marks() const
+{
+  return Glib::SListHandle< Glib::RefPtr<const TextMark> >(gtk_text_iter_get_marks(const_cast<GtkTextIter*>(gobj())), Glib::OWNERSHIP_SHALLOW);
+}
+
+Glib::RefPtr<TextChildAnchor> TextIter::get_child_anchor()
+{
+
+  Glib::RefPtr<TextChildAnchor> retvalue = Glib::wrap(gtk_text_iter_get_child_anchor(gobj()));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::RefPtr<const TextChildAnchor> TextIter::get_child_anchor() const
+{
+
+  Glib::RefPtr<const TextChildAnchor> retvalue = Glib::wrap(gtk_text_iter_get_child_anchor(const_cast<GtkTextIter*>(gobj())));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::SListHandle< Glib::RefPtr<TextTag> > TextIter::get_toggled_tags(bool toggled_on)
+{
+  return Glib::SListHandle< Glib::RefPtr<TextTag> >(gtk_text_iter_get_toggled_tags(gobj(), static_cast<int>(toggled_on)), Glib::OWNERSHIP_SHALLOW);
+}
+
+Glib::SListHandle< Glib::RefPtr<const TextTag> > TextIter::get_toggled_tags(bool toggled_on) const
+{
+  return Glib::SListHandle< Glib::RefPtr<const TextTag> >(gtk_text_iter_get_toggled_tags(const_cast<GtkTextIter*>(gobj()), static_cast<int>(toggled_on)), Glib::OWNERSHIP_SHALLOW);
+}
+
+bool TextIter::begins_tag(const Glib::RefPtr<const TextTag>& tag) const
+{
+  return gtk_text_iter_begins_tag(const_cast<GtkTextIter*>(gobj()), const_cast<GtkTextTag*>(Glib::unwrap<TextTag>(tag)));
+}
+
+bool TextIter::ends_tag(const Glib::RefPtr<const TextTag>& tag) const
+{
+  return gtk_text_iter_ends_tag(const_cast<GtkTextIter*>(gobj()), const_cast<GtkTextTag*>(Glib::unwrap<TextTag>(tag)));
+}
+
+bool TextIter::toggles_tag(const Glib::RefPtr<const TextTag>& tag) const
+{
+  return gtk_text_iter_toggles_tag(const_cast<GtkTextIter*>(gobj()), const_cast<GtkTextTag*>(Glib::unwrap<TextTag>(tag)));
+}
+
+bool TextIter::has_tag(const Glib::RefPtr<const TextTag>& tag) const
+{
+  return gtk_text_iter_has_tag(const_cast<GtkTextIter*>(gobj()), const_cast<GtkTextTag*>(Glib::unwrap<TextTag>(tag)));
+}
+
+Glib::SListHandle< Glib::RefPtr<TextTag> > TextIter::get_tags()
+{
+  return Glib::SListHandle< Glib::RefPtr<TextTag> >(gtk_text_iter_get_tags(gobj()), Glib::OWNERSHIP_SHALLOW);
+}
+
+Glib::SListHandle< Glib::RefPtr<const TextTag> > TextIter::get_tags() const
+{
+  return Glib::SListHandle< Glib::RefPtr<const TextTag> >(gtk_text_iter_get_tags(const_cast<GtkTextIter*>(gobj())), Glib::OWNERSHIP_SHALLOW);
+}
+
+bool TextIter::editable(bool default_setting) const
+{
+  return gtk_text_iter_editable(const_cast<GtkTextIter*>(gobj()), static_cast<int>(default_setting));
+}
+
+bool TextIter::can_insert(bool default_editability) const
+{
+  return gtk_text_iter_can_insert(const_cast<GtkTextIter*>(gobj()), static_cast<int>(default_editability));
+}
+
+bool TextIter::starts_word() const
+{
+  return gtk_text_iter_starts_word(const_cast<GtkTextIter*>(gobj()));
+}
+
+bool TextIter::ends_word() const
+{
+  return gtk_text_iter_ends_word(const_cast<GtkTextIter*>(gobj()));
+}
+
+bool TextIter::inside_word() const
+{
+  return gtk_text_iter_inside_word(const_cast<GtkTextIter*>(gobj()));
+}
+
+bool TextIter::starts_sentence() const
+{
+  return gtk_text_iter_starts_sentence(const_cast<GtkTextIter*>(gobj()));
+}
+
+bool TextIter::ends_sentence() const
+{
+  return gtk_text_iter_ends_sentence(const_cast<GtkTextIter*>(gobj()));
+}
+
+bool TextIter::inside_sentence() const
+{
+  return gtk_text_iter_inside_sentence(const_cast<GtkTextIter*>(gobj()));
+}
+
+bool TextIter::starts_line() const
+{
+  return gtk_text_iter_starts_line(const_cast<GtkTextIter*>(gobj()));
+}
+
+bool TextIter::ends_line() const
+{
+  return gtk_text_iter_ends_line(const_cast<GtkTextIter*>(gobj()));
+}
+
+bool TextIter::is_cursor_position() const
+{
+  return gtk_text_iter_is_cursor_position(const_cast<GtkTextIter*>(gobj()));
+}
+
+int TextIter::get_chars_in_line() const
+{
+  return gtk_text_iter_get_chars_in_line(const_cast<GtkTextIter*>(gobj()));
+}
+
+int TextIter::get_bytes_in_line() const
+{
+  return gtk_text_iter_get_bytes_in_line(const_cast<GtkTextIter*>(gobj()));
+}
+
+Pango::Language TextIter::get_language() const
+{
+  return Pango::Language(gtk_text_iter_get_language(const_cast<GtkTextIter*>(gobj())));
+}
+
+bool TextIter::is_end() const
+{
+  return gtk_text_iter_is_end(const_cast<GtkTextIter*>(gobj()));
+}
+
+bool TextIter::is_start() const
+{
+  return gtk_text_iter_is_start(const_cast<GtkTextIter*>(gobj()));
+}
+
+bool TextIter::forward_char()
+{
+  return gtk_text_iter_forward_char(gobj());
+}
+
+bool TextIter::backward_char()
+{
+  return gtk_text_iter_backward_char(gobj());
+}
+
+bool TextIter::forward_chars(int count)
+{
+  return gtk_text_iter_forward_chars(gobj(), count);
+}
+
+bool TextIter::backward_chars(int count)
+{
+  return gtk_text_iter_backward_chars(gobj(), count);
+}
+
+bool TextIter::forward_line()
+{
+  return gtk_text_iter_forward_line(gobj());
+}
+
+bool TextIter::backward_line()
+{
+  return gtk_text_iter_backward_line(gobj());
+}
+
+bool TextIter::forward_lines(int count)
+{
+  return gtk_text_iter_forward_lines(gobj(), count);
+}
+
+bool TextIter::backward_lines(int count)
+{
+  return gtk_text_iter_backward_lines(gobj(), count);
+}
+
+bool TextIter::forward_word_end()
+{
+  return gtk_text_iter_forward_word_end(gobj());
+}
+
+bool TextIter::backward_word_start()
+{
+  return gtk_text_iter_backward_word_start(gobj());
+}
+
+bool TextIter::forward_word_ends(int count)
+{
+  return gtk_text_iter_forward_word_ends(gobj(), count);
+}
+
+bool TextIter::backward_word_starts(int count)
+{
+  return gtk_text_iter_backward_word_starts(gobj(), count);
+}
+
+bool TextIter::forward_visible_word_end()
+{
+  return gtk_text_iter_forward_visible_word_end(gobj());
+}
+
+bool TextIter::backward_visible_word_start()
+{
+  return gtk_text_iter_backward_visible_word_start(gobj());
+}
+
+bool TextIter::forward_visible_word_ends(int count)
+{
+  return gtk_text_iter_forward_visible_word_ends(gobj(), count);
+}
+
+bool TextIter::backward_visible_word_starts(int count)
+{
+  return gtk_text_iter_backward_visible_word_starts(gobj(), count);
+}
+
+bool TextIter::forward_sentence_end()
+{
+  return gtk_text_iter_forward_sentence_end(gobj());
+}
+
+bool TextIter::backward_sentence_start()
+{
+  return gtk_text_iter_backward_sentence_start(gobj());
+}
+
+bool TextIter::forward_sentence_ends(int count)
+{
+  return gtk_text_iter_forward_sentence_ends(gobj(), count);
+}
+
+bool TextIter::backward_sentence_starts(int count)
+{
+  return gtk_text_iter_backward_sentence_starts(gobj(), count);
+}
+
+bool TextIter::forward_cursor_position()
+{
+  return gtk_text_iter_forward_cursor_position(gobj());
+}
+
+bool TextIter::backward_cursor_position()
+{
+  return gtk_text_iter_backward_cursor_position(gobj());
+}
+
+bool TextIter::forward_cursor_positions(int count)
+{
+  return gtk_text_iter_forward_cursor_positions(gobj(), count);
+}
+
+bool TextIter::backward_cursor_positions(int count)
+{
+  return gtk_text_iter_backward_cursor_positions(gobj(), count);
+}
+
+bool TextIter::forward_visible_cursor_position()
+{
+  return gtk_text_iter_forward_visible_cursor_position(gobj());
+}
+
+bool TextIter::backward_visible_cursor_position()
+{
+  return gtk_text_iter_backward_visible_cursor_position(gobj());
+}
+
+bool TextIter::forward_visible_cursor_positions(int count)
+{
+  return gtk_text_iter_forward_visible_cursor_positions(gobj(), count);
+}
+
+bool TextIter::backward_visible_cursor_positions(int count)
+{
+  return gtk_text_iter_backward_visible_cursor_positions(gobj(), count);
+}
+
+void TextIter::set_offset(int char_offset)
+{
+  gtk_text_iter_set_offset(gobj(), char_offset);
+}
+
+void TextIter::set_line(int line_number)
+{
+  gtk_text_iter_set_line(gobj(), line_number);
+}
+
+void TextIter::set_line_offset(int char_on_line)
+{
+  gtk_text_iter_set_line_offset(gobj(), char_on_line);
+}
+
+void TextIter::set_line_index(int byte_on_line)
+{
+  gtk_text_iter_set_line_index(gobj(), byte_on_line);
+}
+
+void TextIter::forward_to_end()
+{
+  gtk_text_iter_forward_to_end(gobj());
+}
+
+bool TextIter::forward_to_line_end()
+{
+  return gtk_text_iter_forward_to_line_end(gobj());
+}
+
+void TextIter::set_visible_line_offset(int char_on_line)
+{
+  gtk_text_iter_set_visible_line_offset(gobj(), char_on_line);
+}
+
+void TextIter::set_visible_line_index(int byte_on_line)
+{
+  gtk_text_iter_set_visible_line_index(gobj(), byte_on_line);
+}
+
+bool TextIter::forward_to_tag_toggle(const Glib::RefPtr<TextTag>& tag)
+{
+  return gtk_text_iter_forward_to_tag_toggle(gobj(), Glib::unwrap(tag));
+}
+
+bool TextIter::backward_to_tag_toggle(const Glib::RefPtr<TextTag>& tag)
+{
+  return gtk_text_iter_backward_to_tag_toggle(gobj(), Glib::unwrap(tag));
+}
+
+bool TextIter::forward_search(const Glib::ustring& str, TextSearchFlags flags, TextIter& match_start, TextIter& match_end, const TextIter& limit) const
+{
+  return gtk_text_iter_forward_search(const_cast<GtkTextIter*>(gobj()), str.c_str(), ((GtkTextSearchFlags)(flags)), (match_start).gobj(), (match_end).gobj(), (limit).gobj());
+}
+
+bool TextIter::backward_search(const Glib::ustring& str, TextSearchFlags flags, TextIter& match_start, TextIter& match_end, const TextIter& limit) const
+{
+  return gtk_text_iter_backward_search(const_cast<GtkTextIter*>(gobj()), str.c_str(), ((GtkTextSearchFlags)(flags)), (match_start).gobj(), (match_end).gobj(), (limit).gobj());
+}
+
+int TextIter::compare(const TextIter& rhs) const
+{
+  return gtk_text_iter_compare(const_cast<GtkTextIter*>(gobj()), (rhs).gobj());
+}
+
+bool TextIter::in_range(const TextIter& start, const TextIter& end) const
+{
+  return gtk_text_iter_in_range(const_cast<GtkTextIter*>(gobj()), (start).gobj(), (end).gobj());
+}
+
+void TextIter::order(TextIter& second)
+{
+  gtk_text_iter_order(gobj(), (second).gobj());
+}
+
+
+bool operator==(const TextIter& lhs, const TextIter& rhs)
+{
+  return (gtk_text_iter_equal(lhs.gobj(), rhs.gobj()) != 0);
+}
+
+bool operator!=(const TextIter& lhs, const TextIter& rhs)
+{
+  return (gtk_text_iter_equal(lhs.gobj(), rhs.gobj()) == 0);
+}
+
+bool operator<(const TextIter& lhs, const TextIter& rhs)
+{
+  return (gtk_text_iter_compare(lhs.gobj(), rhs.gobj()) < 0);
+}
+
+bool operator>(const TextIter& lhs, const TextIter& rhs)
+{
+  return (gtk_text_iter_compare(lhs.gobj(), rhs.gobj()) > 0);
+}
+
+bool operator<=(const TextIter& lhs, const TextIter& rhs)
+{
+  return (gtk_text_iter_compare(lhs.gobj(), rhs.gobj()) <= 0);
+}
+
+bool operator>=(const TextIter& lhs, const TextIter& rhs)
+{
+  return (gtk_text_iter_compare(lhs.gobj(), rhs.gobj()) >= 0);
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/textiter.h b/libs/gtkmm2/gtk/gtkmm/textiter.h
new file mode 100644
index 0000000000..5a8cf919d0
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/textiter.h
@@ -0,0 +1,1210 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_TEXTITER_H
+#define _GTKMM_TEXTITER_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* Copyright(C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software, ) you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library, ) if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <glibmm/exceptionhandler.h>
+#include <glibmm/slisthandle.h>
+#include <gdkmm/pixbuf.h>
+#include <gtkmm/texttag.h>
+#include <gtkmm/textchildanchor.h>
+#include <gtkmm/textattributes.h>
+#include <gtk/gtktextiter.h> /* we need the definition of GtkTextIter */
+
+
+namespace Gtk
+{
+
+
+/** @addtogroup gtkmmEnums Enums and Flags */
+
+/**
+ * @ingroup gtkmmEnums
+ * @par Bitwise operators:
+ * <tt>%TextSearchFlags operator|(TextSearchFlags, TextSearchFlags)</tt><br>
+ * <tt>%TextSearchFlags operator&(TextSearchFlags, TextSearchFlags)</tt><br>
+ * <tt>%TextSearchFlags operator^(TextSearchFlags, TextSearchFlags)</tt><br>
+ * <tt>%TextSearchFlags operator~(TextSearchFlags)</tt><br>
+ * <tt>%TextSearchFlags& operator|=(TextSearchFlags&, TextSearchFlags)</tt><br>
+ * <tt>%TextSearchFlags& operator&=(TextSearchFlags&, TextSearchFlags)</tt><br>
+ * <tt>%TextSearchFlags& operator^=(TextSearchFlags&, TextSearchFlags)</tt><br>
+ */
+enum TextSearchFlags
+{
+  TEXT_SEARCH_VISIBLE_ONLY = 1 << 0,
+  TEXT_SEARCH_TEXT_ONLY = 1 << 1
+};
+
+/** @ingroup gtkmmEnums */
+inline TextSearchFlags operator|(TextSearchFlags lhs, TextSearchFlags rhs)
+  { return static_cast<TextSearchFlags>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs)); }
+
+/** @ingroup gtkmmEnums */
+inline TextSearchFlags operator&(TextSearchFlags lhs, TextSearchFlags rhs)
+  { return static_cast<TextSearchFlags>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs)); }
+
+/** @ingroup gtkmmEnums */
+inline TextSearchFlags operator^(TextSearchFlags lhs, TextSearchFlags rhs)
+  { return static_cast<TextSearchFlags>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs)); }
+
+/** @ingroup gtkmmEnums */
+inline TextSearchFlags operator~(TextSearchFlags flags)
+  { return static_cast<TextSearchFlags>(~static_cast<unsigned>(flags)); }
+
+/** @ingroup gtkmmEnums */
+inline TextSearchFlags& operator|=(TextSearchFlags& lhs, TextSearchFlags rhs)
+  { return (lhs = static_cast<TextSearchFlags>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs))); }
+
+/** @ingroup gtkmmEnums */
+inline TextSearchFlags& operator&=(TextSearchFlags& lhs, TextSearchFlags rhs)
+  { return (lhs = static_cast<TextSearchFlags>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs))); }
+
+/** @ingroup gtkmmEnums */
+inline TextSearchFlags& operator^=(TextSearchFlags& lhs, TextSearchFlags rhs)
+  { return (lhs = static_cast<TextSearchFlags>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs))); }
+
+} // namespace Gtk
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Gtk::TextSearchFlags> : public Glib::Value_Flags<Gtk::TextSearchFlags>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{
+
+
+class TextBuffer;
+class TextMark;
+
+/** Typefed as Gtk::TextBuffer::iterator.
+ * An iterator represents a position between two characters in the text buffer. Iterators are not valid indefinitely; whenever the buffer is
+ * modified in a way that affects the number of characters in the buffer, all outstanding iterators become invalid. (Note that
+ * deleting 5 characters and then reinserting 5 still invalidates iterators, though you end up with the same number of characters
+ * you pass through a state with a different number).
+ *
+ * Because of this, iterators can't be used to preserve positions across buffer modifications. To preserve a position, the
+ * @link Gtk::TextMark Gtk::TextBuffer::Mark@endlink object is ideal.
+ *
+ * You can iterate over characters, words, lines, and sentences,
+ * but operator*() and operator++() deal only in characters.
+ *
+ * TODO: Maybe we should have separate iterators for words, lines, and sentences.
+ * @ingroup TextView
+ */
+class TextIter
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef TextIter CppObjectType;
+  typedef GtkTextIter BaseObjectType;
+
+  static GType get_type() G_GNUC_CONST;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  TextIter();
+
+  explicit TextIter(const GtkTextIter* gobject); // always takes a copy
+
+  ///Provides access to the underlying C instance.
+  GtkTextIter*       gobj()       { return &gobject_; }
+
+  ///Provides access to the underlying C instance.
+  const GtkTextIter* gobj() const { return &gobject_; }
+
+protected:
+  GtkTextIter gobject_;
+
+private:
+  
+  
+public:
+  typedef std::bidirectional_iterator_tag iterator_category;
+  typedef gunichar                        value_type;
+  typedef int                             difference_type;
+  typedef value_type                      reference;
+  typedef void                            pointer;
+
+  /** Alias for forward_char(). */
+  inline TextIter&      operator++();
+  inline const TextIter operator++(int);
+
+  /** Alias for backward_char(). */
+  inline TextIter&      operator--();
+  inline const TextIter operator--(int);
+
+  /** Alias for get_char(). */
+  inline value_type operator*() const;
+
+  /** Alias for !is_end(). */
+  inline operator bool() const;
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+protected:
+  template <class Predicate>
+  struct PredicateAdapter
+  {
+    Predicate predicate_;
+    inline PredicateAdapter(const Predicate& predicate);
+    static gboolean gtk_callback(gunichar uc, void* user_data);
+  };
+
+  
+  /** Advances @a iter , calling @a pred  on each character. If
+   *  @a pred  returns <tt>true</tt>, returns <tt>true</tt> and stops scanning.
+   * If @a pred  never returns <tt>true</tt>, @a iter  is set to @a limit  if
+   *  @a limit  is non-<tt>0</tt>, otherwise to the end iterator.
+   * @param pred A function to be called on each character.
+   * @param user_data User data for @a pred .
+   * @param limit Search limit, or <tt>0</tt> for none.
+   * @return Whether a match was found.
+   */
+  bool forward_find_char_impl(GtkTextCharPredicate predicate,
+                                           void* user_data,
+                                           const GtkTextIter* limit);
+
+  
+  /** Same as gtk_text_iter_forward_find_char(), but goes backward from @a iter .
+   * @param pred Function to be called on each character.
+   * @param user_data User data for @a pred .
+   * @param limit Search limit, or <tt>0</tt> for none.
+   * @return Whether a match was found.
+   */
+  bool backward_find_char_impl(GtkTextCharPredicate predicate,
+                                            void* user_data,
+                                            const GtkTextIter* limit);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+  
+  /** Returns the Gtk::TextBuffer this iterator is associated with.
+   * @return The buffer.
+   */
+  Glib::RefPtr<TextBuffer> get_buffer() const;
+
+  
+  /** Returns the character offset of an iterator.
+   * Each character in a Gtk::TextBuffer has an offset,
+   * starting with 0 for the first character in the buffer.
+   * Use Gtk::TextBuffer::get_iter_at_offset() to convert an
+   * offset back into an iterator.
+   * @return A character offset.
+   */
+  int get_offset() const;
+  
+  /** Returns the line number containing the iterator. Lines in
+   * a Gtk::TextBuffer are numbered beginning with 0 for the first
+   * line in the buffer.
+   * @return A line number.
+   */
+  int get_line() const;
+  
+  /** Returns the character offset of the iterator,
+   * counting from the start of a newline-terminated line.
+   * The first character on the line has offset 0.
+   * @return Offset from start of line.
+   */
+  int get_line_offset() const;
+  
+  /** Returns the byte index of the iterator, counting
+   * from the start of a newline-terminated line.
+   * Remember that Gtk::TextBuffer encodes text in
+   * UTF-8, and that characters can require a variable
+   * number of bytes to represent.
+   * @return Distance from start of line, in bytes.
+   */
+  int get_line_index() const;
+
+  
+  /** Returns the offset in characters from the start of the
+   * line to the given @a iter , not counting characters that
+   * are invisible due to tags with the "invisible" flag
+   * toggled on.
+   * @return Offset in visible characters from the start of the line.
+   */
+  int get_visible_line_offset() const;
+  
+  /** Returns the number of bytes from the start of the
+   * line to the given @a iter , not counting bytes that
+   * are invisible due to tags with the "invisible" flag
+   * toggled on.
+   * @return Byte index of @a iter  with respect to the start of the line.
+   */
+  int get_visible_line_index() const;
+
+  
+  /** Returns the Unicode character at this iterator.  (Equivalent to
+   * operator* on a C++ iterator.)  If the element at this iterator is a
+   * non-character element, such as an image embedded in the buffer, the
+   * Unicode "unknown" character 0xFFFC is returned. If invoked on
+   * the end iterator, zero is returned; zero is not a valid Unicode character.
+   * So you can write a loop which ends when gtk_text_iter_get_char()
+   * returns 0.
+   * @return A Unicode character, or 0 if @a iter  is not dereferenceable.
+   */
+  gunichar get_char() const;
+  
+  /** Returns the text in the given range. A "slice" is an array of
+   * characters encoded in UTF-8 format, including the Unicode "unknown"
+   * character 0xFFFC for iterable non-character elements in the buffer,
+   * such as images.  Because images are encoded in the slice, byte and
+   * character offsets in the returned array will correspond to byte
+   * offsets in the text buffer. Note that 0xFFFC can occur in normal
+   * text as well, so it is not a reliable indicator that a pixbuf or
+   * widget is in the buffer.
+   * @param end Iterator at end of a range.
+   * @return Slice of text from the buffer.
+   */
+  Glib::ustring get_slice(const TextIter& end) const;
+  
+  /** Returns <em>text</em> in the given range.  If the range
+   * contains non-text elements such as images, the character and byte
+   * offsets in the returned string will not correspond to character and
+   * byte offsets in the buffer. If you want offsets to correspond, see
+   * gtk_text_iter_get_slice().
+   * @param end Iterator at end of a range.
+   * @return Array of characters from the buffer.
+   */
+  Glib::ustring get_text(const TextIter& end) const;
+  
+  /** Like gtk_text_iter_get_slice(), but invisible text is not included.
+   * Invisible text is usually invisible because a Gtk::TextTag with the
+   * "invisible" attribute turned on has been applied to it.
+   * @param end Iterator at end of range.
+   * @return Slice of text from the buffer.
+   */
+  Glib::ustring get_visible_slice(const TextIter& end) const;
+  
+  /** Like gtk_text_iter_get_text(), but invisible text is not included.
+   * Invisible text is usually invisible because a Gtk::TextTag with the
+   * "invisible" attribute turned on has been applied to it.
+   * @param end Iterator at end of range.
+   * @return String containing visible text in the range.
+   */
+  Glib::ustring get_visible_text(const TextIter& end) const;
+
+  
+  /** If the element at @a iter  is a pixbuf, the pixbuf is returned
+   * (with no new reference count added). Otherwise,
+   * <tt>0</tt> is returned.
+   * @return The pixbuf at @a iter .
+   */
+  Glib::RefPtr<Gdk::Pixbuf> get_pixbuf() const;
+  
+  /** Returns a list of all Gtk::TextMark at this location. Because marks
+   * are not iterable (they don't take up any "space" in the buffer,
+   * they are just marks in between iterable locations), multiple marks
+   * can exist in the same place. The returned list is not in any
+   * meaningful order.
+   * @return List of Gtk::TextMark.
+   */
+  Glib::SListHandle< Glib::RefPtr<TextMark> > get_marks();
+  
+  /** Returns a list of all Gtk::TextMark at this location. Because marks
+   * are not iterable (they don't take up any "space" in the buffer,
+   * they are just marks in between iterable locations), multiple marks
+   * can exist in the same place. The returned list is not in any
+   * meaningful order.
+   * @return List of Gtk::TextMark.
+   */
+  Glib::SListHandle< Glib::RefPtr<const TextMark> > get_marks() const;
+  
+  
+  /** If the location at @a iter  contains a child anchor, the
+   * anchor is returned (with no new reference count added). Otherwise,
+   * <tt>0</tt> is returned.
+   * @return The anchor at @a iter .
+   */
+  Glib::RefPtr<TextChildAnchor> get_child_anchor();
+  
+  /** If the location at @a iter  contains a child anchor, the
+   * anchor is returned (with no new reference count added). Otherwise,
+   * <tt>0</tt> is returned.
+   * @return The anchor at @a iter .
+   */
+  Glib::RefPtr<const TextChildAnchor> get_child_anchor() const;
+
+  
+  /** Returns a list of Gtk::TextTag that are toggled on or off at this
+   * point.  (If @a toggled_on  is <tt>true</tt>, the list contains tags that are
+   * toggled on.) If a tag is toggled on at @a iter , then some non-empty
+   * range of characters following @a iter  has that tag applied to it.  If
+   * a tag is toggled off, then some non-empty range following @a iter 
+   * does <em>not</em> have the tag applied to it.
+   * @param toggled_on <tt>true</tt> to get toggled-on tags.
+   * @return Tags toggled at this point.
+   */
+  Glib::SListHandle< Glib::RefPtr<TextTag> > get_toggled_tags(bool toggled_on = true);
+  
+  /** Returns a list of Gtk::TextTag that are toggled on or off at this
+   * point.  (If @a toggled_on  is <tt>true</tt>, the list contains tags that are
+   * toggled on.) If a tag is toggled on at @a iter , then some non-empty
+   * range of characters following @a iter  has that tag applied to it.  If
+   * a tag is toggled off, then some non-empty range following @a iter 
+   * does <em>not</em> have the tag applied to it.
+   * @param toggled_on <tt>true</tt> to get toggled-on tags.
+   * @return Tags toggled at this point.
+   */
+  Glib::SListHandle< Glib::RefPtr<const TextTag> > get_toggled_tags(bool toggled_on = true) const;
+
+  
+  /** Returns <tt>true</tt> if @a tag  is toggled on at exactly this point. If @a tag 
+   * is <tt>0</tt>, returns <tt>true</tt> if any tag is toggled on at this point. Note
+   * that the gtk_text_iter_begins_tag() returns <tt>true</tt> if @a iter  is the
+   * <em>start</em> of the tagged range;
+   * gtk_text_iter_has_tag() tells you whether an iterator is
+   * <em>within</em> a tagged range.
+   * @param tag A Gtk::TextTag, or <tt>0</tt>.
+   * @return Whether @a iter  is the start of a range tagged with @a tag .
+   */
+  bool begins_tag(const Glib::RefPtr<const TextTag>& tag) const;
+  bool begins_tag() const;
+  
+  /** Returns <tt>true</tt> if @a tag  is toggled off at exactly this point. If @a tag 
+   * is <tt>0</tt>, returns <tt>true</tt> if any tag is toggled off at this point. Note
+   * that the gtk_text_iter_ends_tag() returns <tt>true</tt> if @a iter  is the
+   * <em>end</em> of the tagged range;
+   * gtk_text_iter_has_tag() tells you whether an iterator is
+   * <em>within</em> a tagged range.
+   * @param tag A Gtk::TextTag, or <tt>0</tt>.
+   * @return Whether @a iter  is the end of a range tagged with @a tag .
+   */
+  bool ends_tag(const Glib::RefPtr<const TextTag>& tag) const;
+  bool ends_tag() const;
+  
+  /** This is equivalent to (gtk_text_iter_begins_tag() ||
+   * gtk_text_iter_ends_tag()), i.e.\ it tells you whether a range with
+   *  @a tag  applied to it begins <em>or</em> ends at @a iter .
+   * @param tag A Gtk::TextTag, or <tt>0</tt>.
+   * @return Whether @a tag  is toggled on or off at @a iter .
+   */
+  bool toggles_tag(const Glib::RefPtr<const TextTag>& tag) const;
+  bool toggles_tag() const;
+
+  
+  /** Returns <tt>true</tt> if @a iter  is within a range tagged with @a tag .
+   * @param tag A Gtk::TextTag.
+   * @return Whether @a iter  is tagged with @a tag .
+   */
+  bool has_tag(const Glib::RefPtr<const TextTag>& tag) const;
+  bool has_tag() const;
+  
+  
+  /** Returns a list of tags that apply to @a iter , in ascending order of
+   * priority (highest-priority tags are last).
+   * @return List of Gtk::TextTag.
+   */
+  Glib::SListHandle< Glib::RefPtr<TextTag> > get_tags();
+  
+  /** Returns a list of tags that apply to @a iter , in ascending order of
+   * priority (highest-priority tags are last).
+   * @return List of Gtk::TextTag.
+   */
+  Glib::SListHandle< Glib::RefPtr<const TextTag> > get_tags() const;
+
+  
+  /** Returns whether the character at @a iter  is within an editable region
+   * of text.  Non-editable text is "locked" and can't be changed by the
+   * user via Gtk::TextView. This function is simply a convenience
+   * wrapper around gtk_text_iter_get_attributes(). If no tags applied
+   * to this text affect editability, @a default_setting  will be returned.
+   * 
+   * You don't want to use this function to decide whether text can be
+   * inserted at @a iter , because for insertion you don't want to know
+   * whether the char at @a iter  is inside an editable range, you want to
+   * know whether a new character inserted at @a iter  would be inside an
+   * editable range. Use gtk_text_iter_can_insert() to handle this
+   * case.
+   * @param default_setting <tt>true</tt> if text is editable by default.
+   * @return Whether @a iter  is inside an editable range.
+   */
+  bool editable(bool default_setting = true) const;
+  
+  /** Considering the default editability of the buffer, and tags that
+   * affect editability, determines whether text inserted at @a iter  would
+   * be editable. If text inserted at @a iter  would be editable then the
+   * user should be allowed to insert text at @a iter .
+   * Gtk::TextBuffer::insert_interactive() uses this function to decide
+   * whether insertions are allowed at a given position.
+   * @param default_editability <tt>true</tt> if text is editable by default.
+   * @return Whether text inserted at @a iter  would be editable.
+   */
+  bool can_insert(bool default_editability = true) const;
+
+  
+  /** Determines whether @a iter  begins a natural-language word.  Word
+   * breaks are determined by Pango and should be correct for nearly any
+   * language (if not, the correct fix would be to the Pango word break
+   * algorithms).
+   * @return <tt>true</tt> if @a iter  is at the start of a word.
+   */
+  bool starts_word() const;
+  
+  /** Determines whether @a iter  ends a natural-language word.  Word breaks
+   * are determined by Pango and should be correct for nearly any
+   * language (if not, the correct fix would be to the Pango word break
+   * algorithms).
+   * @return <tt>true</tt> if @a iter  is at the end of a word.
+   */
+  bool ends_word() const;
+  
+  /** Determines whether @a iter  is inside a natural-language word (as
+   * opposed to say inside some whitespace).  Word breaks are determined
+   * by Pango and should be correct for nearly any language (if not, the
+   * correct fix would be to the Pango word break algorithms).
+   * @return <tt>true</tt> if @a iter  is inside a word.
+   */
+  bool inside_word() const;
+  
+  /** Determines whether @a iter  begins a sentence.  Sentence boundaries are
+   * determined by Pango and should be correct for nearly any language
+   * (if not, the correct fix would be to the Pango text boundary
+   * algorithms).
+   * @return <tt>true</tt> if @a iter  is at the start of a sentence.
+   */
+  bool starts_sentence() const;
+  
+  /** Determines whether @a iter  ends a sentence.  Sentence boundaries are
+   * determined by Pango and should be correct for nearly any language
+   * (if not, the correct fix would be to the Pango text boundary
+   * algorithms).
+   * @return <tt>true</tt> if @a iter  is at the end of a sentence.
+   */
+  bool ends_sentence() const;
+  
+  /** Determines whether @a iter  is inside a sentence (as opposed to in
+   * between two sentences, e.g.\ after a period and before the first
+   * letter of the next sentence).  Sentence boundaries are determined
+   * by Pango and should be correct for nearly any language (if not, the
+   * correct fix would be to the Pango text boundary algorithms).
+   * @return <tt>true</tt> if @a iter  is inside a sentence.
+   */
+  bool inside_sentence() const;
+  
+  /** Returns <tt>true</tt> if @a iter  begins a paragraph,
+   * i.e.\ if gtk_text_iter_get_line_offset() would return 0.
+   * However this function is potentially more efficient than
+   * gtk_text_iter_get_line_offset() because it doesn't have to compute
+   * the offset, it just has to see whether it's 0.
+   * @return Whether @a iter  begins a line.
+   */
+  bool starts_line() const;
+  
+  /** Returns <tt>true</tt> if @a iter  points to the start of the paragraph
+   * delimiter characters for a line (delimiters will be either a
+   * newline, a carriage return, a carriage return followed by a
+   * newline, or a Unicode paragraph separator character). Note that an
+   * iterator pointing to the <tt>\\n</tt> of a <tt>\\r</tt><tt>\\n</tt> pair will not be counted as
+   * the end of a line, the line ends before the <tt>\\r</tt>. The end iterator is
+   * considered to be at the end of a line, even though there are no
+   * paragraph delimiter chars there.
+   * @return Whether @a iter  is at the end of a line.
+   */
+  bool ends_line() const;
+  
+  /** See gtk_text_iter_forward_cursor_position() or Pango::LogAttr or
+   * pango_break() for details on what a cursor position is.
+   * @return <tt>true</tt> if the cursor can be placed at @a iter .
+   */
+  bool is_cursor_position() const;
+
+  
+  /** Returns the number of characters in the line containing @a iter ,
+   * including the paragraph delimiters.
+   * @return Number of characters in the line.
+   */
+  int get_chars_in_line() const;
+  
+  /** Returns the number of bytes in the line containing @a iter ,
+   * including the paragraph delimiters.
+   * @return Number of bytes in the line.
+   */
+  int get_bytes_in_line() const;
+
+  bool get_attributes(TextAttributes& values) const;
+  
+  /** A convenience wrapper around gtk_text_iter_get_attributes(),
+   * which returns the language in effect at @a iter . If no tags affecting
+   * language apply to @a iter , the return value is identical to that of
+   * gtk_get_default_language().
+   * @return Language in effect at @a iter .
+   */
+  Pango::Language get_language() const;
+  
+  /** Returns <tt>true</tt> if @a iter  is the end iterator, i.e.\ one past the last
+   * dereferenceable iterator in the buffer. gtk_text_iter_is_end() is
+   * the most efficient way to check whether an iterator is the end
+   * iterator.
+   * @return Whether @a iter  is the end iterator.
+   */
+  bool is_end() const;
+  
+  /** Returns <tt>true</tt> if @a iter  is the first iterator in the buffer, that is
+   * if @a iter  has a character offset of 0.
+   * @return Whether @a iter  is the first in the buffer.
+   */
+  bool is_start() const;
+
+  
+  /** Moves @a iter  forward by one character offset. Note that images
+   * embedded in the buffer occupy 1 character slot, so
+   * gtk_text_iter_forward_char() may actually move onto an image instead
+   * of a character, if you have images in your buffer.  If @a iter  is the
+   * end iterator or one character before it, @a iter  will now point at
+   * the end iterator, and gtk_text_iter_forward_char() returns <tt>false</tt> for
+   * convenience when writing loops.
+   * @return Whether @a iter  moved and is dereferenceable.
+   */
+  bool forward_char();
+  
+  /** Moves backward by one character offset. Returns <tt>true</tt> if movement
+   * was possible; if @a iter  was the first in the buffer (character
+   * offset 0), gtk_text_iter_backward_char() returns <tt>false</tt> for convenience when
+   * writing loops.
+   * @return Whether movement was possible.
+   */
+  bool backward_char();
+  
+  /** Moves @a count  characters if possible (if @a count  would move past the
+   * start or end of the buffer, moves to the start or end of the
+   * buffer). The return value indicates whether the new position of
+   *  @a iter  is different from its original position, and dereferenceable
+   * (the last iterator in the buffer is not dereferenceable). If @a count 
+   * is 0, the function does nothing and returns <tt>false</tt>.
+   * @param count Number of characters to move, may be negative.
+   * @return Whether @a iter  moved and is dereferenceable.
+   */
+  bool forward_chars(int count);
+  
+  /** Moves @a count  characters backward, if possible (if @a count  would move
+   * past the start or end of the buffer, moves to the start or end of
+   * the buffer).  The return value indicates whether the iterator moved
+   * onto a dereferenceable position; if the iterator didn't move, or
+   * moved onto the end iterator, then <tt>false</tt> is returned. If @a count  is 0,
+   * the function does nothing and returns <tt>false</tt>.
+   * @param count Number of characters to move.
+   * @return Whether @a iter  moved and is dereferenceable.
+   */
+  bool backward_chars(int count);
+  
+  /** Moves @a iter  to the start of the next line. Returns <tt>true</tt> if there
+   * was a next line to move to, and <tt>false</tt> if @a iter  was simply moved to
+   * the end of the buffer and is now not dereferenceable, or if @a iter  was
+   * already at the end of the buffer.
+   * @return Whether @a iter  can be dereferenced.
+   */
+  bool forward_line();
+  
+  /** Moves @a iter  to the start of the previous line. Returns <tt>true</tt> if
+   *  @a iter  could be moved; i.e. if @a iter  was at character offset 0, this
+   * function returns <tt>false</tt>. Therefore if @a iter  was already on line 0,
+   * but not at the start of the line, @a iter  is snapped to the start of
+   * the line and the function returns <tt>true</tt>. (Note that this implies that
+   * in a loop calling this function, the line number may not change on
+   * every iteration, if your first iteration is on line 0.)
+   * @return Whether @a iter  moved.
+   */
+  bool backward_line();
+  
+  /** Moves @a count  lines forward, if possible (if @a count  would move
+   * past the start or end of the buffer, moves to the start or end of
+   * the buffer).  The return value indicates whether the iterator moved
+   * onto a dereferenceable position; if the iterator didn't move, or
+   * moved onto the end iterator, then <tt>false</tt> is returned. If @a count  is 0,
+   * the function does nothing and returns <tt>false</tt>. If @a count  is negative,
+   * moves backward by 0 - @a count  lines.
+   * @param count Number of lines to move forward.
+   * @return Whether @a iter  moved and is dereferenceable.
+   */
+  bool forward_lines(int count);
+  
+  /** Moves @a count  lines backward, if possible (if @a count  would move
+   * past the start or end of the buffer, moves to the start or end of
+   * the buffer).  The return value indicates whether the iterator moved
+   * onto a dereferenceable position; if the iterator didn't move, or
+   * moved onto the end iterator, then <tt>false</tt> is returned. If @a count  is 0,
+   * the function does nothing and returns <tt>false</tt>. If @a count  is negative,
+   * moves forward by 0 - @a count  lines.
+   * @param count Number of lines to move backward.
+   * @return Whether @a iter  moved and is dereferenceable.
+   */
+  bool backward_lines(int count);
+  
+  /** Moves forward to the next word end. (If @a iter  is currently on a
+   * word end, moves forward to the next one after that.) Word breaks
+   * are determined by Pango and should be correct for nearly any
+   * language (if not, the correct fix would be to the Pango word break
+   * algorithms).
+   * @return <tt>true</tt> if @a iter  moved and is not the end iterator.
+   */
+  bool forward_word_end();
+  
+  /** Moves backward to the previous word start. (If @a iter  is currently on a
+   * word start, moves backward to the next one after that.) Word breaks
+   * are determined by Pango and should be correct for nearly any
+   * language (if not, the correct fix would be to the Pango word break
+   * algorithms).
+   * @return <tt>true</tt> if @a iter  moved and is not the end iterator.
+   */
+  bool backward_word_start();
+  
+  /** Calls gtk_text_iter_forward_word_end() up to @a count  times.
+   * @param count Number of times to move.
+   * @return <tt>true</tt> if @a iter  moved and is not the end iterator.
+   */
+  bool forward_word_ends(int count);
+  
+  /** Calls gtk_text_iter_backward_word_start() up to @a count  times.
+   * @param count Number of times to move.
+   * @return <tt>true</tt> if @a iter  moved and is not the end iterator.
+   */
+  bool backward_word_starts(int count);
+
+  //TODO: Now that there are so many *_visible_ versions of the methods, maybe we should
+  //just add a visible=false parameter and therefore halve the number of methods. murrayc
+  
+  
+  /** Moves forward to the next visible word end. (If @a iter  is currently on a
+   * word end, moves forward to the next one after that.) Word breaks
+   * are determined by Pango and should be correct for nearly any
+   * language (if not, the correct fix would be to the Pango word break
+   * algorithms).
+   * @return <tt>true</tt> if @a iter  moved and is not the end iterator 
+   * 
+   * Since: 2.4.
+   */
+  bool forward_visible_word_end();
+  
+  /** Moves backward to the previous visible word start. (If @a iter  is currently 
+   * on a word start, moves backward to the next one after that.) Word breaks
+   * are determined by Pango and should be correct for nearly any
+   * language (if not, the correct fix would be to the Pango word break
+   * algorithms).
+   * @return <tt>true</tt> if @a iter  moved and is not the end iterator 
+   * 
+   * Since: 2.4.
+   */
+  bool backward_visible_word_start();
+  
+  /** Calls gtk_text_iter_forward_visible_word_end() up to @a count  times.
+   * @param count Number of times to move.
+   * @return <tt>true</tt> if @a iter  moved and is not the end iterator 
+   * 
+   * Since: 2.4.
+   */
+  bool forward_visible_word_ends(int count);
+  
+  /** Calls gtk_text_iter_backward_visible_word_start() up to @a count  times.
+   * @param count Number of times to move.
+   * @return <tt>true</tt> if @a iter  moved and is not the end iterator 
+   * 
+   * Since: 2.4.
+   */
+  bool backward_visible_word_starts(int count);
+
+  
+  /** Moves forward to the next sentence end. (If @a iter  is at the end of
+   * a sentence, moves to the next end of sentence.)  Sentence
+   * boundaries are determined by Pango and should be correct for nearly
+   * any language (if not, the correct fix would be to the Pango text
+   * boundary algorithms).
+   * @return <tt>true</tt> if @a iter  moved and is not the end iterator.
+   */
+  bool forward_sentence_end();
+  
+  /** Moves backward to the previous sentence start; if @a iter  is already at
+   * the start of a sentence, moves backward to the next one.  Sentence
+   * boundaries are determined by Pango and should be correct for nearly
+   * any language (if not, the correct fix would be to the Pango text
+   * boundary algorithms).
+   * @return <tt>true</tt> if @a iter  moved and is not the end iterator.
+   */
+  bool backward_sentence_start();
+  
+  /** Calls gtk_text_iter_forward_sentence_end() @a count  times (or until
+   * gtk_text_iter_forward_sentence_end() returns <tt>false</tt>). If @a count  is
+   * negative, moves backward instead of forward.
+   * @param count Number of sentences to move.
+   * @return <tt>true</tt> if @a iter  moved and is not the end iterator.
+   */
+  bool forward_sentence_ends(int count);
+  
+  /** Calls gtk_text_iter_backward_sentence_start() up to @a count  times,
+   * or until it returns <tt>false</tt>. If @a count  is negative, moves forward
+   * instead of backward.
+   * @param count Number of sentences to move.
+   * @return <tt>true</tt> if @a iter  moved and is not the end iterator.
+   */
+  bool backward_sentence_starts(int count);
+
+  
+  /** Moves @a iter  forward by a single cursor position. Cursor positions
+   * are (unsurprisingly) positions where the cursor can appear. Perhaps
+   * surprisingly, there may not be a cursor position between all
+   * characters. The most common example for European languages would be
+   * a carriage return/newline sequence. For some Unicode characters,
+   * the equivalent of say the letter "a" with an accent mark will be
+   * represented as two characters, first the letter then a "combining
+   * mark" that causes the accent to be rendered; so the cursor can't go
+   * between those two characters. See also the Pango::LogAttr structure and
+   * pango_break() function.
+   * @return <tt>true</tt> if we moved and the new position is dereferenceable.
+   */
+  bool forward_cursor_position();
+  
+  /** Like gtk_text_iter_forward_cursor_position(), but moves backward.
+   * @return <tt>true</tt> if we moved.
+   */
+  bool backward_cursor_position();
+  
+  /** Moves up to @a count  cursor positions. See
+   * gtk_text_iter_forward_cursor_position() for details.
+   * @param count Number of positions to move.
+   * @return <tt>true</tt> if we moved and the new position is dereferenceable.
+   */
+  bool forward_cursor_positions(int count);
+  
+  /** Moves up to @a count  cursor positions. See
+   * gtk_text_iter_forward_cursor_position() for details.
+   * @param count Number of positions to move.
+   * @return <tt>true</tt> if we moved and the new position is dereferenceable.
+   */
+  bool backward_cursor_positions(int count);
+
+  
+  /** Moves @a iter  forward to the next visible cursor position. See 
+   * gtk_text_iter_forward_cursor_position() for details.
+   * @return <tt>true</tt> if we moved and the new position is dereferenceable
+   * 
+   * Since: 2.4.
+   */
+  bool forward_visible_cursor_position();
+  
+  /** Moves @a iter  forward to the previous visible cursor position. See 
+   * gtk_text_iter_backward_cursor_position() for details.
+   * @return <tt>true</tt> if we moved and the new position is dereferenceable
+   * 
+   * Since: 2.4.
+   */
+  bool backward_visible_cursor_position();
+  
+  /** Moves up to @a count  visible cursor positions. See
+   * gtk_text_iter_forward_cursor_position() for details.
+   * @param count Number of positions to move.
+   * @return <tt>true</tt> if we moved and the new position is dereferenceable
+   * 
+   * Since: 2.4.
+   */
+  bool forward_visible_cursor_positions(int count);
+  
+  /** Moves up to @a count  visible cursor positions. See
+   * gtk_text_iter_forward_cursor_position() for details.
+   * @param count Number of positions to move.
+   * @return <tt>true</tt> if we moved and the new position is dereferenceable
+   * 
+   * Since: 2.4.
+   */
+  bool backward_visible_cursor_positions(int count);
+
+  
+  /** Sets @a iter  to point to @a char_offset . @a char_offset  counts from the start
+   * of the entire text buffer, starting with 0.
+   * @param char_offset A character number.
+   */
+  void set_offset(int char_offset);
+  
+  /** Moves iterator @a iter  to the start of the line @a line_number .  If
+   *  @a line_number  is negative or larger than the number of lines in the
+   * buffer, moves @a iter  to the start of the last line in the buffer.
+   * @param line_number Line number (counted from 0).
+   */
+  void set_line(int line_number);
+  
+  /** Moves @a iter  within a line, to a new <em>character</em>
+   * (not byte) offset. The given character offset must be less than or
+   * equal to the number of characters in the line; if equal, @a iter 
+   * moves to the start of the next line. See
+   * gtk_text_iter_set_line_index() if you have a byte index rather than
+   * a character offset.
+   * @param char_on_line A character offset relative to the start of @a iter 's current line.
+   */
+  void set_line_offset(int char_on_line);
+  
+  /** Same as gtk_text_iter_set_line_offset(), but works with a
+   * <em>byte</em> index. The given byte index must be at
+   * the start of a character, it can't be in the middle of a UTF-8
+   * encoded character.
+   * @param byte_on_line A byte index relative to the start of @a iter 's current line.
+   */
+  void set_line_index(int byte_on_line);
+  
+  /** Moves @a iter  forward to the "end iterator," which points one past the last
+   * valid character in the buffer. gtk_text_iter_get_char() called on the
+   * end iterator returns 0, which is convenient for writing loops.
+   */
+  void forward_to_end();
+  
+  /** Moves the iterator to point to the paragraph delimiter characters,
+   * which will be either a newline, a carriage return, a carriage
+   * return/newline in sequence, or the Unicode paragraph separator
+   * character. If the iterator is already at the paragraph delimiter
+   * characters, moves to the paragraph delimiter characters for the
+   * next line. If @a iter  is on the last line in the buffer, which does
+   * not end in paragraph delimiters, moves to the end iterator (end of
+   * the last line), and returns <tt>false</tt>.
+   * @return <tt>true</tt> if we moved and the new location is not the end iterator.
+   */
+  bool forward_to_line_end();
+
+  
+  /** Like gtk_text_iter_set_line_offset(), but the offset is in visible
+   * characters, i.e.\ text with a tag making it invisible is not
+   * counted in the offset.
+   * @param char_on_line A character offset.
+   */
+  void set_visible_line_offset(int char_on_line);
+  
+  /** Like gtk_text_iter_set_line_index(), but the index is in visible
+   * bytes, i.e.\ text with a tag making it invisible is not counted
+   * in the index.
+   * @param byte_on_line A byte index.
+   */
+  void set_visible_line_index(int byte_on_line);
+
+  
+  /** Moves forward to the next toggle (on or off) of the
+   * Gtk::TextTag @a tag , or to the next toggle of any tag if
+   *  @a tag  is <tt>0</tt>. If no matching tag toggles are found,
+   * returns <tt>false</tt>, otherwise <tt>true</tt>. Does not return toggles
+   * located at @a iter , only toggles after @a iter . Sets @a iter  to
+   * the location of the toggle, or to the end of the buffer
+   * if no toggle is found.
+   * @param tag A Gtk::TextTag, or <tt>0</tt>.
+   * @return Whether we found a tag toggle after @a iter .
+   */
+  bool forward_to_tag_toggle(const Glib::RefPtr<TextTag>& tag);
+  
+  /** Moves backward to the next toggle (on or off) of the
+   * Gtk::TextTag @a tag , or to the next toggle of any tag if
+   *  @a tag  is <tt>0</tt>. If no matching tag toggles are found,
+   * returns <tt>false</tt>, otherwise <tt>true</tt>. Does not return toggles
+   * located at @a iter , only toggles before @a iter . Sets @a iter 
+   * to the location of the toggle, or the start of the buffer
+   * if no toggle is found.
+   * @param tag A Gtk::TextTag, or <tt>0</tt>.
+   * @return Whether we found a tag toggle before @a iter .
+   */
+  bool backward_to_tag_toggle(const Glib::RefPtr<TextTag>& tag);
+
+  template <class Predicate> bool forward_find_char(const Predicate& predicate, const TextIter& limit);
+  template <class Predicate> bool forward_find_char(const Predicate& predicate);
+  template <class Predicate> bool backward_find_char(const Predicate& predicate, const TextIter& limit);
+  template <class Predicate> bool backward_find_char(const Predicate& predicate);
+
+  
+  /** Searches forward for @a str . Any match is returned by setting 
+   *  @a match_start  to the first character of the match and @a match_end  to the 
+   * first character after the match. The search will not continue past
+   *  @a limit . Note that a search is a linear or O(n) operation, so you
+   * may wish to use @a limit  to avoid locking up your UI on large
+   * buffers.
+   * 
+   * If the Gtk::TEXT_SEARCH_VISIBLE_ONLY flag is present, the match may
+   * have invisible text interspersed in @a str . i.e. @a str  will be a
+   * possibly-noncontiguous subsequence of the matched range. similarly,
+   * if you specify Gtk::TEXT_SEARCH_TEXT_ONLY, the match may have
+   * pixbufs or child widgets mixed inside the matched range. If these
+   * flags are not given, the match must be exact; the special 0xFFFC
+   * character in @a str  will match embedded pixbufs or child widgets.
+   * @param str A search string.
+   * @param flags Flags affecting how the search is done.
+   * @param match_start Return location for start of match.
+   * @param match_end Return location for end of match.
+   * @param limit Bound for the search.
+   * @return Whether a match was found.
+   */
+  bool forward_search(const Glib::ustring& str,
+                                   TextSearchFlags flags,
+                                   TextIter& match_start,
+                                   TextIter& match_end,
+                                   const TextIter& limit) const;
+         
+  /** Same as forward_search(), but searchs to the end.
+   *
+   * @param str A search string.
+   * @param flags Flags affecting how the search is done.
+   * @param match_start Return location for start of match, or <tt>0</tt>.
+   * @param match_end Return location for end of match, or <tt>0</tt>.
+   * @return Whether a match was found.
+   */                          
+   bool forward_search(const Glib::ustring& str, TextSearchFlags flags, TextIter& match_start, TextIter& match_end) const;
+
+  
+  /** Same as gtk_text_iter_forward_search(), but moves backward.
+   * @param str Search string.
+   * @param flags Bitmask of flags affecting the search.
+   * @param match_start Return location for start of match.
+   * @param match_end Return location for end of match.
+   * @param limit Location of last possible @a match_start .
+   * @return Whether a match was found.
+   */
+  bool backward_search(const Glib::ustring& str,
+                                    TextSearchFlags flags,
+                                    TextIter& match_start,
+                                    TextIter& match_end,
+                                    const TextIter& limit) const;
+
+  /** Same as backward_search(), but searches to the start.
+   * @param str Search string.
+   * @param flags Bitmask of flags affecting the search.
+   * @param match_start Return location for start of match, or <tt>0</tt>.
+   * @param match_end Return location for end of match, or <tt>0</tt>.
+   * @return Whether a match was found.
+   */                                    
+  bool backward_search(const Glib::ustring& str, TextSearchFlags flags, TextIter& match_start, TextIter& match_end) const;
+
+  
+  /** A qsort()-style function that returns negative if @a lhs  is less than
+   *  @a rhs , positive if @a lhs  is greater than @a rhs , and 0 if they're equal.
+   * Ordering is in character offset order, i.e. the first character in the buffer
+   * is less than the second character in the buffer.
+   * @param rhs Another Gtk::TextIter.
+   * @return -1 if @a lhs  is less than @a rhs , 1 if @a lhs  is greater, 0 if they are equal.
+   */
+  int compare(const TextIter& rhs) const;
+  
+  /** Checks whether @a iter  falls in the range [ @a start , @a end ).
+   *  @a start  and @a end  must be in ascending order.
+   * @param start Start of range.
+   * @param end End of range.
+   * @return <tt>true</tt> if @a iter  is in the range.
+   */
+  bool in_range(const TextIter& start, const TextIter& end) const;
+  
+  /** Swaps the value of @a first  and @a second  if @a second  comes before
+   *  @a first  in the buffer. That is, ensures that @a first  and @a second  are
+   * in sequence. Most text buffer functions that take a range call this
+   * automatically on your behalf, so there's no real reason to call it yourself
+   * in those cases. There are some exceptions, such as gtk_text_iter_in_range(),
+   * that expect a pre-sorted range.
+   * @param second Another Gtk::TextIter.
+   */
+  void order(TextIter& second);
+
+  
+};
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+template <class Predicate> inline
+TextIter::PredicateAdapter<Predicate>::PredicateAdapter(const Predicate& predicate)
+:
+  predicate_ (predicate)
+{}
+
+// static
+template <class Predicate>
+gboolean TextIter::PredicateAdapter<Predicate>::gtk_callback(gunichar uc, void* user_data)
+{
+  try
+  {
+    // This will either use Predicate::operator(), or call a function pointer.
+    // The explicit conditional expression avoids relying on an implicit
+    // conversion of the return type to int, which might be not available.
+    return (static_cast<TextIter::PredicateAdapter<Predicate>*>(user_data)->predicate_(uc)) ? 1 : 0;
+  }
+  catch(...)
+  {
+    Glib::exception_handlers_invoke();
+    return 0;
+  }
+}
+
+inline
+TextIter& TextIter::operator++()
+{
+  forward_char();
+  return *this;
+}
+
+inline
+const TextIter TextIter::operator++(int)
+{
+  const TextIter temp (*this);
+  forward_char();
+  return temp;
+}
+
+inline
+TextIter& TextIter::operator--()
+{
+  backward_char();
+  return *this;
+}
+
+inline
+const TextIter TextIter::operator--(int)
+{
+  const TextIter temp (*this);
+  backward_char();
+  return temp;
+}
+
+inline
+TextIter::value_type TextIter::operator*() const
+{
+  return get_char();
+}
+
+inline
+TextIter::operator bool() const
+{
+  return !is_end();
+}
+
+template <class Predicate>
+bool TextIter::forward_find_char(const Predicate& predicate, const TextIter& limit)
+{
+  typedef TextIter::PredicateAdapter<Predicate> PredAdapter;
+  PredAdapter adapter (predicate);
+  return this->forward_find_char_impl(&PredAdapter::gtk_callback, &adapter, limit.gobj());
+}
+
+template <class Predicate>
+bool TextIter::forward_find_char(const Predicate& predicate)
+{
+  typedef TextIter::PredicateAdapter<Predicate> PredAdapter;
+  PredAdapter adapter (predicate);
+  return this->forward_find_char_impl(&PredAdapter::gtk_callback, &adapter, 0);
+}
+
+template <class Predicate>
+bool TextIter::backward_find_char(const Predicate& predicate, const TextIter& limit)
+{
+  typedef TextIter::PredicateAdapter<Predicate> PredAdapter;
+  PredAdapter adapter (predicate);
+  return this->backward_find_char_impl(&PredAdapter::gtk_callback, &adapter, limit.gobj());
+}
+
+template <class Predicate>
+bool TextIter::backward_find_char(const Predicate& predicate)
+{
+  typedef TextIter::PredicateAdapter<Predicate> PredAdapter;
+  PredAdapter adapter (predicate);
+  return this->backward_find_char_impl(&PredAdapter::gtk_callback, &adapter, 0);
+}
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+} // namespace Gtk
+
+
+namespace Gtk
+{
+
+/** @relates Gtk::TextIter
+ * @param lhs The left-hand side
+ * @param rhs The right-hand side
+ * @result The result
+ */
+bool operator==(const TextIter& lhs, const TextIter& rhs);
+
+/** @relates Gtk::TextIter
+ * @param lhs The left-hand side
+ * @param rhs The right-hand side
+ * @result The result
+ */
+bool operator!=(const TextIter& lhs, const TextIter& rhs);
+
+/** @relates Gtk::TextIter
+ * @param lhs The left-hand side
+ * @param rhs The right-hand side
+ * @result The result
+ */
+bool operator<(const TextIter& lhs, const TextIter& rhs);
+
+/** @relates Gtk::TextIter
+ * @param lhs The left-hand side
+ * @param rhs The right-hand side
+ * @result The result
+ */
+bool operator>(const TextIter& lhs, const TextIter& rhs);
+
+/** @relates Gtk::TextIter
+ * @param lhs The left-hand side
+ * @param rhs The right-hand side
+ * @result The result
+ */
+bool operator<=(const TextIter& lhs, const TextIter& rhs);
+
+/** @relates Gtk::TextIter
+ * @param lhs The left-hand side
+ * @param rhs The right-hand side
+ * @result The result
+ */
+bool operator>=(const TextIter& lhs, const TextIter& rhs);
+
+
+} // namespace Gtk
+
+
+namespace Glib
+{
+
+/** @relates Gtk::TextIter
+ * @param object The C instance
+ * @result A C++ instance that wraps this C instance.
+ */
+Gtk::TextIter& wrap(GtkTextIter* object);
+
+/** @relates Gtk::TextIter
+ * @param object The C instance
+ * @result A C++ instance that wraps this C instance.
+ */
+const Gtk::TextIter& wrap(const GtkTextIter* object);
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+template <>
+class Value<Gtk::TextIter> : public Glib::Value_Boxed<Gtk::TextIter>
+{};
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+} // namespace Glib
+
+#endif /* _GTKMM_TEXTITER_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/textmark.cc b/libs/gtkmm2/gtk/gtkmm/textmark.cc
new file mode 100644
index 0000000000..2252f8715d
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/textmark.cc
@@ -0,0 +1,187 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/textmark.h>
+#include <gtkmm/private/textmark_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* 
+ *
+ * Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+
+#include <gtkmm/textmark.h>
+#include <gtkmm/textbuffer.h>
+#include <gtk/gtktextmark.h>
+
+
+namespace Gtk
+{
+
+TextIter TextMark::get_iter()
+{
+  Glib::RefPtr<TextMark> mark = Glib::RefPtr<TextMark>(this);
+  mark->reference(); // RefPtr (T_CppObject* pCppObject) does not do a reference
+  return get_buffer()->get_iter_at_mark(mark);
+}
+
+} //namespace Gtk
+
+
+namespace
+{
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Glib::RefPtr<Gtk::TextMark> wrap(GtkTextMark* object, bool take_copy)
+{
+  return Glib::RefPtr<Gtk::TextMark>( dynamic_cast<Gtk::TextMark*> (Glib::wrap_auto ((GObject*)(object), take_copy)) );
+  //We use dynamic_cast<> in case of multiple inheritance.
+}
+
+} /* namespace Glib */
+
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& TextMark_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &TextMark_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_text_mark_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void TextMark_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+}
+
+
+Glib::ObjectBase* TextMark_Class::wrap_new(GObject* object)
+{
+  return new TextMark((GtkTextMark*)object);
+}
+
+
+/* The implementation: */
+
+GtkTextMark* TextMark::gobj_copy()
+{
+  reference();
+  return gobj();
+}
+
+TextMark::TextMark(const Glib::ConstructParams& construct_params)
+:
+  Glib::Object(construct_params)
+{}
+
+TextMark::TextMark(GtkTextMark* castitem)
+:
+  Glib::Object((GObject*)(castitem))
+{}
+
+TextMark::~TextMark()
+{}
+
+
+TextMark::CppClassType TextMark::textmark_class_; // initialize static member
+
+GType TextMark::get_type()
+{
+  return textmark_class_.init().get_type();
+}
+
+GType TextMark::get_base_type()
+{
+  return gtk_text_mark_get_type();
+}
+
+
+void TextMark::set_visible(bool setting)
+{
+  gtk_text_mark_set_visible(gobj(), static_cast<int>(setting));
+}
+
+bool TextMark::get_visible() const
+{
+  return gtk_text_mark_get_visible(const_cast<GtkTextMark*>(gobj()));
+}
+
+Glib::ustring TextMark::get_name() const
+{
+  return Glib::convert_const_gchar_ptr_to_ustring(gtk_text_mark_get_name(const_cast<GtkTextMark*>(gobj())));
+}
+
+bool TextMark::get_deleted() const
+{
+  return gtk_text_mark_get_deleted(const_cast<GtkTextMark*>(gobj()));
+}
+
+Glib::RefPtr<TextBuffer> TextMark::get_buffer()
+{
+
+  Glib::RefPtr<TextBuffer> retvalue = Glib::wrap(gtk_text_mark_get_buffer(gobj()));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::RefPtr<const TextBuffer> TextMark::get_buffer() const
+{
+
+  Glib::RefPtr<const TextBuffer> retvalue = Glib::wrap(gtk_text_mark_get_buffer(const_cast<GtkTextMark*>(gobj())));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+bool TextMark::get_left_gravity() const
+{
+  return gtk_text_mark_get_left_gravity(const_cast<GtkTextMark*>(gobj()));
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/textmark.h b/libs/gtkmm2/gtk/gtkmm/textmark.h
new file mode 100644
index 0000000000..559d6ed71d
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/textmark.h
@@ -0,0 +1,197 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_TEXTMARK_H
+#define _GTKMM_TEXTMARK_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* textmark.h
+ * 
+ * Copyright (C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+
+#include <gtkmm/object.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkTextMark GtkTextMark;
+typedef struct _GtkTextMarkClass GtkTextMarkClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class TextMark_Class; } // namespace Gtk
+namespace Gtk
+{
+
+class TextBuffer;
+class TextIter;
+
+/** Typedefed as Gtk::TextBuffer::Mark. A position in the buffer, preserved across buffer modifications.
+ *
+ * A Mark is like a bookmark in a text buffer; it preserves a position in the text.  Unlike iterators, marks remain valid across buffer mutations, because
+ * their behavior is defined when text is inserted or deleted. When text containing a mark is deleted, the mark remains in
+ * the position originally occupied by the deleted text. When text is inserted at a mark, a mark with left gravity will be
+ * moved to the beginning of the newly-inserted text, and a mark with right gravity will be moved to the end.
+ * The standard text cursor in left-to-right languages is a mark with right gravity, because it stays to the right of inserted
+ * text.
+ *
+ * Like tags, marks can be either named or anonymous. There are two marks built-in to Gtk::TextBuffer; these are named "insert" and
+ * "selection_bound" and refer to the insertion point and the boundary of the selection which is not the insertion point,
+ * respectively. If no text is selected, these two marks will be in the same position. You can manipulate what is selected and
+ * where the cursor appears by moving these marks around.
+ *
+ * "left" and "right" here refer to logical direction (left is the toward the start of the buffer); in some languages such as
+ * Hebrew the logically-leftmost text is not actually on the left when displayed.
+ *
+ * You can convert the mark to an @link Gtk::TextIter iterator@endlink using Gtk::TextBuffer::get_iter_at_mark().
+ *
+ * Marks can be deleted from the buffer at any time with Gtk::TextBuffer::delete_mark(). Once deleted from the buffer, a mark is essentially useless.
+ *
+ * Marks optionally have names; these can be convenient to avoid passing the Gtk::TextBuffer::Mark object around.
+ *
+ * Marks are typically created using the Gtk::TextBuffer::create_mark() function.
+ *
+ * @ingroup TextView
+ */
+
+class TextMark : public Glib::Object
+{
+  
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+public:
+  typedef TextMark CppObjectType;
+  typedef TextMark_Class CppClassType;
+  typedef GtkTextMark BaseObjectType;
+  typedef GtkTextMarkClass BaseClassType;
+
+private:  friend class TextMark_Class;
+  static CppClassType textmark_class_;
+
+private:
+  // noncopyable
+  TextMark(const TextMark&);
+  TextMark& operator=(const TextMark&);
+
+protected:
+  explicit TextMark(const Glib::ConstructParams& construct_params);
+  explicit TextMark(GtkTextMark* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+  virtual ~TextMark();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GObject.
+  GtkTextMark*       gobj()       { return reinterpret_cast<GtkTextMark*>(gobject_); }
+
+  ///Provides access to the underlying C GObject.
+  const GtkTextMark* gobj() const { return reinterpret_cast<GtkTextMark*>(gobject_); }
+
+  ///Provides access to the underlying C instance. The caller is responsible for unrefing it. Use when directly setting fields in structs.
+  GtkTextMark* gobj_copy();
+
+private:
+
+protected:
+
+public:
+  
+  /** Sets the visibility of @a mark ; the insertion point is normally
+   * visible, i.e.\ you can see it as a vertical bar. Also, the text
+   * widget uses a visible mark to indicate where a drop will occur when
+   * dragging-and-dropping text. Most other marks are not visible.
+   * Marks are not visible by default.
+   * @param setting Visibility of mark.
+   */
+  void set_visible(bool setting = true);
+  
+  /** Returns <tt>true</tt> if the mark is visible (i.e.\ a cursor is displayed
+   * for it)
+   * @return <tt>true</tt> if visible.
+   */
+  bool get_visible() const;
+  
+  /** Returns the mark name; returns <tt>0</tt> for anonymous marks.
+   * @return Mark name.
+   */
+  Glib::ustring get_name() const;
+  
+  /** Returns <tt>true</tt> if the mark has been removed from its buffer
+   * with Gtk::TextBuffer::delete_mark(). Marks can't be used
+   * once deleted.
+   * @return Whether the mark is deleted.
+   */
+  bool get_deleted() const;
+  
+  /** Gets the buffer this mark is located inside,
+   * or <tt>0</tt> if the mark is deleted.
+   * @return The mark's Gtk::TextBuffer.
+   */
+  Glib::RefPtr<TextBuffer> get_buffer();
+  
+  /** Gets the buffer this mark is located inside,
+   * or <tt>0</tt> if the mark is deleted.
+   * @return The mark's Gtk::TextBuffer.
+   */
+  Glib::RefPtr<const TextBuffer> get_buffer() const;
+  
+  /** Determines whether the mark has left gravity.
+   * @return <tt>true</tt> if the mark has left gravity, <tt>false</tt> otherwise.
+   */
+  bool get_left_gravity() const;
+  TextIter get_iter();
+
+
+public:
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+};
+
+} /* namespace Gtk */
+
+
+namespace Glib
+{
+  /** @relates Gtk::TextMark
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Glib::RefPtr<Gtk::TextMark> wrap(GtkTextMark* object, bool take_copy = false);
+}
+
+
+#endif /* _GTKMM_TEXTMARK_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/texttag.cc b/libs/gtkmm2/gtk/gtkmm/texttag.cc
new file mode 100644
index 0000000000..f1867ef7b4
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/texttag.cc
@@ -0,0 +1,889 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/texttag.h>
+#include <gtkmm/private/texttag_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* 
+ *
+ * Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/textbuffer.h>
+#include <gtkmm/textiter.h>
+#include <gtk/gtktexttag.h>
+
+namespace
+{
+
+gboolean TextTag_signal_event_callback(GtkTextTag* self, GObject* p0,GdkEvent* p1,const GtkTextIter* p2,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< bool,const Glib::RefPtr<Glib::Object>&,GdkEvent*,const TextIter& > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        return static_cast<int>((*static_cast<SlotType*>(slot))(Glib::wrap(p0, true)
+, p1, Glib::wrap(p2)
+));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+gboolean TextTag_signal_event_notify_callback(GtkTextTag* self, GObject* p0,GdkEvent* p1,const GtkTextIter* p2, void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,const Glib::RefPtr<Glib::Object>&,GdkEvent*,const TextIter& > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(Glib::wrap(p0, true)
+, p1, Glib::wrap(p2)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+const Glib::SignalProxyInfo TextTag_signal_event_info =
+{
+  "event",
+  (GCallback) &TextTag_signal_event_callback,
+  (GCallback) &TextTag_signal_event_notify_callback
+};
+
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Glib::RefPtr<Gtk::TextTag> wrap(GtkTextTag* object, bool take_copy)
+{
+  return Glib::RefPtr<Gtk::TextTag>( dynamic_cast<Gtk::TextTag*> (Glib::wrap_auto ((GObject*)(object), take_copy)) );
+  //We use dynamic_cast<> in case of multiple inheritance.
+}
+
+} /* namespace Glib */
+
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& TextTag_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &TextTag_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_text_tag_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void TextTag_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+  klass->event = &event_callback;
+}
+
+
+gboolean TextTag_Class::event_callback(GtkTextTag* self, GObject* p0, GdkEvent* p1, const GtkTextIter* p2)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return static_cast<int>(obj->on_event(Glib::wrap(p0, true)
+, p1, Glib::wrap(p2)
+));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->event)
+      return (*base->event)(self, p0, p1, p2);
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+
+Glib::ObjectBase* TextTag_Class::wrap_new(GObject* object)
+{
+  return new TextTag((GtkTextTag*)object);
+}
+
+
+/* The implementation: */
+
+GtkTextTag* TextTag::gobj_copy()
+{
+  reference();
+  return gobj();
+}
+
+TextTag::TextTag(const Glib::ConstructParams& construct_params)
+:
+  Glib::Object(construct_params)
+{}
+
+TextTag::TextTag(GtkTextTag* castitem)
+:
+  Glib::Object((GObject*)(castitem))
+{}
+
+TextTag::~TextTag()
+{}
+
+
+TextTag::CppClassType TextTag::texttag_class_; // initialize static member
+
+GType TextTag::get_type()
+{
+  return texttag_class_.init().get_type();
+}
+
+GType TextTag::get_base_type()
+{
+  return gtk_text_tag_get_type();
+}
+
+
+TextTag::TextTag()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Glib::Object(Glib::ConstructParams(texttag_class_.init()))
+{
+  }
+
+TextTag::TextTag(const Glib::ustring& name)
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Glib::Object(Glib::ConstructParams(texttag_class_.init(), "name", name.c_str(), (char*) 0))
+{
+  }
+
+Glib::RefPtr<TextTag> TextTag::create()
+{
+  return Glib::RefPtr<TextTag>( new TextTag() );
+}
+Glib::RefPtr<TextTag> TextTag::create(const Glib::ustring& name)
+{
+  return Glib::RefPtr<TextTag>( new TextTag(name) );
+}
+int TextTag::get_priority() const
+{
+  return gtk_text_tag_get_priority(const_cast<GtkTextTag*>(gobj()));
+}
+
+void TextTag::set_priority(int priority)
+{
+  gtk_text_tag_set_priority(gobj(), priority);
+}
+
+bool TextTag::event(const Glib::RefPtr<Glib::Object>& event_object, GdkEvent* event, const TextIter& iter)
+{
+  return gtk_text_tag_event(gobj(), Glib::unwrap(event_object), event, (iter).gobj());
+}
+
+
+Glib::SignalProxy3< bool,const Glib::RefPtr<Glib::Object>&,GdkEvent*,const TextIter& > TextTag::signal_event()
+{
+  return Glib::SignalProxy3< bool,const Glib::RefPtr<Glib::Object>&,GdkEvent*,const TextIter& >(this, &TextTag_signal_event_info);
+}
+
+
+Glib::PropertyProxy_ReadOnly<Glib::ustring> TextTag::property_name() const
+{
+  return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "name");
+}
+
+Glib::PropertyProxy_WriteOnly<Glib::ustring> TextTag::property_background() 
+{
+  return Glib::PropertyProxy_WriteOnly<Glib::ustring>(this, "background");
+}
+
+Glib::PropertyProxy_ReadOnly<Glib::ustring> TextTag::property_background() const
+{
+  return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "background");
+}
+
+Glib::PropertyProxy_WriteOnly<Glib::ustring> TextTag::property_foreground() 
+{
+  return Glib::PropertyProxy_WriteOnly<Glib::ustring>(this, "foreground");
+}
+
+Glib::PropertyProxy_ReadOnly<Glib::ustring> TextTag::property_foreground() const
+{
+  return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "foreground");
+}
+
+Glib::PropertyProxy<Gdk::Color> TextTag::property_background_gdk() 
+{
+  return Glib::PropertyProxy<Gdk::Color>(this, "background-gdk");
+}
+
+Glib::PropertyProxy_ReadOnly<Gdk::Color> TextTag::property_background_gdk() const
+{
+  return Glib::PropertyProxy_ReadOnly<Gdk::Color>(this, "background-gdk");
+}
+
+Glib::PropertyProxy<Gdk::Color> TextTag::property_foreground_gdk() 
+{
+  return Glib::PropertyProxy<Gdk::Color>(this, "foreground-gdk");
+}
+
+Glib::PropertyProxy_ReadOnly<Gdk::Color> TextTag::property_foreground_gdk() const
+{
+  return Glib::PropertyProxy_ReadOnly<Gdk::Color>(this, "foreground-gdk");
+}
+
+Glib::PropertyProxy< Glib::RefPtr<Gdk::Bitmap> > TextTag::property_background_stipple() 
+{
+  return Glib::PropertyProxy< Glib::RefPtr<Gdk::Bitmap> >(this, "background-stipple");
+}
+
+Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::Bitmap> > TextTag::property_background_stipple() const
+{
+  return Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::Bitmap> >(this, "background-stipple");
+}
+
+Glib::PropertyProxy< Glib::RefPtr<Gdk::Bitmap> > TextTag::property_foreground_stipple() 
+{
+  return Glib::PropertyProxy< Glib::RefPtr<Gdk::Bitmap> >(this, "foreground-stipple");
+}
+
+Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::Bitmap> > TextTag::property_foreground_stipple() const
+{
+  return Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::Bitmap> >(this, "foreground-stipple");
+}
+
+Glib::PropertyProxy<Glib::ustring> TextTag::property_font() 
+{
+  return Glib::PropertyProxy<Glib::ustring>(this, "font");
+}
+
+Glib::PropertyProxy_ReadOnly<Glib::ustring> TextTag::property_font() const
+{
+  return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "font");
+}
+
+Glib::PropertyProxy<Pango::FontDescription> TextTag::property_font_desc() 
+{
+  return Glib::PropertyProxy<Pango::FontDescription>(this, "font-desc");
+}
+
+Glib::PropertyProxy_ReadOnly<Pango::FontDescription> TextTag::property_font_desc() const
+{
+  return Glib::PropertyProxy_ReadOnly<Pango::FontDescription>(this, "font-desc");
+}
+
+Glib::PropertyProxy<Glib::ustring> TextTag::property_family() 
+{
+  return Glib::PropertyProxy<Glib::ustring>(this, "family");
+}
+
+Glib::PropertyProxy_ReadOnly<Glib::ustring> TextTag::property_family() const
+{
+  return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "family");
+}
+
+Glib::PropertyProxy<Pango::Style> TextTag::property_style() 
+{
+  return Glib::PropertyProxy<Pango::Style>(this, "style");
+}
+
+Glib::PropertyProxy_ReadOnly<Pango::Style> TextTag::property_style() const
+{
+  return Glib::PropertyProxy_ReadOnly<Pango::Style>(this, "style");
+}
+
+Glib::PropertyProxy<Pango::Variant> TextTag::property_variant() 
+{
+  return Glib::PropertyProxy<Pango::Variant>(this, "variant");
+}
+
+Glib::PropertyProxy_ReadOnly<Pango::Variant> TextTag::property_variant() const
+{
+  return Glib::PropertyProxy_ReadOnly<Pango::Variant>(this, "variant");
+}
+
+Glib::PropertyProxy<int> TextTag::property_weight() 
+{
+  return Glib::PropertyProxy<int>(this, "weight");
+}
+
+Glib::PropertyProxy_ReadOnly<int> TextTag::property_weight() const
+{
+  return Glib::PropertyProxy_ReadOnly<int>(this, "weight");
+}
+
+Glib::PropertyProxy<Pango::Stretch> TextTag::property_stretch() 
+{
+  return Glib::PropertyProxy<Pango::Stretch>(this, "stretch");
+}
+
+Glib::PropertyProxy_ReadOnly<Pango::Stretch> TextTag::property_stretch() const
+{
+  return Glib::PropertyProxy_ReadOnly<Pango::Stretch>(this, "stretch");
+}
+
+Glib::PropertyProxy<int> TextTag::property_size() 
+{
+  return Glib::PropertyProxy<int>(this, "size");
+}
+
+Glib::PropertyProxy_ReadOnly<int> TextTag::property_size() const
+{
+  return Glib::PropertyProxy_ReadOnly<int>(this, "size");
+}
+
+Glib::PropertyProxy<double> TextTag::property_size_points() 
+{
+  return Glib::PropertyProxy<double>(this, "size-points");
+}
+
+Glib::PropertyProxy_ReadOnly<double> TextTag::property_size_points() const
+{
+  return Glib::PropertyProxy_ReadOnly<double>(this, "size-points");
+}
+
+Glib::PropertyProxy<double> TextTag::property_scale() 
+{
+  return Glib::PropertyProxy<double>(this, "scale");
+}
+
+Glib::PropertyProxy_ReadOnly<double> TextTag::property_scale() const
+{
+  return Glib::PropertyProxy_ReadOnly<double>(this, "scale");
+}
+
+Glib::PropertyProxy<int> TextTag::property_pixels_above_lines() 
+{
+  return Glib::PropertyProxy<int>(this, "pixels-above-lines");
+}
+
+Glib::PropertyProxy_ReadOnly<int> TextTag::property_pixels_above_lines() const
+{
+  return Glib::PropertyProxy_ReadOnly<int>(this, "pixels-above-lines");
+}
+
+Glib::PropertyProxy<int> TextTag::property_pixels_below_lines() 
+{
+  return Glib::PropertyProxy<int>(this, "pixels-below-lines");
+}
+
+Glib::PropertyProxy_ReadOnly<int> TextTag::property_pixels_below_lines() const
+{
+  return Glib::PropertyProxy_ReadOnly<int>(this, "pixels-below-lines");
+}
+
+Glib::PropertyProxy<int> TextTag::property_pixels_inside_wrap() 
+{
+  return Glib::PropertyProxy<int>(this, "pixels-inside-wrap");
+}
+
+Glib::PropertyProxy_ReadOnly<int> TextTag::property_pixels_inside_wrap() const
+{
+  return Glib::PropertyProxy_ReadOnly<int>(this, "pixels-inside-wrap");
+}
+
+Glib::PropertyProxy<bool> TextTag::property_editable() 
+{
+  return Glib::PropertyProxy<bool>(this, "editable");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> TextTag::property_editable() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "editable");
+}
+
+Glib::PropertyProxy<WrapMode> TextTag::property_wrap_mode() 
+{
+  return Glib::PropertyProxy<WrapMode>(this, "wrap-mode");
+}
+
+Glib::PropertyProxy_ReadOnly<WrapMode> TextTag::property_wrap_mode() const
+{
+  return Glib::PropertyProxy_ReadOnly<WrapMode>(this, "wrap-mode");
+}
+
+Glib::PropertyProxy<Justification> TextTag::property_justification() 
+{
+  return Glib::PropertyProxy<Justification>(this, "justification");
+}
+
+Glib::PropertyProxy_ReadOnly<Justification> TextTag::property_justification() const
+{
+  return Glib::PropertyProxy_ReadOnly<Justification>(this, "justification");
+}
+
+Glib::PropertyProxy<TextDirection> TextTag::property_direction() 
+{
+  return Glib::PropertyProxy<TextDirection>(this, "direction");
+}
+
+Glib::PropertyProxy_ReadOnly<TextDirection> TextTag::property_direction() const
+{
+  return Glib::PropertyProxy_ReadOnly<TextDirection>(this, "direction");
+}
+
+Glib::PropertyProxy<int> TextTag::property_left_margin() 
+{
+  return Glib::PropertyProxy<int>(this, "left-margin");
+}
+
+Glib::PropertyProxy_ReadOnly<int> TextTag::property_left_margin() const
+{
+  return Glib::PropertyProxy_ReadOnly<int>(this, "left-margin");
+}
+
+Glib::PropertyProxy<int> TextTag::property_indent() 
+{
+  return Glib::PropertyProxy<int>(this, "indent");
+}
+
+Glib::PropertyProxy_ReadOnly<int> TextTag::property_indent() const
+{
+  return Glib::PropertyProxy_ReadOnly<int>(this, "indent");
+}
+
+Glib::PropertyProxy<bool> TextTag::property_strikethrough() 
+{
+  return Glib::PropertyProxy<bool>(this, "strikethrough");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> TextTag::property_strikethrough() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "strikethrough");
+}
+
+Glib::PropertyProxy<int> TextTag::property_right_margin() 
+{
+  return Glib::PropertyProxy<int>(this, "right-margin");
+}
+
+Glib::PropertyProxy_ReadOnly<int> TextTag::property_right_margin() const
+{
+  return Glib::PropertyProxy_ReadOnly<int>(this, "right-margin");
+}
+
+Glib::PropertyProxy<Pango::Underline> TextTag::property_underline() 
+{
+  return Glib::PropertyProxy<Pango::Underline>(this, "underline");
+}
+
+Glib::PropertyProxy_ReadOnly<Pango::Underline> TextTag::property_underline() const
+{
+  return Glib::PropertyProxy_ReadOnly<Pango::Underline>(this, "underline");
+}
+
+Glib::PropertyProxy<int> TextTag::property_rise() 
+{
+  return Glib::PropertyProxy<int>(this, "rise");
+}
+
+Glib::PropertyProxy_ReadOnly<int> TextTag::property_rise() const
+{
+  return Glib::PropertyProxy_ReadOnly<int>(this, "rise");
+}
+
+Glib::PropertyProxy<bool> TextTag::property_background_full_height() 
+{
+  return Glib::PropertyProxy<bool>(this, "background-full-height");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> TextTag::property_background_full_height() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "background-full-height");
+}
+
+Glib::PropertyProxy<Glib::ustring> TextTag::property_language() 
+{
+  return Glib::PropertyProxy<Glib::ustring>(this, "language");
+}
+
+Glib::PropertyProxy_ReadOnly<Glib::ustring> TextTag::property_language() const
+{
+  return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "language");
+}
+
+Glib::PropertyProxy<Pango::TabArray> TextTag::property_tabs() 
+{
+  return Glib::PropertyProxy<Pango::TabArray>(this, "tabs");
+}
+
+Glib::PropertyProxy_ReadOnly<Pango::TabArray> TextTag::property_tabs() const
+{
+  return Glib::PropertyProxy_ReadOnly<Pango::TabArray>(this, "tabs");
+}
+
+Glib::PropertyProxy<bool> TextTag::property_invisible() 
+{
+  return Glib::PropertyProxy<bool>(this, "invisible");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> TextTag::property_invisible() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "invisible");
+}
+
+Glib::PropertyProxy<bool> TextTag::property_background_set() 
+{
+  return Glib::PropertyProxy<bool>(this, "background-set");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> TextTag::property_background_set() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "background-set");
+}
+
+Glib::PropertyProxy<bool> TextTag::property_foreground_set() 
+{
+  return Glib::PropertyProxy<bool>(this, "foreground-set");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> TextTag::property_foreground_set() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "foreground-set");
+}
+
+Glib::PropertyProxy<bool> TextTag::property_background_stipple_set() 
+{
+  return Glib::PropertyProxy<bool>(this, "background-stipple-set");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> TextTag::property_background_stipple_set() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "background-stipple-set");
+}
+
+Glib::PropertyProxy<bool> TextTag::property_foreground_stipple_set() 
+{
+  return Glib::PropertyProxy<bool>(this, "foreground-stipple-set");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> TextTag::property_foreground_stipple_set() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "foreground-stipple-set");
+}
+
+Glib::PropertyProxy<bool> TextTag::property_family_set() 
+{
+  return Glib::PropertyProxy<bool>(this, "family-set");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> TextTag::property_family_set() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "family-set");
+}
+
+Glib::PropertyProxy<bool> TextTag::property_style_set() 
+{
+  return Glib::PropertyProxy<bool>(this, "style-set");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> TextTag::property_style_set() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "style-set");
+}
+
+Glib::PropertyProxy<bool> TextTag::property_variant_set() 
+{
+  return Glib::PropertyProxy<bool>(this, "variant-set");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> TextTag::property_variant_set() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "variant-set");
+}
+
+Glib::PropertyProxy<bool> TextTag::property_weight_set() 
+{
+  return Glib::PropertyProxy<bool>(this, "weight-set");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> TextTag::property_weight_set() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "weight-set");
+}
+
+Glib::PropertyProxy<bool> TextTag::property_stretch_set() 
+{
+  return Glib::PropertyProxy<bool>(this, "stretch-set");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> TextTag::property_stretch_set() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "stretch-set");
+}
+
+Glib::PropertyProxy<bool> TextTag::property_size_set() 
+{
+  return Glib::PropertyProxy<bool>(this, "size-set");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> TextTag::property_size_set() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "size-set");
+}
+
+Glib::PropertyProxy<bool> TextTag::property_scale_set() 
+{
+  return Glib::PropertyProxy<bool>(this, "scale-set");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> TextTag::property_scale_set() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "scale-set");
+}
+
+Glib::PropertyProxy<bool> TextTag::property_pixels_above_lines_set() 
+{
+  return Glib::PropertyProxy<bool>(this, "pixels-above-lines-set");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> TextTag::property_pixels_above_lines_set() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "pixels-above-lines-set");
+}
+
+Glib::PropertyProxy<bool> TextTag::property_pixels_below_lines_set() 
+{
+  return Glib::PropertyProxy<bool>(this, "pixels-below-lines-set");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> TextTag::property_pixels_below_lines_set() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "pixels-below-lines-set");
+}
+
+Glib::PropertyProxy<bool> TextTag::property_pixels_inside_wrap_set() 
+{
+  return Glib::PropertyProxy<bool>(this, "pixels-inside-wrap-set");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> TextTag::property_pixels_inside_wrap_set() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "pixels-inside-wrap-set");
+}
+
+Glib::PropertyProxy<bool> TextTag::property_editable_set() 
+{
+  return Glib::PropertyProxy<bool>(this, "editable-set");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> TextTag::property_editable_set() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "editable-set");
+}
+
+Glib::PropertyProxy<bool> TextTag::property_wrap_mode_set() 
+{
+  return Glib::PropertyProxy<bool>(this, "wrap-mode-set");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> TextTag::property_wrap_mode_set() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "wrap-mode-set");
+}
+
+Glib::PropertyProxy<bool> TextTag::property_justification_set() 
+{
+  return Glib::PropertyProxy<bool>(this, "justification-set");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> TextTag::property_justification_set() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "justification-set");
+}
+
+Glib::PropertyProxy<bool> TextTag::property_left_margin_set() 
+{
+  return Glib::PropertyProxy<bool>(this, "left-margin-set");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> TextTag::property_left_margin_set() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "left-margin-set");
+}
+
+Glib::PropertyProxy<bool> TextTag::property_indent_set() 
+{
+  return Glib::PropertyProxy<bool>(this, "indent-set");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> TextTag::property_indent_set() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "indent-set");
+}
+
+Glib::PropertyProxy<bool> TextTag::property_strikethrough_set() 
+{
+  return Glib::PropertyProxy<bool>(this, "strikethrough-set");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> TextTag::property_strikethrough_set() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "strikethrough-set");
+}
+
+Glib::PropertyProxy<bool> TextTag::property_right_margin_set() 
+{
+  return Glib::PropertyProxy<bool>(this, "right-margin-set");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> TextTag::property_right_margin_set() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "right-margin-set");
+}
+
+Glib::PropertyProxy<bool> TextTag::property_underline_set() 
+{
+  return Glib::PropertyProxy<bool>(this, "underline-set");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> TextTag::property_underline_set() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "underline-set");
+}
+
+Glib::PropertyProxy<bool> TextTag::property_rise_set() 
+{
+  return Glib::PropertyProxy<bool>(this, "rise-set");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> TextTag::property_rise_set() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "rise-set");
+}
+
+Glib::PropertyProxy<bool> TextTag::property_background_full_height_set() 
+{
+  return Glib::PropertyProxy<bool>(this, "background-full-height-set");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> TextTag::property_background_full_height_set() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "background-full-height-set");
+}
+
+Glib::PropertyProxy<bool> TextTag::property_language_set() 
+{
+  return Glib::PropertyProxy<bool>(this, "language-set");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> TextTag::property_language_set() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "language-set");
+}
+
+Glib::PropertyProxy<bool> TextTag::property_tabs_set() 
+{
+  return Glib::PropertyProxy<bool>(this, "tabs-set");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> TextTag::property_tabs_set() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "tabs-set");
+}
+
+Glib::PropertyProxy<bool> TextTag::property_invisible_set() 
+{
+  return Glib::PropertyProxy<bool>(this, "invisible-set");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> TextTag::property_invisible_set() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "invisible-set");
+}
+
+
+bool Gtk::TextTag::on_event(const Glib::RefPtr<Glib::Object>& event_object, GdkEvent* event, const TextIter& iter)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->event)
+    return (*base->event)(gobj(),Glib::unwrap(event_object),event,(iter).gobj());
+
+  typedef bool RType;
+  return RType();
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/texttag.h b/libs/gtkmm2/gtk/gtkmm/texttag.h
new file mode 100644
index 0000000000..c5162c0914
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/texttag.h
@@ -0,0 +1,1158 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_TEXTTAG_H
+#define _GTKMM_TEXTTAG_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* texttag.h
+ * 
+ * Copyright (C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+
+#include <gtkmm/object.h>
+#include <gtkmm/enums.h>
+#include <gdkmm/bitmap.h>
+#include <gdkmm/color.h>
+#include <pangomm/fontdescription.h>
+#include <pangomm/tabarray.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkTextTag GtkTextTag;
+typedef struct _GtkTextTagClass GtkTextTagClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class TextTag_Class; } // namespace Gtk
+namespace Gtk
+{
+
+class TextIter;
+
+/** Typedefed as Gtk::TextBuffer::Tag.
+ *
+ * Text in a buffer can be marked with tags. A tag is an attribute that can be applied to some range of text. For example, a tag
+ * might be called "bold" and might make the text inside the tag bold. However, the tag concept is more general than that; tags don't
+ * have to affect appearance. They can instead affect the behavior of mouse and key presses, "lock" a range of text so the user
+ * can't edit it, or countless other things.
+ * One tag can be applied to any number of text ranges in any number of @link Gtk::TextBuffer Gtk::TextBuffers@endlink.
+ *
+ * Each tag is stored in a @link Gtk::TextTagTable Gtk::TextBuffer::TagTable@endlink, and Tags should be in the
+ * @link Gtk::TextTagTable Gtk::TextBuffer::TagTable@endlink for a given Gtk::TextBuffer before using
+ * them with that buffer.
+ *
+ * Tags can have names, which is convenient sometimes (for example, you can name your tag that makes things bold "bold"), but
+ * they can also be anonymous (which is convenient if you're creating tags on-the-fly). 
+ *
+ * Gtk::TextBuffer::create_tag() is the best way to create tags. See the demo for numerous examples.
+ *
+ * @ingroup TextView
+ */
+
+class TextTag : public Glib::Object
+{
+   
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+public:
+  typedef TextTag CppObjectType;
+  typedef TextTag_Class CppClassType;
+  typedef GtkTextTag BaseObjectType;
+  typedef GtkTextTagClass BaseClassType;
+
+private:  friend class TextTag_Class;
+  static CppClassType texttag_class_;
+
+private:
+  // noncopyable
+  TextTag(const TextTag&);
+  TextTag& operator=(const TextTag&);
+
+protected:
+  explicit TextTag(const Glib::ConstructParams& construct_params);
+  explicit TextTag(GtkTextTag* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+  virtual ~TextTag();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GObject.
+  GtkTextTag*       gobj()       { return reinterpret_cast<GtkTextTag*>(gobject_); }
+
+  ///Provides access to the underlying C GObject.
+  const GtkTextTag* gobj() const { return reinterpret_cast<GtkTextTag*>(gobject_); }
+
+  ///Provides access to the underlying C instance. The caller is responsible for unrefing it. Use when directly setting fields in structs.
+  GtkTextTag* gobj_copy();
+
+private:
+
+protected:
+  TextTag();
+  explicit TextTag(const Glib::ustring& name);
+
+public:
+  
+  static Glib::RefPtr<TextTag> create();
+
+  
+  static Glib::RefPtr<TextTag> create(const Glib::ustring& name);
+
+
+  /** Get the tag priority.
+   * @return The tag's priority.
+   */
+  int get_priority() const;
+  
+  /** Sets the priority of a Gtk::TextTag. Valid priorities are
+   * start at 0 and go to one less than Gtk::TextTagTable::get_size().
+   * Each tag in a table has a unique priority; setting the priority
+   * of one tag shifts the priorities of all the other tags in the
+   * table to maintain a unique priority for each tag. Higher priority
+   * tags "win" if two tags both set the same text attribute. When adding
+   * a tag to a tag table, it will be assigned the highest priority in
+   * the table by default; so normally the precedence of a set of tags
+   * is the order in which they were added to the table, or created with
+   * Gtk::TextBuffer::create_tag(), which adds the tag to the buffer's table
+   * automatically.
+   * @param priority The new priority.
+   */
+  void set_priority(int priority);
+  
+  /** Emits the "event" signal on the Gtk::TextTag.
+   * @param event_object Object that received the event, such as a widget.
+   * @param event The event.
+   * @param iter Location where the event was received.
+   * @return Result of signal emission (whether the event was handled).
+   */
+  bool event(const Glib::RefPtr<Glib::Object>& event_object, GdkEvent* event, const TextIter& iter);
+
+  
+  Glib::SignalProxy3< bool,const Glib::RefPtr<Glib::Object>&,GdkEvent*,const TextIter& > signal_event();
+
+
+  /** Name used to refer to the text tag. NULL for anonymous tags.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Glib::ustring> property_name() const;
+
+ //construct-only.
+  /** Background color as a string.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_WriteOnly<Glib::ustring> property_background() ;
+
+/** Background color as a string.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Glib::ustring> property_background() const;
+
+  /** Foreground color as a string.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_WriteOnly<Glib::ustring> property_foreground() ;
+
+/** Foreground color as a string.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Glib::ustring> property_foreground() const;
+
+  /** Background color as a (possibly unallocated) GdkColor.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Gdk::Color> property_background_gdk() ;
+
+/** Background color as a (possibly unallocated) GdkColor.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Gdk::Color> property_background_gdk() const;
+
+  /** Foreground color as a (possibly unallocated) GdkColor.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Gdk::Color> property_foreground_gdk() ;
+
+/** Foreground color as a (possibly unallocated) GdkColor.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Gdk::Color> property_foreground_gdk() const;
+
+  /** Bitmap to use as a mask when drawing the text background.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy< Glib::RefPtr<Gdk::Bitmap> > property_background_stipple() ;
+
+/** Bitmap to use as a mask when drawing the text background.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::Bitmap> > property_background_stipple() const;
+
+  /** Bitmap to use as a mask when drawing the text foreground.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy< Glib::RefPtr<Gdk::Bitmap> > property_foreground_stipple() ;
+
+/** Bitmap to use as a mask when drawing the text foreground.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::Bitmap> > property_foreground_stipple() const;
+
+  /** Font description as a string
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Glib::ustring> property_font() ;
+
+/** Font description as a string
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Glib::ustring> property_font() const;
+
+  /** Font description as a PangoFontDescription struct.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Pango::FontDescription> property_font_desc() ;
+
+/** Font description as a PangoFontDescription struct.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Pango::FontDescription> property_font_desc() const;
+
+  /** Name of the font family
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Glib::ustring> property_family() ;
+
+/** Name of the font family
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Glib::ustring> property_family() const;
+
+  /** Font style as a PangoStyle
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Pango::Style> property_style() ;
+
+/** Font style as a PangoStyle
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Pango::Style> property_style() const;
+
+  /** Font variant as a PangoVariant
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Pango::Variant> property_variant() ;
+
+/** Font variant as a PangoVariant
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Pango::Variant> property_variant() const;
+
+  /** Font weight as an integer
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<int> property_weight() ;
+
+/** Font weight as an integer
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<int> property_weight() const;
+
+  /** Font stretch as a PangoStretch
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Pango::Stretch> property_stretch() ;
+
+/** Font stretch as a PangoStretch
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Pango::Stretch> property_stretch() const;
+
+  /** Font size in Pango units.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<int> property_size() ;
+
+/** Font size in Pango units.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<int> property_size() const;
+
+  /** Font size in points.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<double> property_size_points() ;
+
+/** Font size in points.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<double> property_size_points() const;
+
+  /** Font size as a scale factor relative to the default font size. This properly adapts to theme changes etc. so is recommended. Pango predefines some scales such as PANGO_SCALE_X_LARGE.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<double> property_scale() ;
+
+/** Font size as a scale factor relative to the default font size. This properly adapts to theme changes etc. so is recommended. Pango predefines some scales such as PANGO_SCALE_X_LARGE.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<double> property_scale() const;
+
+  /** Pixels of blank space above paragraphs.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<int> property_pixels_above_lines() ;
+
+/** Pixels of blank space above paragraphs.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<int> property_pixels_above_lines() const;
+
+  /** Pixels of blank space below paragraphs.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<int> property_pixels_below_lines() ;
+
+/** Pixels of blank space below paragraphs.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<int> property_pixels_below_lines() const;
+
+  /** Pixels of blank space between wrapped lines in a paragraph.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<int> property_pixels_inside_wrap() ;
+
+/** Pixels of blank space between wrapped lines in a paragraph.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<int> property_pixels_inside_wrap() const;
+
+  /** Whether the text can be modified by the user.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_editable() ;
+
+/** Whether the text can be modified by the user.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_editable() const;
+
+  /** Whether to wrap lines never
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<WrapMode> property_wrap_mode() ;
+
+/** Whether to wrap lines never
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<WrapMode> property_wrap_mode() const;
+
+  /** Left
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Justification> property_justification() ;
+
+/** Left
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Justification> property_justification() const;
+
+  /** Text direction
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<TextDirection> property_direction() ;
+
+/** Text direction
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<TextDirection> property_direction() const;
+
+  /** Width of the left margin in pixels.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<int> property_left_margin() ;
+
+/** Width of the left margin in pixels.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<int> property_left_margin() const;
+
+  /** Amount to indent the paragraph
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<int> property_indent() ;
+
+/** Amount to indent the paragraph
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<int> property_indent() const;
+
+  /** Whether to strike through the text.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_strikethrough() ;
+
+/** Whether to strike through the text.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_strikethrough() const;
+
+  /** Width of the right margin in pixels.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<int> property_right_margin() ;
+
+/** Width of the right margin in pixels.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<int> property_right_margin() const;
+
+  /** Style of underline for this text.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Pango::Underline> property_underline() ;
+
+/** Style of underline for this text.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Pango::Underline> property_underline() const;
+
+  /** Offset of text above the baseline (below the baseline if rise is negative) in pixels.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<int> property_rise() ;
+
+/** Offset of text above the baseline (below the baseline if rise is negative) in pixels.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<int> property_rise() const;
+
+  /** Whether the background color fills the entire line height or only the height of the tagged characters.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_background_full_height() ;
+
+/** Whether the background color fills the entire line height or only the height of the tagged characters.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_background_full_height() const;
+
+  /** The language this text is in
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Glib::ustring> property_language() ;
+
+/** The language this text is in
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Glib::ustring> property_language() const;
+
+  /** Custom tabs for this text.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Pango::TabArray> property_tabs() ;
+
+/** Custom tabs for this text.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Pango::TabArray> property_tabs() const;
+
+  /** Whether this text is hidden. Not implemented in GTK 2.0.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_invisible() ;
+
+/** Whether this text is hidden. Not implemented in GTK 2.0.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_invisible() const;
+
+  /** Whether this tag affects the background color.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_background_set() ;
+
+/** Whether this tag affects the background color.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_background_set() const;
+
+  /** Whether this tag affects the foreground color.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_foreground_set() ;
+
+/** Whether this tag affects the foreground color.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_foreground_set() const;
+
+  /** Whether this tag affects the background stipple.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_background_stipple_set() ;
+
+/** Whether this tag affects the background stipple.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_background_stipple_set() const;
+
+  /** Whether this tag affects the foreground stipple.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_foreground_stipple_set() ;
+
+/** Whether this tag affects the foreground stipple.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_foreground_stipple_set() const;
+
+  /** Whether this tag affects the font family.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_family_set() ;
+
+/** Whether this tag affects the font family.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_family_set() const;
+
+  /** Whether this tag affects the font style.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_style_set() ;
+
+/** Whether this tag affects the font style.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_style_set() const;
+
+  /** Whether this tag affects the font variant.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_variant_set() ;
+
+/** Whether this tag affects the font variant.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_variant_set() const;
+
+  /** Whether this tag affects the font weight.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_weight_set() ;
+
+/** Whether this tag affects the font weight.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_weight_set() const;
+
+  /** Whether this tag affects the font stretch.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_stretch_set() ;
+
+/** Whether this tag affects the font stretch.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_stretch_set() const;
+
+  /** Whether this tag affects the font size.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_size_set() ;
+
+/** Whether this tag affects the font size.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_size_set() const;
+
+  /** Whether this tag scales the font size by a factor.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_scale_set() ;
+
+/** Whether this tag scales the font size by a factor.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_scale_set() const;
+
+  /** Whether this tag affects the number of pixels above lines.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_pixels_above_lines_set() ;
+
+/** Whether this tag affects the number of pixels above lines.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_pixels_above_lines_set() const;
+
+  /** Whether this tag affects the number of pixels above lines.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_pixels_below_lines_set() ;
+
+/** Whether this tag affects the number of pixels above lines.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_pixels_below_lines_set() const;
+
+  /** Whether this tag affects the number of pixels between wrapped lines.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_pixels_inside_wrap_set() ;
+
+/** Whether this tag affects the number of pixels between wrapped lines.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_pixels_inside_wrap_set() const;
+
+  /** Whether this tag affects text editability.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_editable_set() ;
+
+/** Whether this tag affects text editability.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_editable_set() const;
+
+  /** Whether this tag affects line wrap mode.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_wrap_mode_set() ;
+
+/** Whether this tag affects line wrap mode.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_wrap_mode_set() const;
+
+  /** Whether this tag affects paragraph justification.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_justification_set() ;
+
+/** Whether this tag affects paragraph justification.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_justification_set() const;
+
+  /** Whether this tag affects the left margin.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_left_margin_set() ;
+
+/** Whether this tag affects the left margin.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_left_margin_set() const;
+
+  /** Whether this tag affects indentation.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_indent_set() ;
+
+/** Whether this tag affects indentation.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_indent_set() const;
+
+  /** Whether this tag affects strikethrough.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_strikethrough_set() ;
+
+/** Whether this tag affects strikethrough.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_strikethrough_set() const;
+
+  /** Whether this tag affects the right margin.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_right_margin_set() ;
+
+/** Whether this tag affects the right margin.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_right_margin_set() const;
+
+  /** Whether this tag affects underlining.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_underline_set() ;
+
+/** Whether this tag affects underlining.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_underline_set() const;
+
+  /** Whether this tag affects the rise.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_rise_set() ;
+
+/** Whether this tag affects the rise.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_rise_set() const;
+
+  /** Whether this tag affects background height.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_background_full_height_set() ;
+
+/** Whether this tag affects background height.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_background_full_height_set() const;
+
+  /** Whether this tag affects the language the text is rendered as.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_language_set() ;
+
+/** Whether this tag affects the language the text is rendered as.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_language_set() const;
+
+  /** Whether this tag affects tabs.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_tabs_set() ;
+
+/** Whether this tag affects tabs.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_tabs_set() const;
+
+  /** Whether this tag affects text visibility.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_invisible_set() ;
+
+/** Whether this tag affects text visibility.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_invisible_set() const;
+
+
+public:
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+  virtual bool on_event(const Glib::RefPtr<Glib::Object>& event_object, GdkEvent* event, const TextIter& iter);
+
+
+};
+
+} /* namespace Gtk */
+
+
+namespace Glib
+{
+  /** @relates Gtk::TextTag
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Glib::RefPtr<Gtk::TextTag> wrap(GtkTextTag* object, bool take_copy = false);
+}
+
+
+#endif /* _GTKMM_TEXTTAG_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/texttagtable.cc b/libs/gtkmm2/gtk/gtkmm/texttagtable.cc
new file mode 100644
index 0000000000..c237a5a325
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/texttagtable.cc
@@ -0,0 +1,466 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/texttagtable.h>
+#include <gtkmm/private/texttagtable_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* 
+ *
+ * Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/texttag.h>
+#include <gtk/gtktexttag.h>
+#include <gtk/gtktexttagtable.h>
+
+namespace Gtk
+{
+
+//This Signal Proxy allows the C++ coder to specify a sigc::slot instead of a static function.
+class SignalProxy_ForEach
+{
+public:
+  typedef TextTagTable::SlotForEach SlotType;
+
+  SignalProxy_ForEach(const SlotType& slot);
+  ~SignalProxy_ForEach();
+
+  static void gtk_callback(GtkTextTag* texttag, gpointer data);
+
+protected:
+  SlotType slot_;
+};
+
+SignalProxy_ForEach::SignalProxy_ForEach(const SlotType& slot)
+{
+  slot_ = slot;
+}
+
+SignalProxy_ForEach::~SignalProxy_ForEach()
+{
+}
+
+void SignalProxy_ForEach::gtk_callback(GtkTextTag* texttag, gpointer data)
+{
+  SignalProxy_ForEach* pSignalProxy = static_cast<SignalProxy_ForEach*>(data);
+  if(pSignalProxy)
+  {
+    //Use Slot::operator():
+    (pSignalProxy->slot_)(Glib::wrap(texttag, true)); //true = take_copy.
+  }
+}
+
+
+void TextTagTable::foreach(const SlotForEach& slot)
+{
+  SignalProxy_ForEach proxy(slot); //It doesn't need to exist for longer than the function call.
+  gtk_text_tag_table_foreach(gobj(),  &SignalProxy_ForEach::gtk_callback, (gpointer)&proxy);
+}
+
+
+} /* namespace Gtk */
+
+
+namespace
+{
+
+void TextTagTable_signal_tag_changed_callback(GtkTextTagTable* self, GtkTextTag* p0,gboolean p1,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,const Glib::RefPtr<TextTag>&,bool > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(Glib::wrap(p0, true)
+, p1
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+}
+
+const Glib::SignalProxyInfo TextTagTable_signal_tag_changed_info =
+{
+  "tag_changed",
+  (GCallback) &TextTagTable_signal_tag_changed_callback,
+  (GCallback) &TextTagTable_signal_tag_changed_callback
+};
+
+
+void TextTagTable_signal_tag_added_callback(GtkTextTagTable* self, GtkTextTag* p0,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,const Glib::RefPtr<TextTag>& > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(Glib::wrap(p0, true)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+}
+
+const Glib::SignalProxyInfo TextTagTable_signal_tag_added_info =
+{
+  "tag_added",
+  (GCallback) &TextTagTable_signal_tag_added_callback,
+  (GCallback) &TextTagTable_signal_tag_added_callback
+};
+
+
+void TextTagTable_signal_tag_removed_callback(GtkTextTagTable* self, GtkTextTag* p0,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,const Glib::RefPtr<TextTag>& > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(Glib::wrap(p0, true)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+}
+
+const Glib::SignalProxyInfo TextTagTable_signal_tag_removed_info =
+{
+  "tag_removed",
+  (GCallback) &TextTagTable_signal_tag_removed_callback,
+  (GCallback) &TextTagTable_signal_tag_removed_callback
+};
+
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Glib::RefPtr<Gtk::TextTagTable> wrap(GtkTextTagTable* object, bool take_copy)
+{
+  return Glib::RefPtr<Gtk::TextTagTable>( dynamic_cast<Gtk::TextTagTable*> (Glib::wrap_auto ((GObject*)(object), take_copy)) );
+  //We use dynamic_cast<> in case of multiple inheritance.
+}
+
+} /* namespace Glib */
+
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& TextTagTable_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &TextTagTable_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_text_tag_table_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void TextTagTable_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+  klass->tag_changed = &tag_changed_callback;
+  klass->tag_added = &tag_added_callback;
+  klass->tag_removed = &tag_removed_callback;
+}
+
+
+void TextTagTable_Class::tag_changed_callback(GtkTextTagTable* self, GtkTextTag* p0, gboolean p1)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_tag_changed(Glib::wrap(p0, true)
+, p1
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->tag_changed)
+      (*base->tag_changed)(self, p0, p1);
+  }
+}
+
+void TextTagTable_Class::tag_added_callback(GtkTextTagTable* self, GtkTextTag* p0)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_tag_added(Glib::wrap(p0, true)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->tag_added)
+      (*base->tag_added)(self, p0);
+  }
+}
+
+void TextTagTable_Class::tag_removed_callback(GtkTextTagTable* self, GtkTextTag* p0)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_tag_removed(Glib::wrap(p0, true)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->tag_removed)
+      (*base->tag_removed)(self, p0);
+  }
+}
+
+
+Glib::ObjectBase* TextTagTable_Class::wrap_new(GObject* object)
+{
+  return new TextTagTable((GtkTextTagTable*)object);
+}
+
+
+/* The implementation: */
+
+GtkTextTagTable* TextTagTable::gobj_copy()
+{
+  reference();
+  return gobj();
+}
+
+TextTagTable::TextTagTable(const Glib::ConstructParams& construct_params)
+:
+  Glib::Object(construct_params)
+{}
+
+TextTagTable::TextTagTable(GtkTextTagTable* castitem)
+:
+  Glib::Object((GObject*)(castitem))
+{}
+
+TextTagTable::~TextTagTable()
+{}
+
+
+TextTagTable::CppClassType TextTagTable::texttagtable_class_; // initialize static member
+
+GType TextTagTable::get_type()
+{
+  return texttagtable_class_.init().get_type();
+}
+
+GType TextTagTable::get_base_type()
+{
+  return gtk_text_tag_table_get_type();
+}
+
+
+TextTagTable::TextTagTable()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Glib::Object(Glib::ConstructParams(texttagtable_class_.init()))
+{
+  }
+
+Glib::RefPtr<TextTagTable> TextTagTable::create()
+{
+  return Glib::RefPtr<TextTagTable>( new TextTagTable() );
+}
+void TextTagTable::add(const Glib::RefPtr<TextTag>& tag)
+{
+  gtk_text_tag_table_add(gobj(), Glib::unwrap(tag));
+}
+
+void TextTagTable::remove(const Glib::RefPtr<TextTag>& tag)
+{
+  gtk_text_tag_table_remove(gobj(), Glib::unwrap(tag));
+}
+
+Glib::RefPtr<TextTag> TextTagTable::lookup(const Glib::ustring& name)
+{
+
+  Glib::RefPtr<TextTag> retvalue = Glib::wrap(gtk_text_tag_table_lookup(gobj(), name.c_str()));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::RefPtr<const TextTag> TextTagTable::lookup(const Glib::ustring& name) const
+{
+
+  Glib::RefPtr<const TextTag> retvalue = Glib::wrap(gtk_text_tag_table_lookup(const_cast<GtkTextTagTable*>(gobj()), name.c_str()));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+int TextTagTable::get_size() const
+{
+  return gtk_text_tag_table_get_size(const_cast<GtkTextTagTable*>(gobj()));
+}
+
+
+Glib::SignalProxy2< void,const Glib::RefPtr<TextTag>&,bool > TextTagTable::signal_tag_changed()
+{
+  return Glib::SignalProxy2< void,const Glib::RefPtr<TextTag>&,bool >(this, &TextTagTable_signal_tag_changed_info);
+}
+
+Glib::SignalProxy1< void,const Glib::RefPtr<TextTag>& > TextTagTable::signal_tag_added()
+{
+  return Glib::SignalProxy1< void,const Glib::RefPtr<TextTag>& >(this, &TextTagTable_signal_tag_added_info);
+}
+
+Glib::SignalProxy1< void,const Glib::RefPtr<TextTag>& > TextTagTable::signal_tag_removed()
+{
+  return Glib::SignalProxy1< void,const Glib::RefPtr<TextTag>& >(this, &TextTagTable_signal_tag_removed_info);
+}
+
+
+void Gtk::TextTagTable::on_tag_changed(const Glib::RefPtr<TextTag>& tag, bool size_changed)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->tag_changed)
+    (*base->tag_changed)(gobj(),Glib::unwrap(tag),static_cast<int>(size_changed));
+}
+
+void Gtk::TextTagTable::on_tag_added(const Glib::RefPtr<TextTag>& tag)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->tag_added)
+    (*base->tag_added)(gobj(),Glib::unwrap(tag));
+}
+
+void Gtk::TextTagTable::on_tag_removed(const Glib::RefPtr<TextTag>& tag)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->tag_removed)
+    (*base->tag_removed)(gobj(),Glib::unwrap(tag));
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/texttagtable.h b/libs/gtkmm2/gtk/gtkmm/texttagtable.h
new file mode 100644
index 0000000000..3c8d8215ac
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/texttagtable.h
@@ -0,0 +1,186 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_TEXTTAGTABLE_H
+#define _GTKMM_TEXTTAGTABLE_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* texttagtable.h
+ * 
+ * Copyright (C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/object.h>
+#include <gtkmm/texttag.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkTextTagTable GtkTextTagTable;
+typedef struct _GtkTextTagTableClass GtkTextTagTableClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class TextTagTable_Class; } // namespace Gtk
+namespace Gtk
+{
+
+class TextTag;
+
+/** Typedefed as Gtk::TextBuffer::TagTable. A Collection of @link Gtk::TextTag Gtk::TextBuffer::Tags@endlink that can be used together.
+ *
+ * A tag table defines a set of @link Gtk::TextTag Gtk::TextBuffer::Tags@endlink that can be used together. Each buffer has one tag
+ * table associated with it; only tags from that tag table can be used with the buffer. A single tag table can be shared between
+ * multiple buffers, however.
+ *
+ * @ingroup TextView
+ */
+
+class TextTagTable : public Glib::Object
+{
+   
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+public:
+  typedef TextTagTable CppObjectType;
+  typedef TextTagTable_Class CppClassType;
+  typedef GtkTextTagTable BaseObjectType;
+  typedef GtkTextTagTableClass BaseClassType;
+
+private:  friend class TextTagTable_Class;
+  static CppClassType texttagtable_class_;
+
+private:
+  // noncopyable
+  TextTagTable(const TextTagTable&);
+  TextTagTable& operator=(const TextTagTable&);
+
+protected:
+  explicit TextTagTable(const Glib::ConstructParams& construct_params);
+  explicit TextTagTable(GtkTextTagTable* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+  virtual ~TextTagTable();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GObject.
+  GtkTextTagTable*       gobj()       { return reinterpret_cast<GtkTextTagTable*>(gobject_); }
+
+  ///Provides access to the underlying C GObject.
+  const GtkTextTagTable* gobj() const { return reinterpret_cast<GtkTextTagTable*>(gobject_); }
+
+  ///Provides access to the underlying C instance. The caller is responsible for unrefing it. Use when directly setting fields in structs.
+  GtkTextTagTable* gobj_copy();
+
+private:
+
+protected:
+
+  TextTagTable();
+
+public:
+  
+  static Glib::RefPtr<TextTagTable> create();
+
+
+  /** Add a tag to the table. The tag is assigned the highest priority
+   * in the table.
+   * 
+   *  @a tag  must not be in a tag table already, and may not have
+   * the same name as an already-added tag.
+   * @param tag A Gtk::TextTag.
+   */
+  void add(const Glib::RefPtr<TextTag>& tag);
+  
+  /** Remove a tag from the table. This will remove the table's
+   * reference to the tag, so be careful - the tag will end
+   * up destroyed if you don't have a reference to it.
+   * @param tag A Gtk::TextTag.
+   */
+  void remove(const Glib::RefPtr<TextTag>& tag);
+  
+  /** Look up a named tag.
+   * @param name Name of a tag.
+   * @return The tag, or <tt>0</tt> if none by that name is in the table.
+   */
+  Glib::RefPtr<TextTag> lookup(const Glib::ustring& name);
+  
+  /** Look up a named tag.
+   * @param name Name of a tag.
+   * @return The tag, or <tt>0</tt> if none by that name is in the table.
+   */
+  Glib::RefPtr<const TextTag> lookup(const Glib::ustring& name) const;
+
+  typedef sigc::slot<void, const Glib::RefPtr<TextTag>&> SlotForEach;
+  void foreach(const SlotForEach& slot);
+  
+
+  /** Returns the size of the table (number of tags)
+   * @return Number of tags in @a table .
+   */
+  int get_size() const;
+
+  
+  Glib::SignalProxy2< void,const Glib::RefPtr<TextTag>&,bool > signal_tag_changed();
+
+  
+  Glib::SignalProxy1< void,const Glib::RefPtr<TextTag>& > signal_tag_added();
+
+  
+  Glib::SignalProxy1< void,const Glib::RefPtr<TextTag>& > signal_tag_removed();
+
+
+public:
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+  virtual void on_tag_changed(const Glib::RefPtr<TextTag>& tag, bool size_changed);
+  virtual void on_tag_added(const Glib::RefPtr<TextTag>& tag);
+  virtual void on_tag_removed(const Glib::RefPtr<TextTag>& tag);
+
+
+};
+
+} /* namespace Gtk */
+
+
+namespace Glib
+{
+  /** @relates Gtk::TextTagTable
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Glib::RefPtr<Gtk::TextTagTable> wrap(GtkTextTagTable* object, bool take_copy = false);
+}
+
+
+#endif /* _GTKMM_TEXTTAGTABLE_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/textview.cc b/libs/gtkmm2/gtk/gtkmm/textview.cc
new file mode 100644
index 0000000000..d4d571371f
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/textview.cc
@@ -0,0 +1,920 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/textview.h>
+#include <gtkmm/private/textview_p.h>
+
+#include <gtk/gtktypebuiltins.h>
+// -*- c++ -*-
+/* $Id$ */
+
+/* Copyright 2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtk/gtktextview.h>
+
+namespace Gtk
+{
+
+TextView::TextView(const Glib::RefPtr<TextBuffer>& buffer)
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Container(Glib::ConstructParams(textview_class_.init(), (char*) 0))
+{
+  set_buffer(buffer);
+}
+
+bool TextView::scroll_to(TextBuffer::iterator& iter, double within_margin)
+{
+  //The last 2 arguments are ignored if use_align is FALSE.
+  return gtk_text_view_scroll_to_iter(gobj(), (iter).gobj(), within_margin, FALSE, 0.0, 0.0);
+}
+
+bool TextView::scroll_to(TextBuffer::iterator& iter, double within_margin, double xalign, double yalign)
+{
+  return gtk_text_view_scroll_to_iter(gobj(), (iter).gobj(), within_margin, TRUE /* use_align */, xalign, yalign);
+}
+
+void TextView::scroll_to(const Glib::RefPtr<TextBuffer::Mark>& mark, double within_margin)
+{
+  //The last 2 arguments are ignored if use_align is FALSE.
+  gtk_text_view_scroll_to_mark(gobj(), Glib::unwrap(mark), within_margin, FALSE, 0.0, 0.0);
+}
+
+void TextView::scroll_to(const Glib::RefPtr<TextBuffer::Mark>& mark, double within_margin, double xalign, double yalign)
+{
+  gtk_text_view_scroll_to_mark(gobj(), Glib::unwrap(mark), within_margin, TRUE /* use_align */, xalign, yalign);
+}
+
+//deprecated:
+bool TextView::scroll_to_iter(TextBuffer::iterator& iter, double within_margin)
+{
+  return scroll_to(iter, within_margin);
+}
+
+//deprecated:
+void TextView::scroll_to_mark(const Glib::RefPtr<TextBuffer::Mark>& mark, double within_margin)
+{
+  scroll_to(mark, within_margin);
+}
+
+void TextView::scroll_mark_onscreen(const Glib::RefPtr<TextBuffer::Mark>& mark)
+{
+  scroll_to(mark);
+}
+
+} // namespace Gtk
+
+
+namespace
+{
+
+void TextView_signal_set_scroll_adjustments_callback(GtkTextView* self, GtkAdjustment* p0,GtkAdjustment* p1,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,Adjustment*,Adjustment* > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(Glib::wrap(p0)
+, Glib::wrap(p1)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+}
+
+const Glib::SignalProxyInfo TextView_signal_set_scroll_adjustments_info =
+{
+  "set_scroll_adjustments",
+  (GCallback) &TextView_signal_set_scroll_adjustments_callback,
+  (GCallback) &TextView_signal_set_scroll_adjustments_callback
+};
+
+
+void TextView_signal_populate_popup_callback(GtkTextView* self, GtkMenu* p0,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,Menu* > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(Glib::wrap(p0)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+}
+
+const Glib::SignalProxyInfo TextView_signal_populate_popup_info =
+{
+  "populate_popup",
+  (GCallback) &TextView_signal_populate_popup_callback,
+  (GCallback) &TextView_signal_populate_popup_callback
+};
+
+
+const Glib::SignalProxyInfo TextView_signal_set_anchor_info =
+{
+  "set_anchor",
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
+};
+
+
+void TextView_signal_insert_at_cursor_callback(GtkTextView* self, const gchar* p0,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,const Glib::ustring& > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(Glib::convert_const_gchar_ptr_to_ustring(p0)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+}
+
+const Glib::SignalProxyInfo TextView_signal_insert_at_cursor_info =
+{
+  "insert_at_cursor",
+  (GCallback) &TextView_signal_insert_at_cursor_callback,
+  (GCallback) &TextView_signal_insert_at_cursor_callback
+};
+
+} // anonymous namespace
+
+// static
+GType Glib::Value<Gtk::TextWindowType>::value_type()
+{
+  return gtk_text_window_type_get_type();
+}
+
+
+namespace Glib
+{
+
+Gtk::TextView* wrap(GtkTextView* object, bool take_copy)
+{
+  return dynamic_cast<Gtk::TextView *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& TextView_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &TextView_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_text_view_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void TextView_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+  klass->set_scroll_adjustments = &set_scroll_adjustments_callback;
+  klass->populate_popup = &populate_popup_callback;
+  klass->set_anchor = &set_anchor_callback;
+  klass->insert_at_cursor = &insert_at_cursor_callback;
+}
+
+
+void TextView_Class::set_scroll_adjustments_callback(GtkTextView* self, GtkAdjustment* p0, GtkAdjustment* p1)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_set_scroll_adjustments(Glib::wrap(p0)
+, Glib::wrap(p1)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->set_scroll_adjustments)
+      (*base->set_scroll_adjustments)(self, p0, p1);
+  }
+}
+
+void TextView_Class::populate_popup_callback(GtkTextView* self, GtkMenu* p0)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_populate_popup(Glib::wrap(p0)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->populate_popup)
+      (*base->populate_popup)(self, p0);
+  }
+}
+
+void TextView_Class::set_anchor_callback(GtkTextView* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_set_anchor();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->set_anchor)
+      (*base->set_anchor)(self);
+  }
+}
+
+void TextView_Class::insert_at_cursor_callback(GtkTextView* self, const gchar* p0)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_insert_at_cursor(Glib::convert_const_gchar_ptr_to_ustring(p0)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->insert_at_cursor)
+      (*base->insert_at_cursor)(self, p0);
+  }
+}
+
+
+Glib::ObjectBase* TextView_Class::wrap_new(GObject* o)
+{
+  return manage(new TextView((GtkTextView*)(o)));
+
+}
+
+
+/* The implementation: */
+
+TextView::TextView(const Glib::ConstructParams& construct_params)
+:
+  Gtk::Container(construct_params)
+{
+  }
+
+TextView::TextView(GtkTextView* castitem)
+:
+  Gtk::Container((GtkContainer*)(castitem))
+{
+  }
+
+TextView::~TextView()
+{
+  destroy_();
+}
+
+TextView::CppClassType TextView::textview_class_; // initialize static member
+
+GType TextView::get_type()
+{
+  return textview_class_.init().get_type();
+}
+
+GType TextView::get_base_type()
+{
+  return gtk_text_view_get_type();
+}
+
+
+TextView::TextView()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Container(Glib::ConstructParams(textview_class_.init()))
+{
+  }
+
+void TextView::set_buffer(const Glib::RefPtr<TextBuffer>& buffer)
+{
+  gtk_text_view_set_buffer(gobj(), Glib::unwrap(buffer));
+}
+
+Glib::RefPtr<TextBuffer> TextView::get_buffer()
+{
+
+  Glib::RefPtr<TextBuffer> retvalue = Glib::wrap(gtk_text_view_get_buffer(gobj()));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::RefPtr<const TextBuffer> TextView::get_buffer() const
+{
+
+  Glib::RefPtr<const TextBuffer> retvalue = Glib::wrap(gtk_text_view_get_buffer(const_cast<GtkTextView*>(gobj())));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+bool TextView::move_mark_onscreen(const Glib::RefPtr<TextBuffer::Mark>& mark)
+{
+  return gtk_text_view_move_mark_onscreen(gobj(), Glib::unwrap(mark));
+}
+
+bool TextView::place_cursor_onscreen()
+{
+  return gtk_text_view_place_cursor_onscreen(gobj());
+}
+
+void TextView::get_visible_rect(Gdk::Rectangle& visible_rect) const
+{
+  gtk_text_view_get_visible_rect(const_cast<GtkTextView*>(gobj()), (visible_rect).gobj());
+}
+
+void TextView::set_cursor_visible(bool setting)
+{
+  gtk_text_view_set_cursor_visible(gobj(), static_cast<int>(setting));
+}
+
+bool TextView::get_cursor_visible() const
+{
+  return gtk_text_view_get_cursor_visible(const_cast<GtkTextView*>(gobj()));
+}
+
+void TextView::get_iter_location(const TextBuffer::iterator& iter, Gdk::Rectangle& location) const
+{
+  gtk_text_view_get_iter_location(const_cast<GtkTextView*>(gobj()), (iter).gobj(), (location).gobj());
+}
+
+void TextView::get_iter_at_location(TextBuffer::iterator& iter, int x, int y) const
+{
+  gtk_text_view_get_iter_at_location(const_cast<GtkTextView*>(gobj()), (iter).gobj(), x, y);
+}
+
+void TextView::get_iter_at_position(TextBuffer::iterator& iter, int& trailing, int x, int y) const
+{
+  gtk_text_view_get_iter_at_position(const_cast<GtkTextView*>(gobj()), (iter).gobj(), &trailing, x, y);
+}
+
+void TextView::get_line_yrange(const TextBuffer::iterator& iter, int& y, int& height) const
+{
+  gtk_text_view_get_line_yrange(const_cast<GtkTextView*>(gobj()), (iter).gobj(), &y, &height);
+}
+
+void TextView::get_line_at_y(TextBuffer::iterator& target_iter, int y, int& line_top) const
+{
+  gtk_text_view_get_line_at_y(const_cast<GtkTextView*>(gobj()), (target_iter).gobj(), y, &line_top);
+}
+
+void TextView::buffer_to_window_coords(TextWindowType win, int buffer_x, int buffer_y, int& window_x, int& window_y) const
+{
+  gtk_text_view_buffer_to_window_coords(const_cast<GtkTextView*>(gobj()), ((GtkTextWindowType)(win)), buffer_x, buffer_y, &window_x, &window_y);
+}
+
+void TextView::window_to_buffer_coords(TextWindowType win, int window_x, int window_y, int& buffer_x, int& buffer_y) const
+{
+  gtk_text_view_window_to_buffer_coords(const_cast<GtkTextView*>(gobj()), ((GtkTextWindowType)(win)), window_x, window_y, &buffer_x, &buffer_y);
+}
+
+Glib::RefPtr<Gdk::Window> TextView::get_window(TextWindowType win)
+{
+
+  Glib::RefPtr<Gdk::Window> retvalue = Glib::wrap((GdkWindowObject*)(gtk_text_view_get_window(gobj(), ((GtkTextWindowType)(win)))));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::RefPtr<const Gdk::Window> TextView::get_window(TextWindowType win) const
+{
+
+  Glib::RefPtr<const Gdk::Window> retvalue = Glib::wrap((GdkWindowObject*)(gtk_text_view_get_window(const_cast<GtkTextView*>(gobj()), ((GtkTextWindowType)(win)))));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+TextWindowType TextView::get_window_type(const Glib::RefPtr<Gdk::Window>& window)
+{
+  return ((TextWindowType)(gtk_text_view_get_window_type(gobj(), Glib::unwrap(window))));
+}
+
+void TextView::set_border_window_size(TextWindowType type, int size)
+{
+  gtk_text_view_set_border_window_size(gobj(), ((GtkTextWindowType)(type)), size);
+}
+
+int TextView::get_border_window_size(TextWindowType type) const
+{
+  return gtk_text_view_get_border_window_size(const_cast<GtkTextView*>(gobj()), ((GtkTextWindowType)(type)));
+}
+
+bool TextView::forward_display_line(TextBuffer::iterator& iter)
+{
+  return gtk_text_view_forward_display_line(gobj(), (iter).gobj());
+}
+
+bool TextView::backward_display_line(TextBuffer::iterator& iter)
+{
+  return gtk_text_view_backward_display_line(gobj(), (iter).gobj());
+}
+
+bool TextView::forward_display_line_end(TextBuffer::iterator& iter)
+{
+  return gtk_text_view_forward_display_line_end(gobj(), (iter).gobj());
+}
+
+bool TextView::backward_display_line_start(TextBuffer::iterator& iter)
+{
+  return gtk_text_view_backward_display_line_start(gobj(), (iter).gobj());
+}
+
+bool TextView::starts_display_line(const TextBuffer::iterator& iter)
+{
+  return gtk_text_view_starts_display_line(gobj(), (iter).gobj());
+}
+
+bool TextView::move_visually(TextBuffer::iterator& iter, int count)
+{
+  return gtk_text_view_move_visually(gobj(), (iter).gobj(), count);
+}
+
+void TextView::add_child_at_anchor(Widget& child, const Glib::RefPtr<TextBuffer::ChildAnchor>& anchor)
+{
+  gtk_text_view_add_child_at_anchor(gobj(), (child).gobj(), Glib::unwrap(anchor));
+}
+
+void TextView::add_child_in_window(Widget& child, TextWindowType which_window, int xpos, int ypos)
+{
+  gtk_text_view_add_child_in_window(gobj(), (child).gobj(), ((GtkTextWindowType)(which_window)), xpos, ypos);
+}
+
+void TextView::move_child(Widget& child, int xpos, int ypos)
+{
+  gtk_text_view_move_child(gobj(), (child).gobj(), xpos, ypos);
+}
+
+void TextView::set_wrap_mode(WrapMode wrap_mode)
+{
+  gtk_text_view_set_wrap_mode(gobj(), ((GtkWrapMode)(wrap_mode)));
+}
+
+WrapMode TextView::get_wrap_mode() const
+{
+  return ((WrapMode)(gtk_text_view_get_wrap_mode(const_cast<GtkTextView*>(gobj()))));
+}
+
+void TextView::set_editable(bool setting)
+{
+  gtk_text_view_set_editable(gobj(), static_cast<int>(setting));
+}
+
+bool TextView::get_editable() const
+{
+  return gtk_text_view_get_editable(const_cast<GtkTextView*>(gobj()));
+}
+
+void TextView::set_pixels_above_lines(int pixels_above_lines)
+{
+  gtk_text_view_set_pixels_above_lines(gobj(), pixels_above_lines);
+}
+
+int TextView::get_pixels_above_lines() const
+{
+  return gtk_text_view_get_pixels_above_lines(const_cast<GtkTextView*>(gobj()));
+}
+
+void TextView::set_pixels_below_lines(int pixels_below_lines)
+{
+  gtk_text_view_set_pixels_below_lines(gobj(), pixels_below_lines);
+}
+
+int TextView::get_pixels_below_lines() const
+{
+  return gtk_text_view_get_pixels_below_lines(const_cast<GtkTextView*>(gobj()));
+}
+
+void TextView::set_pixels_inside_wrap(int pixels_inside_wrap)
+{
+  gtk_text_view_set_pixels_inside_wrap(gobj(), pixels_inside_wrap);
+}
+
+int TextView::get_pixels_inside_wrap() const
+{
+  return gtk_text_view_get_pixels_inside_wrap(const_cast<GtkTextView*>(gobj()));
+}
+
+void TextView::set_justification(Justification justification)
+{
+  gtk_text_view_set_justification(gobj(), ((GtkJustification)(justification)));
+}
+
+Justification TextView::get_justification() const
+{
+  return ((Justification)(gtk_text_view_get_justification(const_cast<GtkTextView*>(gobj()))));
+}
+
+void TextView::set_left_margin(int left_margin)
+{
+  gtk_text_view_set_left_margin(gobj(), left_margin);
+}
+
+int TextView::get_left_margin() const
+{
+  return gtk_text_view_get_left_margin(const_cast<GtkTextView*>(gobj()));
+}
+
+void TextView::set_right_margin(int right_margin)
+{
+  gtk_text_view_set_right_margin(gobj(), right_margin);
+}
+
+int TextView::get_right_margin() const
+{
+  return gtk_text_view_get_right_margin(const_cast<GtkTextView*>(gobj()));
+}
+
+void TextView::set_indent(int indent)
+{
+  gtk_text_view_set_indent(gobj(), indent);
+}
+
+int TextView::get_indent() const
+{
+  return gtk_text_view_get_indent(const_cast<GtkTextView*>(gobj()));
+}
+
+void TextView::set_tabs(Pango::TabArray& tabs)
+{
+  gtk_text_view_set_tabs(gobj(), (tabs).gobj());
+}
+
+Pango::TabArray TextView::get_tabs() const
+{
+  return Pango::TabArray((gtk_text_view_get_tabs(const_cast<GtkTextView*>(gobj()))));
+}
+
+TextAttributes TextView::get_default_attributes() const
+{
+  return TextAttributes(gtk_text_view_get_default_attributes(const_cast<GtkTextView*>(gobj())));
+}
+
+void TextView::set_overwrite(bool overwrite)
+{
+  gtk_text_view_set_overwrite(gobj(), static_cast<int>(overwrite));
+}
+
+bool TextView::get_overwrite() const
+{
+  return gtk_text_view_get_overwrite(const_cast<GtkTextView*>(gobj()));
+}
+
+void TextView::set_accepts_tab(bool accepts_tab)
+{
+  gtk_text_view_set_accepts_tab(gobj(), static_cast<int>(accepts_tab));
+}
+
+bool TextView::get_accepts_tab() const
+{
+  return gtk_text_view_get_accepts_tab(const_cast<GtkTextView*>(gobj()));
+}
+
+
+Glib::SignalProxy2< void,Adjustment*,Adjustment* > TextView::signal_set_scroll_adjustments()
+{
+  return Glib::SignalProxy2< void,Adjustment*,Adjustment* >(this, &TextView_signal_set_scroll_adjustments_info);
+}
+
+Glib::SignalProxy1< void,Menu* > TextView::signal_populate_popup()
+{
+  return Glib::SignalProxy1< void,Menu* >(this, &TextView_signal_populate_popup_info);
+}
+
+Glib::SignalProxy0< void > TextView::signal_set_anchor()
+{
+  return Glib::SignalProxy0< void >(this, &TextView_signal_set_anchor_info);
+}
+
+Glib::SignalProxy1< void,const Glib::ustring& > TextView::signal_insert_at_cursor()
+{
+  return Glib::SignalProxy1< void,const Glib::ustring& >(this, &TextView_signal_insert_at_cursor_info);
+}
+
+
+Glib::PropertyProxy<int> TextView::property_pixels_above_lines() 
+{
+  return Glib::PropertyProxy<int>(this, "pixels-above-lines");
+}
+
+Glib::PropertyProxy_ReadOnly<int> TextView::property_pixels_above_lines() const
+{
+  return Glib::PropertyProxy_ReadOnly<int>(this, "pixels-above-lines");
+}
+
+Glib::PropertyProxy<int> TextView::property_pixels_below_lines() 
+{
+  return Glib::PropertyProxy<int>(this, "pixels-below-lines");
+}
+
+Glib::PropertyProxy_ReadOnly<int> TextView::property_pixels_below_lines() const
+{
+  return Glib::PropertyProxy_ReadOnly<int>(this, "pixels-below-lines");
+}
+
+Glib::PropertyProxy<int> TextView::property_pixels_inside_wrap() 
+{
+  return Glib::PropertyProxy<int>(this, "pixels-inside-wrap");
+}
+
+Glib::PropertyProxy_ReadOnly<int> TextView::property_pixels_inside_wrap() const
+{
+  return Glib::PropertyProxy_ReadOnly<int>(this, "pixels-inside-wrap");
+}
+
+Glib::PropertyProxy<bool> TextView::property_editable() 
+{
+  return Glib::PropertyProxy<bool>(this, "editable");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> TextView::property_editable() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "editable");
+}
+
+Glib::PropertyProxy<WrapMode> TextView::property_wrap_mode() 
+{
+  return Glib::PropertyProxy<WrapMode>(this, "wrap-mode");
+}
+
+Glib::PropertyProxy_ReadOnly<WrapMode> TextView::property_wrap_mode() const
+{
+  return Glib::PropertyProxy_ReadOnly<WrapMode>(this, "wrap-mode");
+}
+
+Glib::PropertyProxy<Justification> TextView::property_justification() 
+{
+  return Glib::PropertyProxy<Justification>(this, "justification");
+}
+
+Glib::PropertyProxy_ReadOnly<Justification> TextView::property_justification() const
+{
+  return Glib::PropertyProxy_ReadOnly<Justification>(this, "justification");
+}
+
+Glib::PropertyProxy<int> TextView::property_left_margin() 
+{
+  return Glib::PropertyProxy<int>(this, "left-margin");
+}
+
+Glib::PropertyProxy_ReadOnly<int> TextView::property_left_margin() const
+{
+  return Glib::PropertyProxy_ReadOnly<int>(this, "left-margin");
+}
+
+Glib::PropertyProxy<int> TextView::property_right_margin() 
+{
+  return Glib::PropertyProxy<int>(this, "right-margin");
+}
+
+Glib::PropertyProxy_ReadOnly<int> TextView::property_right_margin() const
+{
+  return Glib::PropertyProxy_ReadOnly<int>(this, "right-margin");
+}
+
+Glib::PropertyProxy<int> TextView::property_indent() 
+{
+  return Glib::PropertyProxy<int>(this, "indent");
+}
+
+Glib::PropertyProxy_ReadOnly<int> TextView::property_indent() const
+{
+  return Glib::PropertyProxy_ReadOnly<int>(this, "indent");
+}
+
+Glib::PropertyProxy<Pango::TabArray> TextView::property_tabs() 
+{
+  return Glib::PropertyProxy<Pango::TabArray>(this, "tabs");
+}
+
+Glib::PropertyProxy_ReadOnly<Pango::TabArray> TextView::property_tabs() const
+{
+  return Glib::PropertyProxy_ReadOnly<Pango::TabArray>(this, "tabs");
+}
+
+Glib::PropertyProxy<bool> TextView::property_cursor_visible() 
+{
+  return Glib::PropertyProxy<bool>(this, "cursor-visible");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> TextView::property_cursor_visible() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "cursor-visible");
+}
+
+Glib::PropertyProxy< Glib::RefPtr<TextBuffer> > TextView::property_buffer() 
+{
+  return Glib::PropertyProxy< Glib::RefPtr<TextBuffer> >(this, "buffer");
+}
+
+Glib::PropertyProxy_ReadOnly< Glib::RefPtr<TextBuffer> > TextView::property_buffer() const
+{
+  return Glib::PropertyProxy_ReadOnly< Glib::RefPtr<TextBuffer> >(this, "buffer");
+}
+
+Glib::PropertyProxy<bool> TextView::property_overwrite() 
+{
+  return Glib::PropertyProxy<bool>(this, "overwrite");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> TextView::property_overwrite() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "overwrite");
+}
+
+Glib::PropertyProxy<bool> TextView::property_accepts_tab() 
+{
+  return Glib::PropertyProxy<bool>(this, "accepts-tab");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> TextView::property_accepts_tab() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "accepts-tab");
+}
+
+
+void Gtk::TextView::on_set_scroll_adjustments(Adjustment* hadjustment, Adjustment* vadjustment)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->set_scroll_adjustments)
+    (*base->set_scroll_adjustments)(gobj(),(GtkAdjustment*)Glib::unwrap(hadjustment),(GtkAdjustment*)Glib::unwrap(vadjustment));
+}
+
+void Gtk::TextView::on_populate_popup(Menu* menu)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->populate_popup)
+    (*base->populate_popup)(gobj(),(GtkMenu*)Glib::unwrap(menu));
+}
+
+void Gtk::TextView::on_set_anchor()
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->set_anchor)
+    (*base->set_anchor)(gobj());
+}
+
+void Gtk::TextView::on_insert_at_cursor(const Glib::ustring& str)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->insert_at_cursor)
+    (*base->insert_at_cursor)(gobj(),str.c_str());
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/textview.h b/libs/gtkmm2/gtk/gtkmm/textview.h
new file mode 100644
index 0000000000..aee4dc44b7
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/textview.h
@@ -0,0 +1,960 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_TEXTVIEW_H
+#define _GTKMM_TEXTVIEW_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* Copyright(C) 2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/container.h>
+#include <gtkmm/textbuffer.h>
+#include <gtkmm/textmark.h>
+#include <gtkmm/menu.h>
+#include <gtkmm/adjustment.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkTextView GtkTextView;
+typedef struct _GtkTextViewClass GtkTextViewClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class TextView_Class; } // namespace Gtk
+namespace Gtk
+{
+
+
+/** @addtogroup gtkmmEnums Enums and Flags */
+
+/**
+ * @ingroup gtkmmEnums
+ */
+enum TextWindowType
+{
+  TEXT_WINDOW_PRIVATE,
+  TEXT_WINDOW_WIDGET,
+  TEXT_WINDOW_TEXT,
+  TEXT_WINDOW_LEFT,
+  TEXT_WINDOW_RIGHT,
+  TEXT_WINDOW_TOP,
+  TEXT_WINDOW_BOTTOM
+};
+
+} // namespace Gtk
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Gtk::TextWindowType> : public Glib::Value_Enum<Gtk::TextWindowType>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{
+
+
+/** @defgroup TextView TextView Classes
+ * These classes are used with the Gtk::TextView widget.
+ */
+
+/** Multi-line text editing widget. It displays a Gtk::TextBuffer.
+ *
+ * @ingroup Widgets
+ * @ingroup Containers
+ * @ingroup TextView
+ */
+
+class TextView : public Container
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef TextView CppObjectType;
+  typedef TextView_Class CppClassType;
+  typedef GtkTextView BaseObjectType;
+  typedef GtkTextViewClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~TextView();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class TextView_Class;
+  static CppClassType textview_class_;
+
+  // noncopyable
+  TextView(const TextView&);
+  TextView& operator=(const TextView&);
+
+protected:
+  explicit TextView(const Glib::ConstructParams& construct_params);
+  explicit TextView(GtkTextView* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GtkTextView*       gobj()       { return reinterpret_cast<GtkTextView*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GtkTextView* gobj() const { return reinterpret_cast<GtkTextView*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+  virtual void on_set_scroll_adjustments(Adjustment* hadjustment, Adjustment* vadjustment);
+  virtual void on_populate_popup(Menu* menu);
+  virtual void on_set_anchor();
+  virtual void on_insert_at_cursor(const Glib::ustring& str);
+
+
+private:
+
+public:
+  TextView();
+  explicit TextView(const Glib::RefPtr<TextBuffer>& buffer);
+
+  
+  /** Sets @a buffer  as the buffer being displayed by @a text_view . The previous
+   * buffer displayed by the text view is unreferenced, and a reference is
+   * added to @a buffer . If you owned a reference to @a buffer  before passing it
+   * to this function, you must remove that reference yourself; Gtk::TextView
+   * will not "adopt" it.
+   * @param buffer A Gtk::TextBuffer.
+   */
+  void set_buffer(const Glib::RefPtr<TextBuffer>& buffer);
+  
+  /** Returns the Gtk::TextBuffer being displayed by this text view.
+   * The reference count on the buffer is not incremented; the caller
+   * of this function won't own a new reference.
+   * @return A Gtk::TextBuffer.
+   */
+  Glib::RefPtr<TextBuffer> get_buffer();
+  
+  /** Returns the Gtk::TextBuffer being displayed by this text view.
+   * The reference count on the buffer is not incremented; the caller
+   * of this function won't own a new reference.
+   * @return A Gtk::TextBuffer.
+   */
+  Glib::RefPtr<const TextBuffer> get_buffer() const;
+
+  #ifndef GTKMM_DISABLE_DEPRECATED
+  /** @deprecated Use scroll_to().
+   */                            
+  bool scroll_to_iter(TextBuffer::iterator& iter, double within_margin);
+
+  /** @deprecated Use scroll_to().
+   */ 
+  void scroll_to_mark(const Glib::RefPtr<TextBuffer::Mark>& mark, double within_margin);
+
+  /** @deprecated Use scroll_to()
+   */
+  void scroll_mark_onscreen(const Glib::RefPtr<TextBuffer::Mark>& mark);
+ 
+  #endif //GTKMM_DISABLE_DEPRECATED
+
+  /** Scrolls the TextView so that @a iter is on the screen, by scrolling the minimal distance to get the mark onscreen,
+   * possibly not scrolling at all. The effective screen for purposes of this function is reduced by a margin of size
+   * @a within_margin.
+   * @note This function uses the currently-computed height of the lines in the text buffer. Note that line heights are computed
+   * in an idle handler; so this function may not have the desired effect if it's called before the height computations. To avoid
+   * oddness, consider using gtk_text_view_scroll_to_mark() which saves a point to be scrolled to after line validation.
+   *
+   * @param iter An iterator pointing to the position that should be made visible by scrolling.
+   * @param within_margin margin as a [0.0,0.5] fraction of screen size.
+   * @result true if scrolling occurred.
+   */
+  bool scroll_to(TextBuffer::iterator& iter, double within_margin = 0);
+
+  /** Scrolls the TextView so that @a iter is on the screen, in the position indicated by xalign and yalign,
+   * possibly not scrolling at all. The effective screen for purposes of this function is reduced by a margin of size
+   * @a within_margin.
+   * @note This function uses the currently-computed height of the lines in the text buffer. Note that line heights are computed
+   * in an idle handler; so this function may not have the desired effect if it's called before the height computations. To avoid
+   * oddness, consider using gtk_text_view_scroll_to_mark() which saves a point to be scrolled to after line validation.
+   *
+   * @param iter An iterator pointing to the position that should be made visible by scrolling.
+   * @param within_margin margin as a [0.0,0.5] fraction of screen size.
+   * @param xalign horizontal alignment of mark within visible area. An alignment of 0.0 indicates left, 1.0 indicates right, 0.5 means center.
+   * @param yalign vertical alignment of mark within visible area. An alignment of 0.0 indicates top, 1.0 indicates bottom, 0.5 means center.
+   * @result true if scrolling occurred.
+   */ 
+  bool scroll_to(TextBuffer::iterator& iter, double within_margin, double xalign, double yalign);
+  
+
+  /** Scrolls text_view so that @a mark is on the screen, by scrolling the minimal distance to get the mark onscreen,
+   * possibly not scrolling at all. The effective screen for purposes of this function is reduced by a margin of size
+   * @a within_margin.
+   *
+   * @param mark An mark pointing to the position that should be made visible by scrolling.
+   * @param within_margin margin as a [0.0,0.5] fraction of screen size.
+   */
+  void scroll_to(const Glib::RefPtr<TextBuffer::Mark>& mark, double within_margin = 0);
+
+ /** Scrolls the TextView so that @a iter is on the screen, in the position indicated by xalign and yalign,
+   * possibly not scrolling at all. The effective screen for purposes of this function is reduced by a margin of size
+   * @a within_margin.
+   *
+   * @param mark An mark pointing to the position that should be made visible by scrolling.
+   * @param within_margin margin as a [0.0,0.5] fraction of screen size.
+   * @param xalign horizontal alignment of mark within visible area. An alignment of 0.0 indicates left, 1.0 indicates right, 0.5 means center.
+   * @param yalign vertical alignment of mark within visible area. An alignment of 0.0 indicates top, 1.0 indicates bottom, 0.5 means center.
+   */
+  void scroll_to(const Glib::RefPtr<TextBuffer::Mark>& mark, double within_margin, double xalign, double yalign);
+  
+ 
+   //It does not do anything more than the default scroll_to(mark).
+
+  
+  /** Moves a mark within the buffer so that it's
+   * located within the currently-visible text area.
+   * @param mark A Gtk::TextMark.
+   * @return <tt>true</tt> if the mark moved (wasn't already onscreen).
+   */
+  bool move_mark_onscreen(const Glib::RefPtr<TextBuffer::Mark>& mark);
+  
+  /** Moves the cursor to the currently visible region of the
+   * buffer, it it isn't there already.
+   * @return <tt>true</tt> if the cursor had to be moved.
+   */
+  bool place_cursor_onscreen();
+
+  
+  /** Fills @a visible_rect  with the currently-visible
+   * region of the buffer, in buffer coordinates. Convert to window coordinates
+   * with buffer_to_window_coords().
+   * @param visible_rect Rectangle to fill.
+   */
+  void get_visible_rect(Gdk::Rectangle& visible_rect) const;
+  
+  /** Toggles whether the insertion point is displayed. A buffer with no editable
+   * text probably shouldn't have a visible cursor, so you may want to turn
+   * the cursor off.
+   * @param setting Whether to show the insertion cursor.
+   */
+  void set_cursor_visible(bool setting = true);
+  
+  /** Find out whether the cursor is being displayed.
+   * @return Whether the insertion mark is visible.
+   */
+  bool get_cursor_visible() const;
+
+  
+  /** Gets a rectangle which roughly contains the character at @a iter .
+   * The rectangle position is in buffer coordinates; use
+   * buffer_to_window_coords() to convert these
+   * coordinates to coordinates for one of the windows in the text view.
+   * @param iter A Gtk::TextIter.
+   * @param location Bounds of the character at @a iter .
+   */
+  void get_iter_location(const TextBuffer::iterator&  iter, Gdk::Rectangle& location) const;
+  
+  /** Retrieves the iterator at buffer coordinates @a x  and @a y . Buffer
+   * coordinates are coordinates for the entire buffer, not just the
+   * currently-displayed portion.  If you have coordinates from an
+   * event, you have to convert those to buffer coordinates with
+   * window_to_buffer_coords().
+   * @param iter A Gtk::TextIter.
+   * @param x X position, in buffer coordinates.
+   * @param y Y position, in buffer coordinates.
+   */
+  void get_iter_at_location(TextBuffer::iterator& iter, int x, int y) const;
+  
+  /** Retrieves the iterator pointing to the character at buffer 
+   * coordinates @a x  and @a y . Buffer coordinates are coordinates for 
+   * the entire buffer, not just the currently-displayed portion.  
+   * If you have coordinates from an event, you have to convert 
+   * those to buffer coordinates with 
+   * window_to_buffer_coords().
+   * 
+   * Note that this is diffferent from get_iter_at_location(),
+   * which returns cursor locations, i.e. positions <em>between</em>
+   * characters.
+   * 
+   * Since: 2.6
+   * @param iter A Gtk::TextIter.
+   * @param x X position, in buffer coordinates.
+   * @param y Y position, in buffer coordinates.
+   */
+  void get_iter_at_position(TextBuffer::iterator& iter, int& trailing, int x, int y) const;
+  
+  /** Gets the y coordinate of the top of the line containing @a iter ,
+   * and the height of the line. The coordinate is a buffer coordinate;
+   * convert to window coordinates with buffer_to_window_coords().
+   * @param iter A Gtk::TextIter.
+   * @param y Return location for a y coordinate.
+   * @param height Return location for a height.
+   */
+  void get_line_yrange(const TextBuffer::iterator& iter, int& y, int& height) const;
+
+  
+  /** Gets the Gtk::TextIter at the start of the line containing
+   * the coordinate @a y . @a y  is in buffer coordinates, convert from
+   * window coordinates with window_to_buffer_coords().
+   * If non-<tt>0</tt>, @a line_top  will be filled with the coordinate of the top
+   * edge of the line.
+   * @param target_iter A Gtk::TextIter.
+   * @param y A y coordinate.
+   * @param line_top Return location for top coordinate of the line.
+   */
+  void get_line_at_y(TextBuffer::iterator& target_iter, int y, int& line_top) const;
+
+  
+  /** Converts coordinate ( @a buffer_x , @a buffer_y ) to coordinates for the window
+   *  @a win , and stores the result in ( @a window_x , @a window_y ). 
+   * 
+   * Note that you can't convert coordinates for a nonexisting window (see 
+   * set_border_window_size()).
+   * @param win A Gtk::TextWindowType except Gtk::TEXT_WINDOW_PRIVATE.
+   * @param buffer_x Buffer x coordinate.
+   * @param buffer_y Buffer y coordinate.
+   * @param window_x Window x coordinate return location.
+   * @param window_y Window y coordinate return location.
+   */
+  void buffer_to_window_coords(TextWindowType  win,
+                                            int buffer_x, int buffer_y,
+                                            int& window_x, int& window_y) const;
+  
+  /** Converts coordinates on the window identified by @a win  to buffer
+   * coordinates, storing the result in ( @a buffer_x , @a buffer_y ).
+   * 
+   * Note that you can't convert coordinates for a nonexisting window (see 
+   * set_border_window_size()).
+   * @param win A Gtk::TextWindowType except Gtk::TEXT_WINDOW_PRIVATE.
+   * @param window_x Window x coordinate.
+   * @param window_y Window y coordinate.
+   * @param buffer_x Buffer x coordinate return location.
+   * @param buffer_y Buffer y coordinate return location.
+   */
+  void window_to_buffer_coords(TextWindowType  win,
+                                            int window_x, int window_y,
+                                            int& buffer_x, int& buffer_y) const;
+
+  
+  /** Retrieves the Gdk::Window corresponding to an area of the text view;
+   * possible windows include the overall widget window, child windows
+   * on the left, right, top, bottom, and the window that displays the
+   * text buffer. Windows are <tt>0</tt> and nonexistent if their width or
+   * height is 0, and are nonexistent before the widget has been
+   * realized.
+   * @param win Window to get.
+   * @return A Gdk::Window, or <tt>0</tt>.
+   */
+  Glib::RefPtr<Gdk::Window> get_window(TextWindowType win);
+  
+  /** Retrieves the Gdk::Window corresponding to an area of the text view;
+   * possible windows include the overall widget window, child windows
+   * on the left, right, top, bottom, and the window that displays the
+   * text buffer. Windows are <tt>0</tt> and nonexistent if their width or
+   * height is 0, and are nonexistent before the widget has been
+   * realized.
+   * @param win Window to get.
+   * @return A Gdk::Window, or <tt>0</tt>.
+   */
+  Glib::RefPtr<const Gdk::Window> get_window(TextWindowType win) const;
+  
+  /** Usually used to find out which window an event corresponds to.
+   * If you connect to an event signal on @a text_view , this function
+   * should be called on <tt>event->window</tt> to
+   * see which window it was.
+   * @param window A window type.
+   * @return The window type.
+   */
+  TextWindowType get_window_type(const Glib::RefPtr<Gdk::Window>& window);
+
+  
+  /** Sets the width of Gtk::TEXT_WINDOW_LEFT or Gtk::TEXT_WINDOW_RIGHT,
+   * or the height of Gtk::TEXT_WINDOW_TOP or Gtk::TEXT_WINDOW_BOTTOM.
+   * Automatically destroys the corresponding window if the size is set
+   * to 0, and creates the window if the size is set to non-zero.  This
+   * function can only be used for the "border windows," it doesn't work
+   * with Gtk::TEXT_WINDOW_WIDGET, Gtk::TEXT_WINDOW_TEXT, or
+   * Gtk::TEXT_WINDOW_PRIVATE.
+   * @param type Window to affect.
+   * @param size Width or height of the window.
+   */
+  void set_border_window_size(TextWindowType type, int size);
+  
+  /** Gets the width of the specified border window. See
+   * set_border_window_size().
+   * @param type Window to return size from.
+   * @return Width of window.
+   */
+  int get_border_window_size(TextWindowType type) const;
+
+  
+  /** Moves the given @a iter  forward by one display (wrapped) line.  A
+   * display line is different from a paragraph. Paragraphs are
+   * separated by newlines or other paragraph separator characters.
+   * Display lines are created by line-wrapping a paragraph.  If
+   * wrapping is turned off, display lines and paragraphs will be the
+   * same. Display lines are divided differently for each view, since
+   * they depend on the view's width; paragraphs are the same in all
+   * views, since they depend on the contents of the Gtk::TextBuffer.
+   * @param iter A Gtk::TextIter.
+   * @return <tt>true</tt> if @a iter  was moved and is not on the end iterator.
+   */
+  bool forward_display_line(TextBuffer::iterator& iter);
+  
+  /** Moves the given @a iter  backward by one display (wrapped) line.  A
+   * display line is different from a paragraph. Paragraphs are
+   * separated by newlines or other paragraph separator characters.
+   * Display lines are created by line-wrapping a paragraph.  If
+   * wrapping is turned off, display lines and paragraphs will be the
+   * same. Display lines are divided differently for each view, since
+   * they depend on the view's width; paragraphs are the same in all
+   * views, since they depend on the contents of the Gtk::TextBuffer.
+   * @param iter A Gtk::TextIter.
+   * @return <tt>true</tt> if @a iter  was moved and is not on the end iterator.
+   */
+  bool backward_display_line(TextBuffer::iterator& iter);
+  
+  /** Moves the given @a iter  forward to the next display line end.  A
+   * display line is different from a paragraph. Paragraphs are
+   * separated by newlines or other paragraph separator characters.
+   * Display lines are created by line-wrapping a paragraph.  If
+   * wrapping is turned off, display lines and paragraphs will be the
+   * same. Display lines are divided differently for each view, since
+   * they depend on the view's width; paragraphs are the same in all
+   * views, since they depend on the contents of the Gtk::TextBuffer.
+   * @param iter A Gtk::TextIter.
+   * @return <tt>true</tt> if @a iter  was moved and is not on the end iterator.
+   */
+  bool forward_display_line_end(TextBuffer::iterator& iter);
+  
+  /** Moves the given @a iter  backward to the next display line start.  A
+   * display line is different from a paragraph. Paragraphs are
+   * separated by newlines or other paragraph separator characters.
+   * Display lines are created by line-wrapping a paragraph.  If
+   * wrapping is turned off, display lines and paragraphs will be the
+   * same. Display lines are divided differently for each view, since
+   * they depend on the view's width; paragraphs are the same in all
+   * views, since they depend on the contents of the Gtk::TextBuffer.
+   * @param iter A Gtk::TextIter.
+   * @return <tt>true</tt> if @a iter  was moved and is not on the end iterator.
+   */
+  bool backward_display_line_start(TextBuffer::iterator& iter);
+  
+  /** Determines whether @a iter  is at the start of a display line.
+   * See forward_display_line() for an explanation of
+   * display lines vs. paragraphs.
+   * @param iter A Gtk::TextIter.
+   * @return <tt>true</tt> if @a iter  begins a wrapped line.
+   */
+  bool starts_display_line(const TextBuffer::iterator&  iter);
+  
+  /** Move the iterator a given number of characters visually, treating
+   * it as the strong cursor position. If @a count  is positive, then the
+   * new strong cursor position will be @a count  positions to the right of
+   * the old cursor position. If @a count  is negative then the new strong
+   * cursor position will be @a count  positions to the left of the old
+   * cursor position.
+   * 
+   * In the presence of bidirection text, the correspondence
+   * between logical and visual order will depend on the direction
+   * of the current run, and there may be jumps when the cursor
+   * is moved off of the end of a run.
+   * @param iter A Gtk::TextIter.
+   * @param count Number of characters to move (negative moves left, positive moves right).
+   * @return <tt>true</tt> if @a iter  moved and is not on the end iterator.
+   */
+  bool move_visually(TextBuffer::iterator& iter, int count);
+
+  
+  /** Adds a child widget in the text buffer, at the given @a anchor .
+   * @param child A Gtk::Widget.
+   * @param anchor A Gtk::TextChildAnchor in the Gtk::TextBuffer for @a text_view .
+   */
+  void add_child_at_anchor(Widget& child, const Glib::RefPtr<TextBuffer::ChildAnchor>& anchor);
+
+  
+  /** Adds a child at fixed coordinates in one of the text widget's
+   * windows.  The window must have nonzero size (see
+   * set_border_window_size()).  Note that the child
+   * coordinates are given relative to the Gdk::Window in question, and
+   * that these coordinates have no sane relationship to scrolling. When
+   * placing a child in Gtk::TEXT_WINDOW_WIDGET, scrolling is
+   * irrelevant, the child floats above all scrollable areas. But when
+   * placing a child in one of the scrollable windows (border windows or
+   * text window), you'll need to compute the child's correct position
+   * in buffer coordinates any time scrolling occurs or buffer changes
+   * occur, and then call move_child() to update the
+   * child's position. Unfortunately there's no good way to detect that
+   * scrolling has occurred, using the current API; a possible hack
+   * would be to update all child positions when the scroll adjustments
+   * change or the text buffer changes. See bug 64518 on
+   * bugzilla.gnome.org for status of fixing this issue.
+   * @param child A Gtk::Widget.
+   * @param which_window Which window the child should appear in.
+   * @param xpos X position of child in window coordinates.
+   * @param ypos Y position of child in window coordinates.
+   */
+  void add_child_in_window(Widget& child, TextWindowType which_window,
+                                        int xpos, int ypos);
+
+  
+  /** Updates the position of a child, as for add_child_in_window().
+   * @param child Child widget already added to the text view.
+   * @param xpos New X position in window coordinates.
+   * @param ypos New Y position in window coordinates.
+   */
+  void move_child(Widget& child, int xpos,int ypos);
+
+  
+  /** Sets the line wrapping for the view.
+   * @param wrap_mode A Gtk::WrapMode.
+   */
+  void set_wrap_mode(WrapMode wrap_mode);
+  
+  /** Gets the line wrapping for the view.
+   * @return The line wrap setting.
+   */
+  WrapMode get_wrap_mode() const;
+  
+  /** Sets the default editability of the Gtk::TextView. You can override
+   * this default setting with tags in the buffer, using the "editable"
+   * attribute of tags.
+   * @param setting Whether it's editable.
+   */
+  void set_editable(bool setting = true);
+  
+  /** Returns the default editability of the Gtk::TextView. Tags in the
+   * buffer may override this setting for some ranges of text.
+   * @return Whether text is editable by default.
+   */
+  bool get_editable() const;
+  
+  /** Sets the default number of blank pixels above paragraphs in @a text_view .
+   * Tags in the buffer for @a text_view  may override the defaults.
+   * @param pixels_above_lines Pixels above paragraphs.
+   */
+  void set_pixels_above_lines(int pixels_above_lines);
+  
+  /** Gets the default number of pixels to put above paragraphs.
+   * @return Default number of pixels above paragraphs.
+   */
+  int get_pixels_above_lines() const;
+  
+  /** Sets the default number of pixels of blank space
+   * to put below paragraphs in @a text_view . May be overridden
+   * by tags applied to @a text_view 's buffer.
+   * @param pixels_below_lines Pixels below paragraphs.
+   */
+  void set_pixels_below_lines(int pixels_below_lines);
+  
+  /** Gets the value set by set_pixels_below_lines().
+   * @return Default number of blank pixels below paragraphs.
+   */
+  int get_pixels_below_lines() const;
+  
+  /** Sets the default number of pixels of blank space to leave between
+   * display/wrapped lines within a paragraph. May be overridden by
+   * tags in @a text_view 's buffer.
+   * @param pixels_inside_wrap Default number of pixels between wrapped lines.
+   */
+  void set_pixels_inside_wrap(int pixels_inside_wrap);
+  
+  /** Gets the value set by set_pixels_inside_wrap().
+   * @return Default number of pixels of blank space between wrapped lines.
+   */
+  int get_pixels_inside_wrap() const;
+  
+  /** Sets the default justification of text in @a text_view .
+   * Tags in the view's buffer may override the default.
+   * @param justification Justification.
+   */
+  void set_justification(Justification justification);
+  
+  /** Gets the default justification of paragraphs in @a text_view .
+   * Tags in the buffer may override the default.
+   * @return Default justification.
+   */
+  Justification get_justification() const;
+  
+  /** Sets the default left margin for text in @a text_view .
+   * Tags in the buffer may override the default.
+   * @param left_margin Left margin in pixels.
+   */
+  void set_left_margin(int left_margin);
+  
+  /** Gets the default left margin size of paragraphs in the @a text_view .
+   * Tags in the buffer may override the default.
+   * @return Left margin in pixels.
+   */
+  int get_left_margin() const;
+  
+  /** Sets the default right margin for text in the text view.
+   * Tags in the buffer may override the default.
+   * @param right_margin Right margin in pixels.
+   */
+  void set_right_margin(int right_margin);
+  
+  /** Gets the default right margin for text in @a text_view . Tags
+   * in the buffer may override the default.
+   * @return Right margin in pixels.
+   */
+  int get_right_margin() const;
+  
+  /** Sets the default indentation for paragraphs in @a text_view .
+   * Tags in the buffer may override the default.
+   * @param indent Indentation in pixels.
+   */
+  void set_indent(int indent);
+  
+  /** Gets the default indentation of paragraphs in @a text_view .
+   * Tags in the view's buffer may override the default.
+   * The indentation may be negative.
+   * @return Number of pixels of indentation.
+   */
+  int get_indent() const;
+  
+  /** Sets the default tab stops for paragraphs in @a text_view .
+   * Tags in the buffer may override the default.
+   * @param tabs Tabs as a Pango::TabArray.
+   */
+  void set_tabs(Pango::TabArray& tabs);
+  
+  /** Gets the default tabs for @a text_view . Tags in the buffer may
+   * override the defaults. The returned array will be <tt>0</tt> if
+   * "standard" (8-space) tabs are used.
+   * @return Copy of default tab array, or <tt>0</tt> if "standard" tabs are used.
+   */
+  Pango::TabArray get_tabs() const;
+  
+  /** Obtains a copy of the default text attributes. These are the
+   * attributes used for text unless a tag overrides them.
+   * You'd typically pass the default attributes in to
+   * Gtk::TextIter::get_attributes() in order to get the
+   * attributes in effect at a given text position.
+   * @return A new #Gtk::TextAttributes.
+   */
+  TextAttributes get_default_attributes() const;
+
+  
+  /** Changes the Gtk::TextView overwrite mode.
+   * 
+   * Since: 2.4
+   * @param overwrite <tt>true</tt> to turn on overwrite mode, <tt>false</tt> to turn it off.
+   */
+  void set_overwrite(bool overwrite = true);
+  
+  /** Returns whether the Gtk::TextView is in overwrite mode or not.
+   * @return Whether @a text_view  is in overwrite mode or not.
+   * 
+   * Since: 2.4.
+   */
+  bool get_overwrite() const;
+  
+  
+  /** Sets the behavior of the text widget when the Tab key is pressed. If @a accepts_tab 
+   * is <tt>true</tt> a tab character is inserted. If @a accepts_tab  is <tt>false</tt> the keyboard focus
+   * is moved to the next widget in the focus chain.
+   * 
+   * Since: 2.4
+   * @param accepts_tab <tt>true</tt> if pressing the Tab key should insert a tab character, <tt>false</tt>, if pressing the Tab key should move the keyboard focus.
+   */
+  void set_accepts_tab(bool accepts_tab = true);
+  
+  /** Returns whether pressing the Tab key inserts a tab characters.
+   * set_accepts_tab().
+   * @return <tt>true</tt> if pressing the Tab key inserts a tab character, <tt>false</tt> if pressing the Tab key moves the keyboard focus.
+   * 
+   * Since: 2.4.
+   */
+  bool get_accepts_tab() const;
+    
+  
+  Glib::SignalProxy2< void,Adjustment*,Adjustment* > signal_set_scroll_adjustments();
+
+  
+  Glib::SignalProxy1< void,Menu* > signal_populate_popup();
+
+
+  Glib::SignalProxy0< void > signal_set_anchor();
+
+  
+  Glib::SignalProxy1< void,const Glib::ustring& > signal_insert_at_cursor();
+
+  
+  //Keybinding signals:
+  
+  
+  /** Pixels of blank space above paragraphs.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<int> property_pixels_above_lines() ;
+
+/** Pixels of blank space above paragraphs.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<int> property_pixels_above_lines() const;
+
+  /** Pixels of blank space below paragraphs.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<int> property_pixels_below_lines() ;
+
+/** Pixels of blank space below paragraphs.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<int> property_pixels_below_lines() const;
+
+  /** Pixels of blank space between wrapped lines in a paragraph.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<int> property_pixels_inside_wrap() ;
+
+/** Pixels of blank space between wrapped lines in a paragraph.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<int> property_pixels_inside_wrap() const;
+
+  /** Whether the text can be modified by the user.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_editable() ;
+
+/** Whether the text can be modified by the user.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_editable() const;
+
+  /** Whether to wrap lines never
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<WrapMode> property_wrap_mode() ;
+
+/** Whether to wrap lines never
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<WrapMode> property_wrap_mode() const;
+
+  /** Left
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Justification> property_justification() ;
+
+/** Left
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Justification> property_justification() const;
+
+  /** Width of the left margin in pixels.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<int> property_left_margin() ;
+
+/** Width of the left margin in pixels.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<int> property_left_margin() const;
+
+  /** Width of the right margin in pixels.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<int> property_right_margin() ;
+
+/** Width of the right margin in pixels.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<int> property_right_margin() const;
+
+  /** Amount to indent the paragraph
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<int> property_indent() ;
+
+/** Amount to indent the paragraph
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<int> property_indent() const;
+
+  /** Custom tabs for this text.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Pango::TabArray> property_tabs() ;
+
+/** Custom tabs for this text.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Pango::TabArray> property_tabs() const;
+
+  /** If the insertion cursor is shown.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_cursor_visible() ;
+
+/** If the insertion cursor is shown.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_cursor_visible() const;
+
+  /** The buffer which is displayed.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy< Glib::RefPtr<TextBuffer> > property_buffer() ;
+
+/** The buffer which is displayed.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly< Glib::RefPtr<TextBuffer> > property_buffer() const;
+
+  /** Whether entered text overwrites existing contents.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_overwrite() ;
+
+/** Whether entered text overwrites existing contents.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_overwrite() const;
+
+  /** Whether Tab will result in a tab character being entered.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_accepts_tab() ;
+
+/** Whether Tab will result in a tab character being entered.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_accepts_tab() const;
+
+
+};
+
+} /* namespace Gtk */
+
+
+namespace Glib
+{
+  /** @relates Gtk::TextView
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gtk::TextView* wrap(GtkTextView* object, bool take_copy = false);
+}
+#endif /* _GTKMM_TEXTVIEW_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/toggleaction.cc b/libs/gtkmm2/gtk/gtkmm/toggleaction.cc
new file mode 100644
index 0000000000..f9892927db
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/toggleaction.cc
@@ -0,0 +1,257 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/toggleaction.h>
+#include <gtkmm/private/toggleaction_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* Copyright 2003 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtk/gtktoggleaction.h>
+
+
+namespace Gtk
+{
+
+ToggleAction::ToggleAction(const Glib::ustring& name, const Gtk::StockID& stock_id, const Glib::ustring& label, const Glib::ustring& tooltip, bool is_active)
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Action(Glib::ConstructParams(toggleaction_class_.init(), "name",name.c_str(),"stock_id",stock_id.get_c_str(),"label",(label.empty() ? 0 : label.c_str()),"tooltip",(tooltip.empty() ? 0 : tooltip.c_str()), (char*) 0))
+{
+  set_active(is_active);
+}
+
+Glib::RefPtr<ToggleAction> ToggleAction::create(const Glib::ustring& name, const Glib::ustring& label, const Glib::ustring& tooltip, bool is_active)
+{
+  return Glib::RefPtr<ToggleAction>( new ToggleAction(name, Gtk::StockID(), label, tooltip, is_active) );
+}
+
+Glib::RefPtr<ToggleAction> ToggleAction::create(const Glib::ustring& name, const Gtk::StockID& stock_id, const Glib::ustring& label, const Glib::ustring& tooltip, bool is_active)
+{
+  return Glib::RefPtr<ToggleAction>( new ToggleAction(name, stock_id, label, tooltip, is_active) );
+}
+
+
+} // namespace Gtk
+
+
+namespace
+{
+
+const Glib::SignalProxyInfo ToggleAction_signal_toggled_info =
+{
+  "toggled",
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
+};
+
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Glib::RefPtr<Gtk::ToggleAction> wrap(GtkToggleAction* object, bool take_copy)
+{
+  return Glib::RefPtr<Gtk::ToggleAction>( dynamic_cast<Gtk::ToggleAction*> (Glib::wrap_auto ((GObject*)(object), take_copy)) );
+  //We use dynamic_cast<> in case of multiple inheritance.
+}
+
+} /* namespace Glib */
+
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& ToggleAction_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &ToggleAction_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_toggle_action_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void ToggleAction_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+  klass->toggled = &toggled_callback;
+}
+
+
+void ToggleAction_Class::toggled_callback(GtkToggleAction* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_toggled();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->toggled)
+      (*base->toggled)(self);
+  }
+}
+
+
+Glib::ObjectBase* ToggleAction_Class::wrap_new(GObject* object)
+{
+  return new ToggleAction((GtkToggleAction*)object);
+}
+
+
+/* The implementation: */
+
+GtkToggleAction* ToggleAction::gobj_copy()
+{
+  reference();
+  return gobj();
+}
+
+ToggleAction::ToggleAction(const Glib::ConstructParams& construct_params)
+:
+  Gtk::Action(construct_params)
+{}
+
+ToggleAction::ToggleAction(GtkToggleAction* castitem)
+:
+  Gtk::Action((GtkAction*)(castitem))
+{}
+
+ToggleAction::~ToggleAction()
+{}
+
+
+ToggleAction::CppClassType ToggleAction::toggleaction_class_; // initialize static member
+
+GType ToggleAction::get_type()
+{
+  return toggleaction_class_.init().get_type();
+}
+
+GType ToggleAction::get_base_type()
+{
+  return gtk_toggle_action_get_type();
+}
+
+
+ToggleAction::ToggleAction()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Action(Glib::ConstructParams(toggleaction_class_.init()))
+{
+  }
+
+Glib::RefPtr<ToggleAction> ToggleAction::create()
+{
+  return Glib::RefPtr<ToggleAction>( new ToggleAction() );
+}
+void ToggleAction::toggled()
+{
+  gtk_toggle_action_toggled(gobj());
+}
+
+void ToggleAction::set_active(bool is_active)
+{
+  gtk_toggle_action_set_active(gobj(), static_cast<int>(is_active));
+}
+
+bool ToggleAction::get_active() const
+{
+  return gtk_toggle_action_get_active(const_cast<GtkToggleAction*>(gobj()));
+}
+
+void ToggleAction::set_draw_as_radio(bool draw_as_radio)
+{
+  gtk_toggle_action_set_draw_as_radio(gobj(), static_cast<int>(draw_as_radio));
+}
+
+bool ToggleAction::get_draw_as_radio() const
+{
+  return gtk_toggle_action_get_draw_as_radio(const_cast<GtkToggleAction*>(gobj()));
+}
+
+
+Glib::SignalProxy0< void > ToggleAction::signal_toggled()
+{
+  return Glib::SignalProxy0< void >(this, &ToggleAction_signal_toggled_info);
+}
+
+
+Glib::PropertyProxy<bool> ToggleAction::property_draw_as_radio() 
+{
+  return Glib::PropertyProxy<bool>(this, "draw-as-radio");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> ToggleAction::property_draw_as_radio() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "draw-as-radio");
+}
+
+
+void Gtk::ToggleAction::on_toggled()
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->toggled)
+    (*base->toggled)(gobj());
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/toggleaction.h b/libs/gtkmm2/gtk/gtkmm/toggleaction.h
new file mode 100644
index 0000000000..b44872026e
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/toggleaction.h
@@ -0,0 +1,184 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_TOGGLEACTION_H
+#define _GTKMM_TOGGLEACTION_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* Copyright (C) 2003 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/action.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkToggleAction GtkToggleAction;
+typedef struct _GtkToggleActionClass GtkToggleActionClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class ToggleAction_Class; } // namespace Gtk
+namespace Gtk
+{
+
+
+class ToggleAction : public Gtk::Action
+{
+  
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+public:
+  typedef ToggleAction CppObjectType;
+  typedef ToggleAction_Class CppClassType;
+  typedef GtkToggleAction BaseObjectType;
+  typedef GtkToggleActionClass BaseClassType;
+
+private:  friend class ToggleAction_Class;
+  static CppClassType toggleaction_class_;
+
+private:
+  // noncopyable
+  ToggleAction(const ToggleAction&);
+  ToggleAction& operator=(const ToggleAction&);
+
+protected:
+  explicit ToggleAction(const Glib::ConstructParams& construct_params);
+  explicit ToggleAction(GtkToggleAction* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+  virtual ~ToggleAction();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GObject.
+  GtkToggleAction*       gobj()       { return reinterpret_cast<GtkToggleAction*>(gobject_); }
+
+  ///Provides access to the underlying C GObject.
+  const GtkToggleAction* gobj() const { return reinterpret_cast<GtkToggleAction*>(gobject_); }
+
+  ///Provides access to the underlying C instance. The caller is responsible for unrefing it. Use when directly setting fields in structs.
+  GtkToggleAction* gobj_copy();
+
+private:
+
+
+protected:
+  ToggleAction();
+   explicit ToggleAction(const Glib::ustring& name, const StockID& stock_id, const Glib::ustring& label = Glib::ustring(), const Glib::ustring& tooltip = Glib::ustring(), bool is_active = false);
+
+public:
+  
+  static Glib::RefPtr<ToggleAction> create();
+
+   static Glib::RefPtr<ToggleAction> create(const Glib::ustring& name, const Glib::ustring& label = Glib::ustring(), const Glib::ustring& tooltip =  Glib::ustring(), bool is_active = false);
+   static Glib::RefPtr<ToggleAction> create(const Glib::ustring& name, const Gtk::StockID& stock_id, const Glib::ustring& label =  Glib::ustring(), const Glib::ustring& tooltip =  Glib::ustring(), bool is_active = false);
+
+  
+  /** Emits the "toggled" signal on the toggle action.
+   * 
+   * Since: 2.4
+   */
+  void toggled();
+  
+  /** Sets the checked state on the toggle action.
+   * 
+   * Since: 2.4
+   * @param is_active Whether the action should be checked or not.
+   */
+  void set_active(bool is_active = true);
+  
+  /** Returns the checked state of the toggle action.
+   * @return The checked state of the toggle action
+   * 
+   * Since: 2.4.
+   */
+  bool get_active() const;
+  
+  /** Sets whether the action should have proxies like a radio action.
+   * 
+   * Since: 2.4
+   * @param draw_as_radio Whether the action should have proxies like a radio 
+   * action.
+   */
+  void set_draw_as_radio(bool draw_as_radio = true);
+  
+  /** Returns whether the action should have proxies like a radio action.
+   * @return Whether the action should have proxies like a radio action.
+   * 
+   * Since: 2.4.
+   */
+  bool get_draw_as_radio() const;
+
+  
+  Glib::SignalProxy0< void > signal_toggled();
+
+
+  /** Whether the proxies for this action look like radio action proxies.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_draw_as_radio() ;
+
+/** Whether the proxies for this action look like radio action proxies.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_draw_as_radio() const;
+          
+
+public:
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+  virtual void on_toggled();
+
+
+};
+
+} // namespace Gtk
+
+
+namespace Glib
+{
+  /** @relates Gtk::ToggleAction
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Glib::RefPtr<Gtk::ToggleAction> wrap(GtkToggleAction* object, bool take_copy = false);
+}
+
+
+#endif /* _GTKMM_TOGGLEACTION_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/togglebutton.cc b/libs/gtkmm2/gtk/gtkmm/togglebutton.cc
new file mode 100644
index 0000000000..e7600d0406
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/togglebutton.cc
@@ -0,0 +1,267 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/togglebutton.h>
+#include <gtkmm/private/togglebutton_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* 
+ *
+ * Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtk/gtktogglebutton.h>
+
+namespace Gtk
+{
+
+ToggleButton::ToggleButton(const Glib::ustring& label, bool mnemonic)
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Button(Glib::ConstructParams(togglebutton_class_.init(), "label",label.c_str(),"use_underline",gboolean(mnemonic), (char*) 0))
+{}
+
+} // namespace Gtk
+
+
+namespace
+{
+
+const Glib::SignalProxyInfo ToggleButton_signal_toggled_info =
+{
+  "toggled",
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
+};
+
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Gtk::ToggleButton* wrap(GtkToggleButton* object, bool take_copy)
+{
+  return dynamic_cast<Gtk::ToggleButton *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& ToggleButton_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &ToggleButton_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_toggle_button_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void ToggleButton_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+  klass->toggled = &toggled_callback;
+}
+
+
+void ToggleButton_Class::toggled_callback(GtkToggleButton* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_toggled();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->toggled)
+      (*base->toggled)(self);
+  }
+}
+
+
+Glib::ObjectBase* ToggleButton_Class::wrap_new(GObject* o)
+{
+  return manage(new ToggleButton((GtkToggleButton*)(o)));
+
+}
+
+
+/* The implementation: */
+
+ToggleButton::ToggleButton(const Glib::ConstructParams& construct_params)
+:
+  Gtk::Button(construct_params)
+{
+  }
+
+ToggleButton::ToggleButton(GtkToggleButton* castitem)
+:
+  Gtk::Button((GtkButton*)(castitem))
+{
+  }
+
+ToggleButton::~ToggleButton()
+{
+  destroy_();
+}
+
+ToggleButton::CppClassType ToggleButton::togglebutton_class_; // initialize static member
+
+GType ToggleButton::get_type()
+{
+  return togglebutton_class_.init().get_type();
+}
+
+GType ToggleButton::get_base_type()
+{
+  return gtk_toggle_button_get_type();
+}
+
+
+ToggleButton::ToggleButton()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Button(Glib::ConstructParams(togglebutton_class_.init()))
+{
+  }
+
+void ToggleButton::set_mode(bool draw_indicator)
+{
+  gtk_toggle_button_set_mode(gobj(), static_cast<int>(draw_indicator));
+}
+
+bool ToggleButton::get_mode() const
+{
+  return gtk_toggle_button_get_mode(const_cast<GtkToggleButton*>(gobj()));
+}
+
+void ToggleButton::set_active(bool is_active)
+{
+  gtk_toggle_button_set_active(gobj(), static_cast<int>(is_active));
+}
+
+bool ToggleButton::get_active() const
+{
+  return gtk_toggle_button_get_active(const_cast<GtkToggleButton*>(gobj()));
+}
+
+void ToggleButton::set_inconsistent(bool setting)
+{
+  gtk_toggle_button_set_inconsistent(gobj(), static_cast<int>(setting));
+}
+
+bool ToggleButton::get_inconsistent() const
+{
+  return gtk_toggle_button_get_inconsistent(const_cast<GtkToggleButton*>(gobj()));
+}
+
+void ToggleButton::toggled()
+{
+  gtk_toggle_button_toggled(gobj());
+}
+
+
+Glib::SignalProxy0< void > ToggleButton::signal_toggled()
+{
+  return Glib::SignalProxy0< void >(this, &ToggleButton_signal_toggled_info);
+}
+
+
+Glib::PropertyProxy<bool> ToggleButton::property_active() 
+{
+  return Glib::PropertyProxy<bool>(this, "active");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> ToggleButton::property_active() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "active");
+}
+
+Glib::PropertyProxy<bool> ToggleButton::property_inconsistent() 
+{
+  return Glib::PropertyProxy<bool>(this, "inconsistent");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> ToggleButton::property_inconsistent() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "inconsistent");
+}
+
+Glib::PropertyProxy<bool> ToggleButton::property_draw_indicator() 
+{
+  return Glib::PropertyProxy<bool>(this, "draw-indicator");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> ToggleButton::property_draw_indicator() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "draw-indicator");
+}
+
+
+void Gtk::ToggleButton::on_toggled()
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->toggled)
+    (*base->toggled)(gobj());
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/togglebutton.h b/libs/gtkmm2/gtk/gtkmm/togglebutton.h
new file mode 100644
index 0000000000..df0da34b34
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/togglebutton.h
@@ -0,0 +1,235 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_TOGGLEBUTTON_H
+#define _GTKMM_TOGGLEBUTTON_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* togglebutton.h
+ * 
+ * Copyright (C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/button.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkToggleButton GtkToggleButton;
+typedef struct _GtkToggleButtonClass GtkToggleButtonClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class ToggleButton_Class; } // namespace Gtk
+namespace Gtk
+{
+
+/** A Gtk::ToggleButton will remain 'pressed-in' when clicked. Clicking again will cause the toggle button to return to it's normal state.
+ * The state of a Gtk::ToggleButton can be set specifically using set_active(), and retrieved using get_active().
+ * To simply switch the state of a toggle button, use toggled().
+ *
+ * @ingroup Widgets
+ */
+
+class ToggleButton : public Button
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef ToggleButton CppObjectType;
+  typedef ToggleButton_Class CppClassType;
+  typedef GtkToggleButton BaseObjectType;
+  typedef GtkToggleButtonClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~ToggleButton();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class ToggleButton_Class;
+  static CppClassType togglebutton_class_;
+
+  // noncopyable
+  ToggleButton(const ToggleButton&);
+  ToggleButton& operator=(const ToggleButton&);
+
+protected:
+  explicit ToggleButton(const Glib::ConstructParams& construct_params);
+  explicit ToggleButton(GtkToggleButton* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GtkToggleButton*       gobj()       { return reinterpret_cast<GtkToggleButton*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GtkToggleButton* gobj() const { return reinterpret_cast<GtkToggleButton*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+  virtual void on_toggled();
+
+
+private:
+
+public:
+
+  /** Create an empty toggle button.
+   * With an empty button, you can Gtk::Button::add() a widget such as a
+   * Gtk::Pixmap or Gtk::Box.
+   *
+   * If you just wish to add a Gtk::Label, you may want to use the
+   * Gtk::ToggleButton(const Glib::ustring &label) constructor directly
+   * instead.
+   */
+  ToggleButton();
+
+  /** Create a toggle button with a label.
+   * You won't be able
+   * to add a widget to this button since it already contains a Gtk::Label
+   */
+  explicit ToggleButton(const Glib::ustring& label, bool mnemonic = false);
+  
+
+  /** Sets whether the button is displayed as a separate indicator and label.
+   * You can call this function on a checkbutton or a radiobutton with
+   *  @a draw_indicator  = <tt>false</tt> to make the button look like a normal button
+   * 
+   * This function only effects instances of classes like Gtk::CheckButton
+   * and Gtk::RadioButton that derive from Gtk::ToggleButton,
+   * not instances of Gtk::ToggleButton itself.
+   * @param draw_indicator If <tt>true</tt>, draw the button as a separate indicator
+   * and label; if <tt>false</tt>, draw the button like a normal button.
+   */
+  void set_mode(bool draw_indicator = true);
+  
+  /** Retrieves whether the button is displayed as a separate indicator
+   * and label. See set_mode().
+   * @return <tt>true</tt> if the togglebutton is drawn as a separate indicator
+   * and label.
+   */
+  bool get_mode() const;
+
+  
+  void set_active(bool is_active = true);
+  
+  bool get_active() const;
+
+  
+  /** If the user has selected a range of elements (such as some text or
+   * spreadsheet cells) that are affected by a toggle button, and the
+   * current values in that range are inconsistent, you may want to
+   * display the toggle in an "in between" state. This function turns on
+   * "in between" display.  Normally you would turn off the inconsistent
+   * state again if the user toggles the toggle button. This has to be
+   * done manually, set_inconsistent() only affects
+   * visual appearance, it doesn't affect the semantics of the button.
+   * @param setting <tt>true</tt> if state is inconsistent.
+   */
+  void set_inconsistent(bool setting = true);
+  
+  /** Gets the value set by set_inconsistent().
+   * @return <tt>true</tt> if the button is displayed as inconsistent, <tt>false</tt> otherwise.
+   */
+  bool get_inconsistent() const;
+
+  
+  void toggled();
+
+  
+  Glib::SignalProxy0< void > signal_toggled();
+
+
+  /** If the toggle button should be pressed in or not.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_active() ;
+
+/** If the toggle button should be pressed in or not.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_active() const;
+
+  /** If the toggle button is in an in-between state.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_inconsistent() ;
+
+/** If the toggle button is in an in-between state.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_inconsistent() const;
+
+  /** If the toggle part of the button is displayed.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_draw_indicator() ;
+
+/** If the toggle part of the button is displayed.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_draw_indicator() const;
+
+
+};
+
+} /* namespace Gtk */
+
+
+namespace Glib
+{
+  /** @relates Gtk::ToggleButton
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gtk::ToggleButton* wrap(GtkToggleButton* object, bool take_copy = false);
+}
+#endif /* _GTKMM_TOGGLEBUTTON_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/toggletoolbutton.cc b/libs/gtkmm2/gtk/gtkmm/toggletoolbutton.cc
new file mode 100644
index 0000000000..3aadab7948
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/toggletoolbutton.cc
@@ -0,0 +1,226 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/toggletoolbutton.h>
+#include <gtkmm/private/toggletoolbutton_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* 
+ *
+ * Copyright 2003 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtk/gtktoggletoolbutton.h>
+
+namespace Gtk
+{
+
+ToggleToolButton::ToggleToolButton(const Glib::ustring& label)
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::ToolButton(Glib::ConstructParams(toggletoolbutton_class_.init(), "label", label.c_str(), (char*) 0))
+{
+}
+
+ToggleToolButton::ToggleToolButton(Widget& icon_widget, const Glib::ustring& label)
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::ToolButton(Glib::ConstructParams(toggletoolbutton_class_.init(), "icon_widget", (icon_widget).gobj(), "label", label.c_str(), (char*) 0))
+{
+}
+
+} // namespace Gtk
+
+
+namespace
+{
+
+const Glib::SignalProxyInfo ToggleToolButton_signal_toggled_info =
+{
+  "toggled",
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
+};
+
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Gtk::ToggleToolButton* wrap(GtkToggleToolButton* object, bool take_copy)
+{
+  return dynamic_cast<Gtk::ToggleToolButton *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& ToggleToolButton_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &ToggleToolButton_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_toggle_tool_button_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void ToggleToolButton_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+  klass->toggled = &toggled_callback;
+}
+
+
+void ToggleToolButton_Class::toggled_callback(GtkToggleToolButton* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_toggled();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->toggled)
+      (*base->toggled)(self);
+  }
+}
+
+
+Glib::ObjectBase* ToggleToolButton_Class::wrap_new(GObject* o)
+{
+  return manage(new ToggleToolButton((GtkToggleToolButton*)(o)));
+
+}
+
+
+/* The implementation: */
+
+ToggleToolButton::ToggleToolButton(const Glib::ConstructParams& construct_params)
+:
+  Gtk::ToolButton(construct_params)
+{
+  }
+
+ToggleToolButton::ToggleToolButton(GtkToggleToolButton* castitem)
+:
+  Gtk::ToolButton((GtkToolButton*)(castitem))
+{
+  }
+
+ToggleToolButton::~ToggleToolButton()
+{
+  destroy_();
+}
+
+ToggleToolButton::CppClassType ToggleToolButton::toggletoolbutton_class_; // initialize static member
+
+GType ToggleToolButton::get_type()
+{
+  return toggletoolbutton_class_.init().get_type();
+}
+
+GType ToggleToolButton::get_base_type()
+{
+  return gtk_toggle_tool_button_get_type();
+}
+
+
+ToggleToolButton::ToggleToolButton()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::ToolButton(Glib::ConstructParams(toggletoolbutton_class_.init()))
+{
+  }
+
+ToggleToolButton::ToggleToolButton(const Gtk::StockID& stock_id)
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::ToolButton(Glib::ConstructParams(toggletoolbutton_class_.init(), "stock_id", (stock_id).get_c_str(), (char*) 0))
+{
+  }
+
+void ToggleToolButton::set_active(bool is_active)
+{
+  gtk_toggle_tool_button_set_active(gobj(), static_cast<int>(is_active));
+}
+
+bool ToggleToolButton::get_active() const
+{
+  return gtk_toggle_tool_button_get_active(const_cast<GtkToggleToolButton*>(gobj()));
+}
+
+
+Glib::SignalProxy0< void > ToggleToolButton::signal_toggled()
+{
+  return Glib::SignalProxy0< void >(this, &ToggleToolButton_signal_toggled_info);
+}
+
+
+void Gtk::ToggleToolButton::on_toggled()
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->toggled)
+    (*base->toggled)(gobj());
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/toggletoolbutton.h b/libs/gtkmm2/gtk/gtkmm/toggletoolbutton.h
new file mode 100644
index 0000000000..331d65976e
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/toggletoolbutton.h
@@ -0,0 +1,170 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_TOGGLETOOLBUTTON_H
+#define _GTKMM_TOGGLETOOLBUTTON_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* box.h
+ *
+ * Copyright (C) 2003 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/toolbutton.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkToggleToolButton GtkToggleToolButton;
+typedef struct _GtkToggleToolButtonClass GtkToggleToolButtonClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class ToggleToolButton_Class; } // namespace Gtk
+namespace Gtk
+{
+
+/** A Gtk::ToolItem containing a toggle button.
+ *
+ * A ToggleToolButton is a Gtk::ToolItem that contains a toggle button.
+ * @ingroup Widgets
+ */
+
+class ToggleToolButton : public ToolButton
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef ToggleToolButton CppObjectType;
+  typedef ToggleToolButton_Class CppClassType;
+  typedef GtkToggleToolButton BaseObjectType;
+  typedef GtkToggleToolButtonClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~ToggleToolButton();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class ToggleToolButton_Class;
+  static CppClassType toggletoolbutton_class_;
+
+  // noncopyable
+  ToggleToolButton(const ToggleToolButton&);
+  ToggleToolButton& operator=(const ToggleToolButton&);
+
+protected:
+  explicit ToggleToolButton(const Glib::ConstructParams& construct_params);
+  explicit ToggleToolButton(GtkToggleToolButton* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GtkToggleToolButton*       gobj()       { return reinterpret_cast<GtkToggleToolButton*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GtkToggleToolButton* gobj() const { return reinterpret_cast<GtkToggleToolButton*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+  virtual void on_toggled();
+
+
+private:
+
+public:
+
+  /** Creates a new ToggleToolButton.
+   */
+  ToggleToolButton();
+  
+  /** Creates a new ToggleToolButton from a StockID.
+   *
+   * The ToggleToolButton will be created according to the @a stock_id properties.
+   * 
+   * @param stock_id The StockID which determines the look of the ToggleToolButton.
+   */
+  explicit ToggleToolButton(const Gtk::StockID& stock_id);
+  
+  /** Creates a new ToggleToolButton with a label.
+   *
+   * The ToggleToolButton will have the label @a label.
+   *
+   * @param label The string used to display the label for this ToggleToolButton.
+   */
+  explicit ToggleToolButton(const Glib::ustring& label);
+  
+  /** Creates a new ToggleToolButton with an image.
+   *
+   * The ToggleToolButton will have the label @a label and an image widget @a icon_widget.
+   *
+   * @param icon_widget The widget placed as the ToggleToolButton's icon.
+   * @param label The string used to display the label for this ToggleToolButton.
+   */
+  explicit ToggleToolButton(Widget& icon_widget, const Glib::ustring& label = Glib::ustring());
+
+  
+  /** Sets the status of the toggle tool button. Set to <tt>true</tt> if you
+   * want the GtkToggleButton to be 'pressed in', and <tt>false</tt> to raise it.
+   * This action causes the toggled signal to be emitted.
+   * 
+   * Since: 2.4
+   * @param is_active Whether @a button  should be active.
+   */
+  void set_active(bool is_active = true);
+  
+  /** Queries a Gtk::ToggleToolButton and returns its current state.
+   * Returns <tt>true</tt> if the toggle button is pressed in and <tt>false</tt> if it is raised.
+   * @return <tt>true</tt> if the toggle tool button is pressed in, <tt>false</tt> if not
+   * 
+   * Since: 2.4.
+   */
+  bool get_active() const;
+
+  
+  Glib::SignalProxy0< void > signal_toggled();
+
+
+};
+
+} // namespace Gtk
+
+
+namespace Glib
+{
+  /** @relates Gtk::ToggleToolButton
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gtk::ToggleToolButton* wrap(GtkToggleToolButton* object, bool take_copy = false);
+}
+#endif /* _GTKMM_TOGGLETOOLBUTTON_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/toolbar.cc b/libs/gtkmm2/gtk/gtkmm/toolbar.cc
new file mode 100644
index 0000000000..a8d10a7dde
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/toolbar.cc
@@ -0,0 +1,609 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/toolbar.h>
+#include <gtkmm/private/toolbar_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* 
+ *
+ * Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+//Define this to make sure that we don't use any of the deprecated GtkToolbar API.
+//Normally we just deprecate it in gtkmm too,
+//but the GtkToolbar compatibility system is particularly unpleasant, so we just removed it in gtkmm 2.4. murrayc.
+//In future, this GTK_DISABLE_DEPRECATED might be inappropriate because it might cover extra GTK+ API. Just remove it then.
+
+#define GTK_DISABLE_DEPRECATED
+
+#include <glib.h>
+#include <gtkmm/button.h>
+#include <gtkmm/togglebutton.h>
+#include <gtkmm/radiobutton.h>
+#include <gtkmm/tooltips.h>
+//#include <gtkmm/image.h>
+#include <gtkmm/label.h>
+#include <gtk/gtklabel.h>
+#include <gtk/gtktoolbar.h>
+
+namespace Gtk
+{
+
+void Toolbar::insert(ToolButton& item, int pos, const sigc::slot<void>& clicked_slot)
+{
+  item.signal_clicked().connect(clicked_slot);
+  gtk_toolbar_insert(gobj(), (GtkToolItem*)((item).gobj()), pos);
+}
+
+void Toolbar::insert(ToggleToolButton& item, int pos, const sigc::slot<void>& toggled_slot)
+{
+  item.signal_toggled().connect(toggled_slot);
+  gtk_toolbar_insert(gobj(), (GtkToolItem*)((item).gobj()), pos);
+}
+
+void Toolbar::append(ToolItem& item)
+{
+  gtk_toolbar_insert(gobj(), (item).gobj(), -1 /* See GTK+ docs */);
+}
+
+void Toolbar::append(ToolButton& item, const sigc::slot<void>& clicked_slot)
+{
+  item.signal_clicked().connect(clicked_slot);
+  gtk_toolbar_insert(gobj(), (GtkToolItem*)((item).gobj()), -1 /* See GTK+ docs */);
+}
+
+void Toolbar::append(ToggleToolButton& item, const sigc::slot<void>& toggled_slot)
+{
+  item.signal_toggled().connect(toggled_slot);
+  gtk_toolbar_insert(gobj(), (GtkToolItem*)((item).gobj()), -1 /* See GTK+ docs */);
+}
+
+void Toolbar::prepend(ToolItem& item)
+{
+  gtk_toolbar_insert(gobj(), (item).gobj(), 0 /* See GTK+ docs */);
+}
+
+void Toolbar::prepend(ToolButton& item, const sigc::slot<void>& clicked_slot)
+{
+  item.signal_clicked().connect(clicked_slot);
+  gtk_toolbar_insert(gobj(), (GtkToolItem*)((item).gobj()), 0 /* See GTK+ docs */);
+}
+
+void Toolbar::prepend(ToggleToolButton& item, const sigc::slot<void>& toggled_slot)
+{
+  item.signal_toggled().connect(toggled_slot);
+  gtk_toolbar_insert(gobj(), (GtkToolItem*)((item).gobj()), 0 /* See GTK+ docs */);
+}
+
+void Toolbar::unset_drop_highlight_item()
+{
+  //See GTK+ docs.
+  gtk_toolbar_set_drop_highlight_item(gobj(), 0, 0);
+}
+
+} // namespace Gtk
+
+
+namespace
+{
+
+void Toolbar_signal_orientation_changed_callback(GtkToolbar* self, GtkOrientation p0,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,Orientation > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(((Orientation)(p0))
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+}
+
+const Glib::SignalProxyInfo Toolbar_signal_orientation_changed_info =
+{
+  "orientation_changed",
+  (GCallback) &Toolbar_signal_orientation_changed_callback,
+  (GCallback) &Toolbar_signal_orientation_changed_callback
+};
+
+
+void Toolbar_signal_toolbar_style_changed_callback(GtkToolbar* self, GtkToolbarStyle p0,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,ToolbarStyle > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(((ToolbarStyle)(p0))
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+}
+
+const Glib::SignalProxyInfo Toolbar_signal_toolbar_style_changed_info =
+{
+  "style_changed",
+  (GCallback) &Toolbar_signal_toolbar_style_changed_callback,
+  (GCallback) &Toolbar_signal_toolbar_style_changed_callback
+};
+
+
+gboolean Toolbar_signal_popup_context_menu_callback(GtkToolbar* self, gint p0,gint p1,gint p2,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< bool,int,int,int > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        return static_cast<int>((*static_cast<SlotType*>(slot))(p0
+, p1
+, p2
+));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+gboolean Toolbar_signal_popup_context_menu_notify_callback(GtkToolbar* self, gint p0,gint p1,gint p2, void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,int,int,int > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(p0
+, p1
+, p2
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+const Glib::SignalProxyInfo Toolbar_signal_popup_context_menu_info =
+{
+  "popup_context_menu",
+  (GCallback) &Toolbar_signal_popup_context_menu_callback,
+  (GCallback) &Toolbar_signal_popup_context_menu_notify_callback
+};
+
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Gtk::Toolbar* wrap(GtkToolbar* object, bool take_copy)
+{
+  return dynamic_cast<Gtk::Toolbar *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& Toolbar_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &Toolbar_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_toolbar_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void Toolbar_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+  klass->orientation_changed = &orientation_changed_callback;
+  klass->style_changed = &style_changed_callback;
+  klass->popup_context_menu = &popup_context_menu_callback;
+}
+
+
+void Toolbar_Class::orientation_changed_callback(GtkToolbar* self, GtkOrientation p0)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_orientation_changed(((Orientation)(p0))
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->orientation_changed)
+      (*base->orientation_changed)(self, p0);
+  }
+}
+
+void Toolbar_Class::style_changed_callback(GtkToolbar* self, GtkToolbarStyle p0)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_toolbar_style_changed(((ToolbarStyle)(p0))
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->style_changed)
+      (*base->style_changed)(self, p0);
+  }
+}
+
+gboolean Toolbar_Class::popup_context_menu_callback(GtkToolbar* self, gint p0, gint p1, gint p2)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return static_cast<int>(obj->on_popup_context_menu(p0
+, p1
+, p2
+));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->popup_context_menu)
+      return (*base->popup_context_menu)(self, p0, p1, p2);
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+
+Glib::ObjectBase* Toolbar_Class::wrap_new(GObject* o)
+{
+  return manage(new Toolbar((GtkToolbar*)(o)));
+
+}
+
+
+/* The implementation: */
+
+Toolbar::Toolbar(const Glib::ConstructParams& construct_params)
+:
+  Gtk::Container(construct_params)
+{
+  }
+
+Toolbar::Toolbar(GtkToolbar* castitem)
+:
+  Gtk::Container((GtkContainer*)(castitem))
+{
+  }
+
+Toolbar::~Toolbar()
+{
+  destroy_();
+}
+
+Toolbar::CppClassType Toolbar::toolbar_class_; // initialize static member
+
+GType Toolbar::get_type()
+{
+  return toolbar_class_.init().get_type();
+}
+
+GType Toolbar::get_base_type()
+{
+  return gtk_toolbar_get_type();
+}
+
+
+Toolbar::Toolbar()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Container(Glib::ConstructParams(toolbar_class_.init()))
+{
+  }
+
+void Toolbar::insert(ToolItem& item, int pos)
+{
+  gtk_toolbar_insert(gobj(), (item).gobj(), pos);
+}
+
+int Toolbar::get_item_index(const ToolItem& item) const
+{
+  return gtk_toolbar_get_item_index(const_cast<GtkToolbar*>(gobj()), const_cast<GtkToolItem*>((item).gobj()));
+}
+
+int Toolbar::get_n_items() const
+{
+  return gtk_toolbar_get_n_items(const_cast<GtkToolbar*>(gobj()));
+}
+
+ToolItem* Toolbar::get_nth_item(int n)
+{
+  return Glib::wrap(gtk_toolbar_get_nth_item(gobj(), n));
+}
+
+const ToolItem* Toolbar::get_nth_item(int n) const
+{
+  return Glib::wrap(gtk_toolbar_get_nth_item(const_cast<GtkToolbar*>(gobj()), n));
+}
+
+bool Toolbar::get_show_arrow() const
+{
+  return gtk_toolbar_get_show_arrow(const_cast<GtkToolbar*>(gobj()));
+}
+
+void Toolbar::set_show_arrow(bool show_arrow)
+{
+  gtk_toolbar_set_show_arrow(gobj(), static_cast<int>(show_arrow));
+}
+
+void Toolbar::set_orientation(Orientation orientation)
+{
+  gtk_toolbar_set_orientation(gobj(), ((GtkOrientation)(orientation)));
+}
+
+Orientation Toolbar::get_orientation() const
+{
+  return ((Orientation)(gtk_toolbar_get_orientation(const_cast<GtkToolbar*>(gobj()))));
+}
+
+void Toolbar::set_toolbar_style(ToolbarStyle style)
+{
+  gtk_toolbar_set_style(gobj(), ((GtkToolbarStyle)(style)));
+}
+
+ToolbarStyle Toolbar::get_toolbar_style() const
+{
+  return ((ToolbarStyle)(gtk_toolbar_get_style(const_cast<GtkToolbar*>(gobj()))));
+}
+
+void Toolbar::set_tooltips(bool enable)
+{
+  gtk_toolbar_set_tooltips(gobj(), static_cast<int>(enable));
+}
+
+bool Toolbar::get_tooltips() const
+{
+  return gtk_toolbar_get_tooltips(const_cast<GtkToolbar*>(gobj()));
+}
+
+void Toolbar::unset_toolbar_style()
+{
+  gtk_toolbar_unset_style(gobj());
+}
+
+IconSize Toolbar::get_icon_size() const
+{
+  return IconSize(static_cast<int>(gtk_toolbar_get_icon_size(const_cast<GtkToolbar*>(gobj()))));
+}
+
+ReliefStyle Toolbar::get_relief_style() const
+{
+  return ((ReliefStyle)(gtk_toolbar_get_relief_style(const_cast<GtkToolbar*>(gobj()))));
+}
+
+int Toolbar::get_drop_index(int x, int y) const
+{
+  return gtk_toolbar_get_drop_index(const_cast<GtkToolbar*>(gobj()), x, y);
+}
+
+void Toolbar::set_drop_highlight_item(ToolItem& tool_item, int index)
+{
+  gtk_toolbar_set_drop_highlight_item(gobj(), (tool_item).gobj(), index);
+}
+
+Tooltips* Toolbar::get_tooltips_object() const
+{
+  return Glib::wrap(gobj()->tooltips);
+}
+
+
+Glib::SignalProxy1< void,Orientation > Toolbar::signal_orientation_changed()
+{
+  return Glib::SignalProxy1< void,Orientation >(this, &Toolbar_signal_orientation_changed_info);
+}
+
+Glib::SignalProxy1< void,ToolbarStyle > Toolbar::signal_toolbar_style_changed()
+{
+  return Glib::SignalProxy1< void,ToolbarStyle >(this, &Toolbar_signal_toolbar_style_changed_info);
+}
+
+Glib::SignalProxy3< bool,int,int,int > Toolbar::signal_popup_context_menu()
+{
+  return Glib::SignalProxy3< bool,int,int,int >(this, &Toolbar_signal_popup_context_menu_info);
+}
+
+
+Glib::PropertyProxy<Orientation> Toolbar::property_orientation() 
+{
+  return Glib::PropertyProxy<Orientation>(this, "orientation");
+}
+
+Glib::PropertyProxy_ReadOnly<Orientation> Toolbar::property_orientation() const
+{
+  return Glib::PropertyProxy_ReadOnly<Orientation>(this, "orientation");
+}
+
+Glib::PropertyProxy<ToolbarStyle> Toolbar::property_toolbar_style() 
+{
+  return Glib::PropertyProxy<ToolbarStyle>(this, "toolbar-style");
+}
+
+Glib::PropertyProxy_ReadOnly<ToolbarStyle> Toolbar::property_toolbar_style() const
+{
+  return Glib::PropertyProxy_ReadOnly<ToolbarStyle>(this, "toolbar-style");
+}
+
+Glib::PropertyProxy<bool> Toolbar::property_show_arrow() 
+{
+  return Glib::PropertyProxy<bool>(this, "show-arrow");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> Toolbar::property_show_arrow() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "show-arrow");
+}
+
+
+void Gtk::Toolbar::on_orientation_changed(Orientation orientation)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->orientation_changed)
+    (*base->orientation_changed)(gobj(),((GtkOrientation)(orientation)));
+}
+
+void Gtk::Toolbar::on_toolbar_style_changed(ToolbarStyle style)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->style_changed)
+    (*base->style_changed)(gobj(),((GtkToolbarStyle)(style)));
+}
+
+bool Gtk::Toolbar::on_popup_context_menu(int x, int y, int button_number)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->popup_context_menu)
+    return (*base->popup_context_menu)(gobj(),x,y,button_number);
+
+  typedef bool RType;
+  return RType();
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/toolbar.h b/libs/gtkmm2/gtk/gtkmm/toolbar.h
new file mode 100644
index 0000000000..8cf6431014
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/toolbar.h
@@ -0,0 +1,370 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_TOOLBAR_H
+#define _GTKMM_TOOLBAR_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* Copyright (C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/toolitem.h>
+#include <gtkmm/toolbutton.h>
+#include <gtkmm/toggletoolbutton.h>
+#include <glibmm/helperlist.h>
+#include <gtkmm/container.h>
+#include <gtkmm/stockid.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkToolbar GtkToolbar;
+typedef struct _GtkToolbarClass GtkToolbarClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class Toolbar_Class; } // namespace Gtk
+namespace Gtk
+{
+
+/** Bars of buttons and other widgets.
+ * @ingroup Widgets
+ * @ingroup Containers
+ * @ingroup Toolbars
+ */
+
+class Toolbar : public Container
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Toolbar CppObjectType;
+  typedef Toolbar_Class CppClassType;
+  typedef GtkToolbar BaseObjectType;
+  typedef GtkToolbarClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~Toolbar();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class Toolbar_Class;
+  static CppClassType toolbar_class_;
+
+  // noncopyable
+  Toolbar(const Toolbar&);
+  Toolbar& operator=(const Toolbar&);
+
+protected:
+  explicit Toolbar(const Glib::ConstructParams& construct_params);
+  explicit Toolbar(GtkToolbar* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GtkToolbar*       gobj()       { return reinterpret_cast<GtkToolbar*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GtkToolbar* gobj() const { return reinterpret_cast<GtkToolbar*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+  virtual void on_orientation_changed(Orientation orientation);
+  virtual void on_toolbar_style_changed(ToolbarStyle style);
+  virtual bool on_popup_context_menu(int x, int y, int button_number);
+
+
+private:
+
+public:
+  Toolbar();
+
+  
+  /** Insert a Gtk::ToolItem into the toolbar at position @a pos . If @a pos  is
+   * 0 the item is prepended to the start of the toolbar. If @a pos  is
+   * negative, the item is appended to the end of the toolbar.
+   * 
+   * Since: 2.4
+   * @param item A Gtk::ToolItem.
+   * @param pos The position of the new item.
+   */
+  void insert(ToolItem& item, int pos);
+  void insert(ToolButton& item, int pos, const sigc::slot<void>& clicked_slot);
+  void insert(ToggleToolButton& item, int pos, const sigc::slot<void>& toggled_slot);
+  
+  void append(ToolItem& item);
+  void append(ToolButton& item, const sigc::slot<void>& clicked_slot);
+  void append(ToggleToolButton& item, const sigc::slot<void>& toggled_slot);
+  
+  void prepend(ToolItem& item);
+  void prepend(ToolButton& item, const sigc::slot<void>& clicked_slot);
+  void prepend(ToggleToolButton& item, const sigc::slot<void>& toggled_slot);
+  
+  
+  /** Returns the position of @a item  on the toolbar, starting from 0.
+   * It is an error if @a item  is not a child of the toolbar.
+   * @param item A Gtk::ToolItem that is a child of @a toolbar .
+   * @return The position of item on the toolbar.
+   * 
+   * Since: 2.4.
+   */
+  int get_item_index(const ToolItem& item) const;
+  
+  /** Returns the number of items on the toolbar.
+   * @return The number of items on the toolbar
+   * 
+   * Since: 2.4.
+   */
+  int get_n_items() const;
+  
+  /** Returns the @a n &lt;!-- --&gt;'s item on @a toolbar , or <tt>0</tt> if the
+   * toolbar does not contain an @a n &lt;!-- --&gt;'th item.
+   * @param n A position on the toolbar.
+   * @return The @a n &lt;!-- --&gt;'th Gtk::ToolItem on @a toolbar , or <tt>0</tt> if there
+   * isn't an @a n &lt;!-- --&gt;th item.
+   * 
+   * Since: 2.4.
+   */
+  ToolItem* get_nth_item(int n);
+  
+  /** Returns the @a n &lt;!-- --&gt;'s item on @a toolbar , or <tt>0</tt> if the
+   * toolbar does not contain an @a n &lt;!-- --&gt;'th item.
+   * @param n A position on the toolbar.
+   * @return The @a n &lt;!-- --&gt;'th Gtk::ToolItem on @a toolbar , or <tt>0</tt> if there
+   * isn't an @a n &lt;!-- --&gt;th item.
+   * 
+   * Since: 2.4.
+   */
+  const ToolItem* get_nth_item(int n) const;
+  
+  /** Returns whether the toolbar has an overflow menu.
+   * See set_show_arrow()
+   * @return Since: 2.4.
+   */
+  bool get_show_arrow() const;
+  
+  /** Sets whether to show an overflow menu when
+   *  @a toolbar  doesn't have room for all items on it. If <tt>true</tt>,
+   * items that there are not room are available through an
+   * overflow menu.
+   * 
+   * Since: 2.4
+   * @param show_arrow Whether to show an overflow menu.
+   */
+  void set_show_arrow(bool show_arrow = true);
+
+
+/* Style methods */
+  
+  /** Sets whether a toolbar should appear horizontally or vertically.
+   * @param orientation A new Gtk::Orientation.
+   */
+  void set_orientation(Orientation orientation);
+  
+  /** Retrieves the current orientation of the toolbar. See
+   * set_orientation().
+   * @return The orientation.
+   */
+  Orientation get_orientation() const;
+
+  
+  /** Alters the view of @a toolbar  to display either icons only, text only, or both.
+   * @param style The new style for @a toolbar .
+   */
+  void set_toolbar_style(ToolbarStyle style);
+  
+  /** Retrieves whether the toolbar has text, icons, or both . See
+   * set_style().
+   * @return The current style of @a toolbar .
+   */
+  ToolbarStyle get_toolbar_style() const;
+
+  
+  /** Sets if the tooltips of a toolbar should be active or not.
+   * @param enable Set to <tt>false</tt> to disable the tooltips, or <tt>true</tt> to enable them.
+   */
+  void set_tooltips(bool enable = true);
+  
+  /** Retrieves whether tooltips are enabled. See
+   * set_tooltips().
+   * @return <tt>true</tt> if tooltips are enabled.
+   */
+  bool get_tooltips() const;
+
+  
+  /** Unsets a toolbar style set with set_style(), so that
+   * user preferences will be used to determine the toolbar style.
+   */
+  void unset_toolbar_style();
+  
+  //Note that gtk_toolbar_set_icon_size() is deprecated, bug gtk_toolbar_get_icon_size() is not.
+  
+  /** Retrieves the icon size fo the toolbar. See set_icon_size().
+   * @return The current icon size for the icons on the toolbar.
+   */
+  IconSize get_icon_size() const;
+ 
+  
+  /** Returns the relief style of buttons on @a toolbar . See
+   * Gtk::Button::set_relief().
+   * @return The relief style of buttons on @a toolbar .
+   * 
+   * Since: 2.4.
+   */
+  ReliefStyle get_relief_style() const;
+  
+  /** Returns the position corresponding to the indicated point on
+   *  @a toolbar . This is useful when dragging items to the toolbar:
+   * this function returns the position a new item should be
+   * inserted.
+   * 
+   *  @a x  and @a y  are in @a toolbar  coordinates.
+   * @param x X coordinate of a point on the toolbar.
+   * @param y Y coordinate of a point on the toolbar.
+   * @return The position corresponding to the point ( @a x , @a y ) on the toolbar.
+   * 
+   * Since: 2.4.
+   */
+  int get_drop_index(int x, int y) const;
+  
+  /** Highlights @a toolbar  to give an idea of what it would look like
+   * if @a item  was added to @a toolbar  at the position indicated by @a index . 
+   * If @a item  is <tt>0</tt>, highlighting is turned off. In that case @a index  
+   * is ignored.
+   * 
+   * The @a tool_item  passed to this function must not be part of any widget
+   * hierarchy. When an item is set as drop highlight item it can not
+   * added to any widget hierarchy or used as highlight item for another
+   * toolbar.
+   * 
+   * Since: 2.4
+   * @param tool_item A Gtk::ToolItem, or <tt>0</tt> to turn of highlighting.
+   * @param index A position on @a toolbar .
+   */
+  void set_drop_highlight_item(ToolItem& tool_item, int index);
+  void unset_drop_highlight_item();
+
+  
+  Glib::SignalProxy1< void,Orientation > signal_orientation_changed();
+
+  
+  Glib::SignalProxy1< void,ToolbarStyle > signal_toolbar_style_changed();
+
+  
+  Glib::SignalProxy3< bool,int,int,int > signal_popup_context_menu();
+
+  
+  //This is called get_tooltips_object() to avoid a clash with get_tooltips(), which just says whether they are enabled.
+  
+  Tooltips* get_tooltips_object() const;
+  
+  //This is probably the same as Container::children().size(), which is deprecated anyway?
+  //_MEMBER_GET(num_children, num_children, int, gint)
+
+  //There is already set/get_orientation():
+  //_MEMBER_GET(orientation, orientation, GtkOrientation, Orientation)
+
+  //There is already set/get_toolbar_style():
+  //_MEMBER_GET(style, style, GtkToolbarStyle, ToolbarStyle)
+
+  //There is already set/get_icon_size():
+  //_MEMBER_GET(icon_size, icon_size, int, gint)
+
+  //Ignore deprecated GtkToolbarAPI:
+  //Normally we just deprecate it in gtkmm too,
+  //but the GtkToolbar compatibility system is particularly unpleasant, so we just removed it in gtkmm 2.4. murrayc.
+  
+    
+  /** The orientation of the toolbar.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Orientation> property_orientation() ;
+
+/** The orientation of the toolbar.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Orientation> property_orientation() const;
+
+  /** How to draw the toolbar.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<ToolbarStyle> property_toolbar_style() ;
+
+/** How to draw the toolbar.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<ToolbarStyle> property_toolbar_style() const;
+
+  /** If an arrow should be shown if the toolbar doesn't fit.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_show_arrow() ;
+
+/** If an arrow should be shown if the toolbar doesn't fit.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_show_arrow() const;
+
+
+};
+
+} // namespace Gtk
+
+
+namespace Glib
+{
+  /** @relates Gtk::Toolbar
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gtk::Toolbar* wrap(GtkToolbar* object, bool take_copy = false);
+}
+#endif /* _GTKMM_TOOLBAR_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/toolbutton.cc b/libs/gtkmm2/gtk/gtkmm/toolbutton.cc
new file mode 100644
index 0000000000..29519767d2
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/toolbutton.cc
@@ -0,0 +1,327 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/toolbutton.h>
+#include <gtkmm/private/toolbutton_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* 
+ *
+ * Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtk/gtktoolbutton.h>
+
+namespace Gtk
+{
+
+ToolButton::ToolButton(const Glib::ustring& label)
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::ToolItem(Glib::ConstructParams(toolbutton_class_.init(), "label", label.c_str(), (char*) 0))
+{
+}
+
+} // namespace Gtk
+
+
+namespace
+{
+
+const Glib::SignalProxyInfo ToolButton_signal_clicked_info =
+{
+  "clicked",
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
+};
+
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Gtk::ToolButton* wrap(GtkToolButton* object, bool take_copy)
+{
+  return dynamic_cast<Gtk::ToolButton *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& ToolButton_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &ToolButton_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_tool_button_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void ToolButton_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+  klass->clicked = &clicked_callback;
+}
+
+
+void ToolButton_Class::clicked_callback(GtkToolButton* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_clicked();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->clicked)
+      (*base->clicked)(self);
+  }
+}
+
+
+Glib::ObjectBase* ToolButton_Class::wrap_new(GObject* o)
+{
+  return manage(new ToolButton((GtkToolButton*)(o)));
+
+}
+
+
+/* The implementation: */
+
+ToolButton::ToolButton(const Glib::ConstructParams& construct_params)
+:
+  Gtk::ToolItem(construct_params)
+{
+  }
+
+ToolButton::ToolButton(GtkToolButton* castitem)
+:
+  Gtk::ToolItem((GtkToolItem*)(castitem))
+{
+  }
+
+ToolButton::~ToolButton()
+{
+  destroy_();
+}
+
+ToolButton::CppClassType ToolButton::toolbutton_class_; // initialize static member
+
+GType ToolButton::get_type()
+{
+  return toolbutton_class_.init().get_type();
+}
+
+GType ToolButton::get_base_type()
+{
+  return gtk_tool_button_get_type();
+}
+
+
+ToolButton::ToolButton()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::ToolItem(Glib::ConstructParams(toolbutton_class_.init()))
+{
+  }
+
+ToolButton::ToolButton(const Gtk::StockID& stock_id)
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::ToolItem(Glib::ConstructParams(toolbutton_class_.init(), "stock_id", (stock_id).get_c_str(), (char*) 0))
+{
+  }
+
+ToolButton::ToolButton(Widget& icon_widget, const Glib::ustring& label)
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::ToolItem(Glib::ConstructParams(toolbutton_class_.init(), "icon_widget", (icon_widget).gobj(), "label", label.c_str(), (char*) 0))
+{
+  }
+
+void ToolButton::set_label(const Glib::ustring& label)
+{
+  gtk_tool_button_set_label(gobj(), label.c_str());
+}
+
+Glib::ustring ToolButton::get_label() const
+{
+  return Glib::convert_const_gchar_ptr_to_ustring(gtk_tool_button_get_label(const_cast<GtkToolButton*>(gobj())));
+}
+
+void ToolButton::set_use_underline(bool use_underline)
+{
+  gtk_tool_button_set_use_underline(gobj(), static_cast<int>(use_underline));
+}
+
+bool ToolButton::get_use_underline() const
+{
+  return gtk_tool_button_get_use_underline(const_cast<GtkToolButton*>(gobj()));
+}
+
+void ToolButton::set_stock_id(const Gtk::StockID& stock_id)
+{
+  gtk_tool_button_set_stock_id(gobj(), (stock_id).get_c_str());
+}
+
+Glib::ustring ToolButton::get_stock_id() const
+{
+  return Glib::convert_const_gchar_ptr_to_ustring(gtk_tool_button_get_stock_id(const_cast<GtkToolButton*>(gobj())));
+}
+
+void ToolButton::set_icon_widget(Widget& icon_widget)
+{
+  gtk_tool_button_set_icon_widget(gobj(), (icon_widget).gobj());
+}
+
+Widget* ToolButton::get_icon_widget()
+{
+  return Glib::wrap(gtk_tool_button_get_icon_widget(gobj()));
+}
+
+const Widget* ToolButton::get_icon_widget() const
+{
+  return Glib::wrap(gtk_tool_button_get_icon_widget(const_cast<GtkToolButton*>(gobj())));
+}
+
+void ToolButton::set_label_widget(Widget& label_widget)
+{
+  gtk_tool_button_set_label_widget(gobj(), (label_widget).gobj());
+}
+
+Widget* ToolButton::get_label_widget()
+{
+  return Glib::wrap(gtk_tool_button_get_label_widget(gobj()));
+}
+
+const Widget* ToolButton::get_label_widget() const
+{
+  return Glib::wrap(gtk_tool_button_get_label_widget(const_cast<GtkToolButton*>(gobj())));
+}
+
+
+Glib::SignalProxy0< void > ToolButton::signal_clicked()
+{
+  return Glib::SignalProxy0< void >(this, &ToolButton_signal_clicked_info);
+}
+
+
+Glib::PropertyProxy<Glib::ustring> ToolButton::property_label() 
+{
+  return Glib::PropertyProxy<Glib::ustring>(this, "label");
+}
+
+Glib::PropertyProxy_ReadOnly<Glib::ustring> ToolButton::property_label() const
+{
+  return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "label");
+}
+
+Glib::PropertyProxy<bool> ToolButton::property_use_underline() 
+{
+  return Glib::PropertyProxy<bool>(this, "use-underline");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> ToolButton::property_use_underline() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "use-underline");
+}
+
+Glib::PropertyProxy<Gtk::Widget*> ToolButton::property_label_widget() 
+{
+  return Glib::PropertyProxy<Gtk::Widget*>(this, "label-widget");
+}
+
+Glib::PropertyProxy_ReadOnly<Gtk::Widget*> ToolButton::property_label_widget() const
+{
+  return Glib::PropertyProxy_ReadOnly<Gtk::Widget*>(this, "label-widget");
+}
+
+Glib::PropertyProxy<Glib::ustring> ToolButton::property_stock_id() 
+{
+  return Glib::PropertyProxy<Glib::ustring>(this, "stock-id");
+}
+
+Glib::PropertyProxy_ReadOnly<Glib::ustring> ToolButton::property_stock_id() const
+{
+  return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "stock-id");
+}
+
+Glib::PropertyProxy<Gtk::Widget> ToolButton::property_icon_widget() 
+{
+  return Glib::PropertyProxy<Gtk::Widget>(this, "icon-widget");
+}
+
+Glib::PropertyProxy_ReadOnly<Gtk::Widget> ToolButton::property_icon_widget() const
+{
+  return Glib::PropertyProxy_ReadOnly<Gtk::Widget>(this, "icon-widget");
+}
+
+
+void Gtk::ToolButton::on_clicked()
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->clicked)
+    (*base->clicked)(gobj());
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/toolbutton.h b/libs/gtkmm2/gtk/gtkmm/toolbutton.h
new file mode 100644
index 0000000000..c4a2622b95
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/toolbutton.h
@@ -0,0 +1,346 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_TOOLBUTTON_H
+#define _GTKMM_TOOLBUTTON_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* box.h
+ * 
+ * Copyright (C) 2003 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/toolitem.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkToolButton GtkToolButton;
+typedef struct _GtkToolButtonClass GtkToolButtonClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class ToolButton_Class; } // namespace Gtk
+namespace Gtk
+{
+
+/** A Gtk::ToolItem subclass that displays buttons.
+ * 
+ * A ToolButton is are Gtk::ToolItem containing a button.
+ * @ingroup Widgets
+ */
+
+class ToolButton : public ToolItem
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef ToolButton CppObjectType;
+  typedef ToolButton_Class CppClassType;
+  typedef GtkToolButton BaseObjectType;
+  typedef GtkToolButtonClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~ToolButton();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class ToolButton_Class;
+  static CppClassType toolbutton_class_;
+
+  // noncopyable
+  ToolButton(const ToolButton&);
+  ToolButton& operator=(const ToolButton&);
+
+protected:
+  explicit ToolButton(const Glib::ConstructParams& construct_params);
+  explicit ToolButton(GtkToolButton* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GtkToolButton*       gobj()       { return reinterpret_cast<GtkToolButton*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GtkToolButton* gobj() const { return reinterpret_cast<GtkToolButton*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+  virtual void on_clicked();
+
+
+private:
+
+public:
+
+  /** Creates a new ToolButton.
+   */
+  ToolButton();
+  
+  /** Creates a new ToolButton from a StockID.
+   *
+   * The ToolButton will be created according to the @a stock_id properties.
+   * 
+   * @param stock_id The StockID which determines the look of the ToolButton.
+   */
+  explicit ToolButton(const Gtk::StockID& stock_id);
+  
+  /** Creates a new ToolButton with a label.
+   *
+   * The ToolButton will have the label @a label.
+   *
+   * @param label The string used to display the label for this ToolButton.
+   */
+  explicit ToolButton(const Glib::ustring& label);
+  
+  /** Creates a new ToolButton with an image.
+   *
+   * The ToolButton will have the label @a label and an image widget @a icon_widget.
+   *
+   * @param icon_widget The widget placed as the ToolButton's icon.
+   * @param label The string used to display the label for this ToolButton.
+   */
+  explicit ToolButton(Widget& icon_widget, const Glib::ustring& label = Glib::ustring());
+
+  
+  /** Sets @a label  as the label used for the tool button. The "label" property
+   * only has an effect if not overridden by a non-<tt>0</tt> "label_widget" property.
+   * If both the "label_widget" and "label" properties are <tt>0</tt>, the label
+   * is determined by the "stock_id" property. If the "stock_id" property is also
+   * <tt>0</tt>, @a button  will not have a label.
+   * 
+   * Since: 2.4
+   * @param label A string that will be used as label, or <tt>0</tt>.
+   */
+  void set_label(const Glib::ustring& label);
+  
+  /** Returns the label used by the tool button, or <tt>0</tt> if the tool button
+   * doesn't have a label. or uses a the label from a stock item. The returned
+   * string is owned by GTK+, and must not be modified or freed.
+   * @return The label, or <tt>0</tt>
+   * 
+   * Since: 2.4.
+   */
+  Glib::ustring get_label() const;
+  
+  /** If set, an underline in the label property indicates that the next character
+   * should be used for the mnemonic accelerator key in the overflow menu. For
+   * example, if the label property is "_Open" and @a use_underline  is <tt>true</tt>,
+   * the label on the tool button will be "Open" and the item on the overflow
+   * menu will have an underlined 'O'.
+   * 
+   * Labels shown on tool buttons never have mnemonics on them; this property
+   * only affects the menu item on the overflow menu.
+   * 
+   * Since: 2.4
+   * @param use_underline Whether the button label has the form "_Open".
+   */
+  void set_use_underline(bool use_underline = true);
+  
+  /** Returns whether underscores in the label property are used as mnemonics
+   * on menu items on the overflow menu. See set_use_underline().
+   * @return <tt>true</tt> if underscores in the label property are used as
+   * mnemonics on menu items on the overflow menu.
+   * 
+   * Since: 2.4.
+   */
+  bool get_use_underline() const;
+  
+  /** Sets the name of the stock item. See new_from_stock().
+   * The stock_id property only has an effect if not
+   * overridden by non-<tt>0</tt> "label" and "icon_widget" properties.
+   * 
+   * Since: 2.4
+   * @param stock_id A name of a stock item, or <tt>0</tt>.
+   */
+  void set_stock_id(const Gtk::StockID& stock_id);
+  
+  /** Returns the name of the stock item. See set_stock_id().
+   * The returned string is owned by GTK+ and must not be freed or modifed.
+   * @return The name of the stock item for @a button .
+   * 
+   * Since: 2.4.
+   */
+  Glib::ustring get_stock_id() const;
+  
+  /** Sets @a icon  as the widget used as icon on @a button . If @a icon_widget  is
+   * <tt>0</tt> the icon is determined by the "stock_id" property. If the
+   * "stock_id" property is also <tt>0</tt>, @a button  will not have an icon.
+   * 
+   * Since: 2.4
+   * @param icon_widget The widget used as icon, or <tt>0</tt>.
+   */
+  void set_icon_widget(Widget& icon_widget);
+  
+  /** Return the widget used as icon widget on @a button . See
+   * set_icon_widget().
+   * @return The widget used as icon on @a button , or <tt>0</tt>.
+   * 
+   * Since: 2.4.
+   */
+  Widget* get_icon_widget();
+  
+  /** Return the widget used as icon widget on @a button . See
+   * set_icon_widget().
+   * @return The widget used as icon on @a button , or <tt>0</tt>.
+   * 
+   * Since: 2.4.
+   */
+  const Widget* get_icon_widget() const;
+  
+  /** Sets @a label_widget  as the widget that will be used as the label
+   * for @a button . If @a label_widget  is <tt>0</tt> the "label" property is used
+   * as label. If "label" is also <tt>0</tt>, the label in the stock item
+   * determined by the "stock_id" property is used as label. If
+   * "stock_id" is also <tt>0</tt>, @a button  does not have a label.
+   * 
+   * Since: 2.4
+   * @param label_widget The widget used as label, or <tt>0</tt>.
+   */
+  void set_label_widget(Widget& label_widget);
+  
+  /** Returns the widget used as label on @a button . See
+   * set_label_widget().
+   * @return The widget used as label on @a button , or <tt>0</tt>.
+   * 
+   * Since: 2.4.
+   */
+  Widget* get_label_widget();
+  
+  /** Returns the widget used as label on @a button . See
+   * set_label_widget().
+   * @return The widget used as label on @a button , or <tt>0</tt>.
+   * 
+   * Since: 2.4.
+   */
+  const Widget* get_label_widget() const;
+
+  
+  Glib::SignalProxy0< void > signal_clicked();
+
+
+  /** Text to show in the item.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Glib::ustring> property_label() ;
+
+/** Text to show in the item.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Glib::ustring> property_label() const;
+
+  /** If set
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_use_underline() ;
+
+/** If set
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_use_underline() const;
+
+  /** Widget to use as the item label.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Gtk::Widget*> property_label_widget() ;
+
+/** Widget to use as the item label.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Gtk::Widget*> property_label_widget() const;
+
+  /** The stock icon displayed on the item.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Glib::ustring> property_stock_id() ;
+
+/** The stock icon displayed on the item.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Glib::ustring> property_stock_id() const;
+
+  /** Icon widget to display in the item.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Gtk::Widget> property_icon_widget() ;
+
+/** Icon widget to display in the item.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Gtk::Widget> property_icon_widget() const;
+              
+
+};
+
+} // namespace Gtk
+
+
+namespace Glib
+{
+  /** @relates Gtk::ToolButton
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gtk::ToolButton* wrap(GtkToolButton* object, bool take_copy = false);
+}
+#endif /* _GTKMM_TOOLBUTTON_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/toolitem.cc b/libs/gtkmm2/gtk/gtkmm/toolitem.cc
new file mode 100644
index 0000000000..bc9e5dbc98
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/toolitem.cc
@@ -0,0 +1,517 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/toolitem.h>
+#include <gtkmm/private/toolitem_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* 
+ *
+ * Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtk/gtktoolitem.h>
+
+namespace Gtk
+{
+
+
+} // namespace Gtk
+
+
+namespace
+{
+
+gboolean ToolItem_signal_create_menu_proxy_callback(GtkToolItem* self, void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< bool > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        return static_cast<int>((*static_cast<SlotType*>(slot))());
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+gboolean ToolItem_signal_create_menu_proxy_notify_callback(GtkToolItem* self,  void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+const Glib::SignalProxyInfo ToolItem_signal_create_menu_proxy_info =
+{
+  "create_menu_proxy",
+  (GCallback) &ToolItem_signal_create_menu_proxy_callback,
+  (GCallback) &ToolItem_signal_create_menu_proxy_notify_callback
+};
+
+
+const Glib::SignalProxyInfo ToolItem_signal_toolbar_reconfigured_info =
+{
+  "toolbar_reconfigured",
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
+};
+
+
+gboolean ToolItem_signal_set_tooltip_callback(GtkToolItem* self, GtkTooltips* p0,const gchar* p1,const gchar* p2,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< bool,Tooltips*,const Glib::ustring&,const Glib::ustring& > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        return static_cast<int>((*static_cast<SlotType*>(slot))(Glib::wrap(p0)
+, Glib::convert_const_gchar_ptr_to_ustring(p1)
+, Glib::convert_const_gchar_ptr_to_ustring(p2)
+));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+gboolean ToolItem_signal_set_tooltip_notify_callback(GtkToolItem* self, GtkTooltips* p0,const gchar* p1,const gchar* p2, void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,Tooltips*,const Glib::ustring&,const Glib::ustring& > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(Glib::wrap(p0)
+, Glib::convert_const_gchar_ptr_to_ustring(p1)
+, Glib::convert_const_gchar_ptr_to_ustring(p2)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+const Glib::SignalProxyInfo ToolItem_signal_set_tooltip_info =
+{
+  "set_tooltip",
+  (GCallback) &ToolItem_signal_set_tooltip_callback,
+  (GCallback) &ToolItem_signal_set_tooltip_notify_callback
+};
+
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Gtk::ToolItem* wrap(GtkToolItem* object, bool take_copy)
+{
+  return dynamic_cast<Gtk::ToolItem *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& ToolItem_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &ToolItem_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_tool_item_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void ToolItem_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+  klass->create_menu_proxy = &create_menu_proxy_callback;
+  klass->toolbar_reconfigured = &toolbar_reconfigured_callback;
+}
+
+
+gboolean ToolItem_Class::create_menu_proxy_callback(GtkToolItem* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return static_cast<int>(obj->on_create_menu_proxy());
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->create_menu_proxy)
+      return (*base->create_menu_proxy)(self);
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+void ToolItem_Class::toolbar_reconfigured_callback(GtkToolItem* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_toolbar_reconfigured();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->toolbar_reconfigured)
+      (*base->toolbar_reconfigured)(self);
+  }
+}
+
+
+Glib::ObjectBase* ToolItem_Class::wrap_new(GObject* o)
+{
+  return manage(new ToolItem((GtkToolItem*)(o)));
+
+}
+
+
+/* The implementation: */
+
+ToolItem::ToolItem(const Glib::ConstructParams& construct_params)
+:
+  Gtk::Bin(construct_params)
+{
+  }
+
+ToolItem::ToolItem(GtkToolItem* castitem)
+:
+  Gtk::Bin((GtkBin*)(castitem))
+{
+  }
+
+ToolItem::~ToolItem()
+{
+  destroy_();
+}
+
+ToolItem::CppClassType ToolItem::toolitem_class_; // initialize static member
+
+GType ToolItem::get_type()
+{
+  return toolitem_class_.init().get_type();
+}
+
+GType ToolItem::get_base_type()
+{
+  return gtk_tool_item_get_type();
+}
+
+
+ToolItem::ToolItem()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Bin(Glib::ConstructParams(toolitem_class_.init()))
+{
+  }
+
+void ToolItem::set_homogeneous(bool homogeneous)
+{
+  gtk_tool_item_set_homogeneous(gobj(), static_cast<int>(homogeneous));
+}
+
+bool ToolItem::get_homogeneous() const
+{
+  return gtk_tool_item_get_homogeneous(const_cast<GtkToolItem*>(gobj()));
+}
+
+void ToolItem::set_expand(bool expand)
+{
+  gtk_tool_item_set_expand(gobj(), static_cast<int>(expand));
+}
+
+bool ToolItem::get_expand() const
+{
+  return gtk_tool_item_get_expand(const_cast<GtkToolItem*>(gobj()));
+}
+
+void ToolItem::set_tooltip(Tooltips& tooltips, const Glib::ustring& tip_text, const Glib::ustring& tip_private)
+{
+  gtk_tool_item_set_tooltip(gobj(), (tooltips).gobj(), tip_text.c_str(), tip_private.c_str());
+}
+
+void ToolItem::set_use_drag_window(bool use_drag_window)
+{
+  gtk_tool_item_set_use_drag_window(gobj(), static_cast<int>(use_drag_window));
+}
+
+bool ToolItem::get_use_drag_window() const
+{
+  return gtk_tool_item_get_use_drag_window(const_cast<GtkToolItem*>(gobj()));
+}
+
+void ToolItem::set_visible_horizontal(bool visible_horizontal)
+{
+  gtk_tool_item_set_visible_horizontal(gobj(), static_cast<int>(visible_horizontal));
+}
+
+bool ToolItem::get_visible_horizontal() const
+{
+  return gtk_tool_item_get_visible_horizontal(const_cast<GtkToolItem*>(gobj()));
+}
+
+void ToolItem::set_visible_vertical(bool visible_vertical)
+{
+  gtk_tool_item_set_visible_vertical(gobj(), static_cast<int>(visible_vertical));
+}
+
+bool ToolItem::get_visible_vertical() const
+{
+  return gtk_tool_item_get_visible_vertical(const_cast<GtkToolItem*>(gobj()));
+}
+
+bool ToolItem::get_is_important() const
+{
+  return gtk_tool_item_get_is_important(const_cast<GtkToolItem*>(gobj()));
+}
+
+void ToolItem::set_is_important(bool is_important)
+{
+  gtk_tool_item_set_is_important(gobj(), static_cast<int>(is_important));
+}
+
+IconSize ToolItem::get_icon_size() const
+{
+  return IconSize(static_cast<int>(gtk_tool_item_get_icon_size(const_cast<GtkToolItem*>(gobj()))));
+}
+
+Orientation ToolItem::get_orientation() const
+{
+  return ((Orientation)(gtk_tool_item_get_orientation(const_cast<GtkToolItem*>(gobj()))));
+}
+
+ToolbarStyle ToolItem::get_toolbar_style() const
+{
+  return ((ToolbarStyle)(gtk_tool_item_get_toolbar_style(const_cast<GtkToolItem*>(gobj()))));
+}
+
+ReliefStyle ToolItem::get_relief_style() const
+{
+  return ((ReliefStyle)(gtk_tool_item_get_relief_style(const_cast<GtkToolItem*>(gobj()))));
+}
+
+Widget* ToolItem::retrieve_proxy_menu_item()
+{
+  return Glib::wrap(gtk_tool_item_retrieve_proxy_menu_item(gobj()));
+}
+
+const Widget* ToolItem::retrieve_proxy_menu_item() const
+{
+  return Glib::wrap(gtk_tool_item_retrieve_proxy_menu_item(const_cast<GtkToolItem*>(gobj())));
+}
+
+Widget* ToolItem::get_proxy_menu_item(const Glib::ustring& menu_item_id)
+{
+  return Glib::wrap(gtk_tool_item_get_proxy_menu_item(gobj(), menu_item_id.c_str()));
+}
+
+const Widget* ToolItem::get_proxy_menu_item(const Glib::ustring& menu_item_id) const
+{
+  return Glib::wrap(gtk_tool_item_get_proxy_menu_item(const_cast<GtkToolItem*>(gobj()), menu_item_id.c_str()));
+}
+
+void ToolItem::set_proxy_menu_item(const Glib::ustring& menu_item_id, Widget& menu_item)
+{
+  gtk_tool_item_set_proxy_menu_item(gobj(), menu_item_id.c_str(), (menu_item).gobj());
+}
+
+void ToolItem::rebuild_menu()
+{
+  gtk_tool_item_rebuild_menu(gobj());
+}
+
+
+Glib::SignalProxy0< bool > ToolItem::signal_create_menu_proxy()
+{
+  return Glib::SignalProxy0< bool >(this, &ToolItem_signal_create_menu_proxy_info);
+}
+
+Glib::SignalProxy0< void > ToolItem::signal_toolbar_reconfigured()
+{
+  return Glib::SignalProxy0< void >(this, &ToolItem_signal_toolbar_reconfigured_info);
+}
+
+Glib::SignalProxy3< bool,Tooltips*,const Glib::ustring&,const Glib::ustring& > ToolItem::signal_set_tooltip()
+{
+  return Glib::SignalProxy3< bool,Tooltips*,const Glib::ustring&,const Glib::ustring& >(this, &ToolItem_signal_set_tooltip_info);
+}
+
+
+Glib::PropertyProxy<bool> ToolItem::property_visible_horizontal() 
+{
+  return Glib::PropertyProxy<bool>(this, "visible-horizontal");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> ToolItem::property_visible_horizontal() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "visible-horizontal");
+}
+
+Glib::PropertyProxy<bool> ToolItem::property_visible_vertical() 
+{
+  return Glib::PropertyProxy<bool>(this, "visible-vertical");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> ToolItem::property_visible_vertical() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "visible-vertical");
+}
+
+Glib::PropertyProxy<bool> ToolItem::property_is_important() 
+{
+  return Glib::PropertyProxy<bool>(this, "is-important");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> ToolItem::property_is_important() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "is-important");
+}
+
+
+bool Gtk::ToolItem::on_create_menu_proxy()
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->create_menu_proxy)
+    return (*base->create_menu_proxy)(gobj());
+
+  typedef bool RType;
+  return RType();
+}
+
+void Gtk::ToolItem::on_toolbar_reconfigured()
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->toolbar_reconfigured)
+    (*base->toolbar_reconfigured)(gobj());
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/toolitem.h b/libs/gtkmm2/gtk/gtkmm/toolitem.h
new file mode 100644
index 0000000000..29b4bf2850
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/toolitem.h
@@ -0,0 +1,442 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_TOOLITEM_H
+#define _GTKMM_TOOLITEM_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* box.h
+ * 
+ * Copyright (C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/bin.h>
+#include <gtkmm/tooltips.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkToolItem GtkToolItem;
+typedef struct _GtkToolItemClass GtkToolItemClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class ToolItem_Class; } // namespace Gtk
+namespace Gtk
+{
+
+/** 
+ *
+ * @ingroup Widgets
+ */
+
+class ToolItem : public Bin
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef ToolItem CppObjectType;
+  typedef ToolItem_Class CppClassType;
+  typedef GtkToolItem BaseObjectType;
+  typedef GtkToolItemClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~ToolItem();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class ToolItem_Class;
+  static CppClassType toolitem_class_;
+
+  // noncopyable
+  ToolItem(const ToolItem&);
+  ToolItem& operator=(const ToolItem&);
+
+protected:
+  explicit ToolItem(const Glib::ConstructParams& construct_params);
+  explicit ToolItem(GtkToolItem* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GtkToolItem*       gobj()       { return reinterpret_cast<GtkToolItem*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GtkToolItem* gobj() const { return reinterpret_cast<GtkToolItem*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+  virtual bool on_create_menu_proxy();
+  virtual void on_toolbar_reconfigured();
+
+
+private:
+
+public:
+  ToolItem();
+
+  
+  /** Sets whether @a tool_item  is to be allocated the same size as other
+   * homogeneous items. The effect is that all homogeneous items will have
+   * the same width as the widest of the items.
+   * 
+   * Since: 2.4
+   * @param homogeneous Whether @a tool_item  is the same size as other homogeneous items.
+   */
+  void set_homogeneous(bool homogeneous = true);
+  
+  /** Returns whether @a tool_item  is the same size as other homogeneous
+   * items. See set_homogeneous().
+   * @return <tt>true</tt> if the item is the same size as other homogeneous
+   * item.s
+   * 
+   * Since: 2.4.
+   */
+  bool get_homogeneous() const;
+
+  
+  /** Sets whether @a tool_item  is allocated extra space when there
+   * is more room on the toolbar then needed for the items. The
+   * effect is that the item gets bigger when the toolbar gets bigger
+   * and smaller when the toolbar gets smaller.
+   * 
+   * Since: 2.4
+   * @param expand Whether @a tool_item  is allocated extra space.
+   */
+  void set_expand(bool expand = true);
+  
+  /** Returns whether @a tool_item  is allocated extra space.
+   * See set_expand().
+   * @return <tt>true</tt> if @a tool_item  is allocated extra space.
+   * 
+   * Since: 2.4.
+   */
+  bool get_expand() const;
+
+  
+  /** Sets the Gtk::Tooltips object to be used for @a tool_item , the
+   * text to be displayed as tooltip on the item and the private text
+   * to be used. See Gtk::Tooltips::set_tip().
+   * 
+   * Since: 2.4
+   * @param tooltips The Gtk::Tooltips object to be used.
+   * @param tip_text Text to be used as tooltip text for @a tool_item .
+   * @param tip_private Text to be used as private tooltip text.
+   */
+  void set_tooltip(Tooltips& tooltips, const Glib::ustring& tip_text, const Glib::ustring& tip_private = Glib::ustring());
+  
+  
+  /** Sets whether @a toolitem  has a drag window. When <tt>true</tt> the
+   * toolitem can be used as a drag source through gtk_drag_source_set().
+   * When @a toolitem  has a drag window it will intercept all events,
+   * even those that would otherwise be sent to a child of @a toolitem .
+   * 
+   * Since: 2.4
+   * @param use_drag_window Whether @a toolitem  has a drag window.
+   */
+  void set_use_drag_window(bool use_drag_window = true);
+  
+  /** Returns whether @a toolitem  has a drag window. See
+   * set_use_drag_window().
+   * @return <tt>true</tt> if @a toolitem  uses a drag window.
+   * 
+   * Since: 2.4.
+   */
+  bool get_use_drag_window() const;
+
+  
+  /** Sets whether @a toolitem  is visible when the toolbar is docked horizontally.
+   * 
+   * Since: 2.4
+   * @param visible_horizontal Whether @a toolitem  is visible when in horizontal mode.
+   */
+  void set_visible_horizontal(bool visible_horizontal = true);
+  
+  /** Returns whether the @a toolitem  is visible on toolbars that are
+   * docked horizontally.
+   * @return <tt>true</tt> if @a toolitem  is visible on toolbars that are
+   * docked horizontally.
+   * 
+   * Since: 2.4.
+   */
+  bool get_visible_horizontal() const;
+
+  
+  /** Sets whether @a toolitem  is visible when the toolbar is docked
+   * vertically. Some tool items, such as text entries, are too wide to be
+   * useful on a vertically docked toolbar. If @a visible_vertical  is <tt>false</tt>
+   *  @a toolitem  will not appear on toolbars that are docked vertically.
+   * 
+   * Since: 2.4
+   * @param visible_vertical Whether @a toolitem  is visible when the toolbar
+   * is in vertical mode.
+   */
+  void set_visible_vertical(bool visible_vertical = true);
+  
+  /** Returns whether @a toolitem  is visible when the toolbar is docked vertically.
+   * See set_visible_vertical().
+   * @return Whether @a toolitem  is visible when the toolbar is docked vertically
+   * 
+   * Since: 2.4.
+   */
+  bool get_visible_vertical() const;
+
+  
+  /** Returns whether @a tool_item  is considered important. See
+   * set_is_important()
+   * @return <tt>true</tt> if @a tool_item  is considered important.
+   * 
+   * Since: 2.4.
+   */
+  bool get_is_important() const;
+  
+  /** Sets whether @a tool_item  should be considered important. The Gtk::ToolButton
+   * class uses this property to determine whether to show or hide its label
+   * when the toolbar style is Gtk::TOOLBAR_BOTH_HORIZ. The result is that
+   * only tool buttons with the "is_important" property set have labels, an
+   * effect known as "priority text"
+   * 
+   * Since: 2.4
+   * @param is_important Whether the tool item should be considered important.
+   */
+  void set_is_important(bool is_important = true);
+
+  
+  /** Returns the icon size used for @a tool_item . Custom subclasses of
+   * Gtk::ToolItem should call this function to find out what size icons
+   * they should use.
+   * @return A Gtk::IconSize indicating the icon size used for @a tool_item 
+   * 
+   * Since: 2.4.
+   */
+  IconSize get_icon_size () const;
+  
+  /** Returns the orientation used for @a tool_item . Custom subclasses of
+   * Gtk::ToolItem should call this function to find out what size icons
+   * they should use.
+   * @return A Gtk::Orientation indicating the orientation
+   * used for @a tool_item 
+   * 
+   * Since: 2.4.
+   */
+  Orientation get_orientation() const;
+  
+  /** Returns the toolbar style used for @a tool_item . Custom subclasses of
+   * Gtk::ToolItem should call this function in the handler of the
+   * GtkToolItem::toolbar_reconfigured signal to find out in what style
+   * the toolbar is displayed and change themselves accordingly 
+   * 
+   * Possibilities are:
+   * &lt;itemizedlist&gt;
+   * &lt;listitem&gt; GTK_TOOLBAR_BOTH, meaning the tool item should show
+   * both an icon and a label, stacked vertically &lt;/listitem&gt;
+   * &lt;listitem&gt; GTK_TOOLBAR_ICONS, meaning the toolbar shows
+   * only icons &lt;/listitem&gt;
+   * &lt;listitem&gt; GTK_TOOLBAR_TEXT, meaning the tool item should only
+   * show text&lt;/listitem&gt;
+   * &lt;listitem&gt; GTK_TOOLBAR_BOTH_HORIZ, meaning the tool item should show
+   * both an icon and a label, arranged horizontally (however, note the 
+   * Gtk::ToolButton::has_text_horizontally that makes tool buttons not
+   * show labels when the toolbar style is GTK_TOOLBAR_BOTH_HORIZ.
+   * &lt;/listitem&gt;
+   * &lt;/itemizedlist&gt;
+   * @return A Gtk::ToolbarStyle indicating the toolbar style used
+   * for @a tool_item .
+   * 
+   * Since: 2.4.
+   */
+  ToolbarStyle get_toolbar_style() const;
+  
+  /** Returns the relief style of @a tool_item . See gtk_button_set_relief_style().
+   * Custom subclasses of Gtk::ToolItem should call this function in the handler
+   * of the Gtk::ToolItem::toolbar_reconfigured signal to find out the
+   * relief style of buttons.
+   * @return A Gtk::ReliefStyle indicating the relief style used
+   * for @a tool_item .
+   * 
+   * Since: 2.4.
+   */
+  ReliefStyle get_relief_style() const;
+
+  
+  /** Returns the Gtk::MenuItem that was last set by
+   * set_proxy_menu_item(), ie. the Gtk::MenuItem
+   * that is going to appear in the overflow menu.
+   * @return The Gtk::MenuItem that is going to appear in the
+   * overflow menu for @a tool_item .
+   * 
+   * Since: 2.4.
+   */
+  Widget* retrieve_proxy_menu_item();
+  
+  /** Returns the Gtk::MenuItem that was last set by
+   * set_proxy_menu_item(), ie. the Gtk::MenuItem
+   * that is going to appear in the overflow menu.
+   * @return The Gtk::MenuItem that is going to appear in the
+   * overflow menu for @a tool_item .
+   * 
+   * Since: 2.4.
+   */
+  const Widget* retrieve_proxy_menu_item() const;
+  
+  /** If @a menu_item_id  matches the string passed to
+   * set_proxy_menu_item() return the corresponding Gtk::MenuItem.
+   * 
+   * Custom subclasses of Gtk::ToolItem should use this function to update
+   * their menu item when the Gtk::ToolItem changes. That the
+   *  @a menu_item_id &lt;!-- --&gt;s must match ensures that a Gtk::ToolItem will not
+   * inadvertently change a menu item that they did not create.
+   * @param menu_item_id A string used to identify the menu item.
+   * @return The Gtk::MenuItem passed to
+   * set_proxy_menu_item(), if the @a menu_item_id &lt;!-- --&gt;s match.
+   * 
+   * Since: 2.4.
+   */
+  Widget* get_proxy_menu_item(const Glib::ustring& menu_item_id);
+  
+  /** If @a menu_item_id  matches the string passed to
+   * set_proxy_menu_item() return the corresponding Gtk::MenuItem.
+   * 
+   * Custom subclasses of Gtk::ToolItem should use this function to update
+   * their menu item when the Gtk::ToolItem changes. That the
+   *  @a menu_item_id &lt;!-- --&gt;s must match ensures that a Gtk::ToolItem will not
+   * inadvertently change a menu item that they did not create.
+   * @param menu_item_id A string used to identify the menu item.
+   * @return The Gtk::MenuItem passed to
+   * set_proxy_menu_item(), if the @a menu_item_id &lt;!-- --&gt;s match.
+   * 
+   * Since: 2.4.
+   */
+  const Widget* get_proxy_menu_item(const Glib::ustring& menu_item_id) const;
+  
+  /** Sets the Gtk::MenuItem used in the toolbar overflow menu. The
+   *  @a menu_item_id  is used to identify the caller of this function and
+   * should also be used with get_proxy_menu_item().
+   * 
+   * Since: 2.4
+   * @param menu_item_id A string used to identify @a menu_item .
+   * @param menu_item A Gtk::MenuItem to be used in the overflow menu.
+   */
+  void set_proxy_menu_item(const Glib::ustring& menu_item_id, Widget& menu_item);
+
+  
+  /** Calling this function signals to the toolbar that the
+   * overflow menu item for @a tool_item  has changed. If the
+   * overflow menu is visible when this function it called,
+   * the menu will be rebuilt.
+   * 
+   * The function must be called when the tool item
+   * changes what it will do in response to the "create_menu_proxy"
+   * signal.
+   * 
+   * Since: 2.6
+   */
+  void rebuild_menu();
+  
+  
+  Glib::SignalProxy0< bool > signal_create_menu_proxy();
+
+  
+  Glib::SignalProxy0< void > signal_toolbar_reconfigured();
+
+
+  //We use no_default_handler for this, because we can not add a new vfunc to 2.5 without breaking ABI.
+  //TODO: Remove no_default_handler when we do an ABI-break-with-parallel-install.
+  
+
+  Glib::SignalProxy3< bool,Tooltips*,const Glib::ustring&,const Glib::ustring& > signal_set_tooltip();
+
+  
+  /** Whether the toolbar item is visible when the toolbar is in a horizontal orientation.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_visible_horizontal() ;
+
+/** Whether the toolbar item is visible when the toolbar is in a horizontal orientation.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_visible_horizontal() const;
+
+  /** Whether the toolbar item is visible when the toolbar is in a vertical orientation.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_visible_vertical() ;
+
+/** Whether the toolbar item is visible when the toolbar is in a vertical orientation.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_visible_vertical() const;
+
+  /** Whether the toolbar item is considered important. When TRUE
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_is_important() ;
+
+/** Whether the toolbar item is considered important. When TRUE
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_is_important() const;
+
+
+};
+
+} // namespace Gtk
+
+
+namespace Glib
+{
+  /** @relates Gtk::ToolItem
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gtk::ToolItem* wrap(GtkToolItem* object, bool take_copy = false);
+}
+#endif /* _GTKMM_TOOLITEM_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/tooltips.cc b/libs/gtkmm2/gtk/gtkmm/tooltips.cc
new file mode 100644
index 0000000000..80b1946879
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/tooltips.cc
@@ -0,0 +1,171 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/tooltips.h>
+#include <gtkmm/private/tooltips_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtk/gtkwidget.h>
+#include <gtk/gtktooltips.h>
+#include <gdkmm/color.h>
+#include <gtkmm/widget.h>
+
+
+namespace Gtk
+{
+
+void Tooltips::set_tip(Gtk::Widget& widget, const Glib::ustring& tip_text)
+{
+  gtk_tooltips_set_tip(gobj(), widget.gobj(), tip_text.c_str(), 0);
+}
+
+void Tooltips::unset_tip(Gtk::Widget& widget)
+{
+  gtk_tooltips_set_tip(gobj(), widget.gobj(), 0, 0);
+}
+
+} // namespace Gtk
+
+
+namespace
+{
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Gtk::Tooltips* wrap(GtkTooltips* object, bool take_copy)
+{
+  return dynamic_cast<Gtk::Tooltips *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& Tooltips_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &Tooltips_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_tooltips_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void Tooltips_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+}
+
+
+Glib::ObjectBase* Tooltips_Class::wrap_new(GObject* o)
+{
+  return manage(new Tooltips((GtkTooltips*)(o)));
+
+}
+
+
+/* The implementation: */
+
+Tooltips::Tooltips(const Glib::ConstructParams& construct_params)
+:
+  Gtk::Object(construct_params)
+{
+  }
+
+Tooltips::Tooltips(GtkTooltips* castitem)
+:
+  Gtk::Object((GtkObject*)(castitem))
+{
+  }
+
+Tooltips::~Tooltips()
+{
+  destroy_();
+}
+
+Tooltips::CppClassType Tooltips::tooltips_class_; // initialize static member
+
+GType Tooltips::get_type()
+{
+  return tooltips_class_.init().get_type();
+}
+
+GType Tooltips::get_base_type()
+{
+  return gtk_tooltips_get_type();
+}
+
+
+Tooltips::Tooltips()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Object(Glib::ConstructParams(tooltips_class_.init()))
+{
+  }
+
+void Tooltips::enable()
+{
+  gtk_tooltips_enable(gobj());
+}
+
+void Tooltips::disable()
+{
+  gtk_tooltips_disable(gobj());
+}
+
+void Tooltips::set_tip(Widget& widget, const Glib::ustring& tip_text, const Glib::ustring& tip_private)
+{
+  gtk_tooltips_set_tip(gobj(), (widget).gobj(), tip_text.c_str(), tip_private.c_str());
+}
+
+GtkTooltipsData* Tooltips::data_get(Widget& widget)
+{
+  return gtk_tooltips_data_get((widget).gobj());
+}
+
+void Tooltips::force_window()
+{
+  gtk_tooltips_force_window(gobj());
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/tooltips.h b/libs/gtkmm2/gtk/gtkmm/tooltips.h
new file mode 100644
index 0000000000..277dc72466
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/tooltips.h
@@ -0,0 +1,145 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_TOOLTIPS_H
+#define _GTKMM_TOOLTIPS_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* Copyright (C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gdkmm/color.h>
+#include <gtkmm/object.h>
+
+
+typedef struct _GtkTooltipsData GtkTooltipsData;
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkTooltips GtkTooltips;
+typedef struct _GtkTooltipsClass GtkTooltipsClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class Tooltips_Class; } // namespace Gtk
+namespace Gtk
+{
+
+class Widget;
+
+/** Tooltips are the messages that appear next to a widget when the mouse
+ * pointer is held over it for a short amount of time. They are especially
+ * helpful for adding more verbose descriptions of things such as buttons
+ * in a toolbar. 
+ *
+ * This widget holds tooltips for other widgets.  You should only need one
+ * Tooltip widget for all widgets you wish to add tips to.
+ */
+
+class Tooltips : public Object
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Tooltips CppObjectType;
+  typedef Tooltips_Class CppClassType;
+  typedef GtkTooltips BaseObjectType;
+  typedef GtkTooltipsClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~Tooltips();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class Tooltips_Class;
+  static CppClassType tooltips_class_;
+
+  // noncopyable
+  Tooltips(const Tooltips&);
+  Tooltips& operator=(const Tooltips&);
+
+protected:
+  explicit Tooltips(const Glib::ConstructParams& construct_params);
+  explicit Tooltips(GtkTooltips* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GtkTooltips*       gobj()       { return reinterpret_cast<GtkTooltips*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GtkTooltips* gobj() const { return reinterpret_cast<GtkTooltips*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+private:
+
+  
+public:
+  Tooltips();
+
+  
+  void enable();
+  
+  void disable();
+
+  
+  void set_tip(Widget& widget, const Glib::ustring& tip_text, const Glib::ustring& tip_private);
+  void set_tip(Widget& widget, const Glib::ustring& tip_text);
+  void unset_tip(Widget& widget);
+
+protected:
+  
+  static GtkTooltipsData* data_get(Widget& widget);
+
+public:
+  
+  void force_window();
+
+
+};
+
+} //namespace Gtk
+
+
+namespace Glib
+{
+  /** @relates Gtk::Tooltips
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gtk::Tooltips* wrap(GtkTooltips* object, bool take_copy = false);
+}
+#endif /* _GTKMM_TOOLTIPS_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/treedragdest.cc b/libs/gtkmm2/gtk/gtkmm/treedragdest.cc
new file mode 100644
index 0000000000..d201fbddea
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/treedragdest.cc
@@ -0,0 +1,244 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/treedragdest.h>
+#include <gtkmm/private/treedragdest_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/treepath.h>
+#include <gtkmm/selectiondata_private.h>
+#include <gtk/gtktreednd.h>
+
+
+namespace
+{
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Glib::RefPtr<Gtk::TreeDragDest> wrap(GtkTreeDragDest* object, bool take_copy)
+{
+  return Glib::RefPtr<Gtk::TreeDragDest>( dynamic_cast<Gtk::TreeDragDest*> (Glib::wrap_auto ((GObject*)(object), take_copy)) );
+  //We use dynamic_cast<> in case of multiple inheritance.
+}
+
+} // namespace Glib
+
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Interface_Class& TreeDragDest_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Interface_Class has to know the interface init function
+    // in order to add interfaces to implementing types.
+    class_init_func_ = &TreeDragDest_Class::iface_init_function;
+
+    // We can not derive from another interface, and it is not necessary anyway.
+    gtype_ = gtk_tree_drag_dest_get_type();
+  }
+
+  return *this;
+}
+
+void TreeDragDest_Class::iface_init_function(void* g_iface, void*)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_iface);
+
+  //This is just to avoid an "unused variable" warning when there are no vfuncs or signal handlers to connect.
+  //This is a temporary fix until I find out why I can not seem to derive a GtkFileChooser interface. murrayc
+  g_assert(klass != 0); 
+
+  klass->drag_data_received = &drag_data_received_vfunc_callback;
+  klass->row_drop_possible = &row_drop_possible_vfunc_callback;
+}
+
+gboolean TreeDragDest_Class::drag_data_received_vfunc_callback(GtkTreeDragDest* self, GtkTreePath* dest, GtkSelectionData* selection_data)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return static_cast<int>(obj->drag_data_received_vfunc(Gtk::TreePath(dest, true)
+, SelectionData_WithoutOwnership(selection_data)
+));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->drag_data_received)
+      return (*base->drag_data_received)(self, dest, selection_data);
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+gboolean TreeDragDest_Class::row_drop_possible_vfunc_callback(GtkTreeDragDest* self, GtkTreePath* dest_path, GtkSelectionData* selection_data)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return static_cast<int>(obj->row_drop_possible_vfunc(Gtk::TreePath(dest_path, true)
+, SelectionData_WithoutOwnership(selection_data)
+));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->row_drop_possible)
+      return (*base->row_drop_possible)(self, dest_path, selection_data);
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+
+Glib::ObjectBase* TreeDragDest_Class::wrap_new(GObject* object)
+{
+  return new TreeDragDest((GtkTreeDragDest*)(object));
+}
+
+
+/* The implementation: */
+
+TreeDragDest::TreeDragDest()
+:
+  Glib::Interface(treedragdest_class_.init())
+{}
+
+TreeDragDest::TreeDragDest(GtkTreeDragDest* castitem)
+:
+  Glib::Interface((GObject*)(castitem))
+{}
+
+TreeDragDest::~TreeDragDest()
+{}
+
+// static
+void TreeDragDest::add_interface(GType gtype_implementer)
+{
+  treedragdest_class_.init().add_interface(gtype_implementer);
+}
+
+TreeDragDest::CppClassType TreeDragDest::treedragdest_class_; // initialize static member
+
+GType TreeDragDest::get_type()
+{
+  return treedragdest_class_.init().get_type();
+}
+
+GType TreeDragDest::get_base_type()
+{
+  return gtk_tree_drag_dest_get_type();
+}
+
+
+bool TreeDragDest::drag_data_received(const TreeModel::Path& dest, const SelectionData& selection_data)
+{
+  return gtk_tree_drag_dest_drag_data_received(gobj(), const_cast<GtkTreePath*>((dest).gobj()), const_cast<GtkSelectionData*>((selection_data).gobj()));
+}
+
+bool TreeDragDest::row_drop_possible(const TreeModel::Path& dest_path, const SelectionData& selection_data) const
+{
+  return gtk_tree_drag_dest_row_drop_possible(const_cast<GtkTreeDragDest*>(gobj()), const_cast<GtkTreePath*>((dest_path).gobj()), const_cast<GtkSelectionData*>((selection_data).gobj()));
+}
+
+
+bool Gtk::TreeDragDest::drag_data_received_vfunc(const TreeModel::Path& dest, const SelectionData& selection_data) 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->drag_data_received)
+    return (*base->drag_data_received)(gobj(),const_cast<GtkTreePath*>((dest).gobj()),const_cast<GtkSelectionData*>((selection_data).gobj()));
+
+  typedef bool RType;
+  return RType();
+}
+
+bool Gtk::TreeDragDest::row_drop_possible_vfunc(const TreeModel::Path& dest, const SelectionData& selection_data) const
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->row_drop_possible)
+    return (*base->row_drop_possible)(const_cast<GtkTreeDragDest*>(gobj()),const_cast<GtkTreePath*>((dest).gobj()),const_cast<GtkSelectionData*>((selection_data).gobj()));
+
+  typedef bool RType;
+  return RType();
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/treedragdest.h b/libs/gtkmm2/gtk/gtkmm/treedragdest.h
new file mode 100644
index 0000000000..afd98c697c
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/treedragdest.h
@@ -0,0 +1,161 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_TREEDRAGDEST_H
+#define _GTKMM_TREEDRAGDEST_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* Copyright (C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <glibmm/interface.h>
+#include <gtkmm/treemodel.h>
+#include <gtkmm/selectiondata.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+extern "C"
+{
+typedef struct _GtkTreeDragDestIface GtkTreeDragDestIface;
+typedef struct _GtkSelectionData GtkSelectionData;
+}
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkTreeDragDest GtkTreeDragDest;
+typedef struct _GtkTreeDragDestClass GtkTreeDragDestClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class TreeDragDest_Class; } // namespace Gtk
+namespace Gtk
+{
+
+/**
+ * @ingroup TreeView
+ */
+
+class TreeDragDest : public Glib::Interface
+{
+  
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+public:
+  typedef TreeDragDest CppObjectType;
+  typedef TreeDragDest_Class CppClassType;
+  typedef GtkTreeDragDest BaseObjectType;
+  typedef GtkTreeDragDestIface BaseClassType;
+
+private:
+  friend class TreeDragDest_Class;
+  static CppClassType treedragdest_class_;
+
+  // noncopyable
+  TreeDragDest(const TreeDragDest&);
+  TreeDragDest& operator=(const TreeDragDest&);
+
+protected:
+  TreeDragDest(); // you must derive from this class
+  explicit TreeDragDest(GtkTreeDragDest* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+  virtual ~TreeDragDest();
+
+  static void add_interface(GType gtype_implementer);
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GObject.
+  GtkTreeDragDest*       gobj()       { return reinterpret_cast<GtkTreeDragDest*>(gobject_); }
+
+  ///Provides access to the underlying C GObject.  
+  const GtkTreeDragDest* gobj() const { return reinterpret_cast<GtkTreeDragDest*>(gobject_); }
+
+private:
+
+
+public:
+
+  
+  /** Asks the Gtk::TreeDragDest to insert a row before the path @a dest ,
+   * deriving the contents of the row from @a selection_data . If @a dest  is
+   * outside the tree so that inserting before it is impossible, <tt>false</tt>
+   * will be returned. Also, <tt>false</tt> may be returned if the new row is
+   * not created for some model-specific reason.  Should robustly handle
+   * a @a dest  no longer found in the model!
+   * @param dest Row to drop in front of.
+   * @param selection_data Data to drop.
+   * @return Whether a new row was created before position @a dest .
+   */
+  bool drag_data_received(const TreeModel::Path& dest, const SelectionData& selection_data);              
+
+  
+  /** Determines whether a drop is possible before the given @a dest_path ,
+   * at the same depth as @a dest_path . i.e., can we drop the data in
+   *  @a selection_data  at that location. @a dest_path  does not have to
+   * exist; the return value will almost certainly be <tt>false</tt> if the
+   * parent of @a dest_path  doesn't exist, though.
+   * @param dest_path Destination row.
+   * @param selection_data The data being dragged.
+   * @return <tt>true</tt> if a drop is possible before @a dest_path .
+   */
+  bool row_drop_possible(const TreeModel::Path& dest_path, const SelectionData& selection_data) const;
+                             
+protected:
+    virtual bool drag_data_received_vfunc(const TreeModel::Path& dest, const SelectionData& selection_data);
+
+    virtual bool row_drop_possible_vfunc(const TreeModel::Path& dest, const SelectionData& selection_data) const;
+
+
+public:
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+};
+
+} // namespace Gtk
+
+
+namespace Glib
+{
+  /** @relates Gtk::TreeDragDest
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Glib::RefPtr<Gtk::TreeDragDest> wrap(GtkTreeDragDest* object, bool take_copy = false);
+
+} // namespace Glib
+
+#endif /* _GTKMM_TREEDRAGDEST_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/treedragsource.cc b/libs/gtkmm2/gtk/gtkmm/treedragsource.cc
new file mode 100644
index 0000000000..57cbdeb64b
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/treedragsource.cc
@@ -0,0 +1,309 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/treedragsource.h>
+#include <gtkmm/private/treedragsource_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/treepath.h>
+#include <gtkmm/selectiondata_private.h> //For SelectionData_WithoutOwnership
+#include <gtk/gtktreednd.h>
+
+
+namespace Gtk
+{
+
+//This vfunc wrapper is manually written, so that we can use a temporary instance for the SelectionData& output parameter:
+
+gboolean TreeDragSource_Class::drag_data_get_vfunc_callback(GtkTreeDragSource* self, GtkTreePath* path, GtkSelectionData* selection_data)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      SelectionData_WithoutOwnership temp_instance(selection_data);
+      return static_cast<int>(obj->drag_data_get_vfunc(Gtk::TreePath(path, true), temp_instance));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->drag_data_get)
+      return (*base->drag_data_get)(self, path, selection_data);
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+bool Gtk::TreeDragSource::drag_data_get_vfunc(const TreeModel::Path& path, SelectionData& selection_data) const
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->drag_data_get)
+    return (*base->drag_data_get)(const_cast<GtkTreeDragSource*>(gobj()),const_cast<GtkTreePath*>((path).gobj()), selection_data.gobj());
+
+  typedef bool RType;
+  return RType();
+}
+
+} //namespace Gtk
+
+
+namespace
+{
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Glib::RefPtr<Gtk::TreeDragSource> wrap(GtkTreeDragSource* object, bool take_copy)
+{
+  return Glib::RefPtr<Gtk::TreeDragSource>( dynamic_cast<Gtk::TreeDragSource*> (Glib::wrap_auto ((GObject*)(object), take_copy)) );
+  //We use dynamic_cast<> in case of multiple inheritance.
+}
+
+} // namespace Glib
+
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Interface_Class& TreeDragSource_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Interface_Class has to know the interface init function
+    // in order to add interfaces to implementing types.
+    class_init_func_ = &TreeDragSource_Class::iface_init_function;
+
+    // We can not derive from another interface, and it is not necessary anyway.
+    gtype_ = gtk_tree_drag_source_get_type();
+  }
+
+  return *this;
+}
+
+void TreeDragSource_Class::iface_init_function(void* g_iface, void*)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_iface);
+
+  //This is just to avoid an "unused variable" warning when there are no vfuncs or signal handlers to connect.
+  //This is a temporary fix until I find out why I can not seem to derive a GtkFileChooser interface. murrayc
+  g_assert(klass != 0); 
+
+    klass->drag_data_get = &drag_data_get_vfunc_callback;
+    klass->row_draggable = &row_draggable_vfunc_callback;
+  klass->drag_data_delete = &drag_data_delete_vfunc_callback;
+}
+
+gboolean TreeDragSource_Class::row_draggable_vfunc_callback(GtkTreeDragSource* self, GtkTreePath* path)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return static_cast<int>(obj->row_draggable_vfunc(Gtk::TreePath(path, true)
+));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->row_draggable)
+      return (*base->row_draggable)(self, path);
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+gboolean TreeDragSource_Class::drag_data_delete_vfunc_callback(GtkTreeDragSource* self, GtkTreePath* path)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return static_cast<int>(obj->drag_data_delete_vfunc(Gtk::TreePath(path, true)
+));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->drag_data_delete)
+      return (*base->drag_data_delete)(self, path);
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+
+Glib::ObjectBase* TreeDragSource_Class::wrap_new(GObject* object)
+{
+  return new TreeDragSource((GtkTreeDragSource*)(object));
+}
+
+
+/* The implementation: */
+
+TreeDragSource::TreeDragSource()
+:
+  Glib::Interface(treedragsource_class_.init())
+{}
+
+TreeDragSource::TreeDragSource(GtkTreeDragSource* castitem)
+:
+  Glib::Interface((GObject*)(castitem))
+{}
+
+TreeDragSource::~TreeDragSource()
+{}
+
+// static
+void TreeDragSource::add_interface(GType gtype_implementer)
+{
+  treedragsource_class_.init().add_interface(gtype_implementer);
+}
+
+TreeDragSource::CppClassType TreeDragSource::treedragsource_class_; // initialize static member
+
+GType TreeDragSource::get_type()
+{
+  return treedragsource_class_.init().get_type();
+}
+
+GType TreeDragSource::get_base_type()
+{
+  return gtk_tree_drag_source_get_type();
+}
+
+
+bool TreeDragSource::row_draggable(const TreeModel::Path& path) const
+{
+  return gtk_tree_drag_source_row_draggable(const_cast<GtkTreeDragSource*>(gobj()), const_cast<GtkTreePath*>((path).gobj()));
+}
+
+bool TreeDragSource::drag_data_get(const TreeModel::Path& path, SelectionData& selection_data)
+{
+  return gtk_tree_drag_source_drag_data_get(gobj(), const_cast<GtkTreePath*>((path).gobj()), (selection_data).gobj());
+}
+
+bool TreeDragSource::drag_data_delete(const TreeModel::Path& path)
+{
+  return gtk_tree_drag_source_drag_data_delete(gobj(), const_cast<GtkTreePath*>((path).gobj()));
+}
+
+
+bool Gtk::TreeDragSource::row_draggable_vfunc(const TreeModel::Path& path) const
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->row_draggable)
+    return (*base->row_draggable)(const_cast<GtkTreeDragSource*>(gobj()),const_cast<GtkTreePath*>((path).gobj()));
+
+  typedef bool RType;
+  return RType();
+}
+
+bool Gtk::TreeDragSource::drag_data_delete_vfunc(const TreeModel::Path& path) 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->drag_data_delete)
+    return (*base->drag_data_delete)(gobj(),const_cast<GtkTreePath*>((path).gobj()));
+
+  typedef bool RType;
+  return RType();
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/treedragsource.h b/libs/gtkmm2/gtk/gtkmm/treedragsource.h
new file mode 100644
index 0000000000..41bdf732ec
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/treedragsource.h
@@ -0,0 +1,171 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_TREEDRAGSOURCE_H
+#define _GTKMM_TREEDRAGSOURCE_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* Copyright (C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <glibmm/interface.h>
+#include <gtkmm/treemodel.h>
+#include <gtkmm/selectiondata.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+extern "C"
+{
+typedef struct _GtkTreeDragSourceIface GtkTreeDragSourceIface;
+typedef struct _GtkSelectionData GtkSelectionData;
+}
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkTreeDragSource GtkTreeDragSource;
+typedef struct _GtkTreeDragSourceClass GtkTreeDragSourceClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class TreeDragSource_Class; } // namespace Gtk
+namespace Gtk
+{
+
+/**
+ * @ingroup TreeView
+*/
+
+class TreeDragSource : public Glib::Interface
+{
+  
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+public:
+  typedef TreeDragSource CppObjectType;
+  typedef TreeDragSource_Class CppClassType;
+  typedef GtkTreeDragSource BaseObjectType;
+  typedef GtkTreeDragSourceIface BaseClassType;
+
+private:
+  friend class TreeDragSource_Class;
+  static CppClassType treedragsource_class_;
+
+  // noncopyable
+  TreeDragSource(const TreeDragSource&);
+  TreeDragSource& operator=(const TreeDragSource&);
+
+protected:
+  TreeDragSource(); // you must derive from this class
+  explicit TreeDragSource(GtkTreeDragSource* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+  virtual ~TreeDragSource();
+
+  static void add_interface(GType gtype_implementer);
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GObject.
+  GtkTreeDragSource*       gobj()       { return reinterpret_cast<GtkTreeDragSource*>(gobject_); }
+
+  ///Provides access to the underlying C GObject.  
+  const GtkTreeDragSource* gobj() const { return reinterpret_cast<GtkTreeDragSource*>(gobject_); }
+
+private:
+
+
+public:
+  
+  /** Asks the Gtk::TreeDragSource whether a particular row can be used as
+   * the source of a DND operation. If the source doesn't implement
+   * this interface, the row is assumed draggable.
+   * @param path Row on which user is initiating a drag.
+   * @return <tt>true</tt> if the row can be dragged.
+   */
+  bool row_draggable(const TreeModel::Path& path) const;
+
+  
+  /** Asks the Gtk::TreeDragSource to fill in @a selection_data  with a
+   * representation of the row at @a path . @a selection_data -&gt;target gives
+   * the required type of the data.  Should robustly handle a @a path  no
+   * longer found in the model!
+   * @param path Row that was dragged.
+   * @param selection_data A Gtk::SelectionData to fill with data from the dragged row.
+   * @return <tt>true</tt> if data of the required type was provided.
+   */
+  bool drag_data_get(const TreeModel::Path& path, SelectionData& selection_data);
+               
+  
+  /** Asks the Gtk::TreeDragSource to delete the row at @a path , because
+   * it was moved somewhere else via drag-and-drop. Returns <tt>false</tt>
+   * if the deletion fails because @a path  no longer exists, or for
+   * some model-specific reason. Should robustly handle a @a path  no
+   * longer found in the model!
+   * @param path Row that was being dragged.
+   * @return <tt>true</tt> if the row was successfully deleted.
+   */
+  bool drag_data_delete(const TreeModel::Path& path);
+
+protected:
+
+
+    virtual bool row_draggable_vfunc(const TreeModel::Path& path) const;
+
+  //We hand-code this so that we can use a temporary instance for teh SelectionData& output parameter:
+  virtual bool drag_data_get_vfunc(const TreeModel::Path& path, SelectionData& selection_data) const;
+   
+    virtual bool drag_data_delete_vfunc(const TreeModel::Path& path);
+
+
+public:
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+};
+
+} // namespace Gtk
+
+
+namespace Glib
+{
+  /** @relates Gtk::TreeDragSource
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Glib::RefPtr<Gtk::TreeDragSource> wrap(GtkTreeDragSource* object, bool take_copy = false);
+
+} // namespace Glib
+
+#endif /* _GTKMM_TREEDRAGSOURCE_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/treeiter.cc b/libs/gtkmm2/gtk/gtkmm/treeiter.cc
new file mode 100644
index 0000000000..8c355c353d
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/treeiter.cc
@@ -0,0 +1,395 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/treeiter.h>
+#include <gtkmm/private/treeiter_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/treemodel.h>
+
+namespace
+{
+
+// This is copied from Totem. In future there might be a version in GTK+ itself - see bug #
+void gtkmm_gtk_tree_model_iter_previous(GtkTreeModel* tree_model, GtkTreeIter* iter)
+{
+  GtkTreePath *const path = gtk_tree_model_get_path(tree_model, iter);
+
+  if(gtk_tree_path_prev(path))
+    gtk_tree_model_get_iter(tree_model, iter, path);
+  else
+    g_assert_not_reached();
+
+  gtk_tree_path_free(path);
+}
+
+} // anonymous namespace
+
+
+namespace Gtk
+{
+
+/**** Gtk::TreeIter ********************************************************/
+
+TreeIter::TreeIter()
+:
+  TreeIterBase(),
+  model_      (0),
+  is_end_     (false)
+{}
+
+TreeIter::TreeIter(TreeModel* model)
+:
+  TreeIterBase(),
+  model_      (model),
+  is_end_     (false)
+{}
+
+TreeIter::TreeIter(GtkTreeModel* model, const GtkTreeIter* iter)
+:
+  TreeIterBase(iter),
+  model_      (dynamic_cast<TreeModel*>(Glib::wrap_auto((GObject*) model))),
+  is_end_     (iter == 0)
+{}
+
+TreeIter& TreeIter::operator++()
+{
+  g_assert(!is_end_);
+
+  GtkTreeIter previous = gobject_;
+
+  if(!gtk_tree_model_iter_next(model_->gobj(), &gobject_))
+  {
+    is_end_ = true;
+    gtk_tree_model_iter_parent(model_->gobj(), &gobject_, &previous);
+  }
+
+  return *this;
+}
+
+const TreeIter TreeIter::operator++(int)
+{
+  g_assert(!is_end_);
+
+  TreeIter previous (*this);
+
+  if(!gtk_tree_model_iter_next(model_->gobj(), &gobject_))
+  {
+    is_end_ = true;
+    gtk_tree_model_iter_parent(model_->gobj(), &gobject_, &previous.gobject_);
+  }
+
+  return previous;
+}
+
+TreeIter& TreeIter::operator--()
+{
+  if(!is_end_)
+  {
+    gtkmm_gtk_tree_model_iter_previous(model_->gobj(), &gobject_);
+  }
+  else // --end yields last
+  {
+    GtkTreeIter next = gobject_;
+    GtkTreeIter *const parent = (next.stamp != 0) ? &next : 0;
+
+    const int index = gtk_tree_model_iter_n_children(model_->gobj(), parent) - 1;
+    is_end_ = !gtk_tree_model_iter_nth_child(model_->gobj(), &gobject_, parent, index);
+
+    g_assert(!is_end_);
+  }
+
+  return *this;
+}
+
+const TreeIter TreeIter::operator--(int)
+{
+  TreeIter next (*this);
+
+  if(!is_end_)
+  {
+    gtkmm_gtk_tree_model_iter_previous(model_->gobj(), &gobject_);
+  }
+  else // --end yields last
+  {
+    GtkTreeIter *const parent = (next.gobject_.stamp != 0) ? &next.gobject_ : 0;
+
+    const int index = gtk_tree_model_iter_n_children(model_->gobj(), parent) - 1;
+    is_end_ = !gtk_tree_model_iter_nth_child(model_->gobj(), &gobject_, parent, index);
+
+    g_assert(!is_end_);
+  }
+
+  return next;
+}
+
+/* There is no public gtk_tree_iter_equal(), so we must write our own.
+ */
+bool TreeIter::equal(const TreeIter& other) const
+{
+  g_assert(model_ == other.model_);
+
+  // A GtkTreeIter has the same stamp value as its model.
+  g_assert(gobject_.stamp == other.gobject_.stamp || is_end_ || other.is_end_);
+
+  //TODO: Allow custom treemodels to provide a different implementation.
+  
+  // If all user_data pointers are equal we can assume the iterators to be
+  // equal.  This should be safe since GtkTreeIter lacks destroy notification,
+  // thus there is no way to attach more data fields to the iterator.
+  return (is_end_ == other.is_end_) &&
+         (gobject_.user_data  == other.gobject_.user_data)  &&
+         (gobject_.user_data2 == other.gobject_.user_data2) &&
+         (gobject_.user_data3 == other.gobject_.user_data3);
+}
+
+TreeIter::operator bool() const
+{
+  // Test whether the GtkTreeIter is valid and not an end iterator.  This check
+  // is almost the same as the private VALID_ITER() macro in gtkliststore.c and
+  // gtktreestore.c.
+  return (!is_end_ && gobject_.stamp != 0);
+}
+
+void TreeIter::setup_end_iterator(const TreeIter& last_valid)
+{
+  g_assert(model_ == last_valid.model_);
+
+  if(last_valid.is_end_)
+    gobject_ = last_valid.gobject_;
+  else
+    gtk_tree_model_iter_parent(model_->gobj(), &gobject_, const_cast<GtkTreeIter*>(&last_valid.gobject_));
+
+  is_end_ = true;
+}
+
+void TreeIter::set_model_refptr(const Glib::RefPtr<TreeModel>& model)
+{
+  model_ = model.operator->();
+}
+
+void TreeIter::set_model_gobject(GtkTreeModel* model)
+{
+  model_ = dynamic_cast<TreeModel*>(Glib::wrap_auto((GObject*) model));
+}
+
+GtkTreeModel* TreeIter::get_model_gobject() const
+{
+  return (model_) ? model_->gobj() : 0;
+}
+
+
+int TreeIter::get_stamp() const
+{
+  return gobj()->stamp;
+}
+
+void TreeIter::set_stamp(int stamp)
+{
+  gobj()->stamp = stamp;
+} 
+
+
+/**** Gtk::TreeRow *********************************************************/
+
+const TreeNodeChildren& TreeRow::children() const
+{
+  g_assert(!is_end_);
+
+  return static_cast<const TreeNodeChildren&>(static_cast<const TreeIter&>(*this));
+}
+
+TreeIter TreeRow::parent() const
+{
+  TreeIter iter (model_);
+
+  if(is_end_)
+    iter.gobject_ = gobject_;
+  else
+    gtk_tree_model_iter_parent(model_->gobj(), iter.gobj(), const_cast<GtkTreeIter*>(&gobject_));
+
+  return iter;
+}
+
+void TreeRow::set_value_impl(int column, const Glib::ValueBase& value) const
+{
+  model_->set_value_impl(*this, column, value);
+}
+
+void TreeRow::get_value_impl(int column, Glib::ValueBase& value) const
+{
+  model_->get_value_impl(*this, column, value);
+}
+
+TreeRow::operator bool() const
+{
+  return TreeIter::operator bool();
+}
+
+
+/**** Gtk::TreeNodeChildren ************************************************/
+
+TreeNodeChildren::iterator TreeNodeChildren::begin()
+{
+  iterator iter (model_);
+
+  // If the iterator is invalid (stamp == 0), assume a 'virtual' toplevel
+  // node.  This behaviour is needed to implement Gtk::TreeModel::children().
+
+  if(gobject_.stamp != 0)
+  {
+    if(!gtk_tree_model_iter_children(model_->gobj(), iter.gobj(), const_cast<GtkTreeIter*>(&gobject_)))
+    {
+      // Assign the already known parent, in order to create an end iterator.
+      iter.gobject_ = gobject_;
+      iter.is_end_ = true;
+    }
+  }
+  else
+  {
+    if(!gtk_tree_model_get_iter_first(model_->gobj(), iter.gobj()))
+    {
+      // No need to copy the GtkTreeIter, since iter.gobject_ is already empty.
+      iter.is_end_ = true;
+    }
+  }
+
+  return iter;
+}
+
+TreeNodeChildren::const_iterator TreeNodeChildren::begin() const
+{
+  //TODO: Reduce the copy/paste from the non-const begin()?
+  
+  const_iterator iter (model_);
+
+  // If the iterator is invalid (stamp == 0), assume a 'virtual' toplevel
+  // node.  This behaviour is needed to implement Gtk::TreeModel::children().
+
+  if(gobject_.stamp != 0)
+  {
+    if(!gtk_tree_model_iter_children(model_->gobj(), iter.gobj(), const_cast<GtkTreeIter*>(&gobject_)))
+    {
+      // Assign the already known parent, in order to create an end iterator.
+      iter.gobject_ = gobject_;
+      iter.is_end_ = true;
+    }
+  }
+  else
+  {
+    if(!gtk_tree_model_get_iter_first(model_->gobj(), iter.gobj()))
+    {
+      // No need to copy the GtkTreeIter, since iter.gobject_ is already empty.
+      iter.is_end_ = true;
+    }
+  }
+
+  return iter;
+}
+
+TreeNodeChildren::iterator TreeNodeChildren::end()
+{
+  // Just copy the parent, and turn it into an end iterator.
+  iterator iter (*this);
+  iter.is_end_ = true;
+  return iter;
+}
+
+TreeNodeChildren::const_iterator TreeNodeChildren::end() const
+{
+  // Just copy the parent, and turn it into an end iterator.
+  const_iterator iter (*this);
+  iter.is_end_ = true;
+  return iter;
+}
+
+TreeNodeChildren::value_type TreeNodeChildren::operator[](TreeNodeChildren::size_type index) const
+{
+  iterator iter (model_);
+
+  GtkTreeIter *const parent = const_cast<GtkTreeIter*>(get_parent_gobject());
+
+  if(!gtk_tree_model_iter_nth_child(model_->gobj(), iter.gobj(), parent, index))
+  {
+    // Assign the already known parent, in order to create an end iterator.
+    iter.gobject_ = gobject_;
+    iter.is_end_ = true;
+  }
+
+  return *iter;
+}
+
+TreeNodeChildren::size_type TreeNodeChildren::size() const
+{
+  GtkTreeIter *const parent = const_cast<GtkTreeIter*>(get_parent_gobject());
+
+  return gtk_tree_model_iter_n_children(model_->gobj(), parent);
+}
+
+bool TreeNodeChildren::empty() const
+{
+  // If the iterator is invalid (stamp == 0), assume a 'virtual' toplevel
+  // node.  This behaviour is needed to implement Gtk::TreeModel::children().
+
+  if(gobject_.stamp == 0)
+  {
+    GtkTreeIter dummy;
+    return !gtk_tree_model_get_iter_first(model_->gobj(), &dummy);
+  }
+
+  return !gtk_tree_model_iter_has_child(model_->gobj(), const_cast<GtkTreeIter*>(&gobject_));
+}
+
+} // namespace Gtk
+
+
+namespace
+{
+} // anonymous namespace
+
+
+namespace Gtk
+{
+
+
+// static
+GType TreeIterBase::get_type()
+{
+  return gtk_tree_iter_get_type();
+}
+
+TreeIterBase::TreeIterBase()
+{
+  GLIBMM_INITIALIZE_STRUCT(gobject_, GtkTreeIter);
+}
+
+TreeIterBase::TreeIterBase(const GtkTreeIter* gobject)
+{
+  if(gobject)
+    gobject_ = *gobject;
+  else
+    GLIBMM_INITIALIZE_STRUCT(gobject_, GtkTreeIter);
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/treeiter.h b/libs/gtkmm2/gtk/gtkmm/treeiter.h
new file mode 100644
index 0000000000..49a639d4cf
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/treeiter.h
@@ -0,0 +1,517 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_TREEITER_H
+#define _GTKMM_TREEITER_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* Copyright(C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software, ) you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library, ) if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+
+#include <gtkmm/treemodelcolumn.h>
+#include <gtkmmconfig.h>
+#include <iterator>
+#include <gtk/gtktreemodel.h> /* for GtkTreeIter */
+
+GLIBMM_USING_STD(forward_iterator_tag)
+
+
+namespace Gtk
+{
+
+class TreeModel;
+class TreeRow;
+class TreeNodeChildren;
+
+/**
+ * @ingroup TreeView
+ */
+class TreeIterBase
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef TreeIterBase CppObjectType;
+  typedef GtkTreeIter BaseObjectType;
+
+  static GType get_type() G_GNUC_CONST;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  TreeIterBase();
+
+  explicit TreeIterBase(const GtkTreeIter* gobject); // always takes a copy
+
+  ///Provides access to the underlying C instance.
+  GtkTreeIter*       gobj()       { return &gobject_; }
+
+  ///Provides access to the underlying C instance.
+  const GtkTreeIter* gobj() const { return &gobject_; }
+
+protected:
+  GtkTreeIter gobject_;
+
+private:
+  
+  
+  //A wrap() for TreeIterBase* wouldn't be very helpful.
+
+
+};
+
+
+// In order to offer STL-like iterator functionality, we cannot wrap
+// GtkTreeIter directly.  Most GTK+ functions that operate on GtkTreeIter
+// are virtual functions in GtkTreeModel.  Therefore, the C++ TreeIter
+// must store a pointer to the Gtk::TreeModel to which it belongs.
+//
+// Another problem, which is much worse, is that the GTK+ tree iterator
+// doesn't support the STL-style half-open interval [begin,end).  Instead,
+// it uses a [first,last] interval, and functions return FALSE to indicate
+// the end was reached.  Also, some functions accept a NULL GtkTreeIter*,
+// which will be interpreted as the end() iterator.
+//
+// Most of the immense complexity in the Gtk::TreeIter implementation is
+// needed for proper emulation of [begin,end) intervals.  Unfortunately,
+// it's not even possible to encapsulate everything in the TreeIter
+// class.  Almost all wrapper methods dealing with GtkTreeIter must be
+// carefully implemented by hand.  TODO: document implementation details
+
+//TODO: Implement a const_iterator too:
+//danielk says that this ConstTreeIter class should return a ConstTreeRow, which would not allow operator=.
+
+/** A Gtk::TreeModel::iterator is a reference to a specific node on a specific
+ * model.
+ *
+ * It is a generic structure with an integer and three generic pointers.
+ * These are filled in by the model in a model-specific way.
+ *
+ * One can convert a path to an iterator by calling Gtk::TreeModel::get_iter().
+ *
+ * These iterators are the primary way of accessing a model and are similar to the iterators
+ * used by Gtk::TextBuffer. The model interface defines a set of operations
+ * using them for navigating the model.
+ *
+ * The lifecycle of an iterator can be a little confusing at first. Iterators
+ * are expected to always be valid for as long as the model is unchanged (and
+ * doesn't emit a signal).
+ * Additionally, some models guarantee that an iterator is valid for as
+ * long as the node it refers to is valid (most notably the Gtk::TreeStore and
+ * Gtk::ListStore).
+ *
+ * Although generally uninteresting, as one always has to
+ * allow for the case where iterators do not persist beyond a signal, some very
+ * important performance enhancements were made in the sort model. As a result,
+ * the Gtk::TREE_MODEL_ITERS_PERSIST flag was added to indicate this behaviour -
+ * see Gtk::TreeModel::get_flags().
+ *
+ * Typedefed as Gtk::TreeModel::iterator.
+ * The Gtk::TreeModel iterator.
+ * @ingroup TreeView
+ */
+class TreeIter : public TreeIterBase
+{
+public:
+  typedef std::bidirectional_iterator_tag iterator_category;
+  typedef Gtk::TreeRow              value_type;
+  typedef int                       difference_type;
+  typedef const Gtk::TreeRow&       reference;
+  typedef const Gtk::TreeRow*       pointer;
+
+  TreeIter();
+
+  TreeIter&      operator++();
+  const TreeIter operator++(int);
+
+  /** Please note that this is very slow compared to operator++().
+   */
+  TreeIter&      operator--();
+
+  /** Please note that this is very slow compared to operator++().
+   */
+  const TreeIter operator--(int);
+  
+  inline reference operator*()  const;
+  inline pointer   operator->() const;
+
+  bool equal(const TreeIter& other) const;
+
+  /** Discover whether the iterator is valid, and not equal to end().
+   */
+  operator bool() const;
+
+  /** This is only useful when implementing a custom Gtk::TreeModel class.
+   * Compare the iterator's stamp with your model's stamp to discover whether it is valid.
+   * @see set_stamp().
+   * @result The iterator's stamp.
+   */
+  int get_stamp() const;
+
+  /** This is only useful when implementing a custom Gtk::TreeModel class.
+   * Set the stamp to be equal to your model's stamp, to mark the iterator as valid.
+   * When your model's structure changes, you should increment your model's stamp
+   * to mark all older iterators as invalid. They will be recognised as invalid because
+   * they will then have an incorrect stamp.
+   */
+  void set_stamp(int stamp);
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+  explicit TreeIter(TreeModel* model); // used in TreeModel methods
+  TreeIter(GtkTreeModel* model, const GtkTreeIter* iter); // used by signal proxies
+
+  void set_model_refptr(const Glib::RefPtr<TreeModel>& model);
+  void set_model_gobject(GtkTreeModel* model);
+  GtkTreeModel* get_model_gobject() const;
+
+  void setup_end_iterator(const TreeIter& last_valid);
+
+  const GtkTreeIter* get_gobject_if_not_end() const
+    { return (!is_end_) ? &gobject_ : 0; }
+
+  const GtkTreeIter* get_parent_gobject_if_end() const
+    { return (is_end_ && gobject_.stamp) ? &gobject_ : 0; }
+
+protected:
+
+  // Yes, using a simple TreeModel* rather than Glib::RefPtr<TreeModel>
+  // violates the general policy.  But Gtk::TreeIter should have a trivial
+  // copy constructor and assignment operator, i.e. it must contain only
+  // POD (plain old data).
+  //
+  // Gtk::TreeIter is copied a lot, particularly often as return value from
+  // methods.  Postfix ++ must return by value, and STL algorithms usually
+  // pass iterators by value, too.  With a RefPtr<> as member data, copying
+  // would no longer be trivial, and even cause frequent calls to reference()
+  // and unreference().  That usually doesn't matter much for GUI stuff, but
+  // Gtk::TreeModel is used as a generic container.  Imagine a for-loop that
+  // checks whether iter != children.end() on each iteration.
+
+  TreeModel* model_;
+  bool       is_end_;
+
+  friend class Gtk::TreeRow;
+  friend class Gtk::TreeNodeChildren;
+  friend class Gtk::TreeModel;
+
+#endif // DOXYGEN_SHOULD_SKIP_THIS
+};
+
+/** @relates Gtk::TreeIter */
+inline bool operator==(const TreeIter& lhs, const TreeIter& rhs)
+  { return lhs.equal(rhs); }
+
+/** @relates Gtk::TreeIter */
+inline bool operator!=(const TreeIter& lhs, const TreeIter& rhs)
+  { return !lhs.equal(rhs); }
+
+
+template <class ColumnType>
+class TreeValueProxy
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  inline TreeValueProxy(const TreeRow& row, const TreeModelColumn<ColumnType>& column);
+#endif
+
+  inline TreeValueProxy<ColumnType>& operator=(const ColumnType& data);
+  inline operator ColumnType() const;
+
+private:
+  const TreeRow&                      row_;
+  const TreeModelColumn<ColumnType>&  column_;
+
+  // no copy assignment
+  TreeValueProxy<ColumnType>& operator=(const TreeValueProxy<ColumnType>&);
+};
+
+
+/** Typedefed as TreeModel::Row.
+ *
+ * Dereference a TreeModel::iterator to get the Row. Use operator[] or set_value() and get_value() to access the
+ * values in the columns of this row.
+ *
+ * If the model contains a hierarchy of rows (such as Gtk::TreeStore), then you can access the child rows with
+ * children().
+ *
+ * You can use a const TreeModel::Row& for any parameter that takes a const TreeModel::iterator&.
+ * @ingroup TreeView
+ */
+class TreeRow : public TreeIter //We use public inheritance so that we can cast from a TreeRow to a TreeIter.
+{
+public:
+
+  /** Use this to set and get the value of this @a column of this row.
+   * This is a templated method, so the compiler will not allow you to provide an inappropriate type
+   * of data for the model column.
+   *
+   * This is just a more convient syntax that does the same thing as set_value() and get_value().
+   *
+   * @param column The model column..
+   */
+  template <class ColumnType> inline
+  TreeValueProxy<ColumnType> operator[](const TreeModelColumn<ColumnType>& column) const;
+
+  /** Sets the value of this @a column of this row.
+   * This is a templated method, so the compiler will not allow you to provide an inappropriate type
+   * of @a data for the model column.
+   *
+   * See also operator[].
+   *
+   * @param column The model column.
+   * @param data The new value to use for this column of this row.
+   */
+  template <class ColumnType>
+  void set_value(const TreeModelColumn<ColumnType>& column, const ColumnType& data) const;
+
+  /** Use set_value(const TreeModelColumn<>& column, const ColumnType& data) unless
+   * you do not know the column type at compile-time.
+   * If the @a data is of an inappropriate C++ type then this might fail at runtime.
+   * @param column The number of the column whose value you want to change.
+   * @param data The new value to use for this column of this row.
+   */
+  template <class ColumnType>
+  void set_value(int column, const ColumnType& data) const;
+
+  /** Gets the value of this @a column of this row.
+   * This is a templated method, so the compiler will not allow you to provide an inappropriate type
+   * of data for the model column.
+   *
+   * See also operator[].
+   *
+   * @param column The model column.
+   * @result The new value to use for this column of this row.
+   */
+  template <class ColumnType>
+  ColumnType get_value(const TreeModelColumn<ColumnType>& column) const;
+
+  /** Use get_value(const TreeModelColumn<>& column) unless
+   * you do not know the column type at compile-time.
+   * If the @a data output argument is of an inappropriate C++ type then this might fail at runtime.
+   * @param column The number of the column whose value you want to change.
+   * @retval data An output argument which will contain the value of this column of this row.
+   */
+  template <class ColumnType>
+  void get_value(int column, ColumnType& data) const;
+
+  /** This returns an STL-like container API, for iterating over the rows.
+   * See also Gtk::TreeModel::children() for the top-level children.
+   */
+  const TreeNodeChildren& children() const;
+
+  /** Gets an iterator to the parent row of this row.
+   * @result An iterator to the parent row.
+   */
+  TreeIter parent() const;
+
+  /** Discover whether this is a valid row.
+   */
+  operator bool() const;
+
+  /// Provides access to the underlying C GObject.  
+  GtkTreeIter*       gobj()       { return TreeIter::gobj(); }
+
+  /// Provides access to the underlying C GObject.  
+  const GtkTreeIter* gobj() const { return TreeIter::gobj(); }
+
+private:
+  // Forwarders to Gtk::TreeModel virtual methods.
+  void set_value_impl(int column, const Glib::ValueBase& value) const;
+  void get_value_impl(int column, Glib::ValueBase& value) const;
+};
+
+
+//TODO: Document begin(), end(), size(), etc, in an STL-style way. murrayc.
+
+/** typedefed as TreeModel::Children.
+ * Virtual container of TreeModel::Row items.
+ * @ingroup TreeView
+ */
+class TreeNodeChildren : public TreeIter
+{
+public:
+  typedef Gtk::TreeRow  value_type;
+  typedef unsigned int  size_type;
+  typedef int           difference_type;
+  typedef Gtk::TreeIter iterator;
+
+  #ifndef GLIBMM_HAVE_SUN_REVERSE_ITERATOR
+    typedef std::reverse_iterator<iterator> reverse_iterator;
+  #else
+    typedef std::reverse_iterator<iterator, std::random_access_iterator_tag,
+                                  int, int&, int*, ptrdiff_t> reverse_iterator;
+  #endif
+
+    typedef Gtk::TreeIter const_iterator; //TODO: Make it a real const_iterator.
+
+  #ifndef GLIBMM_HAVE_SUN_REVERSE_ITERATOR
+    typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+  #else
+    typedef std::reverse_iterator<const_iterator, std::random_access_iterator_tag,
+                                  int, const int&, const int*, ptrdiff_t> const_reverse_iterator;
+  #endif
+
+  iterator begin();
+  const_iterator begin() const;
+  iterator end();
+  const_iterator end()   const;
+
+  // Note: there is no advantage in not inlining these methods.
+  // We can't change them without breaking ABI anyway.
+  reverse_iterator       rbegin()       { return reverse_iterator(end());         }
+  reverse_iterator       rend()         { return reverse_iterator(begin());       }
+  const_reverse_iterator rbegin() const { return const_reverse_iterator(end());   }
+  const_reverse_iterator rend()   const { return const_reverse_iterator(begin()); }
+
+  value_type operator[](size_type index) const;
+
+  size_type size() const;
+  bool empty() const;
+  operator bool() const { return !empty(); }
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+  explicit TreeNodeChildren(TreeModel* model)
+    : TreeIter(model) {}
+
+  const GtkTreeIter* get_parent_gobject() const
+    { return (gobject_.stamp != 0) ? &gobject_ : 0; }
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+};
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+/**** Gtk::TreeIter ********************************************************/
+
+inline
+TreeIter::reference TreeIter::operator*() const
+{
+  return static_cast<const TreeRow&>(*this);
+}
+
+inline
+TreeIter::pointer TreeIter::operator->() const
+{
+  return static_cast<const TreeRow*>(this);
+}
+
+
+/**** Gtk::TreeValueProxy<> ************************************************/
+
+template <class ColumnType> inline
+TreeValueProxy<ColumnType>::TreeValueProxy(const TreeRow& row, const TreeModelColumn<ColumnType>& column)
+:
+  row_    (row),
+  column_ (column)
+{}
+
+template <class ColumnType> inline
+TreeValueProxy<ColumnType>& TreeValueProxy<ColumnType>::operator=(const ColumnType& data)
+{
+  row_.set_value(column_, data);
+  return *this;
+}
+
+template <class ColumnType> inline
+TreeValueProxy<ColumnType>::operator ColumnType() const
+{
+  return row_.get_value(column_);
+}
+
+
+/**** Gtk::TreeRow *********************************************************/
+
+template <class ColumnType> inline
+TreeValueProxy<ColumnType> TreeRow::operator[](const TreeModelColumn<ColumnType>& column) const
+{
+  return TreeValueProxy<ColumnType>(*this, column);
+}
+
+template <class ColumnType>
+void TreeRow::set_value(const TreeModelColumn<ColumnType>& column, const ColumnType& data) const
+{
+  typedef typename Gtk::TreeModelColumn<ColumnType>::ValueType ValueType;
+
+  ValueType value;
+  value.init(column.type());
+
+  value.set(data);
+  this->set_value_impl(column.index(), value);
+}
+
+template <class ColumnType>
+void TreeRow::set_value(int column, const ColumnType& data) const
+{
+  //This could fail at run-time, because the wrong ColumnType might be used.
+  //It's only for dynamically generated model columns.
+
+  typedef typename Gtk::TreeModelColumn<ColumnType> type_cppcolumn;
+  typedef typename type_cppcolumn::ValueType ValueType;
+
+  ValueType value;
+  value.init(ValueType::value_type());
+
+  value.set(data);
+  this->set_value_impl(column, value);
+}
+
+template <class ColumnType>
+ColumnType TreeRow::get_value(const TreeModelColumn<ColumnType>& column) const
+{
+  typedef typename Gtk::TreeModelColumn<ColumnType>::ValueType ValueType;
+
+  ValueType value;
+  this->get_value_impl(column.index(), value);
+
+  return value.get();
+}
+
+template <class ColumnType>
+void TreeRow::get_value(int column, ColumnType& data) const
+{
+  //This could fail at run-time, because the wrong ColumnType might be used.
+  //It's only for dynamically generated model columns.
+
+  typedef typename Gtk::TreeModelColumn<ColumnType>::ValueType ValueType;
+
+  ValueType value;
+  this->get_value_impl(column, value);
+
+  data = value.get();
+}
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+} // namespace Gtk
+
+
+namespace Glib
+{
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+template <>
+class Value<Gtk::TreeIterBase> : public Glib::Value_Boxed<Gtk::TreeIterBase>
+{};
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+} // namespace Glib
+
+#endif /* _GTKMM_TREEITER_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/treemodel.cc b/libs/gtkmm2/gtk/gtkmm/treemodel.cc
new file mode 100644
index 0000000000..b6989dff58
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/treemodel.cc
@@ -0,0 +1,1612 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/treemodel.h>
+#include <gtkmm/private/treemodel_p.h>
+
+#include <gtk/gtktypebuiltins.h>
+// -*- c++ -*-
+/* $Id$ */
+
+/* Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/treeiter.h>
+#include <gtkmm/treepath.h>
+#include <gtk/gtktreestore.h>
+#include <gtk/gtktreemodel.h>
+
+namespace
+{
+
+gboolean proxy_foreach_iter_callback(GtkTreeModel* model, GtkTreePath*, GtkTreeIter* iter, void* data)
+{
+  typedef Gtk::TreeModel::SlotForeachIter SlotType;
+  SlotType& slot = *static_cast<SlotType*>(data);
+
+  try
+  {
+    return slot(Gtk::TreeModel::iterator(model, iter));
+  }
+  catch(...)
+  {
+    Glib::exception_handlers_invoke();
+  }
+
+  return 1;
+}
+
+gboolean proxy_foreach_path_callback(GtkTreeModel*, GtkTreePath* path, GtkTreeIter*, void* data)
+{
+  typedef Gtk::TreeModel::SlotForeachPath SlotType;
+  SlotType& slot = *static_cast<SlotType*>(data);
+
+  try
+  {
+    return slot(Gtk::TreeModel::Path(path, true));
+  }
+  catch(...)
+  {
+    Glib::exception_handlers_invoke();
+  }
+
+  return 1;
+}
+
+gboolean proxy_foreach_path_and_iter_callback(GtkTreeModel* model, GtkTreePath* path,
+                                              GtkTreeIter* iter, void* data)
+{
+  typedef Gtk::TreeModel::SlotForeachPathAndIter SlotType;
+  SlotType& slot = *static_cast<SlotType*>(data);
+
+  try
+  {
+    return slot(Gtk::TreeModel::Path(path, true), Gtk::TreeModel::iterator(model, iter));
+  }
+  catch(...)
+  {
+    Glib::exception_handlers_invoke();
+  }
+
+  return 1;
+}
+
+} //anonymous namespace
+
+
+//Help the code generator, so that it doesn't have to fully qualify this type:
+typedef Gtk::TreeModel::iterator iterator;
+
+namespace Gtk
+{
+
+TreeModel::iterator TreeModel::get_iter(const Path& path)
+{
+  Gtk::TreeModel::iterator iter(this);
+  gtk_tree_model_get_iter(gobj(), iter.gobj(), const_cast<GtkTreePath*>(path.gobj()));
+  return iter;
+}
+
+TreeModel::iterator TreeModel::get_iter(const Glib::ustring& path_string)
+{
+  Gtk::TreeModel::iterator iter (this);
+  gtk_tree_model_get_iter_from_string(gobj(), iter.gobj(), path_string.c_str());
+  return iter;
+}
+
+TreeModel::Children TreeModel::children()
+{
+  return TreeNodeChildren(this);
+}
+
+TreeModel::Children TreeModel::children() const
+{              
+  //TODO: Remove the const when we have a real const TreeNodeChildren, when we have a real const_iterator.
+  return TreeNodeChildren(const_cast<TreeModel*>(this));
+}
+
+void TreeModel::set_value_impl(const iterator&, int, const Glib::ValueBase&)
+{
+  g_assert_not_reached();
+}
+
+void TreeModel::get_value_impl(const iterator& row, int column, Glib::ValueBase& value) const
+{
+  gtk_tree_model_get_value(
+      const_cast<GtkTreeModel*>(gobj()),
+      const_cast<GtkTreeIter*>(row.gobj()),
+      column, value.gobj());
+}
+
+void TreeModel::foreach_iter(const SlotForeachIter& slot)
+{
+  SlotForeachIter slot_copy (slot);
+  gtk_tree_model_foreach(gobj(), &proxy_foreach_iter_callback, &slot_copy);
+}
+
+void TreeModel::foreach_path(const SlotForeachPath& slot)
+{
+  SlotForeachPath slot_copy (slot);
+  gtk_tree_model_foreach(gobj(), &proxy_foreach_path_callback, &slot_copy);
+}
+
+void TreeModel::foreach(const SlotForeachPathAndIter& slot)
+{
+  SlotForeachPathAndIter slot_copy (slot);
+  gtk_tree_model_foreach(gobj(), &proxy_foreach_path_and_iter_callback, &slot_copy);
+}
+
+bool TreeModel::iter_is_valid(const iterator& iter) const
+{
+  //This method is overriden in TreeStore and ListStore.
+  //This implementation will only be used as a default for custom derived TreeModels,
+  //and when we wrap a C GtkTreeModel with a Gtk::TreeModel instance, without knowing what derived C type it is.
+  
+  // This check is almost the same as the private VALID_ITER() macro in gtkliststore.c and
+  // gtktreestore.c.
+  return (!iter.is_end_ && iter.gobj()->stamp != 0);
+}
+
+// Custom vfunc callbacks, because the C++ vfuncs have different parameters and return types
+// that can not be generated automatically:
+gboolean TreeModel_Class::iter_next_vfunc_callback(GtkTreeModel* self, GtkTreeIter* iter)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      TreeModel::iterator iter_input = TreeModel::iterator(self, iter);
+      TreeModel::iterator iter_next( self, iter ); //Copies iter by value.
+      gboolean test = obj->iter_next_vfunc(iter_input, iter_next);
+
+      //Copy the new iter value to the C output parameter:
+      if(test)
+        *iter = *(iter_next.gobj());
+
+      return test;
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+        g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+      )
+    );
+
+    // Call the original underlying C function:
+    if(base && base->iter_next)
+      return (*base->iter_next)(self, iter);
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+
+bool TreeModel::iter_next_vfunc(const iterator& iter, iterator& iter_next) const
+{
+  //Call the default C implementation:
+  
+  BaseClassType *const base = static_cast<BaseClassType*>(
+    g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+      g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+    )
+  );
+
+  if(base && base->iter_next)
+  {
+    TreeModel::iterator iter_copy = iter;
+    gboolean test = (*base->iter_next)(const_cast<GtkTreeModel*>(gobj()), iter_copy.gobj());
+    if(test)
+      iter_next = iter_copy;
+
+    return test;
+  }
+
+  return bool();
+}
+
+gboolean TreeModel_Class::get_iter_vfunc_callback(GtkTreeModel* self, GtkTreeIter* iter, GtkTreePath* path)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      Gtk::TreeModel::iterator iter_out(self, iter); //copies the iter by value.
+      gboolean test = obj->get_iter_vfunc(Gtk::TreePath(path, true), iter_out);
+
+      //Copy the new iter value to the C output parameter:
+      if(test)
+        *iter = *(iter_out.gobj());
+
+      return test;
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->get_iter)
+      return (*base->get_iter)(self, iter, const_cast<GtkTreePath*>(path));
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+bool TreeModel::get_iter_vfunc(const Path& path, iterator& iter) const
+{
+  //Call the default C implementation:
+
+  BaseClassType *const base = static_cast<BaseClassType*>(
+    g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+      g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+    )
+  );
+
+  if(base && base->get_iter)
+  {
+    return (*base->get_iter)( const_cast<GtkTreeModel*>(gobj()), iter.gobj(), const_cast<GtkTreePath*>(path.gobj()) );
+  }
+
+  return bool();
+}
+
+gboolean TreeModel_Class::iter_children_vfunc_callback(GtkTreeModel* self, GtkTreeIter* iter, GtkTreeIter* parent)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      Gtk::TreeModel::iterator iter_out(self, iter); //copies the iter by value.
+
+      gboolean test = false;
+      if(!parent)
+      {
+        //Deal with this case, which is documented in the C docs as:
+        //" If @parent is %NULL returns the first node, equivalent to
+        //  <literal>gtk_tree_model_get_iter_first (tree_model, iter);</literal> "
+        test = obj->iter_nth_root_child_vfunc(0, iter_out);
+      }
+      else
+      {
+        //Normal case: 
+         Gtk::TreeModel::iterator parent_cpp(self, parent);
+         test = obj->iter_children_vfunc(parent_cpp, iter_out);
+      }
+
+      //Copy the new iter value to the C output parameter:
+      if(test)
+        *iter = *(iter_out.gobj());
+        
+      return test;
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->iter_children)
+      return (*base->iter_children)(self, iter, parent);
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+bool TreeModel::iter_children_vfunc(const iterator& parent, iterator& iter) const
+{
+  //Call the default C implementation:
+
+  BaseClassType *const base = static_cast<BaseClassType*>(
+    g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+      g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+    )
+  );
+
+  if(base && base->iter_children)
+  {
+    return (*base->iter_children)( const_cast<GtkTreeModel*>(gobj()), iter.gobj(), const_cast<GtkTreeIter*>(parent.gobj()) );
+  }
+
+  return bool();
+}
+
+gboolean TreeModel_Class::iter_parent_vfunc_callback(GtkTreeModel* self, GtkTreeIter* iter, GtkTreeIter* child)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      Gtk::TreeModel::iterator iter_out(self, iter);
+      Gtk::TreeModel::iterator child_cpp(self, child);
+      gboolean test = obj->iter_parent_vfunc(child_cpp, iter_out);
+
+      //Copy the new iter value to the C output parameter:
+      if(test)
+        *iter = *(iter_out.gobj());
+
+      return test;
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->iter_parent)
+      return (*base->iter_parent)(self, iter, child);
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+bool TreeModel::iter_parent_vfunc(const iterator& child, iterator& iter) const
+{
+  //Call the default C implementation:
+
+  BaseClassType *const base = static_cast<BaseClassType*>(
+    g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+      g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+    )
+  );
+
+  if(base && base->iter_parent)
+  {
+    return (*base->iter_parent)( const_cast<GtkTreeModel*>(gobj()), iter.gobj(), const_cast<GtkTreeIter*>(child.gobj()) );
+  }
+
+  return bool();
+}
+
+gboolean TreeModel_Class::iter_nth_child_vfunc_callback(GtkTreeModel* self, GtkTreeIter* iter, GtkTreeIter* parent, int n)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      Gtk::TreeModel::iterator iter_out(self, iter);
+
+      gboolean test = false;
+      if(!parent)
+      {
+        // Deal with this special case, docuemnted in the C docs as:
+        // "As a special case, if @parent is %NULL, then the nth root node is set.":
+        test = obj->iter_nth_root_child_vfunc(n, iter_out);
+      }
+      else
+      {
+        //The normal case:
+        Gtk::TreeModel::iterator parent_cpp(self, parent);
+        test = obj->iter_nth_child_vfunc(parent_cpp, n, iter_out);
+      }
+
+      //Copy the new iter value to the C output parameter:
+      if(test)
+        *iter = *(iter_out.gobj());
+
+      return test;
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->iter_nth_child)
+      return (*base->iter_nth_child)(self, iter, parent, n);
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+bool TreeModel::iter_nth_child_vfunc(const iterator& parent, int n, iterator& iter) const
+{
+  //Call the default C implementation:
+
+  BaseClassType *const base = static_cast<BaseClassType*>(
+    g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+      g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+    )
+  );
+
+  if(base && base->iter_nth_child)
+  {
+    return (*base->iter_nth_child)( const_cast<GtkTreeModel*>(gobj()), iter.gobj(), const_cast<GtkTreeIter*>(parent.gobj()), n );
+  }
+
+  return bool();
+}
+
+//See the implementation of iter_children_vfunc_callback() and iter_nth_child_vfunc_callback()
+//to find out why this virtual function exists:
+bool TreeModel::iter_nth_root_child_vfunc(int n, iterator& iter) const
+{
+  //Call the default C implementation:
+
+  BaseClassType *const base = static_cast<BaseClassType*>(
+    g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+      g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+    )
+  );
+
+  if(base && base->iter_nth_child)
+  {
+    //This means that iter_nth_child(0) might be called by iter_children_vfunc_callback(),
+    //but hopefully that's exactly the same thing. TODO: Ask why both vfuncs exist. murrayc. 
+    return (*base->iter_nth_child)( const_cast<GtkTreeModel*>(gobj()), iter.gobj(), 0 /* the null parent */, n );
+  }
+
+  return bool();
+}
+
+gboolean TreeModel_Class::iter_n_children_vfunc_callback(GtkTreeModel* self, GtkTreeIter* iter)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+
+      //Deal with the case that iter is null, as described in the C docs:
+      if(iter)
+        return obj->iter_n_children_vfunc( Gtk::TreeModel::iterator(self, iter) );
+      else
+        return obj->iter_n_root_children_vfunc();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->iter_n_children)
+      return (*base->iter_n_children)(self, iter);
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+int TreeModel::iter_n_children_vfunc(const iterator& iter) const
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->iter_n_children)
+    return (*base->iter_n_children)(const_cast<GtkTreeModel*>(gobj()), const_cast<GtkTreeIter*>((iter).gobj()));
+
+  typedef int RType;
+  return RType();
+}
+
+int TreeModel::iter_n_root_children_vfunc() const
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->iter_n_children)
+    return (*base->iter_n_children)(const_cast<GtkTreeModel*>(gobj()), 0 /* null iter to mean root node, as described in C docs */);
+
+  typedef int RType;
+  return RType();
+}
+
+
+void TreeModel::rows_reordered(const Path& path, const iterator& iter, const Glib::ArrayHandle<int>& new_order)
+{
+  //The size of the array seems to be based on the known number of children. murrayc.
+  gtk_tree_model_rows_reordered(gobj(), const_cast<GtkTreePath*>((path).gobj()), const_cast<GtkTreeIter*>((iter).gobj()), const_cast<int*>(new_order.data()));
+}
+ 
+
+} // namespace Gtk
+
+
+namespace
+{
+
+void TreeModel_signal_row_changed_callback(GtkTreeModel* self, GtkTreePath* path,GtkTreeIter* iter,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,const TreeModel::Path&,const TreeModel::iterator& > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(Gtk::TreePath(path, true)
+, Gtk::TreeModel::iterator(self, iter)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+}
+
+const Glib::SignalProxyInfo TreeModel_signal_row_changed_info =
+{
+  "row_changed",
+  (GCallback) &TreeModel_signal_row_changed_callback,
+  (GCallback) &TreeModel_signal_row_changed_callback
+};
+
+
+void TreeModel_signal_row_inserted_callback(GtkTreeModel* self, GtkTreePath* path,GtkTreeIter* iter,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,const TreeModel::Path&,const TreeModel::iterator& > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(Gtk::TreePath(path, true)
+, Gtk::TreeModel::iterator(self, iter)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+}
+
+const Glib::SignalProxyInfo TreeModel_signal_row_inserted_info =
+{
+  "row_inserted",
+  (GCallback) &TreeModel_signal_row_inserted_callback,
+  (GCallback) &TreeModel_signal_row_inserted_callback
+};
+
+
+void TreeModel_signal_row_has_child_toggled_callback(GtkTreeModel* self, GtkTreePath* path,GtkTreeIter* iter,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,const TreeModel::Path&,const TreeModel::iterator& > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(Gtk::TreePath(path, true)
+, Gtk::TreeModel::iterator(self, iter)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+}
+
+const Glib::SignalProxyInfo TreeModel_signal_row_has_child_toggled_info =
+{
+  "row_has_child_toggled",
+  (GCallback) &TreeModel_signal_row_has_child_toggled_callback,
+  (GCallback) &TreeModel_signal_row_has_child_toggled_callback
+};
+
+
+void TreeModel_signal_row_deleted_callback(GtkTreeModel* self, GtkTreePath* path,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,const TreeModel::Path& > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(Gtk::TreePath(path, true)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+}
+
+const Glib::SignalProxyInfo TreeModel_signal_row_deleted_info =
+{
+  "row_deleted",
+  (GCallback) &TreeModel_signal_row_deleted_callback,
+  (GCallback) &TreeModel_signal_row_deleted_callback
+};
+
+
+void TreeModel_signal_rows_reordered_callback(GtkTreeModel* self, GtkTreePath* path,GtkTreeIter* iter,gint* new_order,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,const TreeModel::Path&,const TreeModel::iterator&,int* > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(Gtk::TreePath(path, true)
+, Gtk::TreeModel::iterator(self, iter)
+, new_order
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+}
+
+const Glib::SignalProxyInfo TreeModel_signal_rows_reordered_info =
+{
+  "rows_reordered",
+  (GCallback) &TreeModel_signal_rows_reordered_callback,
+  (GCallback) &TreeModel_signal_rows_reordered_callback
+};
+
+} // anonymous namespace
+
+// static
+GType Glib::Value<Gtk::TreeModelFlags>::value_type()
+{
+  return gtk_tree_model_flags_get_type();
+}
+
+
+namespace Glib
+{
+
+Glib::RefPtr<Gtk::TreeModel> wrap(GtkTreeModel* object, bool take_copy)
+{
+  return Glib::RefPtr<Gtk::TreeModel>( dynamic_cast<Gtk::TreeModel*> (Glib::wrap_auto ((GObject*)(object), take_copy)) );
+  //We use dynamic_cast<> in case of multiple inheritance.
+}
+
+} // namespace Glib
+
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Interface_Class& TreeModel_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Interface_Class has to know the interface init function
+    // in order to add interfaces to implementing types.
+    class_init_func_ = &TreeModel_Class::iface_init_function;
+
+    // We can not derive from another interface, and it is not necessary anyway.
+    gtype_ = gtk_tree_model_get_type();
+  }
+
+  return *this;
+}
+
+void TreeModel_Class::iface_init_function(void* g_iface, void*)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_iface);
+
+  //This is just to avoid an "unused variable" warning when there are no vfuncs or signal handlers to connect.
+  //This is a temporary fix until I find out why I can not seem to derive a GtkFileChooser interface. murrayc
+  g_assert(klass != 0); 
+
+  klass->get_flags = &get_flags_vfunc_callback;
+  klass->get_n_columns = &get_n_columns_vfunc_callback;
+  klass->get_column_type = &get_column_type_vfunc_callback;
+    klass->iter_next = &iter_next_vfunc_callback;
+    klass->get_iter = &get_iter_vfunc_callback;
+    klass->iter_children = &iter_children_vfunc_callback;
+    klass->iter_parent = &iter_parent_vfunc_callback;
+    klass->iter_nth_child = &iter_nth_child_vfunc_callback;
+    klass->iter_n_children = &iter_n_children_vfunc_callback;
+    klass->iter_has_child = &iter_has_child_vfunc_callback;
+  klass->ref_node = &ref_node_vfunc_callback;
+  klass->unref_node = &unref_node_vfunc_callback;
+  klass->get_path = &get_path_vfunc_callback;
+  klass->get_value = &get_value_vfunc_callback;
+  klass->row_changed = &row_changed_callback;
+  klass->row_inserted = &row_inserted_callback;
+  klass->row_has_child_toggled = &row_has_child_toggled_callback;
+  klass->row_deleted = &row_deleted_callback;
+  klass->rows_reordered = &rows_reordered_callback;
+}
+
+GtkTreeModelFlags TreeModel_Class::get_flags_vfunc_callback(GtkTreeModel* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return ((GtkTreeModelFlags)(obj->get_flags_vfunc()));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->get_flags)
+      return (*base->get_flags)(self);
+  }
+
+  typedef GtkTreeModelFlags RType;
+  return RType();
+}
+
+gint TreeModel_Class::get_n_columns_vfunc_callback(GtkTreeModel* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return obj->get_n_columns_vfunc();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->get_n_columns)
+      return (*base->get_n_columns)(self);
+  }
+
+  typedef gint RType;
+  return RType();
+}
+
+GType TreeModel_Class::get_column_type_vfunc_callback(GtkTreeModel* self, gint index)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return obj->get_column_type_vfunc(index
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->get_column_type)
+      return (*base->get_column_type)(self, index);
+  }
+
+  typedef GType RType;
+  return RType();
+}
+
+gboolean TreeModel_Class::iter_has_child_vfunc_callback(GtkTreeModel* self, GtkTreeIter* iter)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return static_cast<int>(obj->iter_has_child_vfunc(Gtk::TreeModel::iterator(self, iter)
+));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->iter_has_child)
+      return (*base->iter_has_child)(self, iter);
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+void TreeModel_Class::ref_node_vfunc_callback(GtkTreeModel* self, GtkTreeIter* iter)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->ref_node_vfunc(Gtk::TreeModel::iterator(self, iter)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->ref_node)
+      (*base->ref_node)(self, iter);
+  }
+}
+
+void TreeModel_Class::unref_node_vfunc_callback(GtkTreeModel* self, GtkTreeIter* iter)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->unref_node_vfunc(Gtk::TreeModel::iterator(self, iter)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->unref_node)
+      (*base->unref_node)(self, iter);
+  }
+}
+
+GtkTreePath* TreeModel_Class::get_path_vfunc_callback(GtkTreeModel* self, GtkTreeIter* iter)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return (obj->get_path_vfunc(Gtk::TreeModel::iterator(self, iter)
+)).gobj_copy();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->get_path)
+      return (*base->get_path)(self, iter);
+  }
+
+  typedef GtkTreePath* RType;
+  return RType();
+}
+
+void TreeModel_Class::get_value_vfunc_callback(GtkTreeModel* self, GtkTreeIter* iter, gint column, GValue* value)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->get_value_vfunc(Gtk::TreeModel::iterator(self, iter)
+, column
+, *reinterpret_cast<Glib::ValueBase*>(value)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->get_value)
+      (*base->get_value)(self, iter, column, value);
+  }
+}
+
+
+void TreeModel_Class::row_changed_callback(GtkTreeModel* self, GtkTreePath* path, GtkTreeIter* iter)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_row_changed(Gtk::TreePath(path, true)
+, Gtk::TreeModel::iterator(self, iter)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->row_changed)
+      (*base->row_changed)(self, path, iter);
+  }
+}
+
+void TreeModel_Class::row_inserted_callback(GtkTreeModel* self, GtkTreePath* path, GtkTreeIter* iter)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_row_inserted(Gtk::TreePath(path, true)
+, Gtk::TreeModel::iterator(self, iter)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->row_inserted)
+      (*base->row_inserted)(self, path, iter);
+  }
+}
+
+void TreeModel_Class::row_has_child_toggled_callback(GtkTreeModel* self, GtkTreePath* path, GtkTreeIter* iter)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_row_has_child_toggled(Gtk::TreePath(path, true)
+, Gtk::TreeModel::iterator(self, iter)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->row_has_child_toggled)
+      (*base->row_has_child_toggled)(self, path, iter);
+  }
+}
+
+void TreeModel_Class::row_deleted_callback(GtkTreeModel* self, GtkTreePath* path)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_row_deleted(Gtk::TreePath(path, true)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->row_deleted)
+      (*base->row_deleted)(self, path);
+  }
+}
+
+void TreeModel_Class::rows_reordered_callback(GtkTreeModel* self, GtkTreePath* path, GtkTreeIter* iter, gint* new_order)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_rows_reordered(Gtk::TreePath(path, true)
+, Gtk::TreeModel::iterator(self, iter)
+, new_order
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->rows_reordered)
+      (*base->rows_reordered)(self, path, iter, new_order);
+  }
+}
+
+
+Glib::ObjectBase* TreeModel_Class::wrap_new(GObject* object)
+{
+  return new TreeModel((GtkTreeModel*)(object));
+}
+
+
+/* The implementation: */
+
+TreeModel::TreeModel()
+:
+  Glib::Interface(treemodel_class_.init())
+{}
+
+TreeModel::TreeModel(GtkTreeModel* castitem)
+:
+  Glib::Interface((GObject*)(castitem))
+{}
+
+TreeModel::~TreeModel()
+{}
+
+// static
+void TreeModel::add_interface(GType gtype_implementer)
+{
+  treemodel_class_.init().add_interface(gtype_implementer);
+}
+
+TreeModel::CppClassType TreeModel::treemodel_class_; // initialize static member
+
+GType TreeModel::get_type()
+{
+  return treemodel_class_.init().get_type();
+}
+
+GType TreeModel::get_base_type()
+{
+  return gtk_tree_model_get_type();
+}
+
+
+TreeModelFlags TreeModel::get_flags() const
+{
+  return ((TreeModelFlags)(gtk_tree_model_get_flags(const_cast<GtkTreeModel*>(gobj()))));
+}
+
+int TreeModel::get_n_columns() const
+{
+  return gtk_tree_model_get_n_columns(const_cast<GtkTreeModel*>(gobj()));
+}
+
+GType TreeModel::get_column_type(int index) const
+{
+  return gtk_tree_model_get_column_type(const_cast<GtkTreeModel*>(gobj()), index);
+}
+
+TreeModel::Path TreeModel::get_path(const iterator& iter) const
+{
+  return Gtk::TreePath(gtk_tree_model_get_path(const_cast<GtkTreeModel*>(gobj()), const_cast<GtkTreeIter*>((iter).gobj())), false);
+}
+
+void TreeModel::row_changed(const Path& path, const iterator& iter)
+{
+  gtk_tree_model_row_changed(gobj(), const_cast<GtkTreePath*>((path).gobj()), const_cast<GtkTreeIter*>((iter).gobj()));
+}
+
+void TreeModel::row_inserted(const Path& path, const iterator& iter)
+{
+  gtk_tree_model_row_inserted(gobj(), const_cast<GtkTreePath*>((path).gobj()), const_cast<GtkTreeIter*>((iter).gobj()));
+}
+
+void TreeModel::row_has_child_toggled(const Path& path, const iterator& iter)
+{
+  gtk_tree_model_row_has_child_toggled(gobj(), const_cast<GtkTreePath*>((path).gobj()), const_cast<GtkTreeIter*>((iter).gobj()));
+}
+
+void TreeModel::row_deleted(const Path& path)
+{
+  gtk_tree_model_row_deleted(gobj(), const_cast<GtkTreePath*>((path).gobj()));
+}
+
+void TreeModel::rows_reordered(const Path& path, const iterator& iter, int* new_order)
+{
+  gtk_tree_model_rows_reordered(gobj(), const_cast<GtkTreePath*>((path).gobj()), const_cast<GtkTreeIter*>((iter).gobj()), new_order);
+}
+
+Glib::ustring TreeModel::get_string(const iterator& iter) const
+{
+  return Glib::convert_return_gchar_ptr_to_ustring(gtk_tree_model_get_string_from_iter(const_cast<GtkTreeModel*>(gobj()), const_cast<GtkTreeIter*>((iter).gobj())));
+}
+
+
+Glib::SignalProxy2< void,const TreeModel::Path&,const TreeModel::iterator& > TreeModel::signal_row_changed()
+{
+  return Glib::SignalProxy2< void,const TreeModel::Path&,const TreeModel::iterator& >(this, &TreeModel_signal_row_changed_info);
+}
+
+Glib::SignalProxy2< void,const TreeModel::Path&,const TreeModel::iterator& > TreeModel::signal_row_inserted()
+{
+  return Glib::SignalProxy2< void,const TreeModel::Path&,const TreeModel::iterator& >(this, &TreeModel_signal_row_inserted_info);
+}
+
+Glib::SignalProxy2< void,const TreeModel::Path&,const TreeModel::iterator& > TreeModel::signal_row_has_child_toggled()
+{
+  return Glib::SignalProxy2< void,const TreeModel::Path&,const TreeModel::iterator& >(this, &TreeModel_signal_row_has_child_toggled_info);
+}
+
+Glib::SignalProxy1< void,const TreeModel::Path& > TreeModel::signal_row_deleted()
+{
+  return Glib::SignalProxy1< void,const TreeModel::Path& >(this, &TreeModel_signal_row_deleted_info);
+}
+
+Glib::SignalProxy3< void,const TreeModel::Path&,const TreeModel::iterator&,int* > TreeModel::signal_rows_reordered()
+{
+  return Glib::SignalProxy3< void,const TreeModel::Path&,const TreeModel::iterator&,int* >(this, &TreeModel_signal_rows_reordered_info);
+}
+
+
+void Gtk::TreeModel::on_row_changed(const TreeModel::Path& path, const TreeModel::iterator& iter)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->row_changed)
+    (*base->row_changed)(gobj(),const_cast<GtkTreePath*>((path).gobj()),const_cast<GtkTreeIter*>((iter).gobj()));
+}
+
+void Gtk::TreeModel::on_row_inserted(const TreeModel::Path& path, const TreeModel::iterator& iter)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->row_inserted)
+    (*base->row_inserted)(gobj(),const_cast<GtkTreePath*>((path).gobj()),const_cast<GtkTreeIter*>((iter).gobj()));
+}
+
+void Gtk::TreeModel::on_row_has_child_toggled(const TreeModel::Path& path, const TreeModel::iterator& iter)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->row_has_child_toggled)
+    (*base->row_has_child_toggled)(gobj(),const_cast<GtkTreePath*>((path).gobj()),const_cast<GtkTreeIter*>((iter).gobj()));
+}
+
+void Gtk::TreeModel::on_row_deleted(const TreeModel::Path& path)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->row_deleted)
+    (*base->row_deleted)(gobj(),const_cast<GtkTreePath*>((path).gobj()));
+}
+
+void Gtk::TreeModel::on_rows_reordered(const TreeModel::Path& path, const TreeModel::iterator& iter, int* new_order)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->rows_reordered)
+    (*base->rows_reordered)(gobj(),const_cast<GtkTreePath*>((path).gobj()),const_cast<GtkTreeIter*>((iter).gobj()),new_order);
+}
+
+
+TreeModelFlags Gtk::TreeModel::get_flags_vfunc() const
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->get_flags)
+    return ((TreeModelFlags)((*base->get_flags)(const_cast<GtkTreeModel*>(gobj()))));
+
+  typedef TreeModelFlags RType;
+  return RType();
+}
+
+int Gtk::TreeModel::get_n_columns_vfunc() const
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->get_n_columns)
+    return (*base->get_n_columns)(const_cast<GtkTreeModel*>(gobj()));
+
+  typedef int RType;
+  return RType();
+}
+
+GType Gtk::TreeModel::get_column_type_vfunc(int index) const
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->get_column_type)
+    return (*base->get_column_type)(const_cast<GtkTreeModel*>(gobj()),index);
+
+  typedef GType RType;
+  return RType();
+}
+
+bool Gtk::TreeModel::iter_has_child_vfunc(const iterator& iter) const
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->iter_has_child)
+    return (*base->iter_has_child)(const_cast<GtkTreeModel*>(gobj()),const_cast<GtkTreeIter*>((iter).gobj()));
+
+  typedef bool RType;
+  return RType();
+}
+
+void Gtk::TreeModel::ref_node_vfunc(const iterator& iter) const
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->ref_node)
+    (*base->ref_node)(const_cast<GtkTreeModel*>(gobj()),const_cast<GtkTreeIter*>((iter).gobj()));
+}
+
+void Gtk::TreeModel::unref_node_vfunc(const iterator& iter) const
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->unref_node)
+    (*base->unref_node)(const_cast<GtkTreeModel*>(gobj()),const_cast<GtkTreeIter*>((iter).gobj()));
+}
+
+TreeModel::Path Gtk::TreeModel::get_path_vfunc(const iterator& iter) const
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->get_path)
+    return Gtk::TreePath((*base->get_path)(const_cast<GtkTreeModel*>(gobj()),const_cast<GtkTreeIter*>((iter).gobj())), false);
+
+  typedef TreeModel::Path RType;
+  return RType();
+}
+
+void Gtk::TreeModel::get_value_vfunc(const iterator& iter, int column, Glib::ValueBase& value) const
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->get_value)
+    (*base->get_value)(const_cast<GtkTreeModel*>(gobj()),const_cast<GtkTreeIter*>((iter).gobj()),column,(value).gobj());
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/treemodel.h b/libs/gtkmm2/gtk/gtkmm/treemodel.h
new file mode 100644
index 0000000000..25e0eb92e3
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/treemodel.h
@@ -0,0 +1,597 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_TREEMODEL_H
+#define _GTKMM_TREEMODEL_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* Copyright (C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtk/gtktreemodel.h>
+#include <glibmm/interface.h>
+#include <gtkmm/treeiter.h>
+#include <gtkmm/treemodelcolumn.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkTreeModel GtkTreeModel;
+typedef struct _GtkTreeModelClass GtkTreeModelClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class TreeModel_Class; } // namespace Gtk
+namespace Gtk
+{
+
+class TreeModelSort;
+class TreePath;
+class TreeRowReference;
+
+
+/** @addtogroup gtkmmEnums Enums and Flags */
+
+/**
+ * @ingroup gtkmmEnums
+ * @par Bitwise operators:
+ * <tt>%TreeModelFlags operator|(TreeModelFlags, TreeModelFlags)</tt><br>
+ * <tt>%TreeModelFlags operator&(TreeModelFlags, TreeModelFlags)</tt><br>
+ * <tt>%TreeModelFlags operator^(TreeModelFlags, TreeModelFlags)</tt><br>
+ * <tt>%TreeModelFlags operator~(TreeModelFlags)</tt><br>
+ * <tt>%TreeModelFlags& operator|=(TreeModelFlags&, TreeModelFlags)</tt><br>
+ * <tt>%TreeModelFlags& operator&=(TreeModelFlags&, TreeModelFlags)</tt><br>
+ * <tt>%TreeModelFlags& operator^=(TreeModelFlags&, TreeModelFlags)</tt><br>
+ */
+enum TreeModelFlags
+{
+  TREE_MODEL_ITERS_PERSIST = 1 << 0,
+  TREE_MODEL_LIST_ONLY = 1 << 1
+};
+
+/** @ingroup gtkmmEnums */
+inline TreeModelFlags operator|(TreeModelFlags lhs, TreeModelFlags rhs)
+  { return static_cast<TreeModelFlags>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs)); }
+
+/** @ingroup gtkmmEnums */
+inline TreeModelFlags operator&(TreeModelFlags lhs, TreeModelFlags rhs)
+  { return static_cast<TreeModelFlags>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs)); }
+
+/** @ingroup gtkmmEnums */
+inline TreeModelFlags operator^(TreeModelFlags lhs, TreeModelFlags rhs)
+  { return static_cast<TreeModelFlags>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs)); }
+
+/** @ingroup gtkmmEnums */
+inline TreeModelFlags operator~(TreeModelFlags flags)
+  { return static_cast<TreeModelFlags>(~static_cast<unsigned>(flags)); }
+
+/** @ingroup gtkmmEnums */
+inline TreeModelFlags& operator|=(TreeModelFlags& lhs, TreeModelFlags rhs)
+  { return (lhs = static_cast<TreeModelFlags>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs))); }
+
+/** @ingroup gtkmmEnums */
+inline TreeModelFlags& operator&=(TreeModelFlags& lhs, TreeModelFlags rhs)
+  { return (lhs = static_cast<TreeModelFlags>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs))); }
+
+/** @ingroup gtkmmEnums */
+inline TreeModelFlags& operator^=(TreeModelFlags& lhs, TreeModelFlags rhs)
+  { return (lhs = static_cast<TreeModelFlags>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs))); }
+
+} // namespace Gtk
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Gtk::TreeModelFlags> : public Glib::Value_Flags<Gtk::TreeModelFlags>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{
+
+
+//TODO: Remove any mention of null arguments from the method documentation, by adding overrides in gtk_docs_override.xml.
+/** This class defines a generic tree interface for use by the Gtk::TreeView widget.
+ * @ingroup TreeView
+ *
+ * It is is designed to be usable with any appropriate data structure. The
+ * programmer just has to implement this interface on their own data type for
+ * it to be viewable by a Gtk::TreeView widget.
+ *
+ * The model is represented as a hierarchical tree of strongly-typed, columned
+ * data. In other words, the model can be seen as a tree where every node has
+ * different values depending on which column is being queried.  The type of
+ * data found in a column is determined by TreeModel::Column<> templates.
+ * The types are homogeneous per column across all nodes. It is important to note that this
+ * interface only provides a way of examining a model and observing changes.
+ * The implementation of each individual model decides how and if changes are
+ * made.
+ *
+ * In order to make life simpler for programmers who do not need to write their
+ * own specialized model, two generic models are provided - the Gtk::TreeStore
+ * and the Gtk::ListStore. To use these, the developer simply pushes data into
+ * these models as necessary. These models provide the data structure as well
+ * as all appropriate tree interfaces. As a result, implementing drag and drop,
+ * sorting, and storing data is trivial. For the vast majority of trees and
+ * lists, these two models are sufficient.
+ *
+ * Models are accessed on a node/column level of granularity. One can query for
+ * the value of a model at a certain node and a certain column on that node.
+ * There are two structures used to reference a particular node in a model.
+ * They are the @link Gtk::TreePath Path@endlink and the iterator. Most of the interface consists of
+ * operations on an @link Gtk::TreeIter iterator@endlink.
+ *
+ * A @link Gtk::TreePath Gtk::TreeModel::Path@endlink is essentially a potential node. It is a location on a model that may
+ * or may not actually correspond to a node on a specific model.
+ *
+ * By contrast, an @link Gtk::TreeIter Gtk::TreeModel::iterator@endlink  is a reference to a specific node on a specific
+ * model. One can convert a path to an @link Gtk::TreeIter iterator@endlink by calling Gtk::TreeModel::get_iter().
+ * These iterators are the primary way of accessing a model and are similar to the iterators
+ * used by Gtk::TextBuffer. The model interface defines a set of operations
+ * using them for navigating the model.
+ *
+ * The @link Gtk::TreeRowReference RowReference@endlink is also useful, because it remains
+ * valid as long as there is an existing row pointed to by it's path. You can convert between RowReferences and iterators and @link Gtk::TreePath Path@endlink s.
+ */
+
+class TreeModel : public Glib::Interface
+{
+  
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+public:
+  typedef TreeModel CppObjectType;
+  typedef TreeModel_Class CppClassType;
+  typedef GtkTreeModel BaseObjectType;
+  typedef GtkTreeModelIface BaseClassType;
+
+private:
+  friend class TreeModel_Class;
+  static CppClassType treemodel_class_;
+
+  // noncopyable
+  TreeModel(const TreeModel&);
+  TreeModel& operator=(const TreeModel&);
+
+protected:
+  TreeModel(); // you must derive from this class
+  explicit TreeModel(GtkTreeModel* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+  virtual ~TreeModel();
+
+  static void add_interface(GType gtype_implementer);
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GObject.
+  GtkTreeModel*       gobj()       { return reinterpret_cast<GtkTreeModel*>(gobject_); }
+
+  ///Provides access to the underlying C GObject.  
+  const GtkTreeModel* gobj() const { return reinterpret_cast<GtkTreeModel*>(gobject_); }
+
+private:
+
+  
+public:
+  typedef TreeModelColumnRecord ColumnRecord;
+
+  typedef TreeNodeChildren Children;
+  typedef Children::iterator iterator;
+  typedef Children::reverse_iterator reverse_iterator;
+  typedef Children::const_iterator const_iterator;
+  typedef Children::const_reverse_iterator const_reverse_iterator;
+  
+  typedef TreeRow Row;
+  typedef TreePath Path;
+  typedef TreeRowReference RowReference;
+  
+
+  //These are part of GtkTreeModelFilter or GtkTreeModelSort, not GtkTreeModel:
+  
+
+  /** Returns a valid iterator pointing to @a path.
+   *
+   * @param path The @link Gtk::TreePath Gtk::TreeModel::Path@endlink.
+   * @result A valid iterator pointing to the path, or an invalid iterator if that is not possible.
+   */
+  iterator get_iter(const Path& path);
+  //TODO: Add const_iterator get_iter(const Path& path) const;
+  //Implement a const_iterator?
+
+  /** Returns a valid iterator pointing to @a path_string.
+   *
+   * @param path_string The path, as a string representation.
+   * @result A valid iterator pointing to the path, or an invalid iterator if that is not possible.
+   */
+  iterator get_iter(const Glib::ustring& path_string);
+  //TODO: Implement a const_iterator? const_iterator get_iter(const Glib::ustring& path_string) const;
+
+  ///This returns an STL-like container API, for iterating over the rows.
+  Children children();
+
+  //TODO: Return a real TreeNodeChildren (a container of const_iterators), when we have a real const_iterator.
+  ///This returns an STL-like container API, for iterating over the rows.
+  Children children() const;
+
+  
+  /** For example,
+   * void on_foreach(const Gtk::TreeModel::iterator& iter);
+   *
+   * If the callback function returns true, then the tree ceases to be walked, and foreach() returns.
+   */
+  typedef sigc::slot<bool, const TreeModel::iterator&> SlotForeachIter;
+
+  /** Calls a callback slot on each node in the model in a depth-first fashion.
+   * If the callback function returns true, then the tree ceases to be walked, and foreach() returns.
+   *
+   * @param slot The function to call for each selected node.
+   */
+  void foreach_iter(const SlotForeachIter& slot);
+
+  /** For example,
+   * void on_foreach(const Gtk::TreeModel::Path& path);
+   *
+   * If the callback function returns true, then the tree ceases to be walked, and foreach() returns.
+   */
+  typedef sigc::slot<bool, const TreeModel::Path&> SlotForeachPath;
+
+  /** Calls a callback slot on each node in the model in a depth-first fashion.
+   * If the callback function returns true, then the tree ceases to be walked, and foreach() returns.
+   *
+   * @param slot The function to call for each selected node.
+   */
+  void foreach_path(const SlotForeachPath& slot);
+
+  /** For example,
+   * void on_foreach(const Gtk::TreeModel::Path& path, const Gtk::TreeModel::iterator& iter);
+   *
+   * If the callback function returns true, then the tree ceases to be walked, and foreach() returns.
+   */
+  typedef sigc::slot<bool, const TreeModel::Path&, const TreeModel::iterator&> SlotForeachPathAndIter;
+
+  /** Calls a callback slot on each node in the model in a depth-first fashion.
+   * If the callback function returns true, then the tree ceases to be walked, and foreach() returns.
+   *
+   * @param slot The function to call for each selected node.
+   */
+  void foreach(const SlotForeachPathAndIter& slot);
+
+  
+  /** Returns a set of flags supported by this interface.  The flags are a bitwise
+   * combination of Gtk::TreeModelFlags.  The flags supported should not change
+   * during the lifecycle of the tree_model.
+   * @return The flags supported by this interface.
+   */
+  TreeModelFlags get_flags() const;
+  
+  /** Returns the number of columns supported by @a tree_model .
+   * @return The number of columns.
+   */
+  int get_n_columns() const;
+  
+  /** Returns the type of the column.
+   * @param index The column index.
+   * @return The type of the column.
+   */
+  GType get_column_type(int index) const;
+  //TODO: A C++-type version of get_column_type()?
+  
+  
+  /** Returns a Gtk::TreePath referenced by @a iter .
+   * @param iter The Gtk::TreeIter.
+   * @return A Gtk::TreePath.
+   */
+  TreeModel::Path get_path(const iterator& iter) const;
+
+  
+  /** Emits the "row_changed" signal on @a tree_model .
+   * @param path A Gtk::TreePath pointing to the changed row.
+   * @param iter A valid Gtk::TreeIter pointing to the changed row.
+   */
+  void row_changed(const Path& path, const iterator& iter);
+  
+  /** Emits the "row_inserted" signal on @a tree_model 
+   * @param path A Gtk::TreePath pointing to the inserted row.
+   * @param iter A valid Gtk::TreeIter pointing to the inserted row.
+   */
+  void row_inserted(const Path& path, const iterator& iter);
+  
+  /** Emits the "row_has_child_toggled" signal on @a tree_model .  This should be
+   * called by models after the child state of a node changes.
+   * @param path A Gtk::TreePath pointing to the changed row.
+   * @param iter A valid Gtk::TreeIter pointing to the changed row.
+   */
+  void row_has_child_toggled(const Path& path, const iterator& iter);
+  
+  /** Emits the "row_deleted" signal on @a tree_model .  This should be called by
+   * models after a row has been removed.  The location pointed to by @a path  should
+   * be the location that the row previously was at.  It may not be a valid
+   * location anymore.
+   * @param path A Gtk::TreePath pointing to the previous location of the deleted row.
+   */
+  void row_deleted(const Path& path);
+
+  void rows_reordered(const Path& path, const iterator& iter, const Glib::ArrayHandle<int>& new_order);
+  
+  
+  /** Emits the "rows_reordered" signal on @a tree_model .  This should be called by
+   * models when their rows have been reordered.
+   * @param path A Gtk::TreePath pointing to the tree node whose children have been reordered.
+   * @param iter A valid Gtk::TreeIter pointing to the node whose children have been reordered.
+   * @param new_order An array of integers mapping the current position of each child
+   * to its old position before the re-ordering,
+   * i.e. @a new_order <tt>[newpos] = oldpos</tt>.
+   */
+  void rows_reordered(const Path& path, const iterator& iter, int* new_order);
+
+  
+  /** Generates a string representation of the iter. This string is a ':'
+   * separated list of numbers. For example, "4:10:0:3" would be an
+   * acceptable return value for this string.
+   * @param iter An Gtk::TreeIter.
+   * @return The string.
+   * 
+   * Since: 2.2.
+   */
+  Glib::ustring get_string(const iterator& iter) const;
+
+ 
+  Glib::SignalProxy2< void,const TreeModel::Path&,const TreeModel::iterator& > signal_row_changed();
+
+  
+  Glib::SignalProxy2< void,const TreeModel::Path&,const TreeModel::iterator& > signal_row_inserted();
+
+  
+  Glib::SignalProxy2< void,const TreeModel::Path&,const TreeModel::iterator& > signal_row_has_child_toggled();
+
+  
+  Glib::SignalProxy1< void,const TreeModel::Path& > signal_row_deleted();
+
+  
+  Glib::SignalProxy3< void,const TreeModel::Path&,const TreeModel::iterator&,int* > signal_rows_reordered();
+
+
+protected:
+    virtual TreeModelFlags get_flags_vfunc() const;
+    virtual int get_n_columns_vfunc() const;
+    virtual GType get_column_type_vfunc(int index) const;
+
+  //These are only for deriving new TreeModels, which isn't very common or easy:
+
+  /** Override and implement this in a derived TreeModel class.
+   * Sets @a iter_next to refer to the node following @a iter it at the current level.
+   * If there is no next iter, false is returned and iter_next is set to be invalid.
+   *
+   * @param iter An iterator.
+   * @param iter_next An iterator that will be set to refer to the next node, or will be set as invalid.
+   * @result true if the operation was possible.
+   */
+  virtual bool iter_next_vfunc(const iterator& iter, iterator& iter_next) const;
+
+  /** Override and implement this in a derived TreeModel class.
+   * Sets @a iter to a valid iterator pointing to @a path
+   *
+   * @param path An path to a node.
+   * @param iter An iterator that will be set to refer to a node to the path, or will be set as invalid.
+   * @result true if the operation was possible.
+   */
+  virtual bool get_iter_vfunc(const Path& path, iterator& iter) const;
+
+  /** Override and implement this in a derived TreeModel class.
+   * Sets @a iter to refer to the first child of @a parent. If @a parent has no children,
+   * false is returned and @a iter is set to be invalid.
+   *
+   * @param parent An iterator.
+   * @param iter An iterator that will be set to refer to the firt child node, or will be set as invalid.
+   * @result true if the operation was possible.
+   */
+  virtual bool iter_children_vfunc(const iterator& parent, iterator& iter) const;
+  
+  /** Override and implement this in a derived TreeModel class.
+   * Sets @a iter to be the parent of @a child. If @a child is at the toplevel, and
+   * doesn't have a parent, then @a iter is set to an invalid iterator and false
+   * is returned.
+   *
+   * @param child An iterator.
+   * @param iter An iterator that will be set to refer to the parent node, or will be set as invalid.
+   * @result true if the operation was possible.
+   */
+  virtual bool iter_parent_vfunc(const iterator& child, iterator& iter) const;
+
+  /** Override and implement this in a derived TreeModel class.
+   * Sets @a iter to be the child of @a parent using the given index.  The first
+   * index is 0.  If @a n is too big, or @a parent has no children, @a iter is set
+   * to an invalid iterator and false is returned.
+   * See also iter_nth_root_child_vfunc()
+   *
+   * @param parent An iterator.
+   * @param n The index of the child node to which @a iter should be set.
+   * @param iter An iterator that will be set to refer to the nth node, or will be set as invalid.
+   * @result true if the operation was possible.
+   */
+  virtual bool iter_nth_child_vfunc(const iterator& parent, int n, iterator& iter) const;
+
+   /** Override and implement this in a derived TreeModel class.
+   * Sets @a iter to be the child of at the root level using the given index.  The first
+   * index is 0.  If @a n is too big, or if there are no children, @a iter is set
+   * to an invalid iterator and false is returned.
+   * See also iter_nth_child_vfunc().
+   *
+   * @param n The index of the child node to which @a iter should be set.
+   * @param iter An iterator that will be set to refer to the nth node, or will be set as invalid.
+   * @result true if the operation was possible.
+   */
+  virtual bool iter_nth_root_child_vfunc(int n, iterator& iter) const;
+
+  
+  /** Override and implement this in a derived TreeModel class.
+   * Returns true if @a iter has children, false otherwise.
+   *
+   * @param iter The iterator to test for children.
+   * @result true if @a iter has children.
+   */
+    virtual bool iter_has_child_vfunc(const iterator& iter) const;
+
+  /** Override and implement this in a derived TreeModel class.
+   * Returns the number of children that @a iter has.
+   * See also iter_n_root_children_vfunc().  
+   *
+   * @param iter The iterator to test for children.
+   * @result The number of children of @a iter.
+   */
+  virtual int iter_n_children_vfunc(const iterator& iter) const;
+
+  /** Override and implement this in a derived TreeModel class.
+   * Returns the number of toplevel nodes.
+   * See also iter_n_children().
+   *
+   * @result The number of children at the root level.
+   */
+  virtual int iter_n_root_children_vfunc() const;
+
+  /** Override and implement this in a derived TreeModel class.
+   * Lets the tree ref the node.  This is an optional method for models to
+   * implement.  To be more specific, models may ignore this call as it exists
+   * primarily for performance reasons.
+   *
+   * This function is primarily meant as a way for views to let caching model know
+   * when nodes are being displayed (and hence, whether or not to cache that
+   * node.)  For example, a file-system based model would not want to keep the
+   * entire file-hierarchy in memory, just the sections that are currently being
+   * displayed by every current view.
+   *
+   * A model should be expected to be able to get an iter independent of its
+   * reffed state.
+   *
+   * @param iter the iterator.
+   */
+    virtual void ref_node_vfunc(const iterator& iter) const;
+
+  /** Override and implement this in a derived TreeModel class.
+   * Lets the tree unref the node.  This is an optional method for models to
+   * implement.  To be more specific, models may ignore this call as it exists
+   * primarily for performance reasons.
+   *
+   * For more information on what this means, see unref_node_vfunc().
+   * Please note that nodes that are deleted are not unreffed.
+   *
+   * @param iter the iterator.
+   */
+    virtual void unref_node_vfunc(const iterator& iter) const;
+
+  /** Override and implement this in a derived TreeModel class.
+   * Returns a Path referenced by @a iter.
+   *
+   * @param iter The iterator.
+   * @result The path.
+   */
+ 
+
+    virtual TreeModel::Path get_path_vfunc(const iterator& iter) const;
+
+  /** Override and implement this in a derived TreeModel class.
+   * Initializes and sets @a value to that at @a column.
+   *
+   * @param iter The iterator.
+   * @param column The column to lookup the value at.
+   * @param value An empty Glib:Value to set.
+   */
+    virtual void get_value_vfunc(const iterator& iter, int column, Glib::ValueBase& value) const;
+
+  /** Override and implement this in a derived TreeModel class.
+   * @note This virtual method is <em>deprecated</em>.  If you want to check
+   * whether an iterator is valid, call TreeStore::iter_is_valid(),
+   * ListStore::iter_is_valid() or TreeModelSort::iter_is_valid() directly
+   * instead.  Because these methods are intended to be used only for debugging
+   * and/or testing purposes, it doesn't make sense to provide an abstract
+   * interface to them.
+   *
+   * @result true if the iterator is valid.
+   *
+   * @deprecated Use iter_is_valid() in the derived class.
+   */
+  virtual bool iter_is_valid(const iterator& iter) const;
+
+  //Called by TreeRow, which is a friend class:
+  //The comment about set_row_changed() in the documentation is based on my reading of the source of
+  //gtk_list_store_set_value() and gtk_tree_store_set_value().  
+  /** Override and implement this in a derived TreeModel class, so that Row::operator() and
+   * Row::set_value() work.
+   * You can probably just implement this by calling set_value_vfunc().
+   * Your implementation of set_value_impl() should also call set_row_changed() after changing the value.
+   */
+  virtual void set_value_impl(const iterator& row, int column, const Glib::ValueBase& value);
+
+  //This might not need to be virtual, but it's not a big deal. murrayc.
+  virtual void get_value_impl(const iterator& row, int column, Glib::ValueBase& value) const;
+
+  friend class Gtk::TreeModelSort;
+  friend class Gtk::TreeRow;
+  friend class Gtk::TreeIter;
+
+
+public:
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+  virtual void on_row_changed(const TreeModel::Path& path, const TreeModel::iterator& iter);
+  virtual void on_row_inserted(const TreeModel::Path& path, const TreeModel::iterator& iter);
+  virtual void on_row_has_child_toggled(const TreeModel::Path& path, const TreeModel::iterator& iter);
+  virtual void on_row_deleted(const TreeModel::Path& path);
+  virtual void on_rows_reordered(const TreeModel::Path& path, const TreeModel::iterator& iter, int* new_order);
+
+
+};
+
+} // namespace Gtk
+
+
+namespace Glib
+{
+  /** @relates Gtk::TreeModel
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Glib::RefPtr<Gtk::TreeModel> wrap(GtkTreeModel* object, bool take_copy = false);
+
+} // namespace Glib
+
+#endif /* _GTKMM_TREEMODEL_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/treemodelcolumn.cc b/libs/gtkmm2/gtk/gtkmm/treemodelcolumn.cc
new file mode 100644
index 0000000000..0cf6986018
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/treemodelcolumn.cc
@@ -0,0 +1,68 @@
+/* $Id$ */
+
+/* Copyright (c) 2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/treemodelcolumn.h>
+
+
+namespace Gtk
+{
+
+/**** Gtk::TreeModelColumnRecord *******************************************/
+
+TreeModelColumnRecord::TreeModelColumnRecord()
+:
+  column_types_ ()
+{}
+
+TreeModelColumnRecord::~TreeModelColumnRecord()
+{}
+
+void TreeModelColumnRecord::add(TreeModelColumnBase& column)
+{
+  g_return_if_fail(column.index_ == -1); //Check that it hasn't been set before.
+
+  column.index_ = column_types_.size();
+  column_types_.push_back(column.type_);
+}
+
+unsigned int TreeModelColumnRecord::size() const
+{
+  return column_types_.size();
+}
+
+const GType* TreeModelColumnRecord::types() const
+{
+  g_return_val_if_fail(!column_types_.empty(), 0);
+
+  // According to Josuttis' book, &vector.front() to get a builtin array is
+  // quasi-standard. It should work fine with any std::vector implementation.
+  return &column_types_.front();
+}
+
+
+/**** Gtk::TreeModelColumnBase *********************************************/
+
+TreeModelColumnBase::TreeModelColumnBase(GType type)
+:
+  type_  (type),
+  index_ (-1) //default to an invalid index.
+{}
+
+} // namespace Gtk
+
diff --git a/libs/gtkmm2/gtk/gtkmm/treemodelcolumn.h b/libs/gtkmm2/gtk/gtkmm/treemodelcolumn.h
new file mode 100644
index 0000000000..1ff824c9c9
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/treemodelcolumn.h
@@ -0,0 +1,145 @@
+#ifndef _GTKMM_TREEMODELCOLUMN_H
+#define _GTKMM_TREEMODELCOLUMN_H
+/* $Id$ */
+
+/* Copyright (c) 2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <glib-object.h>
+#include <glibmm/value.h>
+
+#include <vector>
+#include <gtkmmconfig.h>
+
+GLIBMM_USING_STD(vector)
+
+
+namespace Gtk
+{
+
+class TreeModelColumnBase;
+
+
+/** Typedefed as TreeModel::ColumnRecord.
+ * Keeps a record of @link TreeModelColumn TreeModelColumns@endlink.
+ * @ingroup TreeView
+ * ColumnRecord objects are used to setup a new instance of a TreeModel
+ * (or rather, a new instance of an implementation of the model, such as Gtk::ListStore
+ * or Gtk::TreeStore).  It is convenient to do that by deriving from
+ * TreeModel::ColumnRecord:
+ * @code
+ * class MyModelColumns : public Gtk::TreeModel::ColumnRecord
+ * {
+ * public:
+ *   Gtk::TreeModelColumn<Glib::ustring>                filename;
+ *   Gtk::TreeModelColumn<Glib::ustring>                description;
+ *   Gtk::TreeModelColumn< Glib::RefPtr<Gdk::Pixbuf> >  thumbnail;
+ *
+ *   MyModelColumns() { add(filename); add(description); add(thumbnail); }
+ * };
+ * @endcode
+ *
+ * Whether or not you derive your own ColumnRecord, you need to add the
+ * @link TreeModelColumn TreeModelColumns@endlink to the ColumnRecord with the
+ * add() method.
+ *
+ * A ColumnRecord instance, such as an instance of @c MyModelColumns should then
+ * be passed to ListStore::create() or TreeStore::create().
+ * The @link TreeModelColumn TreeModelColumns@endlink, such as the members
+ * @c filename, @c description and @c thumbnail can then be used with Gtk::TreeRow::operator[]()
+ * to specify the column you're interested in.
+ *
+ * Neither TreeModel::ColumnRecord nor the
+ * @link TreeModelColumn TreeModelColumns@endlink contain any real data --
+ * they merely describe what C++ type is stored in which column
+ * of a TreeModel, and save you from having to repeat that type information in several places.
+ * Thus it's absolutely legal to use a statically allocated
+ * TreeModel::ColumnRecord (as long as you make sure it's instantiated after
+ * Gtk::Main), even when creating multiple models from it.
+ */
+class TreeModelColumnRecord
+{
+public:
+  TreeModelColumnRecord();
+  virtual ~TreeModelColumnRecord();
+
+  /** Adds a TreeModelColumn to this record.
+   * add() not only registers the @a column, but also assigns a column
+   * index to it.  Once registered, the TreeModelColumn is final, and
+   * you're free to pass it around by value.
+   */
+  void add(TreeModelColumnBase& column);
+  
+  unsigned int size()  const;
+  const GType* types() const;
+
+private:
+  std::vector<GType> column_types_;
+
+  // noncopyable
+  TreeModelColumnRecord(const TreeModelColumnRecord&);
+  TreeModelColumnRecord& operator=(const TreeModelColumnRecord&);
+};
+
+
+/** Base class of TreeModelColumn templates.
+ * @ingroup TreeView
+ */
+class TreeModelColumnBase
+{
+public:
+  GType type()  const { return type_;  }
+  int index() const { return index_; }
+
+protected:
+  explicit TreeModelColumnBase(GType type);
+
+private:
+  GType type_;
+  int   index_;
+
+  friend class Gtk::TreeModelColumnRecord;
+};
+
+/** @relates Gtk::TreeModelColumnBase */
+inline bool operator==(const TreeModelColumnBase& lhs, const TreeModelColumnBase& rhs)
+  { return (lhs.index() == rhs.index()); }
+
+/** @relates Gtk::TreeModelColumnBase */
+inline bool operator!=(const TreeModelColumnBase& lhs, const TreeModelColumnBase& rhs)
+  { return (lhs.index() != rhs.index()); }
+
+
+/** A Gtk::TreeModelColumn describes the C++ type of the data in a model column, and identifies that column in the model.
+ * See @link TreeModelColumnRecord Gtk::TreeModel::Columns@endlink for a usage example.
+ * @ingroup TreeView
+ */
+template <class T>
+class TreeModelColumn : public TreeModelColumnBase
+{
+public:
+  typedef T               ElementType;
+  typedef Glib::Value<T>  ValueType;
+
+  TreeModelColumn() : TreeModelColumnBase(ValueType::value_type()) {}
+};
+
+} // namespace Gtk
+
+
+#endif /* _GTKMM_TREEMODELCOLUMN_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/treemodelfilter.cc b/libs/gtkmm2/gtk/gtkmm/treemodelfilter.cc
new file mode 100644
index 0000000000..08670fb795
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/treemodelfilter.cc
@@ -0,0 +1,374 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/treemodelfilter.h>
+#include <gtkmm/private/treemodelfilter_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtk/gtktreemodelfilter.h>
+
+namespace //anonymous
+{
+
+// This Signal Proxy allows the C++ coder to specify
+// a sigc::slot instead of a static function.
+class SignalProxy_Visible
+{
+public:
+  typedef Gtk::TreeModelFilter::SlotVisible SlotType;
+
+  SignalProxy_Visible(const SlotType& slot)
+  : slot_(slot) {}
+
+  ~SignalProxy_Visible();
+
+  static gboolean gtk_callback(GtkTreeModel* model, GtkTreeIter* iter, gpointer data);
+  static void gtk_callback_destroy(void* data);
+
+private:
+  SlotType slot_;
+};
+
+SignalProxy_Visible::~SignalProxy_Visible()
+{}
+
+gboolean SignalProxy_Visible::gtk_callback(GtkTreeModel* model, GtkTreeIter* iter, gpointer data)
+{
+  SignalProxy_Visible *const self = static_cast<SignalProxy_Visible*>(data);
+
+  try
+  {
+    return (self->slot_)( Gtk::TreeModel::const_iterator(model, iter) );
+  }
+  catch(...)
+  {
+    Glib::exception_handlers_invoke();
+  }
+
+  return FALSE; //An arbitary default, just to avoid the compiler warning.
+}
+
+void SignalProxy_Visible::gtk_callback_destroy(void* data)
+{
+  delete static_cast<SignalProxy_Visible*>(data);
+}
+
+
+// This Signal Proxy allows the C++ coder to specify
+// a sigc::slot instead of a static function.
+class SignalProxy_Modify
+{
+public:
+  typedef Gtk::TreeModelFilter::SlotModify SlotType;
+
+  SignalProxy_Modify(const SlotType& slot)
+  : slot_(slot) {}
+
+  ~SignalProxy_Modify();
+
+  static void gtk_callback(GtkTreeModel* model, GtkTreeIter* iter, GValue* value, gint column, gpointer data);
+  static void gtk_callback_destroy(void* data);
+
+private:
+  SlotType slot_;
+};
+
+SignalProxy_Modify::~SignalProxy_Modify()
+{}
+
+void SignalProxy_Modify::gtk_callback(GtkTreeModel* model, GtkTreeIter* iter, GValue* value, gint column, gpointer data)
+{
+  SignalProxy_Modify *const self = static_cast<SignalProxy_Modify*>(data);
+
+  try
+  {
+    //Initialize the input parameter with the appropriate type for this column.
+    //Then the C++ handler can just use operator==() without calling init on the value output arg:
+    Glib::ValueBase cppValue;
+    GType column_type = gtk_tree_model_get_column_type(model, column);
+    cppValue.init(column_type);
+    
+    (self->slot_)( Gtk::TreeModel::const_iterator(model, iter), cppValue, column );
+
+    //GTK+ has already done this for us: g_value_init(value, column_type);
+
+    //If the C++ handler has inited value with an inappropriate GType, then this will fail,
+    //but they should not do that because it makes no sense.
+    g_value_copy(cppValue.gobj() /* source */, value /* destination */);  
+  }
+  catch(...)
+  {
+    Glib::exception_handlers_invoke();
+  }
+}
+
+void SignalProxy_Modify::gtk_callback_destroy(void* data)
+{
+  delete static_cast<SignalProxy_Modify*>(data);
+}
+
+
+} // anonymous namespace
+
+
+typedef Gtk::TreeModel::Path Path; //So that the generated method implemenations can use this a return type.
+
+namespace Gtk
+{
+
+TreeModelFilter::TreeModelFilter(const Glib::RefPtr<TreeModel>& child_model)
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Glib::Object(Glib::ConstructParams(treemodelfilter_class_.init(), "child_model",child_model->gobj(), (char*) 0))
+{
+}
+
+TreeModelFilter::TreeModelFilter(const Glib::RefPtr<TreeModel>& child_model, const TreeModel::Path& virtual_root)
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Glib::Object(Glib::ConstructParams(treemodelfilter_class_.init(), "child_model",child_model->gobj(),"virtual_root",(virtual_root.empty() ? 0 : const_cast<GtkTreePath*>((virtual_root).gobj())) , (char*) 0))
+{
+}
+
+void TreeModelFilter::set_visible_func(const SlotVisible& slot)
+{
+  // Create a signal proxy.  A pointer to this will be passed
+  // through the callback's data parameter.  It will be deleted
+  // when SignalProxy_Visible::gtk_callback_destroy() is called.
+  SignalProxy_Visible *const pSignalProxy = new SignalProxy_Visible(slot);
+
+  gtk_tree_model_filter_set_visible_func(gobj(),
+      &SignalProxy_Visible::gtk_callback, pSignalProxy,
+      &SignalProxy_Visible::gtk_callback_destroy);
+}
+
+
+TreeModel::iterator TreeModelFilter::convert_child_iter_to_iter(const iterator& child_iter) const
+{
+  TreeIter filter_iter (const_cast<TreeModelFilter*>(this));
+
+  gtk_tree_model_filter_convert_child_iter_to_iter(
+      const_cast<GtkTreeModelFilter*>(gobj()), filter_iter.gobj(),
+      const_cast<GtkTreeIter*>(child_iter.gobj()));
+
+  return filter_iter;
+}
+
+TreeModel::iterator TreeModelFilter::convert_iter_to_child_iter(const iterator& filter_iter) const
+{
+  GtkTreeModel *const child_model = gtk_tree_model_filter_get_model(const_cast<GtkTreeModelFilter*>(gobj()));
+
+  TreeIter child_iter (dynamic_cast<TreeModel*>(Glib::wrap_auto((GObject*) child_model, false)));
+
+  gtk_tree_model_filter_convert_iter_to_child_iter(
+      const_cast<GtkTreeModelFilter*>(gobj()), child_iter.gobj(),
+      const_cast<GtkTreeIter*>(filter_iter.gobj()));
+
+  return child_iter;
+}
+
+void TreeModelFilter::set_modify_func(const TreeModelColumnRecord& columns, const SlotModify& slot)
+{
+  // Create a signal proxy.  A pointer to this will be passed
+  // through the callback's data parameter.  It will be deleted
+  // when SignalProxy_Modify::gtk_callback_destroy() is called.
+  SignalProxy_Modify *const pSignalProxy = new SignalProxy_Modify(slot);
+
+  gtk_tree_model_filter_set_modify_func(gobj(),
+    columns.size(), const_cast<GType*>(columns.types()),
+    &SignalProxy_Modify::gtk_callback, pSignalProxy,
+    &SignalProxy_Modify::gtk_callback_destroy);
+}
+
+void TreeModelFilter::set_value_impl(const iterator& /* row */, int /* column */, const Glib::ValueBase& /* value */)
+{
+  g_warning("Attempt to set a value of a row in a TreeModelFilter instead of in the child model.");
+}
+
+
+} // namespace Gtk
+
+
+namespace
+{
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Glib::RefPtr<Gtk::TreeModelFilter> wrap(GtkTreeModelFilter* object, bool take_copy)
+{
+  return Glib::RefPtr<Gtk::TreeModelFilter>( dynamic_cast<Gtk::TreeModelFilter*> (Glib::wrap_auto ((GObject*)(object), take_copy)) );
+  //We use dynamic_cast<> in case of multiple inheritance.
+}
+
+} /* namespace Glib */
+
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& TreeModelFilter_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &TreeModelFilter_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_tree_model_filter_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  TreeModel::add_interface(get_type());
+  }
+
+  return *this;
+}
+
+void TreeModelFilter_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+}
+
+
+Glib::ObjectBase* TreeModelFilter_Class::wrap_new(GObject* object)
+{
+  return new TreeModelFilter((GtkTreeModelFilter*)object);
+}
+
+
+/* The implementation: */
+
+GtkTreeModelFilter* TreeModelFilter::gobj_copy()
+{
+  reference();
+  return gobj();
+}
+
+TreeModelFilter::TreeModelFilter(const Glib::ConstructParams& construct_params)
+:
+  Glib::Object(construct_params)
+{}
+
+TreeModelFilter::TreeModelFilter(GtkTreeModelFilter* castitem)
+:
+  Glib::Object((GObject*)(castitem))
+{}
+
+TreeModelFilter::~TreeModelFilter()
+{}
+
+
+TreeModelFilter::CppClassType TreeModelFilter::treemodelfilter_class_; // initialize static member
+
+GType TreeModelFilter::get_type()
+{
+  return treemodelfilter_class_.init().get_type();
+}
+
+GType TreeModelFilter::get_base_type()
+{
+  return gtk_tree_model_filter_get_type();
+}
+
+
+Glib::RefPtr<TreeModelFilter> TreeModelFilter::create(const Glib::RefPtr<TreeModel>& child_model)
+{
+  return Glib::RefPtr<TreeModelFilter>( new TreeModelFilter(child_model) );
+}
+Glib::RefPtr<TreeModelFilter> TreeModelFilter::create(const Glib::RefPtr<TreeModel>& child_model, const TreeModel::Path& virtual_root)
+{
+  return Glib::RefPtr<TreeModelFilter>( new TreeModelFilter(child_model, virtual_root) );
+}
+void TreeModelFilter::set_visible_column(const TreeModelColumnBase& column)
+{
+  gtk_tree_model_filter_set_visible_column(gobj(), (column).index());
+}
+
+void TreeModelFilter::set_visible_column(int column)
+{
+  gtk_tree_model_filter_set_visible_column(gobj(), column);
+}
+
+Glib::RefPtr<TreeModel> TreeModelFilter::get_model()
+{
+
+  Glib::RefPtr<TreeModel> retvalue = Glib::wrap(gtk_tree_model_filter_get_model(gobj()));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::RefPtr<const TreeModel> TreeModelFilter::get_model() const
+{
+
+  Glib::RefPtr<const TreeModel> retvalue = Glib::wrap(gtk_tree_model_filter_get_model(const_cast<GtkTreeModelFilter*>(gobj())));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Path TreeModelFilter::convert_child_path_to_path(const Path& child_path)
+{
+  return Gtk::TreePath(gtk_tree_model_filter_convert_child_path_to_path(gobj(), const_cast<GtkTreePath*>((child_path).gobj())), false);
+}
+
+Path TreeModelFilter::convert_path_to_child_path(const Path& filter_path)
+{
+  return Gtk::TreePath(gtk_tree_model_filter_convert_path_to_child_path(gobj(), const_cast<GtkTreePath*>((filter_path).gobj())), false);
+}
+
+Path TreeModelFilter::convert_child_path_to_path(const Path& child_path) const
+{
+  return Gtk::TreePath(gtk_tree_model_filter_convert_child_path_to_path(const_cast<GtkTreeModelFilter*>(gobj()), const_cast<GtkTreePath*>((child_path).gobj())), false);
+}
+
+Path TreeModelFilter::convert_path_to_child_path(const Path& filter_path) const
+{
+  return Gtk::TreePath(gtk_tree_model_filter_convert_path_to_child_path(const_cast<GtkTreeModelFilter*>(gobj()), const_cast<GtkTreePath*>((filter_path).gobj())), false);
+}
+
+void TreeModelFilter::refilter()
+{
+  gtk_tree_model_filter_refilter(gobj());
+}
+
+void TreeModelFilter::clear_cache()
+{
+  gtk_tree_model_filter_clear_cache(gobj());
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/treemodelfilter.h b/libs/gtkmm2/gtk/gtkmm/treemodelfilter.h
new file mode 100644
index 0000000000..66ddb7dc90
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/treemodelfilter.h
@@ -0,0 +1,303 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_TREEMODELFILTER_H
+#define _GTKMM_TREEMODELFILTER_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* Copyright(C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/treeiter.h>
+#include <gtkmm/treemodel.h>
+// We couldn't include it in treemodel.h, but doing it here makes it easier for people.
+#include <gtkmm/treepath.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkTreeModelFilter GtkTreeModelFilter;
+typedef struct _GtkTreeModelFilterClass GtkTreeModelFilterClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class TreeModelFilter_Class; } // namespace Gtk
+namespace Gtk
+{
+
+/** 
+ * @ingroup TreeView
+ * 
+ */
+
+class TreeModelFilter :
+  public Glib::Object,
+  public TreeModel
+{
+  
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+public:
+  typedef TreeModelFilter CppObjectType;
+  typedef TreeModelFilter_Class CppClassType;
+  typedef GtkTreeModelFilter BaseObjectType;
+  typedef GtkTreeModelFilterClass BaseClassType;
+
+private:  friend class TreeModelFilter_Class;
+  static CppClassType treemodelfilter_class_;
+
+private:
+  // noncopyable
+  TreeModelFilter(const TreeModelFilter&);
+  TreeModelFilter& operator=(const TreeModelFilter&);
+
+protected:
+  explicit TreeModelFilter(const Glib::ConstructParams& construct_params);
+  explicit TreeModelFilter(GtkTreeModelFilter* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+  virtual ~TreeModelFilter();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GObject.
+  GtkTreeModelFilter*       gobj()       { return reinterpret_cast<GtkTreeModelFilter*>(gobject_); }
+
+  ///Provides access to the underlying C GObject.
+  const GtkTreeModelFilter* gobj() const { return reinterpret_cast<GtkTreeModelFilter*>(gobject_); }
+
+  ///Provides access to the underlying C instance. The caller is responsible for unrefing it. Use when directly setting fields in structs.
+  GtkTreeModelFilter* gobj_copy();
+
+private:
+
+  
+protected:
+
+  explicit TreeModelFilter(const Glib::RefPtr<TreeModel>& child_model);
+  explicit TreeModelFilter(const Glib::RefPtr<TreeModel>& child_model, const TreeModel::Path& virtual_root);
+  
+
+public:
+
+  /** This creates a TreeModelFilter with @a child_model as the child model.
+   * You can use set_visible_func(), set_visible_column() and/or set_modify_func() to change the mapping of child
+   * model to parent model.
+   */
+  
+  static Glib::RefPtr<TreeModelFilter> create(const Glib::RefPtr<TreeModel>& child_model);
+
+
+  /** This creates a TreeModelFilter with @a child_model as the child model, and @a root as the virtual root.
+   * You can use set_visible_func(), set_visible_column() and/or set_modify_func() to change the mapping of child
+   * model to parent model.
+   */
+  
+  static Glib::RefPtr<TreeModelFilter> create(const Glib::RefPtr<TreeModel>& child_model, const TreeModel::Path& virtual_root);
+
+
+  /** For instance,
+   * bool on_visible(const TreeModel::const_iterator& iter);
+   * This should return true if the given row should be visible and false otherwise.
+   */                                     
+  typedef sigc::slot<bool, const TreeModel::const_iterator&> SlotVisible;
+
+  /** Sets the "visible" callback used when filtering the filter.
+   * The callback function should return true if the given row should be visible and false otherwise.
+   *
+   * @param slot A callback slot which determines whether the row should be visible.
+   */
+  void set_visible_func(const SlotVisible& slot);
+  
+
+  //TODO: It would be nicer to use "const TreeModelColumnBase& column" instead of "int column",
+  //but how can we get the TreeModelColumnBase from the int in the SignalProxy?
+  //Maybe we could pass the ColumnsRecord to set_modify_func() and store it in the proxy? murrayc.
+  /** For instance,
+   *   void on_modify(const Gtk::TreeModel::iterator& iter, Glib::ValueBase& value, int column);
+   *
+   * where iter is an iterator to a row in the child model,
+   * value is an output parameter in which you must store the value to be used in the parent model's row,
+   * column is the column in the parent row whose row value you must provide in the value output paramater.
+   */
+  typedef sigc::slot<void, const Gtk::TreeModel::iterator& /* iter */, Glib::ValueBase& /* value */, int /* column */> SlotModify;
+
+  /** Specify columns that will be provided by this model, and a callback that will provide data for these 
+   * columns based on data in the columns of the child model.
+   * The modify function will get called for each data access.
+   *
+   * @param columns Column types for this model (which will be exposed to the parent model/view).
+   * @param slot A callback which will be called for each data access.
+   */
+  void set_modify_func(const TreeModelColumnRecord& columns, const SlotModify& slot);
+  
+ 
+  /** Sets @a column  of the child_model to be the column where @a filter  should
+   * look for visibility information. @a columns  should be a column of type
+   * G::TYPE_BOOLEAN, where <tt>true</tt> means that a row is visible, and <tt>false</tt>
+   * if not.
+   * 
+   * Since: 2.4
+   * @param column A <tt>int</tt> which is the column containing the visible information.
+   */
+  void set_visible_column(const TreeModelColumnBase& column);
+  
+  /** Sets @a column  of the child_model to be the column where @a filter  should
+   * look for visibility information. @a columns  should be a column of type
+   * G::TYPE_BOOLEAN, where <tt>true</tt> means that a row is visible, and <tt>false</tt>
+   * if not.
+   * 
+   * Since: 2.4
+   * @param column A <tt>int</tt> which is the column containing the visible information.
+   */
+  void set_visible_column(int column);
+
+  
+  /** Returns a pointer to the child model of @a filter .
+   * @return A pointer to a Gtk::TreeModel.
+   * 
+   * Since: 2.4.
+   */
+  Glib::RefPtr<TreeModel> get_model();
+  
+  /** Returns a pointer to the child model of @a filter .
+   * @return A pointer to a Gtk::TreeModel.
+   * 
+   * Since: 2.4.
+   */
+  Glib::RefPtr<const TreeModel> get_model() const;
+
+  /** Gets an iterator that points to the sorted row that corresponds to the child row pointed at by child_iter.
+   *
+   * @param child_iter A valid iterator pointing to a row on the child model.
+   * @result A valid iterator that points to the row in this sorted model.
+   */
+  iterator convert_child_iter_to_iter(const iterator& child_iter) const;
+
+  /** Gets an iterator that points to the child row that corresponds to the sorted row pointed at by sorted_iter.
+   *
+   * @param filter_iter A valid iterator pointing to a row on the sorted model.
+   * @result A valid iterator that points to the row in the child model.
+   */
+  iterator convert_iter_to_child_iter(const iterator& filter_iter) const;
+
+  //TODO: Remove these deprecated non-const versions when we can break ABI:
+  
+  /** Converts @a child_path  to a path relative to @a filter . That is, @a child_path 
+   * points to a path in the child model. The rerturned path will point to the
+   * same row in the filtered model. If @a child_path  isn't a valid path on the
+   * child model, then <tt>0</tt> is returned.
+   * @param child_path A Gtk::TreePath to convert.
+   * @return A newly allocated Gtk::TreePath, or <tt>0</tt>.
+   * 
+   * Since: 2.4.
+   */
+  Path convert_child_path_to_path(const Path& child_path);
+  
+  /** Converts @a filter_path  to a path on the child model of @a filter . That is,
+   *  @a filter_path  points to a location in @a filter . The returned path will
+   * point to the same location in the model not being filtered. If @a filter_path 
+   * does not point to a location in the child model, <tt>0</tt> is returned.
+   * @param filter_path A Gtk::TreePath to convert.
+   * @return A newly allocated Gtk::TreePath, or <tt>0</tt>.
+   * 
+   * Since: 2.4.
+   */
+  Path convert_path_to_child_path(const Path& filter_path);
+
+  
+  /** Converts @a child_path  to a path relative to @a filter . That is, @a child_path 
+   * points to a path in the child model. The rerturned path will point to the
+   * same row in the filtered model. If @a child_path  isn't a valid path on the
+   * child model, then <tt>0</tt> is returned.
+   * @param child_path A Gtk::TreePath to convert.
+   * @return A newly allocated Gtk::TreePath, or <tt>0</tt>.
+   * 
+   * Since: 2.4.
+   */
+  Path convert_child_path_to_path(const Path& child_path) const;
+  
+  /** Converts @a filter_path  to a path on the child model of @a filter . That is,
+   *  @a filter_path  points to a location in @a filter . The returned path will
+   * point to the same location in the model not being filtered. If @a filter_path 
+   * does not point to a location in the child model, <tt>0</tt> is returned.
+   * @param filter_path A Gtk::TreePath to convert.
+   * @return A newly allocated Gtk::TreePath, or <tt>0</tt>.
+   * 
+   * Since: 2.4.
+   */
+  Path convert_path_to_child_path(const Path& filter_path) const;
+
+  
+  /** Emits ::row_changed for each row in the child model, which causes
+   * the filter to re-evaluate whether a row is visible or not.
+   * 
+   * Since: 2.4
+   */
+  void refilter();
+  
+  /** This function should almost never be called. It clears the @a filter 
+   * of any cached iterators that haven't been reffed with
+   * ref_node(). This might be useful if the child model
+   * being filtered is static (and doesn't change often) and there has been
+   * a lot of unreffed access to nodes. As a side effect of this function,
+   * all unreffed itters will be invalid.
+   * 
+   * Since: 2.4
+   */
+  void clear_cache();
+
+protected:
+  virtual void set_value_impl(const iterator& row, int column, const Glib::ValueBase& value);
+
+
+public:
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+};
+
+} // namespace Gtk
+
+
+namespace Glib
+{
+  /** @relates Gtk::TreeModelFilter
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Glib::RefPtr<Gtk::TreeModelFilter> wrap(GtkTreeModelFilter* object, bool take_copy = false);
+}
+
+
+#endif /* _GTKMM_TREEMODELFILTER_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/treemodelsort.cc b/libs/gtkmm2/gtk/gtkmm/treemodelsort.cc
new file mode 100644
index 0000000000..00964ef5e0
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/treemodelsort.cc
@@ -0,0 +1,230 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/treemodelsort.h>
+#include <gtkmm/private/treemodelsort_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtk/gtktreemodelsort.h>
+
+
+typedef Gtk::TreeModel::Path Path; //So that the generated method implemenations can use this a return type.
+
+namespace Gtk
+{
+
+TreeModel::iterator TreeModelSort::convert_child_iter_to_iter(const iterator& child_iter) const
+{
+  TreeIter sorted_iter (const_cast<TreeModelSort*>(this));
+
+  gtk_tree_model_sort_convert_child_iter_to_iter(
+      const_cast<GtkTreeModelSort*>(gobj()), sorted_iter.gobj(),
+      const_cast<GtkTreeIter*>(child_iter.gobj()));
+
+  return sorted_iter;
+}
+
+TreeModel::iterator TreeModelSort::convert_iter_to_child_iter(const iterator& sorted_iter) const
+{
+  GtkTreeModel *const child_model = gtk_tree_model_sort_get_model(const_cast<GtkTreeModelSort*>(gobj()));
+
+  TreeIter child_iter (dynamic_cast<TreeModel*>(Glib::wrap_auto((GObject*) child_model, false)));
+
+  gtk_tree_model_sort_convert_iter_to_child_iter(
+      const_cast<GtkTreeModelSort*>(gobj()), child_iter.gobj(),
+      const_cast<GtkTreeIter*>(sorted_iter.gobj()));
+
+  return child_iter;
+}
+
+void TreeModelSort::set_value_impl(const iterator& row, int column, const Glib::ValueBase& value)
+{
+  // Avoid two extra ref/unref cycles -- we don't store the child
+  // model pointer anywhere, so it's OK to do this _internally_.
+
+  TreeModel *const child_model = dynamic_cast<TreeModel*>(
+      Glib::wrap_auto((GObject*) gtk_tree_model_sort_get_model(gobj()), false));
+
+  TreeIter child_iter (child_model);
+
+  gtk_tree_model_sort_convert_iter_to_child_iter(
+      gobj(), child_iter.gobj(), const_cast<GtkTreeIter*>(row.gobj()));
+
+  child_model->set_value_impl(child_iter, column, value);
+}
+
+} // namespace Gtk
+
+
+namespace
+{
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Glib::RefPtr<Gtk::TreeModelSort> wrap(GtkTreeModelSort* object, bool take_copy)
+{
+  return Glib::RefPtr<Gtk::TreeModelSort>( dynamic_cast<Gtk::TreeModelSort*> (Glib::wrap_auto ((GObject*)(object), take_copy)) );
+  //We use dynamic_cast<> in case of multiple inheritance.
+}
+
+} /* namespace Glib */
+
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& TreeModelSort_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &TreeModelSort_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_tree_model_sort_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  TreeModel::add_interface(get_type());
+  TreeSortable::add_interface(get_type());
+  }
+
+  return *this;
+}
+
+void TreeModelSort_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+}
+
+
+Glib::ObjectBase* TreeModelSort_Class::wrap_new(GObject* object)
+{
+  return new TreeModelSort((GtkTreeModelSort*)object);
+}
+
+
+/* The implementation: */
+
+GtkTreeModelSort* TreeModelSort::gobj_copy()
+{
+  reference();
+  return gobj();
+}
+
+TreeModelSort::TreeModelSort(const Glib::ConstructParams& construct_params)
+:
+  Glib::Object(construct_params)
+{}
+
+TreeModelSort::TreeModelSort(GtkTreeModelSort* castitem)
+:
+  Glib::Object((GObject*)(castitem))
+{}
+
+TreeModelSort::~TreeModelSort()
+{}
+
+
+TreeModelSort::CppClassType TreeModelSort::treemodelsort_class_; // initialize static member
+
+GType TreeModelSort::get_type()
+{
+  return treemodelsort_class_.init().get_type();
+}
+
+GType TreeModelSort::get_base_type()
+{
+  return gtk_tree_model_sort_get_type();
+}
+
+
+TreeModelSort::TreeModelSort(const Glib::RefPtr<TreeModel>& model)
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Glib::Object(Glib::ConstructParams(treemodelsort_class_.init(), "model", Glib::unwrap(model), (char*) 0))
+{
+  }
+
+Glib::RefPtr<TreeModelSort> TreeModelSort::create(const Glib::RefPtr<TreeModel>& model)
+{
+  return Glib::RefPtr<TreeModelSort>( new TreeModelSort(model) );
+}
+Glib::RefPtr<TreeModel> TreeModelSort::get_model()
+{
+
+  Glib::RefPtr<TreeModel> retvalue = Glib::wrap(gtk_tree_model_sort_get_model(gobj()));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::RefPtr<const TreeModel> TreeModelSort::get_model() const
+{
+
+  Glib::RefPtr<const TreeModel> retvalue = Glib::wrap(gtk_tree_model_sort_get_model(const_cast<GtkTreeModelSort*>(gobj())));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Path TreeModelSort::convert_child_path_to_path(const Path& child_path) const
+{
+  return Gtk::TreePath(gtk_tree_model_sort_convert_child_path_to_path(const_cast<GtkTreeModelSort*>(gobj()), const_cast<GtkTreePath*>((child_path).gobj())), false);
+}
+
+Path TreeModelSort::convert_path_to_child_path(const Path& sorted_path) const
+{
+  return Gtk::TreePath(gtk_tree_model_sort_convert_path_to_child_path(const_cast<GtkTreeModelSort*>(gobj()), const_cast<GtkTreePath*>((sorted_path).gobj())), false);
+}
+
+void TreeModelSort::reset_default_sort_func()
+{
+  gtk_tree_model_sort_reset_default_sort_func(gobj());
+}
+
+void TreeModelSort::clear_cache()
+{
+  gtk_tree_model_sort_clear_cache(gobj());
+}
+
+bool TreeModelSort::iter_is_valid(const iterator& iter) const
+{
+  return gtk_tree_model_sort_iter_is_valid(const_cast<GtkTreeModelSort*>(gobj()), const_cast<GtkTreeIter*>((iter).gobj()));
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/treemodelsort.h b/libs/gtkmm2/gtk/gtkmm/treemodelsort.h
new file mode 100644
index 0000000000..fd56c18d29
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/treemodelsort.h
@@ -0,0 +1,208 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_TREEMODELSORT_H
+#define _GTKMM_TREEMODELSORT_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* Copyright(C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+
+#include <gtkmm/treeiter.h>
+#include <gtkmm/treemodel.h>
+#include <gtkmm/treesortable.h>
+// We couldn't include it in treemodel.h, but doing it here makes it easier for people.
+#include <gtkmm/treepath.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkTreeModelSort GtkTreeModelSort;
+typedef struct _GtkTreeModelSortClass GtkTreeModelSortClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class TreeModelSort_Class; } // namespace Gtk
+namespace Gtk
+{
+
+/** A wrapper which makes an underlying Gtk::TreeModel sortable.
+ * @ingroup TreeView
+ */
+
+class TreeModelSort : public Glib::Object, public TreeModel, public TreeSortable
+{
+  
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+public:
+  typedef TreeModelSort CppObjectType;
+  typedef TreeModelSort_Class CppClassType;
+  typedef GtkTreeModelSort BaseObjectType;
+  typedef GtkTreeModelSortClass BaseClassType;
+
+private:  friend class TreeModelSort_Class;
+  static CppClassType treemodelsort_class_;
+
+private:
+  // noncopyable
+  TreeModelSort(const TreeModelSort&);
+  TreeModelSort& operator=(const TreeModelSort&);
+
+protected:
+  explicit TreeModelSort(const Glib::ConstructParams& construct_params);
+  explicit TreeModelSort(GtkTreeModelSort* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+  virtual ~TreeModelSort();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GObject.
+  GtkTreeModelSort*       gobj()       { return reinterpret_cast<GtkTreeModelSort*>(gobject_); }
+
+  ///Provides access to the underlying C GObject.
+  const GtkTreeModelSort* gobj() const { return reinterpret_cast<GtkTreeModelSort*>(gobject_); }
+
+  ///Provides access to the underlying C instance. The caller is responsible for unrefing it. Use when directly setting fields in structs.
+  GtkTreeModelSort* gobj_copy();
+
+private:
+
+  
+protected:
+  explicit TreeModelSort(const Glib::RefPtr<TreeModel>& model);
+
+public:
+  
+  static Glib::RefPtr<TreeModelSort> create(const Glib::RefPtr<TreeModel>& model);
+
+
+  /** Returns the model the Gtk::TreeModelSort is sorting.
+   * @return The "child model" being sorted.
+   */
+  Glib::RefPtr<TreeModel> get_model();
+  
+  /** Returns the model the Gtk::TreeModelSort is sorting.
+   * @return The "child model" being sorted.
+   */
+  Glib::RefPtr<const TreeModel> get_model() const;
+
+  
+  /** Converts @a child_path  to a path relative to @a tree_model_sort .  That is,
+   *  @a child_path  points to a path in the child model.  The returned path will
+   * point to the same row in the sorted model.  If @a child_path  isn't a valid path
+   * on the child model, then <tt>0</tt> is returned.
+   * @param child_path A Gtk::TreePath to convert.
+   * @return A newly allocated Gtk::TreePath, or <tt>0</tt>.
+   */
+  Path convert_child_path_to_path(const Path& child_path) const;
+
+  /** Gets an iterator that points to the sorted row that corresponds to the child row pointed at by child_iter.
+   *
+   * @param child_iter A valid iterator pointing to a row on the child model.
+   * @result A valid iterator that points to the row in this sorted model.
+   */
+  iterator convert_child_iter_to_iter(const iterator& child_iter) const;
+
+  
+  /** Converts @a sorted_path  to a path on the child model of @a tree_model_sort .  That
+   * is, @a sorted_path  points to a location in @a tree_model_sort .  The returned path
+   * will point to the same location in the model not being sorted.  If @a sorted_path  
+   * does not point to a location in the child model, <tt>0</tt> is returned.
+   * @param sorted_path A Gtk::TreePath to convert.
+   * @return A newly allocated Gtk::TreePath, or <tt>0</tt>.
+   */
+  Path convert_path_to_child_path(const Path& sorted_path) const;
+
+  /** Gets an iterator that points to the child row that corresponds to the sorted row pointed at by sorted_iter.
+   *
+   * @param sorted_iter A valid iterator pointing to a row on the sorted model.
+   * @result A valid iterator that points to the row in the child model.
+   */
+  iterator convert_iter_to_child_iter(const iterator& sorted_iter) const;
+
+  
+  /** This resets the default sort function to be in the 'unsorted' state.  That
+   * is, it is in the same order as the child model. It will re-sort the model
+   * to be in the same order as the child model only if the Gtk::TreeModelSort
+   * is in 'unsorted' state.
+   */
+  void reset_default_sort_func();
+  
+  /** This function should almost never be called.  It clears the @a tree_model_sort 
+   * of any cached iterators that haven't been reffed with
+   * ref_node().  This might be useful if the child model being
+   * sorted is static (and doesn't change often) and there has been a lot of
+   * unreffed access to nodes.  As a side effect of this function, all unreffed
+   * iters will be invalid.
+   */
+  void clear_cache();
+
+  
+  /** WARNING: This function is slow. Only use it for debugging and/or testing
+   * purposes.
+   * 
+   * Checks if the given iter is a valid iter for this Gtk::TreeModelSort.
+   * @param iter A Gtk::TreeIter.
+   * @return <tt>true</tt> if the iter is valid, <tt>false</tt> if the iter is invalid.
+   * 
+   * Since: 2.2.
+   */
+  bool iter_is_valid(const iterator& iter) const;
+
+protected:
+  virtual void set_value_impl(const iterator& row, int column, const Glib::ValueBase& value);
+
+
+public:
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+};
+
+} // namespace Gtk
+
+
+namespace Glib
+{
+  /** @relates Gtk::TreeModelSort
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Glib::RefPtr<Gtk::TreeModelSort> wrap(GtkTreeModelSort* object, bool take_copy = false);
+}
+
+
+#endif /* _GTKMM_TREEMODELSORT_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/treepath.cc b/libs/gtkmm2/gtk/gtkmm/treepath.cc
new file mode 100644
index 0000000000..a84164113a
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/treepath.cc
@@ -0,0 +1,319 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/treepath.h>
+#include <gtkmm/private/treepath_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/treemodel.h>
+#include <glibmm/utility.h>
+#include <gtk/gtktreemodel.h>
+#include <gtk/gtktreednd.h>
+
+
+namespace Gtk
+{
+
+TreePath::TreePath(TreePath::size_type n, TreePath::value_type value)
+:
+  gobject_ (gtk_tree_path_new())
+{
+  for(; n > 0; --n)
+    gtk_tree_path_append_index(gobject_, value);
+}
+
+TreePath::TreePath(const Glib::ustring& path)
+:
+  gobject_ (gtk_tree_path_new_from_string(path.c_str()))
+{}
+
+TreePath::TreePath(const TreeModel::iterator& iter)
+:
+  // The GtkTreePath* is always newly created.
+  gobject_ (gtk_tree_model_get_path(iter.get_model_gobject(), const_cast<GtkTreeIter*>(iter.gobj())))
+{}
+
+TreePath& TreePath::operator=(const TreeModel::iterator& iter)
+{
+  TreePath temp (iter);
+  swap(temp);
+  return *this;
+}
+
+void TreePath::clear()
+{
+  TreePath empty_path;
+  swap(empty_path);
+}
+
+TreePath::size_type TreePath::size() const
+{
+  return gtk_tree_path_get_depth(gobject_);
+}
+
+bool TreePath::empty() const
+{
+  return (gtk_tree_path_get_depth(gobject_) == 0);
+}
+
+TreePath::reference TreePath::operator[](TreePath::size_type i)
+{
+  int *const indices = gtk_tree_path_get_indices(gobject_);
+  return indices[i];
+}
+
+TreePath::const_reference TreePath::operator[](TreePath::size_type i) const
+{
+  const int *const indices = gtk_tree_path_get_indices(gobject_);
+  return indices[i];
+}
+
+TreePath::iterator TreePath::begin()
+{
+  return gtk_tree_path_get_indices(gobject_);
+}
+
+TreePath::iterator TreePath::end()
+{
+  return gtk_tree_path_get_indices(gobject_) + gtk_tree_path_get_depth(gobject_);
+}
+
+TreePath::const_iterator TreePath::begin() const
+{
+  return gtk_tree_path_get_indices(gobject_);
+}
+
+TreePath::const_iterator TreePath::end() const
+{
+  return gtk_tree_path_get_indices(gobject_) + gtk_tree_path_get_depth(gobject_);
+}
+
+bool TreePath::get_from_selection_data(const SelectionData& selection_data, Glib::RefPtr<TreeModel>& model, TreePath& path) //static 
+{
+  GtkTreeModel* src_model = 0;
+  GtkTreePath* src_path = 0;
+  gboolean result = gtk_tree_get_row_drag_data(const_cast<GtkSelectionData*>(selection_data.gobj()), &src_model, &src_path);
+
+  model = Glib::wrap(src_model, true /* take_copy=true */);
+  
+  //gtk_tree_get_row_drag_data gives us ownership of src_path.
+  path = Glib::wrap(src_path, false /* take_copy=false */);
+
+  return result;
+}
+
+bool TreePath::get_from_selection_data(const SelectionData& selection_data, TreePath& path) //static
+{
+  GtkTreePath* src_path = 0;
+  gboolean result = gtk_tree_get_row_drag_data(const_cast<GtkSelectionData*>(selection_data.gobj()), 0, &src_path);
+
+  //gtk_tree_get_row_drag_data gives us ownership of src_path.
+  path = Glib::wrap(src_path, false /* take_copy=false */);
+
+  return result;
+}
+
+
+bool TreePath::set_in_selection_data(SelectionData& selection_data, const Glib::RefPtr<const TreeModel>& model) const
+{
+  return gtk_tree_set_row_drag_data(selection_data.gobj(), const_cast<GtkTreeModel*>(model->gobj()), const_cast<GtkTreePath*>(gobj()));  
+}
+
+//deprecated:
+Glib::ArrayHandle<int> TreePath::get_indices() const
+{
+  // gtk_tree_path_get_indices() returns a pointer to an internal array,
+  // similar to std::string::data().  Thus the OWNERSHIP_NONE flag.
+
+  return Glib::ArrayHandle<int>(gtk_tree_path_get_indices(gobject_),
+                                gtk_tree_path_get_depth(gobject_),
+                                Glib::OWNERSHIP_NONE);
+}
+  
+} // namespace Gtk
+
+
+namespace
+{
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Gtk::TreePath wrap(GtkTreePath* object, bool take_copy)
+{
+  return Gtk::TreePath(object, take_copy);
+}
+
+} // namespace Glib
+
+
+namespace Gtk
+{
+
+
+// static
+GType TreePath::get_type()
+{
+  return gtk_tree_path_get_type();
+}
+
+TreePath::TreePath()
+:
+  gobject_ (gtk_tree_path_new())
+{}
+
+TreePath::TreePath(const TreePath& other)
+:
+  gobject_ ((other.gobject_) ? gtk_tree_path_copy(other.gobject_) : 0)
+{}
+
+TreePath::TreePath(GtkTreePath* gobject, bool make_a_copy)
+:
+  // For BoxedType wrappers, make_a_copy is true by default.  The static
+  // BoxedType wrappers must always take a copy, thus make_a_copy = true
+  // ensures identical behaviour if the default argument is used.
+  gobject_ ((make_a_copy && gobject) ? gtk_tree_path_copy(gobject) : gobject)
+{}
+
+TreePath& TreePath::operator=(const TreePath& other)
+{
+  TreePath temp (other);
+  swap(temp);
+  return *this;
+}
+
+TreePath::~TreePath()
+{
+  if(gobject_)
+    gtk_tree_path_free(gobject_);
+}
+
+void TreePath::swap(TreePath& other)
+{
+  GtkTreePath *const temp = gobject_;
+  gobject_ = other.gobject_;
+  other.gobject_ = temp;
+}
+
+GtkTreePath* TreePath::gobj_copy() const
+{
+  return gtk_tree_path_copy(gobject_);
+}
+
+
+void TreePath::push_back(int index)
+{
+  gtk_tree_path_append_index(gobj(), index);
+}
+
+void TreePath::push_front(int index)
+{
+  gtk_tree_path_prepend_index(gobj(), index);
+}
+
+void TreePath::next()
+{
+  gtk_tree_path_next(gobj());
+}
+
+bool TreePath::prev()
+{
+  return gtk_tree_path_prev(gobj());
+}
+
+bool TreePath::up()
+{
+  return gtk_tree_path_up(gobj());
+}
+
+void TreePath::down()
+{
+  gtk_tree_path_down(gobj());
+}
+
+bool TreePath::is_ancestor(const TreePath& descendant) const
+{
+  return gtk_tree_path_is_ancestor(const_cast<GtkTreePath*>(gobj()), const_cast<GtkTreePath*>((descendant).gobj()));
+}
+
+bool TreePath::is_descendant(const TreePath& ancestor) const
+{
+  return gtk_tree_path_is_descendant(const_cast<GtkTreePath*>(gobj()), const_cast<GtkTreePath*>((ancestor).gobj()));
+}
+
+Glib::ustring TreePath::to_string() const
+{
+  return Glib::convert_return_gchar_ptr_to_ustring(gtk_tree_path_to_string(const_cast<GtkTreePath*>(gobj())));
+}
+
+
+bool operator==(const TreePath& lhs, const TreePath& rhs)
+{
+  return (gtk_tree_path_compare(lhs.gobj(), rhs.gobj()) == 0);
+}
+
+bool operator!=(const TreePath& lhs, const TreePath& rhs)
+{
+  return (gtk_tree_path_compare(lhs.gobj(), rhs.gobj()) != 0);
+}
+
+bool operator<(const TreePath& lhs, const TreePath& rhs)
+{
+  return (gtk_tree_path_compare(lhs.gobj(), rhs.gobj()) < 0);
+}
+
+bool operator>(const TreePath& lhs, const TreePath& rhs)
+{
+  return (gtk_tree_path_compare(lhs.gobj(), rhs.gobj()) > 0);
+}
+
+bool operator<=(const TreePath& lhs, const TreePath& rhs)
+{
+  return (gtk_tree_path_compare(lhs.gobj(), rhs.gobj()) <= 0);
+}
+
+bool operator>=(const TreePath& lhs, const TreePath& rhs)
+{
+  return (gtk_tree_path_compare(lhs.gobj(), rhs.gobj()) >= 0);
+}
+
+
+void TreePath::append_index(int index)
+{
+  gtk_tree_path_append_index(gobj(), index);
+}
+
+void TreePath::prepend_index(int index)
+{
+  gtk_tree_path_prepend_index(gobj(), index);
+}
+
+int TreePath::get_depth() const
+{
+  return gtk_tree_path_get_depth(const_cast<GtkTreePath*>(gobj()));
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/treepath.h b/libs/gtkmm2/gtk/gtkmm/treepath.h
new file mode 100644
index 0000000000..8e41e81284
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/treepath.h
@@ -0,0 +1,402 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_TREEPATH_H
+#define _GTKMM_TREEPATH_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* Copyright(C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software, ) you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library, ) if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+
+#include <gtkmm/treemodel.h>
+#include <gtkmm/selectiondata.h>
+#include <gtkmmconfig.h>
+
+GLIBMM_USING_STD(random_access_iterator_tag)
+GLIBMM_USING_STD(reverse_iterator)
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+extern "C" { typedef struct _GtkTreePath GtkTreePath; }
+#endif
+
+namespace Gtk
+{
+
+/** A path is essentially a potential node. It is a location on a model that may
+ * or may not actually correspond to a node on a specific model.
+ *
+ * A Path can be converted into either an array of unsigned integers or a string. The string
+ * form is a list of numbers separated by a colon. Each number refers to the
+ * offset at that level. Thus, the path "0" refers to the root node and the
+ * path "2:4" refers to the fifth child of the third node.
+ *
+ * Typedefed as Gtk::TreeModel::Path.
+ * @ingroup TreeView
+ */
+class TreePath
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef TreePath CppObjectType;
+  typedef GtkTreePath BaseObjectType;
+
+  static GType get_type() G_GNUC_CONST;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  TreePath();
+
+  explicit TreePath(GtkTreePath* gobject, bool make_a_copy = true);
+
+  TreePath(const TreePath& other);
+  TreePath& operator=(const TreePath& other);
+
+  ~TreePath();
+
+  void swap(TreePath& other);
+
+  ///Provides access to the underlying C instance.
+  GtkTreePath*       gobj()       { return gobject_; }
+
+  ///Provides access to the underlying C instance.
+  const GtkTreePath* gobj() const { return gobject_; }
+
+  ///Provides access to the underlying C instance. The caller is responsible for freeing it. Use when directly setting fields in structs.
+  GtkTreePath* gobj_copy() const;
+
+protected:
+  GtkTreePath* gobject_;
+
+private:
+
+  
+public:
+  typedef unsigned int  size_type;
+  typedef int           difference_type;
+
+  typedef int           value_type;
+  typedef int&          reference;
+  typedef const int&    const_reference;
+
+  // Use plain pointers for simplicity.
+  typedef int*          iterator;
+  typedef const int*    const_iterator;
+
+#ifndef GLIBMM_HAVE_SUN_REVERSE_ITERATOR
+
+  typedef std::reverse_iterator<iterator>       reverse_iterator;
+  typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+
+#else
+
+  typedef std::reverse_iterator<iterator, std::random_access_iterator_tag,
+                                int, int&, int*, ptrdiff_t> reverse_iterator;
+
+  typedef std::reverse_iterator<const_iterator, std::random_access_iterator_tag,
+                                int, const int&, const int*, ptrdiff_t> const_reverse_iterator;
+
+#endif /* GLIBMM_HAVE_SUN_REVERSE_ITERATOR */
+
+  explicit TreePath(size_type n, value_type value = 0);
+  explicit TreePath(const Glib::ustring& path);
+  explicit TreePath(const TreeModel::iterator& iter);
+
+  template <class In> inline TreePath(In pbegin, In pend);
+
+  void clear();
+
+  // I think it's OK for this assignment to be implicit.  It's very useful.
+  TreePath& operator=(const TreeModel::iterator& iter);
+
+  template <class In> inline void assign(In pbegin, In pend);
+  template <class In>        void append(In pbegin, In pend);
+
+  
+  /** Appends a new index to a path.  As a result, the depth of the path is
+   * increased.
+   * @param index The index.
+   */
+  void push_back(int index);
+  
+  /** Prepends a new index to a path.  As a result, the depth of the path is
+   * increased.
+   * @param index The index.
+   */
+  void push_front(int index);
+
+  size_type size() const;
+  bool empty() const;
+
+  reference       operator[](size_type i);
+  const_reference operator[](size_type i) const;
+
+  iterator begin();
+  iterator end();
+  const_iterator begin() const;
+  const_iterator end()   const;
+
+  // Note: there is no advantage in not inlining these methods.
+  // We can't change them without breaking ABI anyway.
+  reverse_iterator       rbegin()       { return reverse_iterator(end());         }
+  reverse_iterator       rend()         { return reverse_iterator(begin());       }
+  const_reverse_iterator rbegin() const { return const_reverse_iterator(end());   }
+  const_reverse_iterator rend()   const { return const_reverse_iterator(begin()); }
+
+  reference       front()       { return *begin();  }
+  const_reference front() const { return *begin();  }
+  reference       back()        { return *rbegin(); }
+  const_reference back()  const { return *rbegin(); }
+
+  
+  /** Moves the @a path  to point to the next node at the current depth.
+   */
+  void next();
+  
+  /** Moves the @a path  to point to the previous node at the current depth, if it exists.
+   * @return <tt>true</tt> if @a path  has a previous node, and the move was made.
+   */
+  bool prev();
+  
+  /** Moves the @a path  to point to its parent node, if it has a parent.
+   * @return <tt>true</tt> if @a path  has a parent, and the move was made.
+   */
+  bool up();
+  
+  /** Moves @a path  to point to the first child of the current path.
+   */
+  void down();
+
+  
+  /** Returns <tt>true</tt> if @a descendant  is a descendant of @a path .
+   * @param descendant Another Gtk::TreePath.
+   * @return <tt>true</tt> if @a descendant  is contained inside @a path .
+   */
+  bool is_ancestor(const TreePath& descendant) const;
+  
+  /** Returns <tt>true</tt> if @a path  is a descendant of @a ancestor .
+   * @param ancestor Another Gtk::TreePath.
+   * @return <tt>true</tt> if @a ancestor  contains @a path  somewhere below it.
+   */
+  bool is_descendant(const TreePath& ancestor) const;
+
+  
+  /** Generates a string representation of the path.  This string is a ':'
+   * separated list of numbers.  For example, "4:10:0:3" would be an acceptable return value for this string.
+   * @return The string.
+   */
+  Glib::ustring to_string() const;
+
+
+#ifndef GTKMM_DISABLE_DEPRECATED
+  /// @deprecated replaced by push_back():
+  
+  /** Appends a new index to a path.  As a result, the depth of the path is
+   * increased.
+   * @param index The index.
+   */
+  void append_index(int index);
+  /// @deprecated replaced by push_front():
+  
+  /** Prepends a new index to a path.  As a result, the depth of the path is
+   * increased.
+   * @param index The index.
+   */
+  void prepend_index(int index);
+  /// @deprecated replaced by size():
+  
+  /** Returns the current depth of @a path .
+   * @return The depth of @a path .
+   */
+  int get_depth() const;
+  
+  /// @deprecated replaced by begin(), end(), and operator[]
+  Glib::ArrayHandle<int> get_indices() const;
+#endif
+  
+  
+  /**
+   * Obtains a Gtk::TreeModel and Gtk::TreeModel::Path from selection data of target type
+   * "GTK_TREE_MODEL_ROW". Normally called from a drag_data_received handler.
+   * This function can only be used if @a selection_data originates from the same
+   * process that's calling this function, because a pointer to the tree model
+   * is being passed around. If you aren't in the same process, then you'll
+   * get memory corruption. In the Gtk::TreeDragDest drag_data_received signal handler,
+   * you can assume that selection data of type "GTK_TREE_MODEL_ROW" is
+   * from the current process. 
+   *
+   * @param selection_data a #SelectionData
+   * @param model a Gtk::TreeModel
+   * @param path a row in model
+   *
+   * @return true if the selection_data had target type "GTK_TREE_MODEL_ROW" and
+   *  is otherwise valid
+   **/
+  static bool get_from_selection_data(const SelectionData& selection_data, Glib::RefPtr<TreeModel>& model, TreePath& path);
+  //TODO: Add an override that takes a const TreeModel (and deprecate the current version).
+  
+  /// See description in the other overload.
+  static bool get_from_selection_data(const SelectionData& selection_data, TreePath& path);
+
+  /**
+   * Sets selection data of target type "GTK_TREE_MODEL_ROW". Normally used
+   * in a drag_data_get signal handler.
+   *
+   * @param selection_data some #SelectionData
+   * @param model: a Gtk::TreeModel
+   *
+   * @return true if the selection_data had the proper target type to allow us to set a tree row
+   **/
+  bool set_in_selection_data(SelectionData& selection_data, const Glib::RefPtr<const TreeModel>& model) const;
+
+
+};
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+template <class In>
+void TreePath::append(In pbegin, In pend)
+{
+  // push_back() can't throw -- if it could, this code wouldn't be strongly exception-safe.
+  for(; pbegin != pend; ++pbegin)
+    this->push_back(*pbegin);
+}
+
+template <class In> inline
+TreePath::TreePath(In pbegin, In pend)
+{
+  this->append(pbegin, pend);
+}
+
+template <class In> inline
+void TreePath::assign(In pbegin, In pend)
+{
+  TreePath temp (pbegin, pend);
+  this->swap(temp);
+}
+
+
+/* Traits for use of TreePath in a Glib::ListHandle<>.
+ */
+struct TreePath_Traits
+{
+  typedef TreePath            CppType;
+  typedef const GtkTreePath*  CType;
+  typedef GtkTreePath*        CTypeNonConst;
+
+  static CType to_c_type(const CppType& item)
+    { return item.gobj(); }
+
+  static CType to_c_type(CType item)
+    { return item; }
+
+  static CppType to_cpp_type(CType item)
+    { return CppType(const_cast<CTypeNonConst>(item)); } 
+
+  static void release_c_type(CType item)
+    { gtk_tree_path_free(const_cast<CTypeNonConst>(item)); }  
+};
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+} // namespace Gtk
+
+
+namespace Gtk
+{
+
+/** @relates Gtk::TreePath
+ * @param lhs The left-hand side
+ * @param rhs The right-hand side
+ * @result The result
+ */
+bool operator==(const TreePath& lhs, const TreePath& rhs);
+
+/** @relates Gtk::TreePath
+ * @param lhs The left-hand side
+ * @param rhs The right-hand side
+ * @result The result
+ */
+bool operator!=(const TreePath& lhs, const TreePath& rhs);
+
+/** @relates Gtk::TreePath
+ * @param lhs The left-hand side
+ * @param rhs The right-hand side
+ * @result The result
+ */
+bool operator<(const TreePath& lhs, const TreePath& rhs);
+
+/** @relates Gtk::TreePath
+ * @param lhs The left-hand side
+ * @param rhs The right-hand side
+ * @result The result
+ */
+bool operator>(const TreePath& lhs, const TreePath& rhs);
+
+/** @relates Gtk::TreePath
+ * @param lhs The left-hand side
+ * @param rhs The right-hand side
+ * @result The result
+ */
+bool operator<=(const TreePath& lhs, const TreePath& rhs);
+
+/** @relates Gtk::TreePath
+ * @param lhs The left-hand side
+ * @param rhs The right-hand side
+ * @result The result
+ */
+bool operator>=(const TreePath& lhs, const TreePath& rhs);
+
+
+} // namespace Gtk
+
+
+namespace Gtk
+{
+
+/** @relates Gtk::TreePath
+ * @param lhs The left-hand side
+ * @param rhs The right-hand side
+ */
+inline void swap(TreePath& lhs, TreePath& rhs)
+  { lhs.swap(rhs); }
+
+} // namespace Gtk
+
+namespace Glib
+{
+
+/** @relates Gtk::TreePath
+ * @param object The C instance
+ * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+ * @result A C++ instance that wraps this C instance.
+ */
+Gtk::TreePath wrap(GtkTreePath* object, bool take_copy = false);
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+template <>
+class Value<Gtk::TreePath> : public Glib::Value_Boxed<Gtk::TreePath>
+{};
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+} // namespace Glib
+
+#endif /* _GTKMM_TREEPATH_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/treerowreference.cc b/libs/gtkmm2/gtk/gtkmm/treerowreference.cc
new file mode 100644
index 0000000000..591323f942
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/treerowreference.cc
@@ -0,0 +1,128 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/treerowreference.h>
+#include <gtkmm/private/treerowreference_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* Copyright (C) 2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtk/gtktreemodel.h>
+
+
+namespace Gtk
+{
+
+TreeRowReference::TreeRowReference(const Glib::RefPtr<TreeModel>& model, const TreeModel::Path& path)
+:
+  gobject_ ( gtk_tree_row_reference_new(model->gobj(), const_cast<GtkTreePath*>(path.gobj())) )
+{}
+
+TreeRowReference::operator bool() const
+{
+  return is_valid();
+}
+
+} // namespace Gtk
+
+
+namespace
+{
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Gtk::TreeRowReference wrap(GtkTreeRowReference* object, bool take_copy)
+{
+  return Gtk::TreeRowReference(object, take_copy);
+}
+
+} // namespace Glib
+
+
+namespace Gtk
+{
+
+
+// static
+GType TreeRowReference::get_type()
+{
+  return gtk_tree_row_reference_get_type();
+}
+
+TreeRowReference::TreeRowReference()
+:
+  gobject_ (0) // Allows creation of invalid wrapper, e.g. for output arguments to methods.
+{}
+
+TreeRowReference::TreeRowReference(const TreeRowReference& other)
+:
+  gobject_ ((other.gobject_) ? gtk_tree_row_reference_copy(other.gobject_) : 0)
+{}
+
+TreeRowReference::TreeRowReference(GtkTreeRowReference* gobject, bool make_a_copy)
+:
+  // For BoxedType wrappers, make_a_copy is true by default.  The static
+  // BoxedType wrappers must always take a copy, thus make_a_copy = true
+  // ensures identical behaviour if the default argument is used.
+  gobject_ ((make_a_copy && gobject) ? gtk_tree_row_reference_copy(gobject) : gobject)
+{}
+
+TreeRowReference& TreeRowReference::operator=(const TreeRowReference& other)
+{
+  TreeRowReference temp (other);
+  swap(temp);
+  return *this;
+}
+
+TreeRowReference::~TreeRowReference()
+{
+  if(gobject_)
+    gtk_tree_row_reference_free(gobject_);
+}
+
+void TreeRowReference::swap(TreeRowReference& other)
+{
+  GtkTreeRowReference *const temp = gobject_;
+  gobject_ = other.gobject_;
+  other.gobject_ = temp;
+}
+
+GtkTreeRowReference* TreeRowReference::gobj_copy() const
+{
+  return gtk_tree_row_reference_copy(gobject_);
+}
+
+
+TreeModel::Path TreeRowReference::get_path() const
+{
+  return Gtk::TreePath(gtk_tree_row_reference_get_path(const_cast<GtkTreeRowReference*>(gobj())), false);
+}
+
+bool TreeRowReference::is_valid() const
+{
+  return gtk_tree_row_reference_valid(const_cast<GtkTreeRowReference*>(gobj()));
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/treerowreference.h b/libs/gtkmm2/gtk/gtkmm/treerowreference.h
new file mode 100644
index 0000000000..034981d478
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/treerowreference.h
@@ -0,0 +1,138 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_TREEROWREFERENCE_H
+#define _GTKMM_TREEROWREFERENCE_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* Copyright (C) 2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+
+#include <gtkmm/treemodel.h>
+#include <gtkmm/treepath.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+extern "C" { typedef struct _GtkTreeRowReference GtkTreeRowReference; }
+#endif
+
+namespace Gtk
+{
+
+/** Typedefed as Gtk::TreeModel::RowReference.
+ * This reference will keep pointing to
+ * the node pointed to by the Path, so long as it exists.  It listens to all
+ * signals emitted by the Model, and updates its Path appropriately.
+ * @ingroup TreeView
+*/
+class TreeRowReference
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef TreeRowReference CppObjectType;
+  typedef GtkTreeRowReference BaseObjectType;
+
+  static GType get_type() G_GNUC_CONST;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  TreeRowReference();
+
+  explicit TreeRowReference(GtkTreeRowReference* gobject, bool make_a_copy = true);
+
+  TreeRowReference(const TreeRowReference& other);
+  TreeRowReference& operator=(const TreeRowReference& other);
+
+  ~TreeRowReference();
+
+  void swap(TreeRowReference& other);
+
+  ///Provides access to the underlying C instance.
+  GtkTreeRowReference*       gobj()       { return gobject_; }
+
+  ///Provides access to the underlying C instance.
+  const GtkTreeRowReference* gobj() const { return gobject_; }
+
+  ///Provides access to the underlying C instance. The caller is responsible for freeing it. Use when directly setting fields in structs.
+  GtkTreeRowReference* gobj_copy() const;
+
+protected:
+  GtkTreeRowReference* gobject_;
+
+private:
+
+  
+public:
+  TreeRowReference(const Glib::RefPtr<TreeModel>& model, const TreeModel::Path& path);
+
+  ///The same as is_valid().
+  operator bool() const;
+
+  
+  /** Returns a path that the row reference currently points to, or <tt>0</tt> if the
+   * path pointed to is no longer valid.
+   * @return A current path, or <tt>0</tt>.
+   */
+  TreeModel::Path get_path() const;
+
+  
+  /** Returns <tt>true</tt> if the %reference is non-<tt>0</tt> and refers to a current valid
+   * path.
+   * @return <tt>true</tt> if %reference points to a valid path.
+   */
+  bool is_valid() const;
+
+
+};
+
+} // namespace Gtk
+
+
+namespace Gtk
+{
+
+/** @relates Gtk::TreeRowReference
+ * @param lhs The left-hand side
+ * @param rhs The right-hand side
+ */
+inline void swap(TreeRowReference& lhs, TreeRowReference& rhs)
+  { lhs.swap(rhs); }
+
+} // namespace Gtk
+
+namespace Glib
+{
+
+/** @relates Gtk::TreeRowReference
+ * @param object The C instance
+ * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+ * @result A C++ instance that wraps this C instance.
+ */
+Gtk::TreeRowReference wrap(GtkTreeRowReference* object, bool take_copy = false);
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+template <>
+class Value<Gtk::TreeRowReference> : public Glib::Value_Boxed<Gtk::TreeRowReference>
+{};
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+} // namespace Glib
+
+#endif /* _GTKMM_TREEROWREFERENCE_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/treeselection.cc b/libs/gtkmm2/gtk/gtkmm/treeselection.cc
new file mode 100644
index 0000000000..6a6ffffdcc
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/treeselection.cc
@@ -0,0 +1,454 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/treeselection.h>
+#include <gtkmm/private/treeselection_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/treeview.h>
+#include <gtk/gtktreeselection.h>
+
+
+namespace
+{
+
+void proxy_foreach_selection_iter_callback(GtkTreeModel* model, GtkTreePath*, GtkTreeIter* iter, void* data)
+{
+  typedef Gtk::TreeSelection::SlotForeachIter SlotType;
+  SlotType& slot = *static_cast<SlotType*>(data);
+
+  try
+  {
+    slot(Gtk::TreeModel::iterator(model, iter));
+  }
+  catch(...)
+  {
+    Glib::exception_handlers_invoke();
+  }
+}
+
+void proxy_foreach_selection_path_callback(GtkTreeModel*, GtkTreePath* path, GtkTreeIter*, void* data)
+{
+  typedef Gtk::TreeSelection::SlotForeachPath SlotType;
+  SlotType& slot = *static_cast<SlotType*>(data);
+
+  try
+  {
+    slot(Gtk::TreeModel::Path(path, true));
+  }
+  catch(...)
+  {
+    Glib::exception_handlers_invoke();
+  }
+}
+
+void proxy_foreach_selection_path_and_iter_callback(GtkTreeModel* model, GtkTreePath* path,
+                                                    GtkTreeIter* iter, void* data)
+{
+  typedef Gtk::TreeSelection::SlotForeachPathAndIter SlotType;
+  SlotType& slot = *static_cast<SlotType*>(data);
+
+  try
+  {
+    slot(Gtk::TreeModel::Path(path, true), Gtk::TreeModel::iterator(model, iter));
+  }
+  catch(...)
+  {
+    Glib::exception_handlers_invoke();
+  }
+}
+
+
+// This Signal Proxy allows the C++ coder to specify
+// a sigc::slot instead of a static function.
+class SignalProxy_Select
+{
+public:
+  typedef Gtk::TreeSelection::SlotSelect SlotType;
+
+  SignalProxy_Select(const SlotType& slot) : slot_(slot) {}
+  ~SignalProxy_Select();
+
+  static gboolean gtk_callback(GtkTreeSelection*, GtkTreeModel* model, GtkTreePath* path,
+                               gboolean path_currently_selected, void* data);
+
+  static void gtk_callback_destroy(void* data);
+
+private:
+  SlotType slot_;
+};
+
+SignalProxy_Select::~SignalProxy_Select()
+{}
+
+gboolean SignalProxy_Select::gtk_callback(GtkTreeSelection*, GtkTreeModel* model, GtkTreePath* path,
+                                          gboolean path_currently_selected, void* data)
+{
+  SignalProxy_Select *const self = static_cast<SignalProxy_Select*>(data);
+
+  try
+  {
+    return (self->slot_)(Glib::wrap(model, true),   // take copy
+                         Gtk::TreePath(path, true), // take copy
+                         path_currently_selected);
+  }
+  catch(...)
+  {
+    Glib::exception_handlers_invoke();
+  }
+
+  return 0;
+}
+
+void SignalProxy_Select::gtk_callback_destroy(void* data)
+{
+  delete static_cast<SignalProxy_Select*>(data);
+}
+
+} // anonymous namespace
+
+
+namespace Gtk
+{
+
+void TreeSelection::set_select_function(const SlotSelect& slot)
+{
+  // Create a signal proxy.  A pointer to this will be passed
+  // through the callback's data parameter.  It will be deleted
+  // when SignalProxy_Select::gtk_callback_destroy() is called.
+  SignalProxy_Select *const pSignalProxy = new SignalProxy_Select(slot);
+
+  gtk_tree_selection_set_select_function(gobj(),
+      &SignalProxy_Select::gtk_callback, pSignalProxy,
+      &SignalProxy_Select::gtk_callback_destroy);
+}
+
+Glib::RefPtr<TreeModel> TreeSelection::get_model()
+{
+  GtkTreeView *const tree_view = gtk_tree_selection_get_tree_view(gobj());
+  return Glib::wrap(gtk_tree_view_get_model(tree_view), true);
+}
+
+Glib::RefPtr<const TreeModel> TreeSelection::get_model() const
+{
+  GtkTreeView *const tree_view = gtk_tree_selection_get_tree_view(const_cast<GtkTreeSelection*>(gobj()));
+  return Glib::wrap(gtk_tree_view_get_model(tree_view), true);
+}
+
+TreeModel::iterator TreeSelection::get_selected()
+{
+  TreeModel::iterator iter;
+  GtkTreeModel* model_gobject = 0;
+
+  gtk_tree_selection_get_selected(gobj(), &model_gobject, iter.gobj());
+
+  iter.set_model_gobject(model_gobject);
+  return iter;
+}
+
+TreeModel::iterator TreeSelection::get_selected(Glib::RefPtr<TreeModel>& model)
+{
+  TreeModel::iterator iter;
+  GtkTreeModel* model_gobject = 0;
+
+  gtk_tree_selection_get_selected(gobj(), &model_gobject, iter.gobj());
+
+  model = Glib::wrap(model_gobject, true);
+
+  iter.set_model_refptr(model);
+  return iter;
+}
+
+void TreeSelection::selected_foreach_iter(const SlotForeachIter& slot) const
+{
+  SlotForeachIter slot_copy (slot);
+  gtk_tree_selection_selected_foreach(const_cast<GtkTreeSelection*>(gobj()), &proxy_foreach_selection_iter_callback, &slot_copy);
+}
+
+void TreeSelection::selected_foreach_path(const SlotForeachPath& slot) const
+{
+  SlotForeachPath slot_copy (slot);
+  gtk_tree_selection_selected_foreach(const_cast<GtkTreeSelection*>(gobj()), &proxy_foreach_selection_path_callback, &slot_copy);
+}
+
+void TreeSelection::selected_foreach(const SlotForeachPathAndIter& slot) const
+{
+  SlotForeachPathAndIter slot_copy (slot);
+  gtk_tree_selection_selected_foreach(const_cast<GtkTreeSelection*>(gobj()), &proxy_foreach_selection_path_and_iter_callback, &slot_copy);
+}
+
+TreeSelection::ListHandle_Path TreeSelection::get_selected_rows() const
+{
+  return ListHandle_Path(gtk_tree_selection_get_selected_rows(
+      const_cast<GtkTreeSelection*>(gobj()), 0), Glib::OWNERSHIP_DEEP);
+}
+
+TreeSelection::ListHandle_Path TreeSelection::get_selected_rows(Glib::RefPtr<TreeModel>& model)
+{
+  GtkTreeModel* model_gobject = 0;
+
+  const ListHandle_Path result (gtk_tree_selection_get_selected_rows(
+      const_cast<GtkTreeSelection*>(gobj()), &model_gobject), Glib::OWNERSHIP_DEEP);
+
+  model = Glib::wrap(model_gobject, true);
+  return result;
+}
+
+} // namespace Gtk
+
+
+namespace
+{
+
+const Glib::SignalProxyInfo TreeSelection_signal_changed_info =
+{
+  "changed",
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
+};
+
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Glib::RefPtr<Gtk::TreeSelection> wrap(GtkTreeSelection* object, bool take_copy)
+{
+  return Glib::RefPtr<Gtk::TreeSelection>( dynamic_cast<Gtk::TreeSelection*> (Glib::wrap_auto ((GObject*)(object), take_copy)) );
+  //We use dynamic_cast<> in case of multiple inheritance.
+}
+
+} /* namespace Glib */
+
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& TreeSelection_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &TreeSelection_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_tree_selection_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void TreeSelection_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+  klass->changed = &changed_callback;
+}
+
+
+void TreeSelection_Class::changed_callback(GtkTreeSelection* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_changed();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->changed)
+      (*base->changed)(self);
+  }
+}
+
+
+Glib::ObjectBase* TreeSelection_Class::wrap_new(GObject* object)
+{
+  return new TreeSelection((GtkTreeSelection*)object);
+}
+
+
+/* The implementation: */
+
+GtkTreeSelection* TreeSelection::gobj_copy()
+{
+  reference();
+  return gobj();
+}
+
+TreeSelection::TreeSelection(const Glib::ConstructParams& construct_params)
+:
+  Glib::Object(construct_params)
+{}
+
+TreeSelection::TreeSelection(GtkTreeSelection* castitem)
+:
+  Glib::Object((GObject*)(castitem))
+{}
+
+TreeSelection::~TreeSelection()
+{}
+
+
+TreeSelection::CppClassType TreeSelection::treeselection_class_; // initialize static member
+
+GType TreeSelection::get_type()
+{
+  return treeselection_class_.init().get_type();
+}
+
+GType TreeSelection::get_base_type()
+{
+  return gtk_tree_selection_get_type();
+}
+
+
+void TreeSelection::set_mode(SelectionMode type)
+{
+  gtk_tree_selection_set_mode(gobj(), ((GtkSelectionMode)(type)));
+}
+
+SelectionMode TreeSelection::get_mode() const
+{
+  return ((SelectionMode)(gtk_tree_selection_get_mode(const_cast<GtkTreeSelection*>(gobj()))));
+}
+
+TreeView* TreeSelection::get_tree_view()
+{
+  return Glib::wrap(gtk_tree_selection_get_tree_view(gobj()));
+}
+
+const TreeView* TreeSelection::get_tree_view() const
+{
+  return Glib::wrap(gtk_tree_selection_get_tree_view(const_cast<GtkTreeSelection*>(gobj())));
+}
+
+int TreeSelection::count_selected_rows() const
+{
+  return gtk_tree_selection_count_selected_rows(const_cast<GtkTreeSelection*>(gobj()));
+}
+
+void TreeSelection::select(const TreeModel::Path& path)
+{
+  gtk_tree_selection_select_path(gobj(), const_cast<GtkTreePath*>((path).gobj()));
+}
+
+void TreeSelection::select(const TreeModel::iterator& iter)
+{
+  gtk_tree_selection_select_iter(gobj(), const_cast<GtkTreeIter*>((iter).gobj()));
+}
+
+void TreeSelection::select(const TreeModel::Row& row)
+{
+  gtk_tree_selection_select_iter(gobj(), const_cast<GtkTreeIter*>((row).gobj()));
+}
+
+void TreeSelection::select(const TreeModel::Path& start_path, const TreeModel::Path& end_path)
+{
+  gtk_tree_selection_select_range(gobj(), const_cast<GtkTreePath*>((start_path).gobj()), const_cast<GtkTreePath*>((end_path).gobj()));
+}
+
+void TreeSelection::unselect(const TreeModel::Path& path)
+{
+  gtk_tree_selection_unselect_path(gobj(), const_cast<GtkTreePath*>((path).gobj()));
+}
+
+void TreeSelection::unselect(const TreeModel::Path& start_path, const TreeModel::Path& end_path)
+{
+  gtk_tree_selection_unselect_range(gobj(), const_cast<GtkTreePath*>((start_path).gobj()), const_cast<GtkTreePath*>((end_path).gobj()));
+}
+
+void TreeSelection::unselect(const TreeModel::iterator& iter)
+{
+  gtk_tree_selection_unselect_iter(gobj(), const_cast<GtkTreeIter*>((iter).gobj()));
+}
+
+bool TreeSelection::is_selected(const TreeModel::Path& path) const
+{
+  return gtk_tree_selection_path_is_selected(const_cast<GtkTreeSelection*>(gobj()), const_cast<GtkTreePath*>((path).gobj()));
+}
+
+bool TreeSelection::is_selected(const TreeModel::iterator& iter) const
+{
+  return gtk_tree_selection_iter_is_selected(const_cast<GtkTreeSelection*>(gobj()), const_cast<GtkTreeIter*>((iter).gobj()));
+}
+
+void TreeSelection::select_all()
+{
+  gtk_tree_selection_select_all(gobj());
+}
+
+void TreeSelection::unselect_all()
+{
+  gtk_tree_selection_unselect_all(gobj());
+}
+
+
+Glib::SignalProxy0< void > TreeSelection::signal_changed()
+{
+  return Glib::SignalProxy0< void >(this, &TreeSelection_signal_changed_info);
+}
+
+
+void Gtk::TreeSelection::on_changed()
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->changed)
+    (*base->changed)(gobj());
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/treeselection.h b/libs/gtkmm2/gtk/gtkmm/treeselection.h
new file mode 100644
index 0000000000..da3cac7285
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/treeselection.h
@@ -0,0 +1,370 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_TREESELECTION_H
+#define _GTKMM_TREESELECTION_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* Copyright(C) 1998-1999 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+
+#include <gtkmm/enums.h>
+#include <gtkmm/treemodel.h>
+#include <gtkmm/treeiter.h>
+#include <gtkmm/treepath.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkTreeSelection GtkTreeSelection;
+typedef struct _GtkTreeSelectionClass GtkTreeSelectionClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class TreeSelection_Class; } // namespace Gtk
+namespace Gtk
+{
+
+class TreeView;
+class TreeModel;
+class TreePath;
+
+/** Typedefed as Gtk::TreeView::Selection.
+ * This is a helper object to manage the selection for a Gtk::TreeView widget.
+ *
+ * It is automatically created when a new Gtk::TreeView widget is created, and
+ * cannot exist independently of this widget.  The primary reason this class
+ * exists is for cleanliness of code and API. That is, there is no conceptual
+ * reason all these methods could not be methods on the Gtk::TreeView widget
+ * instead of a separate class.
+ *
+ * The Gtk::TreeSelection object can be obtained from a Gtk::TreeView by
+ * calling Gtk::TreeView::get_selection().  It can be manipulated to check the
+ * selection status of the tree, as well as to select and deselect individual
+ * rows.  Selection is done completely view-side. As a result, multiple views
+ * of the same model can have completely different selections.  Additionally,
+ * you cannot change the selection of a row on the model that is not currently
+ * displayed by the view without expanding its parents first.
+ *
+ * When monitoring the selection of a view, it's important to remember that the
+ * "changed" signal is mostly a hint. That is, it may only emit one signal when
+ * a range of rows is selected. Additionally, it may on occasion emit a
+ * "changed" signal when nothing has happened.
+ *
+ * @ingroup TreeView
+ */
+
+class TreeSelection : public Glib::Object
+{
+   
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+public:
+  typedef TreeSelection CppObjectType;
+  typedef TreeSelection_Class CppClassType;
+  typedef GtkTreeSelection BaseObjectType;
+  typedef GtkTreeSelectionClass BaseClassType;
+
+private:  friend class TreeSelection_Class;
+  static CppClassType treeselection_class_;
+
+private:
+  // noncopyable
+  TreeSelection(const TreeSelection&);
+  TreeSelection& operator=(const TreeSelection&);
+
+protected:
+  explicit TreeSelection(const Glib::ConstructParams& construct_params);
+  explicit TreeSelection(GtkTreeSelection* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+  virtual ~TreeSelection();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GObject.
+  GtkTreeSelection*       gobj()       { return reinterpret_cast<GtkTreeSelection*>(gobject_); }
+
+  ///Provides access to the underlying C GObject.
+  const GtkTreeSelection* gobj() const { return reinterpret_cast<GtkTreeSelection*>(gobject_); }
+
+  ///Provides access to the underlying C instance. The caller is responsible for unrefing it. Use when directly setting fields in structs.
+  GtkTreeSelection* gobj_copy();
+
+private:
+
+   
+protected:
+  
+
+public:
+  
+  /** Sets the selection mode of the @a selection .  If the previous type was
+   * Gtk::SELECTION_MULTIPLE, then the anchor is kept selected, if it was
+   * previously selected.
+   * @param type The selection mode.
+   */
+  void set_mode(SelectionMode type);
+  
+  /** Gets the selection mode for @a selection . See
+   * set_mode().
+   * @return The current selection mode.
+   */
+  SelectionMode get_mode() const;
+
+  /** For instance, bool on_select_function(const Glib::RefPtr<TreeModel>& model, const TreeModel::Path& path, bool path_currently_selected)
+   * The select function should return true if the state of the node may be toggled,
+   * and false if the state of the node should be left unchanged.
+   */
+  typedef sigc::slot<bool, const Glib::RefPtr<TreeModel>&, const TreeModel::Path&, bool> SlotSelect;
+
+  /** Sets the selection callback slot. If set, this function is called before any node is selected or unselected,
+   * giving some control over which nodes are selected.
+   *
+   * The select function should return true if the state of the node may be toggled, and FALSE if the state of the node
+   * should be left unchanged.
+   *
+   * @param slot The selection function.
+   */
+  void set_select_function(const SlotSelect& slot);
+
+   // This would be our SignalProxy_Select* data.
+
+  
+  /** Returns the tree view associated with @a selection .
+   * @return A Gtk::TreeView.
+   */
+  TreeView* get_tree_view();
+  
+  /** Returns the tree view associated with @a selection .
+   * @return A Gtk::TreeView.
+   */
+  const TreeView* get_tree_view() const;
+
+  /** Shortcut for get_tree_view()->get_model().
+   * @return The TreeModel associated with this TreeSelection.
+   */
+  Glib::RefPtr<TreeModel> get_model(); // convenience function, not in GTK+
+  Glib::RefPtr<const TreeModel> get_model() const; // convenience function, not in GTK+
+
+  //TODO: Add TreeModel::const_iterator get_selected() const, when we have a real const_iterator.
+  
+  /** Get the currently selected row.
+   * @return The currently selected row.
+   * @note
+   * This method won't work if the selection mode is <tt>Gtk::SELECTION_MULTIPLE</tt>.
+   * Use get_selected_rows() for multiple selections.
+   */
+  TreeModel::iterator get_selected();
+
+  /** Get the currently selected row.
+   * @return The currently selected row. Or end() if no rows were selected.
+   * @retval model The current TreeModel.
+   * @note
+   * This method won't work if the selection mode is <tt>Gtk::SELECTION_MULTIPLE</tt>.
+   * Use get_selected_rows() for multiple selections.
+   */
+  TreeModel::iterator get_selected(Glib::RefPtr<TreeModel>& model);
+
+  typedef Glib::ListHandle<TreeModel::Path, TreePath_Traits> ListHandle_Path;
+
+  /** Creates a list of paths of all selected rows.
+   * Additionally, if you are planning on modifying the model after calling this function,
+   * you may want to convert the returned list into a list of GtkTreeRowReferences.
+   *
+   * @returns a standard container containing a Gtk::Model::Path for each selected row.
+   */
+  ListHandle_Path get_selected_rows() const;
+
+  /** Creates a list of paths of all selected rows.
+   * Additionally, if you are planning on modifying the model after calling this function,
+   * you may want to convert the returned list into a list of GtkTreeRowReferences.
+   *
+   * @retval model The current TreeModel.
+   * @returns a standard container containing a Gtk::Model::Path for each selected row.
+   */
+  ListHandle_Path get_selected_rows(Glib::RefPtr<TreeModel>& model);
+
+  
+  /** Returns the number of rows that have been selected in @a tree .
+   * @return The number of rows selected.
+   * 
+   * Since: 2.2.
+   */
+  int count_selected_rows() const;
+
+  //TODO: Consider deprecating these selected_foreach() methods, because get_selected_rows() should be enough.
+
+  //TODO: SlotForEachIter should take a const_iterator, when we have a real const iterator.
+  /** For example,
+   * void on_foreach(const Gtk::TreeModel::iterator& iter);
+   *
+   * Note that you cannot modify the tree or selection from within the callback function.
+   * As a result, get_selected_rows() might be more useful.
+   */
+  typedef sigc::slot<void, const TreeModel::iterator&> SlotForeachIter;
+
+  /** Calls a callback slot for each selected node.
+   * Note that you cannot modify the tree or selection from within the callback function.
+   * As a result, get_selected_rows() might be more useful.
+   *
+   * @param slot The function to call for each selected node.
+   */
+  void selected_foreach_iter(const SlotForeachIter& slot) const;
+
+  /** For example,
+   * void on_foreach(const Gtk::TreeModel::Path& path);
+   *
+   * Note that you cannot modify the tree or selection from within the callback function.
+   * As a result, get_selected_rows() might be more useful.
+   */
+  typedef sigc::slot<void, const TreeModel::Path&> SlotForeachPath;
+
+  /** Calls a callback slot for each selected node.
+   * Note that you cannot modify the tree or selection from within the callback function.
+   * As a result, get_selected_rows() might be more useful.
+   *
+   * @param slot The function to call for each selected node.
+   */
+  void selected_foreach_path(const SlotForeachPath& slot) const;
+  
+
+  /** For example,
+   * void on_foreach(const Gtk::TreeModel::Path& path, const Gtk::TreeModel::iterator& iter);
+   *
+   * Note that you cannot modify the tree or selection from within the callback function.
+   * As a result, get_selected_rows() might be more useful.
+   */
+  typedef sigc::slot<void, const TreeModel::Path&, const TreeModel::iterator&> SlotForeachPathAndIter;
+
+  /** Calls a callback slot for each selected node.
+   * Note that you cannot modify the tree or selection from within the callback function.
+   * As a result, get_selected_rows() might be more useful.
+   *
+   * @param slot The function to call for each selected node.
+   */
+  void selected_foreach(const SlotForeachPathAndIter& slot) const;
+
+  
+  /** Select the row at @a path .
+   * @param path The Gtk::TreePath to be selected.
+   */
+  void select(const TreeModel::Path& path);
+  
+  /** Selects the specified iterator.
+   * @param iter The Gtk::TreeIter to be selected.
+   */
+  void select(const TreeModel::iterator& iter);
+  
+  /** Selects the specified iterator.
+   * @param iter The Gtk::TreeIter to be selected.
+   */
+  void select(const TreeModel::Row& row);
+  
+  /** Selects a range of nodes, determined by @a start_path  and @a end_path  inclusive.
+   *  @a selection  must be set to Gtk::SELECTION_MULTIPLE mode.
+   * @param start_path The initial node of the range.
+   * @param end_path The final node of the range.
+   */
+  void select(const TreeModel::Path& start_path, const TreeModel::Path& end_path);
+
+  
+  /** Unselects the row at @a path .
+   * @param path The Gtk::TreePath to be unselected.
+   */
+  void unselect(const TreeModel::Path& path);
+  
+  /** Unselects a range of nodes, determined by @a start_path  and @a end_path 
+   * inclusive.
+   * 
+   * Since: 2.2
+   * @param start_path The initial node of the range.
+   * @param end_path The initial node of the range.
+   */
+  void unselect(const TreeModel::Path& start_path, const TreeModel::Path& end_path);
+  
+  /** Unselects the specified iterator.
+   * @param iter The Gtk::TreeIter to be unselected.
+   */
+  void unselect(const TreeModel::iterator& iter);
+
+  
+  /** Returns <tt>true</tt> if the row pointed to by @a path  is currently selected.  If @a path 
+   * does not point to a valid location, <tt>false</tt> is returned
+   * @param path A Gtk::TreePath to check selection on.
+   * @return <tt>true</tt> if @a path  is selected.
+   */
+  bool is_selected(const TreeModel::Path& path) const;
+  
+  /** Returns <tt>true</tt> if the row at @a iter  is currently selected.
+   * @param iter A valid Gtk::TreeIter.
+   * @return <tt>true</tt>, if @a iter  is selected.
+   */
+  bool is_selected(const TreeModel::iterator& iter) const;
+  
+  
+  /** Selects all the nodes. @a selection  must be set to Gtk::SELECTION_MULTIPLE
+   * mode.
+   */
+  void select_all();
+  
+  /** Unselects all the nodes.
+   */
+  void unselect_all();
+  
+  
+  Glib::SignalProxy0< void > signal_changed();
+
+
+public:
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+  virtual void on_changed();
+
+
+};
+
+} // namespace Gtk
+
+
+namespace Glib
+{
+  /** @relates Gtk::TreeSelection
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Glib::RefPtr<Gtk::TreeSelection> wrap(GtkTreeSelection* object, bool take_copy = false);
+}
+
+
+#endif /* _GTKMM_TREESELECTION_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/treesortable.cc b/libs/gtkmm2/gtk/gtkmm/treesortable.cc
new file mode 100644
index 0000000000..3318bd4d0c
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/treesortable.cc
@@ -0,0 +1,606 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/treesortable.h>
+#include <gtkmm/private/treesortable_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+namespace
+{
+
+// This Signal Proxy allows the C++ coder to specify a sigc::slot instead of a static function.
+class SignalProxy_Compare
+{
+public:
+  typedef Gtk::TreeSortable::SlotCompare SlotType;
+
+  explicit SignalProxy_Compare(const SlotType& slot);
+  ~SignalProxy_Compare();
+
+  static int  gtk_callback(GtkTreeModel* model, GtkTreeIter* lhs, GtkTreeIter* rhs, void* data);
+  static void gtk_callback_destroy(void* data);
+
+private:
+  SlotType slot_;
+};
+
+SignalProxy_Compare::SignalProxy_Compare(const SlotType& slot)
+:
+  slot_ (slot)
+{}
+
+SignalProxy_Compare::~SignalProxy_Compare()
+{}
+
+int SignalProxy_Compare::gtk_callback(GtkTreeModel* model, GtkTreeIter* lhs, GtkTreeIter* rhs, void* data)
+{
+  SignalProxy_Compare *const self = static_cast<SignalProxy_Compare*>(data);
+
+  try
+  {
+    // use Slot::operator()
+    return (self->slot_)(Gtk::TreeIter(model, lhs), Gtk::TreeIter(model, rhs));
+  }
+  catch(...)
+  {
+    Glib::exception_handlers_invoke();
+  }
+
+  return 0;
+}
+
+void SignalProxy_Compare::gtk_callback_destroy(void* data)
+{
+  delete static_cast<SignalProxy_Compare*>(data);
+}
+
+} // anonymous namespace
+
+
+namespace Gtk
+{
+
+void TreeSortable::set_sort_func(int sort_column_id, const SlotCompare& slot)
+{
+  SignalProxy_Compare *const pSignalProxy = new SignalProxy_Compare(slot);
+
+  gtk_tree_sortable_set_sort_func(
+      gobj(), sort_column_id,
+      &SignalProxy_Compare::gtk_callback, pSignalProxy,
+      &SignalProxy_Compare::gtk_callback_destroy);
+}
+
+void TreeSortable::set_sort_func(const Gtk::TreeModelColumnBase& sort_column, const SlotCompare& slot)
+{
+  set_sort_func(sort_column.index(), slot);
+}
+
+void TreeSortable::set_default_sort_func(const SlotCompare& slot)
+{
+  SignalProxy_Compare *const pSignalProxy = new SignalProxy_Compare(slot);
+
+  gtk_tree_sortable_set_default_sort_func(
+      gobj(),
+      &SignalProxy_Compare::gtk_callback, pSignalProxy,
+      &SignalProxy_Compare::gtk_callback_destroy);
+}
+
+void TreeSortable::unset_default_sort_func()
+{
+  gtk_tree_sortable_set_default_sort_func(
+      gobj(), 0, 0, 0); /* See GTK+ docs about the 0s. */
+}
+
+//deprecated:
+void TreeSortable::set_sort_column_id(const TreeModelColumnBase& sort_column, SortType order)
+{
+  set_sort_column(sort_column, order);
+}
+
+//deprecated:
+void TreeSortable::set_sort_column_id(int sort_column_id, SortType order)
+{
+  set_sort_column(sort_column_id, order);
+}  
+
+} // namespace Gtk
+
+
+namespace
+{
+
+const Glib::SignalProxyInfo TreeSortable_signal_sort_column_changed_info =
+{
+  "sort_column_changed",
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
+};
+
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Glib::RefPtr<Gtk::TreeSortable> wrap(GtkTreeSortable* object, bool take_copy)
+{
+  return Glib::RefPtr<Gtk::TreeSortable>( dynamic_cast<Gtk::TreeSortable*> (Glib::wrap_auto ((GObject*)(object), take_copy)) );
+  //We use dynamic_cast<> in case of multiple inheritance.
+}
+
+} // namespace Glib
+
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Interface_Class& TreeSortable_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Interface_Class has to know the interface init function
+    // in order to add interfaces to implementing types.
+    class_init_func_ = &TreeSortable_Class::iface_init_function;
+
+    // We can not derive from another interface, and it is not necessary anyway.
+    gtype_ = gtk_tree_sortable_get_type();
+  }
+
+  return *this;
+}
+
+void TreeSortable_Class::iface_init_function(void* g_iface, void*)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_iface);
+
+  //This is just to avoid an "unused variable" warning when there are no vfuncs or signal handlers to connect.
+  //This is a temporary fix until I find out why I can not seem to derive a GtkFileChooser interface. murrayc
+  g_assert(klass != 0); 
+
+  klass->get_sort_column_id = &get_sort_column_id_vfunc_callback;
+  klass->set_sort_column_id = &set_sort_column_id_vfunc_callback;
+  klass->set_sort_func = &set_sort_func_vfunc_callback;
+  klass->set_default_sort_func = &set_default_sort_func_vfunc_callback;
+  klass->has_default_sort_func = &has_default_sort_func_vfunc_callback;
+  klass->sort_column_changed = &sort_column_changed_vfunc_callback;
+  klass->sort_column_changed = &sort_column_changed_callback;
+}
+
+gboolean TreeSortable_Class::get_sort_column_id_vfunc_callback(GtkTreeSortable* self, int* sort_column_id, GtkSortType* order)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return static_cast<int>(obj->get_sort_column_id_vfunc(sort_column_id, ((SortType*) (order))
+));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->get_sort_column_id)
+      return (*base->get_sort_column_id)(self, sort_column_id, order);
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+void TreeSortable_Class::set_sort_column_id_vfunc_callback(GtkTreeSortable* self, int sort_column_id, GtkSortType order)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->set_sort_column_id_vfunc(sort_column_id, ((SortType)(order))
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->set_sort_column_id)
+      (*base->set_sort_column_id)(self, sort_column_id, order);
+  }
+}
+
+void TreeSortable_Class::set_sort_func_vfunc_callback(GtkTreeSortable* self, int sort_column_id, GtkTreeIterCompareFunc func, gpointer data, GtkDestroyNotify destroy)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->set_sort_func_vfunc(sort_column_id, func, data
+, destroy);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->set_sort_func)
+      (*base->set_sort_func)(self, sort_column_id, func, data, destroy);
+  }
+}
+
+void TreeSortable_Class::set_default_sort_func_vfunc_callback(GtkTreeSortable* self, GtkTreeIterCompareFunc func, gpointer data, GtkDestroyNotify destroy)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->set_default_sort_func_vfunc(func, data
+, destroy);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->set_default_sort_func)
+      (*base->set_default_sort_func)(self, func, data, destroy);
+  }
+}
+
+gboolean TreeSortable_Class::has_default_sort_func_vfunc_callback(GtkTreeSortable* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return static_cast<int>(obj->has_default_sort_func_vfunc());
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->has_default_sort_func)
+      return (*base->has_default_sort_func)(self);
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+void TreeSortable_Class::sort_column_changed_vfunc_callback(GtkTreeSortable* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->sort_column_changed_vfunc();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->sort_column_changed)
+      (*base->sort_column_changed)(self);
+  }
+}
+
+
+void TreeSortable_Class::sort_column_changed_callback(GtkTreeSortable* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_sort_column_changed();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
+)    );
+
+    // Call the original underlying C function:
+    if(base && base->sort_column_changed)
+      (*base->sort_column_changed)(self);
+  }
+}
+
+
+Glib::ObjectBase* TreeSortable_Class::wrap_new(GObject* object)
+{
+  return new TreeSortable((GtkTreeSortable*)(object));
+}
+
+
+/* The implementation: */
+
+TreeSortable::TreeSortable()
+:
+  Glib::Interface(treesortable_class_.init())
+{}
+
+TreeSortable::TreeSortable(GtkTreeSortable* castitem)
+:
+  Glib::Interface((GObject*)(castitem))
+{}
+
+TreeSortable::~TreeSortable()
+{}
+
+// static
+void TreeSortable::add_interface(GType gtype_implementer)
+{
+  treesortable_class_.init().add_interface(gtype_implementer);
+}
+
+TreeSortable::CppClassType TreeSortable::treesortable_class_; // initialize static member
+
+GType TreeSortable::get_type()
+{
+  return treesortable_class_.init().get_type();
+}
+
+GType TreeSortable::get_base_type()
+{
+  return gtk_tree_sortable_get_type();
+}
+
+
+bool TreeSortable::get_sort_column_id(int& sort_column_id, SortType& order) const
+{
+  return gtk_tree_sortable_get_sort_column_id(const_cast<GtkTreeSortable*>(gobj()), &sort_column_id, ((GtkSortType*) &(order)));
+}
+
+void TreeSortable::set_sort_column(const TreeModelColumnBase& sort_column_id, SortType order)
+{
+  gtk_tree_sortable_set_sort_column_id(gobj(), (sort_column_id).index(), ((GtkSortType)(order)));
+}
+
+void TreeSortable::set_sort_column(int sort_column_id, SortType order)
+{
+  gtk_tree_sortable_set_sort_column_id(gobj(), sort_column_id, ((GtkSortType)(order)));
+}
+
+bool TreeSortable::has_default_sort_func() const
+{
+  return gtk_tree_sortable_has_default_sort_func(const_cast<GtkTreeSortable*>(gobj()));
+}
+
+void TreeSortable::sort_column_changed()
+{
+  gtk_tree_sortable_sort_column_changed(gobj());
+}
+
+
+Glib::SignalProxy0< void > TreeSortable::signal_sort_column_changed()
+{
+  return Glib::SignalProxy0< void >(this, &TreeSortable_signal_sort_column_changed_info);
+}
+
+
+void Gtk::TreeSortable::on_sort_column_changed()
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->sort_column_changed)
+    (*base->sort_column_changed)(gobj());
+}
+
+
+bool Gtk::TreeSortable::get_sort_column_id_vfunc(int* sort_column_id, SortType* order) const
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->get_sort_column_id)
+    return (*base->get_sort_column_id)(const_cast<GtkTreeSortable*>(gobj()),sort_column_id,((GtkSortType*) (order)));
+
+  typedef bool RType;
+  return RType();
+}
+
+void Gtk::TreeSortable::set_sort_column_id_vfunc(int sort_column_id, SortType order) 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->set_sort_column_id)
+    (*base->set_sort_column_id)(gobj(),sort_column_id,((GtkSortType)(order)));
+}
+
+void Gtk::TreeSortable::set_sort_func_vfunc(int sort_column_id, GtkTreeIterCompareFunc func, void* data, GtkDestroyNotify destroy) 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->set_sort_func)
+    (*base->set_sort_func)(gobj(),sort_column_id,func,data,destroy);
+}
+
+void Gtk::TreeSortable::set_default_sort_func_vfunc(GtkTreeIterCompareFunc func, void* data, GtkDestroyNotify destroy) 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->set_default_sort_func)
+    (*base->set_default_sort_func)(gobj(),func,data,destroy);
+}
+
+bool Gtk::TreeSortable::has_default_sort_func_vfunc() const
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->has_default_sort_func)
+    return (*base->has_default_sort_func)(const_cast<GtkTreeSortable*>(gobj()));
+
+  typedef bool RType;
+  return RType();
+}
+
+void Gtk::TreeSortable::sort_column_changed_vfunc() const
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
+g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
+)  );
+
+  if(base && base->sort_column_changed)
+    (*base->sort_column_changed)(const_cast<GtkTreeSortable*>(gobj()));
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/treesortable.h b/libs/gtkmm2/gtk/gtkmm/treesortable.h
new file mode 100644
index 0000000000..6b295a1f41
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/treesortable.h
@@ -0,0 +1,238 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_TREESORTABLE_H
+#define _GTKMM_TREESORTABLE_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+
+/* Copyright (C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <glibmm/interface.h>
+#include <gtkmm/enums.h>
+#include <gtkmm/treemodelcolumn.h>
+#include <gtkmm/treemodel.h>
+#include <gtkmm/treeiter.h>
+#include <gtk/gtktreesortable.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkTreeSortable GtkTreeSortable;
+typedef struct _GtkTreeSortableClass GtkTreeSortableClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class TreeSortable_Class; } // namespace Gtk
+namespace Gtk
+{
+
+/**
+ * @ingroup TreeView
+*/
+
+class TreeSortable : public Glib::Interface
+{
+  
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+public:
+  typedef TreeSortable CppObjectType;
+  typedef TreeSortable_Class CppClassType;
+  typedef GtkTreeSortable BaseObjectType;
+  typedef GtkTreeSortableIface BaseClassType;
+
+private:
+  friend class TreeSortable_Class;
+  static CppClassType treesortable_class_;
+
+  // noncopyable
+  TreeSortable(const TreeSortable&);
+  TreeSortable& operator=(const TreeSortable&);
+
+protected:
+  TreeSortable(); // you must derive from this class
+  explicit TreeSortable(GtkTreeSortable* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+  virtual ~TreeSortable();
+
+  static void add_interface(GType gtype_implementer);
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GObject.
+  GtkTreeSortable*       gobj()       { return reinterpret_cast<GtkTreeSortable*>(gobject_); }
+
+  ///Provides access to the underlying C GObject.  
+  const GtkTreeSortable* gobj() const { return reinterpret_cast<GtkTreeSortable*>(gobject_); }
+
+private:
+
+
+public:
+
+  enum
+  {
+    /// See set_default_sort_func() and set_sort_column().
+    DEFAULT_SORT_COLUMN_ID = -1,
+    DEFAULT_UNSORTED_COLUMN_ID = -2
+  }; //See GTK+ implementation.
+
+  
+  /** Fills in @a sort_column_id  and @a order  with the current sort column and the
+   * order.  It returns <tt>true</tt> unless the @a sort_column_id  is 
+   * Gtk::TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID or 
+   * Gtk::TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID.
+   * @param sort_column_id The sort column id to be filled in.
+   * @param order The Gtk::SortType to be filled in.
+   * @return <tt>true</tt> if the sort column is not one of the special sort
+   * column ids.
+   */
+  bool get_sort_column_id(int& sort_column_id, SortType& order) const;
+
+  
+  /** Sets the current sort column to be @a sort_column_id .  The @a sortable  will
+   * resort itself to reflect this change, after emitting a
+   * GtkTreeSortable::sort_column_changed signal.  If @a sort_column_id  is
+   * Gtk::TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, then the default sort function
+   * will be used, if it is set.
+   * @param sort_column_id The sort column id to set.
+   * @param order The sort order of the column.
+   */
+  void set_sort_column(const TreeModelColumnBase& sort_column_id, SortType order);
+  
+  /** Sets the current sort column to be @a sort_column_id .  The @a sortable  will
+   * resort itself to reflect this change, after emitting a
+   * GtkTreeSortable::sort_column_changed signal.  If @a sort_column_id  is
+   * Gtk::TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, then the default sort function
+   * will be used, if it is set.
+   * @param sort_column_id The sort column id to set.
+   * @param order The sort order of the column.
+   */
+  void set_sort_column(int sort_column_id, SortType order);
+
+  #ifndef GTKMM_DISABLE_DEPRECATED
+  /** @deprecated Use set_sort_column() instead.
+   */
+  void set_sort_column_id(const TreeModelColumnBase& sort_column_id, SortType order);
+
+  /** @deprecated Use set_sort_column() instead.
+   */
+  void set_sort_column_id(int sort_column_id, SortType order);
+  #endif //GTKMM_DISABLE_DEPRECATED
+
+  /** This callback should return -1 if b compares before a, 0 if they compare equal, 1 if a compares after b. 
+   * For instance, int on_sort_compare(const Gtk::TreeModel::iterator& a, const Gtk::TreeModel::iterator& b);
+   */
+  typedef sigc::slot<int, const Gtk::TreeModel::iterator&, const Gtk::TreeModel::iterator&> SlotCompare;
+
+  
+  /** Sets the comparison function used when sorting a certain column.
+   * If the current sort column is the same as @a sort_column, then the model will sort using this function.
+   * @param sort_column the sort column to set the function for
+   * @param slot The sorting slot callback.
+   */
+  void set_sort_func(const TreeModelColumnBase& sort_column, const SlotCompare& slot);
+
+  /** Sets the comparison function used when sorting a certain column.
+   * If the current sort column id is the same as @a sort_column_id, then the model will sort using this function.
+   * @param sort_column_id the sort column id to set the function for
+   * @param slot The sorting slot callback.
+   */
+  void set_sort_func(int sort_column_id, const SlotCompare& slot);
+
+  /** Sets the default comparison function used when sorting.
+   * If the current sort column id of sortable is DEFAULT_SORT_COLUMN_ID, then the model will
+   * sort using this function.  See also unset_default_sort_func().
+   *
+   * @param slot The sorting function
+   */
+  void set_default_sort_func(const SlotCompare& slot);
+
+  /** Sets the default comparison function used when sorting. See set_default_sort_func().
+   *
+   * After calling this method there will be no default comparison function. This means that once the model has been sorted,
+   * it can't go back to the default state. In this case, when the current sort column id of sortable is
+   * DEFAULT_SORT_COLUMN_ID, the model will be unsorted.
+   */
+  void unset_default_sort_func();
+
+  
+  /** Returns <tt>true</tt> if the model has a default sort function.  This is used
+   * primarily by GtkTreeViewColumns in order to determine if a model can go back
+   * to the default state, or not.
+   * @return <tt>true</tt>, if the model has a default sort function.
+   */
+  bool has_default_sort_func() const;
+
+  
+  /** Emits a GtkTreeSortable::sort_column_changed signal on
+   */
+  void sort_column_changed();
+  
+
+  Glib::SignalProxy0< void > signal_sort_column_changed();
+
+
+protected:
+    virtual bool get_sort_column_id_vfunc(int* sort_column_id, SortType* order) const;
+    virtual void set_sort_column_id_vfunc(int sort_column_id, SortType order);
+    virtual void set_sort_func_vfunc(int sort_column_id, GtkTreeIterCompareFunc func, void* data, GtkDestroyNotify destroy);
+    virtual void set_default_sort_func_vfunc(GtkTreeIterCompareFunc func, void* data, GtkDestroyNotify destroy);
+    virtual bool has_default_sort_func_vfunc() const;
+    virtual void sort_column_changed_vfunc() const;
+
+
+public:
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+  virtual void on_sort_column_changed();
+
+
+};
+
+} // namespace Gtk
+
+
+namespace Glib
+{
+  /** @relates Gtk::TreeSortable
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Glib::RefPtr<Gtk::TreeSortable> wrap(GtkTreeSortable* object, bool take_copy = false);
+
+} // namespace Glib
+
+#endif /* _GTKMM_TREESORTABLE_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/treestore.cc b/libs/gtkmm2/gtk/gtkmm/treestore.cc
new file mode 100644
index 0000000000..cddd5961eb
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/treestore.cc
@@ -0,0 +1,283 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/treestore.h>
+#include <gtkmm/private/treestore_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtk/gtktreestore.h>
+
+
+namespace Gtk
+{
+
+TreeStore::TreeStore(const TreeModelColumnRecord& columns)
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Glib::Object(Glib::ConstructParams(treestore_class_.init(), (char*) 0))
+{
+  gtk_tree_store_set_column_types(gobj(), columns.size(), const_cast<GType*>(columns.types()));
+}
+
+void TreeStore::set_column_types(const TreeModelColumnRecord& columns)
+{
+   gtk_tree_store_set_column_types(gobj(), columns.size(), const_cast<GType*>(columns.types()));
+}
+  
+TreeModel::iterator TreeStore::erase(const iterator& iter)
+{
+  g_assert(iter.get_gobject_if_not_end() != 0);
+
+  iterator next (iter);
+  ++next;
+
+  GtkTreeIter tmp = *iter.gobj();
+  gtk_tree_store_remove(gobj(), &tmp);
+
+  return next;
+}
+
+TreeModel::iterator TreeStore::insert(const iterator& iter)
+{
+  iterator new_pos (this);
+
+  gtk_tree_store_insert_before(
+      gobj(), new_pos.gobj(),
+      const_cast<GtkTreeIter*>(iter.get_parent_gobject_if_end()),
+      const_cast<GtkTreeIter*>(iter.get_gobject_if_not_end()));
+
+  if(new_pos.gobj()->stamp == 0)
+    new_pos.setup_end_iterator(iter);
+
+  return new_pos;
+}
+
+TreeModel::iterator TreeStore::insert_after(const iterator& iter)
+{
+  iterator new_pos (this);
+
+  gtk_tree_store_insert_after(
+      gobj(), new_pos.gobj(),
+      const_cast<GtkTreeIter*>(iter.get_parent_gobject_if_end()),
+      const_cast<GtkTreeIter*>(iter.get_gobject_if_not_end()));
+
+  if(new_pos.gobj()->stamp == 0)
+    new_pos.setup_end_iterator(iter);
+
+  return new_pos;
+}
+
+TreeModel::iterator TreeStore::prepend()
+{
+  iterator new_pos (this);
+  gtk_tree_store_prepend(gobj(), new_pos.gobj(), 0);
+  return new_pos;
+}
+
+TreeModel::iterator TreeStore::prepend(const TreeNodeChildren& node)
+{
+  iterator new_pos (this);
+
+  gtk_tree_store_prepend(
+      gobj(), new_pos.gobj(),
+      const_cast<GtkTreeIter*>(node.get_parent_gobject()));
+
+  return new_pos;
+}
+
+TreeModel::iterator TreeStore::append()
+{
+  iterator new_pos (this);
+  gtk_tree_store_append(gobj(), new_pos.gobj(), 0);
+  return new_pos;
+}
+
+TreeModel::iterator TreeStore::append(const TreeNodeChildren& node)
+{
+  iterator new_pos (this);
+
+  gtk_tree_store_append(
+      gobj(), new_pos.gobj(),
+      const_cast<GtkTreeIter*>(node.get_parent_gobject()));
+
+  return new_pos;
+}
+
+void TreeStore::move(const iterator& source, const iterator& destination)
+{
+  gtk_tree_store_move_before(gobj(),
+      const_cast<GtkTreeIter*>(source.get_gobject_if_not_end()),
+      const_cast<GtkTreeIter*>(destination.get_gobject_if_not_end()));
+}
+
+void TreeStore::reorder(const TreeNodeChildren& node, const Glib::ArrayHandle<int>& new_order)
+{
+  gtk_tree_store_reorder(gobj(),
+      const_cast<GtkTreeIter*>(node.get_parent_gobject()),
+      const_cast<int*>(new_order.data()));
+}
+
+void TreeStore::set_value_impl(const iterator& row, int column, const Glib::ValueBase& value)
+{
+  gtk_tree_store_set_value(
+      gobj(), const_cast<GtkTreeIter*>(row.gobj()),
+      column, const_cast<GValue*>(value.gobj()));
+}
+
+} // namespace Gtk
+
+
+namespace
+{
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Glib::RefPtr<Gtk::TreeStore> wrap(GtkTreeStore* object, bool take_copy)
+{
+  return Glib::RefPtr<Gtk::TreeStore>( dynamic_cast<Gtk::TreeStore*> (Glib::wrap_auto ((GObject*)(object), take_copy)) );
+  //We use dynamic_cast<> in case of multiple inheritance.
+}
+
+} /* namespace Glib */
+
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& TreeStore_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &TreeStore_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_tree_store_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  TreeModel::add_interface(get_type());
+  TreeSortable::add_interface(get_type());
+  TreeDragSource::add_interface(get_type());
+  TreeDragDest::add_interface(get_type());
+  }
+
+  return *this;
+}
+
+void TreeStore_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+}
+
+
+Glib::ObjectBase* TreeStore_Class::wrap_new(GObject* object)
+{
+  return new TreeStore((GtkTreeStore*)object);
+}
+
+
+/* The implementation: */
+
+GtkTreeStore* TreeStore::gobj_copy()
+{
+  reference();
+  return gobj();
+}
+
+TreeStore::TreeStore(const Glib::ConstructParams& construct_params)
+:
+  Glib::Object(construct_params)
+{}
+
+TreeStore::TreeStore(GtkTreeStore* castitem)
+:
+  Glib::Object((GObject*)(castitem))
+{}
+
+TreeStore::~TreeStore()
+{}
+
+
+TreeStore::CppClassType TreeStore::treestore_class_; // initialize static member
+
+GType TreeStore::get_type()
+{
+  return treestore_class_.init().get_type();
+}
+
+GType TreeStore::get_base_type()
+{
+  return gtk_tree_store_get_type();
+}
+
+
+TreeStore::TreeStore()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Glib::Object(Glib::ConstructParams(treestore_class_.init()))
+{
+  }
+
+Glib::RefPtr<TreeStore> TreeStore::create(const TreeModelColumnRecord& columns)
+{
+  return Glib::RefPtr<TreeStore>( new TreeStore(columns) );
+}
+void TreeStore::iter_swap(const iterator& a, const iterator& b)
+{
+  gtk_tree_store_swap(gobj(), const_cast<GtkTreeIter*>((a).gobj()), const_cast<GtkTreeIter*>((b).gobj()));
+}
+
+void TreeStore::clear()
+{
+  gtk_tree_store_clear(gobj());
+}
+
+bool TreeStore::is_ancestor(const iterator& iter, const iterator& descendant) const
+{
+  return gtk_tree_store_is_ancestor(const_cast<GtkTreeStore*>(gobj()), const_cast<GtkTreeIter*>((iter).gobj()), const_cast<GtkTreeIter*>((descendant).gobj()));
+}
+
+int TreeStore::iter_depth(const iterator& iter) const
+{
+  return gtk_tree_store_iter_depth(const_cast<GtkTreeStore*>(gobj()), const_cast<GtkTreeIter*>((iter).gobj()));
+}
+
+bool TreeStore::iter_is_valid(const iterator& iter) const
+{
+  return gtk_tree_store_iter_is_valid(const_cast<GtkTreeStore*>(gobj()), const_cast<GtkTreeIter*>((iter).gobj()));
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/treestore.h b/libs/gtkmm2/gtk/gtkmm/treestore.h
new file mode 100644
index 0000000000..e5d01a4443
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/treestore.h
@@ -0,0 +1,276 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_TREESTORE_H
+#define _GTKMM_TREESTORE_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* Copyright(C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/treeiter.h>
+#include <gtkmm/treemodel.h>
+#include <gtkmm/treesortable.h>
+#include <gtkmm/treedragdest.h>
+#include <gtkmm/treedragsource.h>
+// We couldn't include it in treemodel.h, but doing it here makes it easier for people.
+#include <gtkmm/treepath.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkTreeStore GtkTreeStore;
+typedef struct _GtkTreeStoreClass GtkTreeStoreClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class TreeStore_Class; } // namespace Gtk
+namespace Gtk
+{
+
+/**
+ * @ingroup TreeView
+ */
+
+class TreeStore :
+  public Glib::Object,
+  public Gtk::TreeModel,
+  public TreeSortable,
+  public TreeDragSource,
+  public TreeDragDest
+{
+  
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+public:
+  typedef TreeStore CppObjectType;
+  typedef TreeStore_Class CppClassType;
+  typedef GtkTreeStore BaseObjectType;
+  typedef GtkTreeStoreClass BaseClassType;
+
+private:  friend class TreeStore_Class;
+  static CppClassType treestore_class_;
+
+private:
+  // noncopyable
+  TreeStore(const TreeStore&);
+  TreeStore& operator=(const TreeStore&);
+
+protected:
+  explicit TreeStore(const Glib::ConstructParams& construct_params);
+  explicit TreeStore(GtkTreeStore* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+  virtual ~TreeStore();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GObject.
+  GtkTreeStore*       gobj()       { return reinterpret_cast<GtkTreeStore*>(gobject_); }
+
+  ///Provides access to the underlying C GObject.
+  const GtkTreeStore* gobj() const { return reinterpret_cast<GtkTreeStore*>(gobject_); }
+
+  ///Provides access to the underlying C instance. The caller is responsible for unrefing it. Use when directly setting fields in structs.
+  GtkTreeStore* gobj_copy();
+
+private:
+
+  
+protected:
+  /** When using this constructor, you must use set_column_types() immediately afterwards.
+   * This can be useful when deriving from this class, with a fixed TreeModelColumnRecord
+   * that is a member of the class.
+   * There is no create() method that corresponds to this constructor, because this
+   * constructor should only be used by derived classes.
+   */
+  TreeStore();
+  
+  explicit TreeStore(const TreeModelColumnRecord& columns);
+
+public:
+  /** Instantiate a new TreeStore.
+   * @param columns The column types for this tree model.
+   * @result The new TreeStore.
+   */
+  
+  static Glib::RefPtr<TreeStore> create(const TreeModelColumnRecord& columns);
+
+
+  void set_column_types(const TreeModelColumnRecord& columns);
+  
+
+  /** Removes the given row from the list store.
+   * @param iter The iterator to the row to be removed.
+   * @result An iterator to the next row, or end() if there is none.
+   */
+  iterator erase(const iterator& iter);
+  
+
+  //TODO: Make this documentation similar to documentation for Standard C++ insert methods.
+  /** Creates a new row before the position.
+   * If iter is end() then a new row will be appended to the list.
+   * The row will be empty - to fill in values, you need to dereference the returned iterator and use Row::operator[] or Row::set_value().
+   * See also prepend() and append().
+   *
+   * @param iter An iterator to the row before which the new row will be inserted.
+   * @result An iterator to the new row.
+   */
+  iterator insert(const iterator& iter);
+  
+
+  /** Creates a new row after the position.
+   * If iter is end() then a new row will be prepended to the list.
+   * The row will be empty - to fill in values, you need to dereference the returned iterator and use Row::operator[] or Row::set_value().
+   * See also prepend() and append().
+   *
+   * @param iter An iterator to the row after which the new row will be inserted.
+   * @result An iterator to the new row.
+   */
+  iterator insert_after(const iterator& iter);
+  
+
+  /** Creates a new row at the start of the top-level.
+   * The row will be empty - to fill in values, you need to dereference the returned iterator and use Row::operator[] or Row::set_value().
+   * See also insert() and append().
+   *
+   * @result An iterator to the new row.
+   */
+  iterator prepend();
+
+  /** Creates a new row at the start of the row's children.
+   * The row will be empty - to fill in values, you need to dereference the returned iterator and use Row::operator[] or Row::set_value().
+   * See also insert() and append().
+   *
+   * @param node The list of the parent row's children, as returned by Gtk::TreeModel::iterator::children().
+   * @result An iterator to the new row.
+   */
+  iterator prepend(const TreeNodeChildren& node);
+
+
+  /** Creates a new row at the end of the top-level.
+   * The row will be empty - to fill in values, you need to dereference the returned iterator and use Row::operator[] or Row::set_value().
+   * See also insert() and prepend().
+   *
+   * @result An iterator to the new row.
+   */
+  iterator append();
+
+  /** Creates a new row at the end of the row's children.
+   * The row will be empty - to fill in values, you need to dereference the returned iterator and use Row::operator[] or Row::set_value().
+   * See also insert() and prepend().
+   *
+   * @param node The list of the parent row's children, as returned by Gtk::TreeModel::iterator::children().
+   * @result An iterator to the new row.
+   */  
+  iterator append(const TreeNodeChildren& node);
+
+  
+  /** Swaps @a a  and @a b  in the same level of @a tree_store . Note that this function
+   * only works with unsorted stores.
+   * 
+   * Since: 2.2
+   * @param a A Gtk::TreeIter.
+   * @param b Another Gtk::TreeIter.
+   */
+  void iter_swap(const iterator& a, const iterator& b);
+
+  /** Moves @a source to the position at @a destination.
+   * @a source and @a destination should be at the same level.
+   * Note that this function only works with unsorted stores.
+   * @param source The row that should be moved.
+   * @param destination The position to move to.
+   */
+  void move(const iterator& source, const iterator& destination);
+
+  /** Reorders the children of @a node to follow the order indicated by @a new_order.
+   * Note that this function only works with unsorted stores.
+   */
+  void reorder(const TreeNodeChildren& node, const Glib::ArrayHandle<int>& new_order);
+
+  
+  /** Removes all rows from @a tree_store 
+   */
+  void clear();
+  
+  /** Returns <tt>true</tt> if @a iter  is an ancestor of @a descendant .  That is, @a iter  is the
+   * parent (or grandparent or great-grandparent) of @a descendant .
+   * @param iter A valid Gtk::TreeIter.
+   * @param descendant A valid Gtk::TreeIter.
+   * @return <tt>true</tt>, if @a iter  is an ancestor of @a descendant .
+   */
+  bool is_ancestor(const iterator& iter, const iterator& descendant) const;
+  
+  /** Returns the depth of @a iter .  This will be 0 for anything on the root level, 1
+   * for anything down a level, etc.
+   * @param iter A valid Gtk::TreeIter.
+   * @return The depth of @a iter .
+   */
+  int iter_depth(const iterator& iter) const;
+
+  
+  /** WARNING: This function is slow. Only use it for debugging and/or testing
+   * purposes.
+   * 
+   * Checks if the given iter is a valid iter for this Gtk::TreeStore.
+   * @param iter A Gtk::TreeIter.
+   * @return <tt>true</tt> if the iter is valid, <tt>false</tt> if the iter is invalid.
+   * 
+   * Since: 2.2.
+   */
+  bool iter_is_valid(const iterator& iter) const;
+
+protected:
+  virtual void set_value_impl(const iterator& row, int column, const Glib::ValueBase& value);
+  
+
+public:
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+};
+
+} // namespace Gtk
+
+
+namespace Glib
+{
+  /** @relates Gtk::TreeStore
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Glib::RefPtr<Gtk::TreeStore> wrap(GtkTreeStore* object, bool take_copy = false);
+}
+
+
+#endif /* _GTKMM_TREESTORE_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/treeview.cc b/libs/gtkmm2/gtk/gtkmm/treeview.cc
new file mode 100644
index 0000000000..4337e88c50
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/treeview.cc
@@ -0,0 +1,1727 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/treeview.h>
+#include <gtkmm/private/treeview_p.h>
+
+#include <gtk/gtktypebuiltins.h>
+// -*- c++ -*-
+/* $Id$ */
+
+/* Copyright 2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtk/gtktreeview.h>
+#include <gtkmm/treeviewcolumn.h>
+#include <gtkmm/treeview_private.h>
+#include <gtkmm/treemodel.h>
+#include <gtkmm/treemodelfilter.h>
+
+namespace
+{
+
+//This target name is used in the GTK+ implementation:
+const char treeview_target_row[]   = "GTK_TREE_MODEL_ROW";
+
+} // anonymous namespace
+
+namespace
+{
+
+//SignalProxy_Mapping:
+
+//This Signal Proxy allows the C++ coder to specify a sigc::slot instead of a static function.
+class SignalProxy_Mapping
+{
+public:
+  typedef Gtk::TreeView::SlotMapping SlotType;
+
+  SignalProxy_Mapping(const SlotType& slot);
+  ~SignalProxy_Mapping();
+
+  static void gtk_callback(GtkTreeView* tree_view, GtkTreePath* path, void* data);
+
+protected:
+  SlotType slot_;
+};
+
+SignalProxy_Mapping::SignalProxy_Mapping(const SlotType& slot)
+:
+  slot_ (slot)
+{}
+
+SignalProxy_Mapping::~SignalProxy_Mapping()
+{}
+
+void SignalProxy_Mapping::gtk_callback(GtkTreeView* tree_view, GtkTreePath* path, void* data)
+{
+  SignalProxy_Mapping *const self = static_cast<SignalProxy_Mapping*>(data);
+
+  try
+  {
+    (self->slot_)(Glib::wrap(tree_view), Gtk::TreePath(path, true));
+  }
+  catch(...)
+  {
+    Glib::exception_handlers_invoke();
+  }
+}
+
+
+//SignalProxy_SearchEqual:
+
+//This Signal Proxy allows the C++ coder to specify a sigc::slot instead of a static function.
+class SignalProxy_SearchEqual
+{
+public:
+  typedef Gtk::TreeView::SlotSearchEqual SlotType;
+
+  SignalProxy_SearchEqual(const SlotType& slot);
+  ~SignalProxy_SearchEqual();
+
+  static gboolean gtk_callback(GtkTreeModel* model, int column, const char* key,
+                               GtkTreeIter* iter, void* data);
+  static void gtk_callback_destroy(void* data);
+
+protected:
+  SlotType slot_;
+};
+
+SignalProxy_SearchEqual::SignalProxy_SearchEqual(const SlotType& slot)
+:
+  slot_ (slot)
+{}
+
+SignalProxy_SearchEqual::~SignalProxy_SearchEqual()
+{}
+
+gboolean SignalProxy_SearchEqual::gtk_callback(GtkTreeModel* model, int column, const char* key,
+                                               GtkTreeIter* iter, void* data)
+{
+  SignalProxy_SearchEqual *const self = static_cast<SignalProxy_SearchEqual*>(data);
+
+  try
+  {
+    return (self->slot_)(Glib::wrap(model, true), column, key, Gtk::TreeIter(model, iter));
+  }
+  catch(...)
+  {
+    Glib::exception_handlers_invoke();
+  }
+
+  return 0; // arbitrary value
+}
+
+void SignalProxy_SearchEqual::gtk_callback_destroy(void* data)
+{
+  delete static_cast<SignalProxy_SearchEqual*>(data);
+}
+
+
+//SignalProxy_ColumnDrop:
+
+//This Signal Proxy allows the C++ coder to specify a sigc::slot instead of a static function.
+class SignalProxy_ColumnDrop
+{
+public:
+  typedef Gtk::TreeView::SlotColumnDrop SlotType;
+
+  SignalProxy_ColumnDrop(const SlotType& slot);
+  ~SignalProxy_ColumnDrop();
+
+  static gboolean gtk_callback(GtkTreeView* tree_view, GtkTreeViewColumn* column,
+                               GtkTreeViewColumn* prev_column, GtkTreeViewColumn* next_column,
+                               void* data);
+  static void gtk_callback_destroy(void* data);
+
+protected:
+  SlotType slot_;
+};
+
+SignalProxy_ColumnDrop::SignalProxy_ColumnDrop(const SlotType& slot)
+:
+  slot_ (slot)
+{}
+
+SignalProxy_ColumnDrop::~SignalProxy_ColumnDrop()
+{}
+
+gboolean SignalProxy_ColumnDrop::gtk_callback(GtkTreeView* tree_view, GtkTreeViewColumn* column,
+                                              GtkTreeViewColumn* prev_column,
+                                              GtkTreeViewColumn* next_column, void* data)
+{
+  SignalProxy_ColumnDrop *const self = static_cast<SignalProxy_ColumnDrop*>(data);
+
+  try
+  {
+    return (self->slot_)(Glib::wrap(tree_view), Glib::wrap(column),
+                         Glib::wrap(prev_column), Glib::wrap(next_column));
+  }
+  catch(...)
+  {
+    Glib::exception_handlers_invoke();
+  }
+
+  return 0; // arbitrary value
+}
+
+void SignalProxy_ColumnDrop::gtk_callback_destroy(void* data)
+{
+  delete static_cast<SignalProxy_ColumnDrop*>(data);
+}
+
+} // anonymous namespace
+
+
+namespace Gtk
+{
+
+void TreeView::unset_hadjustment()
+{
+  gtk_tree_view_set_hadjustment(gobj(), 0);
+}
+
+void TreeView::unset_vadjustment()
+{
+  gtk_tree_view_set_vadjustment(gobj(), 0);
+}
+
+int TreeView::insert_column_with_data_func(int position, const Glib::ustring& title, CellRenderer& cell, const SlotCellData& slot)
+{
+  //Create a signal proxy. A pointer to this will be passed through the callback's data parameter.
+  //It will be deleted when TreeView_Private::SignalProxy_CellData::gtk_callback_destroy() is called.
+  TreeView_Private::SignalProxy_CellData *const pSignalProxy =
+      new TreeView_Private::SignalProxy_CellData(slot);
+
+  return gtk_tree_view_insert_column_with_data_func(
+      gobj(), position, title.c_str(), cell.gobj(),
+      &TreeView_Private::SignalProxy_CellData::gtk_callback, pSignalProxy,
+      &TreeView_Private::SignalProxy_CellData::gtk_callback_destroy);
+}
+
+void TreeView::set_cursor(const TreeModel::Path& path)
+{
+  gtk_tree_view_set_cursor(gobj(), const_cast<GtkTreePath*>(path.gobj()), 0, false);
+}
+
+void TreeView::get_cursor(TreeModel::Path& path, TreeViewColumn*& focus_column)
+{
+  GtkTreePath* pTreePath = 0;
+  GtkTreeViewColumn* pTreeViewColumn = 0;
+  gtk_tree_view_get_cursor(gobj(), &pTreePath, &pTreeViewColumn);
+
+  path = TreeModel::Path(pTreePath, true);
+  focus_column = Glib::wrap(pTreeViewColumn);
+}
+
+
+void TreeView::enable_model_drag_source(const ArrayHandle_TargetEntry& targets,
+                              Gdk::ModifierType start_button_mask,
+                              Gdk::DragAction actions)
+{
+  gtk_tree_view_enable_model_drag_source(
+      gobj(), (GdkModifierType) start_button_mask,
+      targets.data(), targets.size(), (GdkDragAction) actions);
+}
+
+void TreeView::enable_model_drag_source(Gdk::ModifierType start_button_mask, Gdk::DragAction actions)
+{
+  std::list<TargetEntry> listTargets;
+  listTargets.push_back(TargetEntry(treeview_target_row));
+  enable_model_drag_source(listTargets, start_button_mask, actions);
+}    
+
+void TreeView::enable_model_drag_dest(const ArrayHandle_TargetEntry& targets, Gdk::DragAction actions)
+{
+  gtk_tree_view_enable_model_drag_dest(
+      gobj(), targets.data(), targets.size(), (GdkDragAction) actions);
+}
+
+void TreeView::enable_model_drag_dest(Gdk::DragAction actions)
+{
+  std::list<TargetEntry> listTargets;
+  listTargets.push_back(TargetEntry(treeview_target_row));
+  enable_model_drag_dest(listTargets, actions);
+}
+
+bool TreeView::get_path_at_pos(int x, int y, TreeModel::Path& path, TreeViewColumn*& column, int& cell_x, int& cell_y)
+{
+  GtkTreePath* pTreePath = 0;
+  GtkTreeViewColumn* pTreeViewColumn = 0;
+  bool result = gtk_tree_view_get_path_at_pos(gobj(), x, y, &pTreePath, &pTreeViewColumn, &cell_x, &cell_y);
+
+  path = TreeModel::Path(pTreePath, false /* don't take a copy, because the gtk_tree_view_get_path_at_pos() docs say that we must free the path */ );
+  column = Glib::wrap(pTreeViewColumn);
+  return result;
+}
+
+int TreeView::insert_column(const Glib::ustring& title, CellRenderer& cell, int position)
+{
+  return gtk_tree_view_insert_column_with_attributes(
+      gobj(), position, const_cast<char*>(title.c_str()), cell.gobj(), (void*)0); //Note that some compilers need the extra (void*) clue.
+}
+
+int TreeView::append_column(const Glib::ustring& title, CellRenderer& cell)
+{
+  return insert_column(title, cell, -1 /* at the end */);
+}
+
+void TreeView::get_drag_dest_row(TreeModel::Path& path, TreeViewDropPosition& pos) const
+{
+  GtkTreePath* pTreePath = 0;
+  gtk_tree_view_get_drag_dest_row(const_cast<GtkTreeView*>(gobj()), &pTreePath, (GtkTreeViewDropPosition*) &pos);
+  path = TreeModel::Path(pTreePath, true); //true = take_copy.
+}
+
+bool TreeView::get_dest_row_at_pos(int drag_x, int drag_y, TreeModel::Path& path, TreeViewDropPosition& pos) const
+{
+  GtkTreePath* pTreePath = 0;
+  const bool bResult = gtk_tree_view_get_dest_row_at_pos(
+      const_cast<GtkTreeView*>(gobj()), drag_x, drag_y, &pTreePath, (GtkTreeViewDropPosition*) &pos);
+
+  path = TreeModel::Path(pTreePath, true); //true = take_copy.
+  return bResult;
+}
+
+void TreeView::map_expanded_rows(const SlotMapping& slot)
+{
+  //Create a signal proxy.
+  SignalProxy_Mapping signalProxy (slot); //It only needs to live as long as this method call.
+
+  gtk_tree_view_map_expanded_rows(gobj(), &SignalProxy_Mapping::gtk_callback, &signalProxy);
+}
+
+void TreeView::set_search_equal_func(const SlotSearchEqual& slot)
+{
+  //Create a signal proxy. A pointer to this will be passed through the callback's data parameter.
+  //It will be deleted when SignalProxy_SearchEqual::gtk_callback_destroy() is called.
+  SignalProxy_SearchEqual *const pSignalProxy = new SignalProxy_SearchEqual(slot);
+
+  gtk_tree_view_set_search_equal_func(gobj(),
+      &SignalProxy_SearchEqual::gtk_callback, pSignalProxy,
+      &SignalProxy_SearchEqual::gtk_callback_destroy);
+}
+
+void TreeView::set_column_drag_function(const SlotColumnDrop& slot)
+{
+  //Create a signal proxy. A pointer to this will be passed through the callback's data parameter.
+  //It will be deleted when SignalProxy_ColumnDrop::gtk_callback_destroy() is called.
+  SignalProxy_ColumnDrop *const pSignalProxy = new SignalProxy_ColumnDrop(slot);
+
+  gtk_tree_view_set_column_drag_function(gobj(),
+      &SignalProxy_ColumnDrop::gtk_callback, pSignalProxy,
+      &SignalProxy_ColumnDrop::gtk_callback_destroy);
+
+}
+
+void TreeView::unset_column_drag_function()
+{
+  gtk_tree_view_set_column_drag_function(gobj(),
+      0, 0, 0); /* See GTK+ docs about the 0s. */
+}
+
+void TreeView::scroll_to_cell(const TreeModel::Path& path, TreeViewColumn& column, float row_align, float col_align)
+{
+  gtk_tree_view_scroll_to_cell(gobj(), const_cast<GtkTreePath*>(path.gobj()), column.gobj(), TRUE, row_align, col_align);
+}
+
+void TreeView::scroll_to_cell(const TreeModel::Path& path, TreeViewColumn& column)
+{
+  gtk_tree_view_scroll_to_cell(gobj(), const_cast<GtkTreePath*>(path.gobj()), column.gobj(), FALSE, 0.0, 0.0);
+}
+
+void TreeView::scroll_to_row(const TreeModel::Path& path, float row_align)
+{
+  gtk_tree_view_scroll_to_cell(gobj(), const_cast<GtkTreePath*>(path.gobj()), 0, TRUE, row_align, 0.0);
+}
+
+void TreeView::scroll_to_row(const TreeModel::Path& path)
+{
+  gtk_tree_view_scroll_to_cell(gobj(), const_cast<GtkTreePath*>(path.gobj()), 0, FALSE, 0.0, 0.0);
+}
+
+void TreeView::scroll_to_column(TreeViewColumn& column, float col_align)
+{
+  gtk_tree_view_scroll_to_cell(gobj(), 0, column.gobj(), TRUE, 0.0, col_align);
+}
+
+void TreeView::scroll_to_column(TreeViewColumn& column)
+{
+  gtk_tree_view_scroll_to_cell(gobj(), 0, column.gobj(), FALSE, 0.0, 0.0);
+}
+
+void TreeView::remove_all_columns()
+{
+  //This method is not in GTK+, but it seems useful.
+
+  //Remove all View columns:
+  typedef std::list< Gtk::TreeView::Column* > type_vecViewColumns;
+  type_vecViewColumns vecViewColumns = get_columns();
+  for(type_vecViewColumns::iterator iter = vecViewColumns.begin(); iter != vecViewColumns.end(); ++iter)
+  {
+    Gtk::TreeView::Column* pViewColumn = *iter;
+    if(pViewColumn)
+      remove_column(*pViewColumn);
+  }
+}
+
+
+CellRenderer* TreeView::get_column_cell_renderer(int n)
+{
+  TreeViewColumn* pColumn = get_column(n);
+  if(pColumn)
+    return pColumn->get_first_cell_renderer();
+  else
+    return 0;
+}
+
+
+const CellRenderer* TreeView::get_column_cell_renderer(int n) const
+{
+   //Do some const_cast-ing to avoid repetition of code:
+  CellRenderer* pRenderer = const_cast<TreeView*>(this)->get_column_cell_renderer(n);
+  return pRenderer;
+}
+
+void TreeView::reset_expander_column()
+{
+  gtk_tree_view_set_expander_column(gobj(), 0 /* see C docs */);
+}
+
+Glib::RefPtr<Gtk::TreeModel> TreeView::_get_base_model()
+{
+  Glib::RefPtr<TreeModel> refModel = get_model();
+
+  bool get_child = true;
+  while(get_child && refModel)
+  {
+    Glib::RefPtr<Gtk::TreeModelFilter> refModelFilter = Glib::RefPtr<Gtk::TreeModelFilter>::cast_dynamic(refModel);
+    if(refModelFilter)
+      refModel = refModelFilter->get_model();
+    else
+      get_child = false;
+  }
+
+  return refModel;
+}
+
+void TreeView::_auto_store_on_cellrenderer_toggle_edited(const Glib::ustring& path_string,
+                                                         int model_column)
+{
+  Gtk::TreePath path (path_string);
+
+  //Get the row from the path:
+  Glib::RefPtr<TreeModel> refModel = _get_base_model();
+
+  Gtk::TreeModel::iterator iter = refModel->get_iter(path);
+  if(iter)
+  {
+      Gtk::TreeRow row = *iter;
+      
+      //Get the new value:
+      //This seems to get the old value, not the new one,
+      //so we will just NOT the model value ourselves.
+      //bool bActive = cell_renderer->get_active();
+      bool bActive = false;
+      row.get_value(model_column, bActive);
+      bActive = !bActive;
+      
+      //Store the user's new text in the model: 
+      row.set_value(model_column, bActive);
+  }
+}
+
+void TreeView::move_column_to_start(TreeViewColumn& column)
+{
+  gtk_tree_view_move_column_after(gobj(), (column).gobj(), 0 /* See C docs */);
+}
+
+void TreeView::set_row_separator_func(const SlotRowSeparator& slot)
+{
+  //Create a signal proxy. A pointer to this will be passed through the callback's data parameter.
+  //It will be deleted when SignalProxy_RowSeparator::gtk_callback_destroy() is called.
+  TreeView_Private::SignalProxy_RowSeparator *const pSignalProxy = new TreeView_Private::SignalProxy_RowSeparator(slot);
+
+  gtk_tree_view_set_row_separator_func(gobj(),
+      &TreeView_Private::SignalProxy_RowSeparator::gtk_callback, pSignalProxy,
+      &TreeView_Private::SignalProxy_RowSeparator::gtk_callback_destroy);
+}
+
+} // namespace Gtk
+
+
+namespace
+{
+
+void TreeView_signal_set_scroll_adjustments_callback(GtkTreeView* self, GtkAdjustment* p0,GtkAdjustment* p1,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,Adjustment*,Adjustment* > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(Glib::wrap(p0)
+, Glib::wrap(p1)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+}
+
+const Glib::SignalProxyInfo TreeView_signal_set_scroll_adjustments_info =
+{
+  "set-scroll-adjustments",
+  (GCallback) &TreeView_signal_set_scroll_adjustments_callback,
+  (GCallback) &TreeView_signal_set_scroll_adjustments_callback
+};
+
+
+void TreeView_signal_row_activated_callback(GtkTreeView* self, GtkTreePath* p0,GtkTreeViewColumn* p1,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,const TreeModel::Path&,TreeViewColumn* > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(Gtk::TreePath(p0, true)
+, Glib::wrap(p1)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+}
+
+const Glib::SignalProxyInfo TreeView_signal_row_activated_info =
+{
+  "row-activated",
+  (GCallback) &TreeView_signal_row_activated_callback,
+  (GCallback) &TreeView_signal_row_activated_callback
+};
+
+
+gboolean TreeView_signal_test_expand_row_callback(GtkTreeView* self, GtkTreeIter* p0,GtkTreePath* p1,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< bool,const TreeModel::iterator&,const TreeModel::Path& > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        return static_cast<int>((*static_cast<SlotType*>(slot))(TreeModel::iterator(gtk_tree_view_get_model(self), p0)
+, Gtk::TreePath(p1, true)
+));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+gboolean TreeView_signal_test_expand_row_notify_callback(GtkTreeView* self, GtkTreeIter* p0,GtkTreePath* p1, void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,const TreeModel::iterator&,const TreeModel::Path& > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(TreeModel::iterator(gtk_tree_view_get_model(self), p0)
+, Gtk::TreePath(p1, true)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+const Glib::SignalProxyInfo TreeView_signal_test_expand_row_info =
+{
+  "test-expand-row",
+  (GCallback) &TreeView_signal_test_expand_row_callback,
+  (GCallback) &TreeView_signal_test_expand_row_notify_callback
+};
+
+
+gboolean TreeView_signal_test_collapse_row_callback(GtkTreeView* self, GtkTreeIter* p0,GtkTreePath* p1,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< bool,const TreeModel::iterator&,const TreeModel::Path& > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        return static_cast<int>((*static_cast<SlotType*>(slot))(TreeModel::iterator(gtk_tree_view_get_model(self), p0)
+, Gtk::TreePath(p1, true)
+));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+gboolean TreeView_signal_test_collapse_row_notify_callback(GtkTreeView* self, GtkTreeIter* p0,GtkTreePath* p1, void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,const TreeModel::iterator&,const TreeModel::Path& > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(TreeModel::iterator(gtk_tree_view_get_model(self), p0)
+, Gtk::TreePath(p1, true)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+const Glib::SignalProxyInfo TreeView_signal_test_collapse_row_info =
+{
+  "test-collapse-row",
+  (GCallback) &TreeView_signal_test_collapse_row_callback,
+  (GCallback) &TreeView_signal_test_collapse_row_notify_callback
+};
+
+
+void TreeView_signal_row_expanded_callback(GtkTreeView* self, GtkTreeIter* p0,GtkTreePath* p1,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,const TreeModel::iterator&,const TreeModel::Path& > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(TreeModel::iterator(gtk_tree_view_get_model(self), p0)
+, Gtk::TreePath(p1, true)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+}
+
+const Glib::SignalProxyInfo TreeView_signal_row_expanded_info =
+{
+  "row-expanded",
+  (GCallback) &TreeView_signal_row_expanded_callback,
+  (GCallback) &TreeView_signal_row_expanded_callback
+};
+
+
+void TreeView_signal_row_collapsed_callback(GtkTreeView* self, GtkTreeIter* p0,GtkTreePath* p1,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,const TreeModel::iterator&,const TreeModel::Path& > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(TreeModel::iterator(gtk_tree_view_get_model(self), p0)
+, Gtk::TreePath(p1, true)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+}
+
+const Glib::SignalProxyInfo TreeView_signal_row_collapsed_info =
+{
+  "row-collapsed",
+  (GCallback) &TreeView_signal_row_collapsed_callback,
+  (GCallback) &TreeView_signal_row_collapsed_callback
+};
+
+
+const Glib::SignalProxyInfo TreeView_signal_cursor_changed_info =
+{
+  "cursor-changed",
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
+};
+
+
+const Glib::SignalProxyInfo TreeView_signal_columns_changed_info =
+{
+  "columns-changed",
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
+};
+
+} // anonymous namespace
+
+// static
+GType Glib::Value<Gtk::TreeViewDropPosition>::value_type()
+{
+  return gtk_tree_view_drop_position_get_type();
+}
+
+
+namespace Glib
+{
+
+Gtk::TreeView* wrap(GtkTreeView* object, bool take_copy)
+{
+  return dynamic_cast<Gtk::TreeView *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& TreeView_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &TreeView_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_tree_view_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void TreeView_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+  klass->set_scroll_adjustments = &set_scroll_adjustments_callback;
+  klass->row_activated = &row_activated_callback;
+  klass->test_expand_row = &test_expand_row_callback;
+  klass->test_collapse_row = &test_collapse_row_callback;
+  klass->row_expanded = &row_expanded_callback;
+  klass->row_collapsed = &row_collapsed_callback;
+  klass->cursor_changed = &cursor_changed_callback;
+  klass->columns_changed = &columns_changed_callback;
+}
+
+
+void TreeView_Class::set_scroll_adjustments_callback(GtkTreeView* self, GtkAdjustment* p0, GtkAdjustment* p1)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_set_scroll_adjustments(Glib::wrap(p0)
+, Glib::wrap(p1)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->set_scroll_adjustments)
+      (*base->set_scroll_adjustments)(self, p0, p1);
+  }
+}
+
+void TreeView_Class::row_activated_callback(GtkTreeView* self, GtkTreePath* p0, GtkTreeViewColumn* p1)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_row_activated(Gtk::TreePath(p0, true)
+, Glib::wrap(p1)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->row_activated)
+      (*base->row_activated)(self, p0, p1);
+  }
+}
+
+gboolean TreeView_Class::test_expand_row_callback(GtkTreeView* self, GtkTreeIter* p0, GtkTreePath* p1)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return static_cast<int>(obj->on_test_expand_row(TreeModel::iterator(gtk_tree_view_get_model(self), p0)
+, Gtk::TreePath(p1, true)
+));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->test_expand_row)
+      return (*base->test_expand_row)(self, p0, p1);
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+gboolean TreeView_Class::test_collapse_row_callback(GtkTreeView* self, GtkTreeIter* p0, GtkTreePath* p1)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return static_cast<int>(obj->on_test_collapse_row(TreeModel::iterator(gtk_tree_view_get_model(self), p0)
+, Gtk::TreePath(p1, true)
+));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->test_collapse_row)
+      return (*base->test_collapse_row)(self, p0, p1);
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+void TreeView_Class::row_expanded_callback(GtkTreeView* self, GtkTreeIter* p0, GtkTreePath* p1)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_row_expanded(TreeModel::iterator(gtk_tree_view_get_model(self), p0)
+, Gtk::TreePath(p1, true)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->row_expanded)
+      (*base->row_expanded)(self, p0, p1);
+  }
+}
+
+void TreeView_Class::row_collapsed_callback(GtkTreeView* self, GtkTreeIter* p0, GtkTreePath* p1)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_row_collapsed(TreeModel::iterator(gtk_tree_view_get_model(self), p0)
+, Gtk::TreePath(p1, true)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->row_collapsed)
+      (*base->row_collapsed)(self, p0, p1);
+  }
+}
+
+void TreeView_Class::cursor_changed_callback(GtkTreeView* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_cursor_changed();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->cursor_changed)
+      (*base->cursor_changed)(self);
+  }
+}
+
+void TreeView_Class::columns_changed_callback(GtkTreeView* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_columns_changed();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->columns_changed)
+      (*base->columns_changed)(self);
+  }
+}
+
+
+Glib::ObjectBase* TreeView_Class::wrap_new(GObject* o)
+{
+  return manage(new TreeView((GtkTreeView*)(o)));
+
+}
+
+
+/* The implementation: */
+
+TreeView::TreeView(const Glib::ConstructParams& construct_params)
+:
+  Gtk::Container(construct_params)
+{
+  }
+
+TreeView::TreeView(GtkTreeView* castitem)
+:
+  Gtk::Container((GtkContainer*)(castitem))
+{
+  }
+
+TreeView::~TreeView()
+{
+  destroy_();
+}
+
+TreeView::CppClassType TreeView::treeview_class_; // initialize static member
+
+GType TreeView::get_type()
+{
+  return treeview_class_.init().get_type();
+}
+
+GType TreeView::get_base_type()
+{
+  return gtk_tree_view_get_type();
+}
+
+
+TreeView::TreeView()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Container(Glib::ConstructParams(treeview_class_.init()))
+{
+  }
+
+TreeView::TreeView(const Glib::RefPtr<TreeModel>& model)
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Container(Glib::ConstructParams(treeview_class_.init(), "model", Glib::unwrap(model), (char*) 0))
+{
+  }
+
+Glib::RefPtr<TreeModel> TreeView::get_model()
+{
+
+  Glib::RefPtr<TreeModel> retvalue = Glib::wrap(gtk_tree_view_get_model(gobj()));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::RefPtr<const TreeModel> TreeView::get_model() const
+{
+
+  Glib::RefPtr<const TreeModel> retvalue = Glib::wrap(gtk_tree_view_get_model(const_cast<GtkTreeView*>(gobj())));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+void TreeView::set_model(const Glib::RefPtr<TreeModel>& model)
+{
+  gtk_tree_view_set_model(gobj(), Glib::unwrap(model));
+}
+
+Glib::RefPtr<TreeSelection> TreeView::get_selection()
+{
+
+  Glib::RefPtr<TreeSelection> retvalue = Glib::wrap(gtk_tree_view_get_selection(gobj()));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::RefPtr<const TreeSelection> TreeView::get_selection() const
+{
+
+  Glib::RefPtr<const TreeSelection> retvalue = Glib::wrap(gtk_tree_view_get_selection(const_cast<GtkTreeView*>(gobj())));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Adjustment* TreeView::get_hadjustment()
+{
+  return Glib::wrap(gtk_tree_view_get_hadjustment(gobj()));
+}
+
+const Adjustment* TreeView::get_hadjustment() const
+{
+  return Glib::wrap(gtk_tree_view_get_hadjustment(const_cast<GtkTreeView*>(gobj())));
+}
+
+void TreeView::set_hadjustment(Adjustment& adjustment)
+{
+  gtk_tree_view_set_hadjustment(gobj(), (adjustment).gobj());
+}
+
+Adjustment* TreeView::get_vadjustment()
+{
+  return Glib::wrap(gtk_tree_view_get_vadjustment(gobj()));
+}
+
+const Adjustment* TreeView::get_vadjustment() const
+{
+  return Glib::wrap(gtk_tree_view_get_vadjustment(const_cast<GtkTreeView*>(gobj())));
+}
+
+void TreeView::set_vadjustment(Adjustment& adjustment)
+{
+  gtk_tree_view_set_vadjustment(gobj(), (adjustment).gobj());
+}
+
+bool TreeView::get_headers_visible() const
+{
+  return gtk_tree_view_get_headers_visible(const_cast<GtkTreeView*>(gobj()));
+}
+
+void TreeView::set_headers_visible(bool headers_visible)
+{
+  gtk_tree_view_set_headers_visible(gobj(), static_cast<int>(headers_visible));
+}
+
+void TreeView::columns_autosize()
+{
+  gtk_tree_view_columns_autosize(gobj());
+}
+
+void TreeView::set_headers_clickable(bool setting)
+{
+  gtk_tree_view_set_headers_clickable(gobj(), static_cast<int>(setting));
+}
+
+void TreeView::set_rules_hint(bool setting)
+{
+  gtk_tree_view_set_rules_hint(gobj(), static_cast<int>(setting));
+}
+
+bool TreeView::get_rules_hint() const
+{
+  return gtk_tree_view_get_rules_hint(const_cast<GtkTreeView*>(gobj()));
+}
+
+int TreeView::append_column(TreeViewColumn& column)
+{
+  return gtk_tree_view_append_column(gobj(), (column).gobj());
+}
+
+int TreeView::remove_column(TreeViewColumn& column)
+{
+  return gtk_tree_view_remove_column(gobj(), (column).gobj());
+}
+
+int TreeView::insert_column(TreeViewColumn& column, int position)
+{
+  return gtk_tree_view_insert_column(gobj(), (column).gobj(), position);
+}
+
+TreeViewColumn* TreeView::get_column(int n)
+{
+  return Glib::wrap(gtk_tree_view_get_column(gobj(), n));
+}
+
+const TreeViewColumn* TreeView::get_column(int n) const
+{
+  return Glib::wrap(gtk_tree_view_get_column(const_cast<GtkTreeView*>(gobj()), n));
+}
+
+Glib::ListHandle<TreeViewColumn*> TreeView::get_columns()
+{
+  return Glib::ListHandle<TreeViewColumn*>(gtk_tree_view_get_columns(gobj()), Glib::OWNERSHIP_SHALLOW);
+}
+
+Glib::ListHandle<const TreeViewColumn*> TreeView::get_columns() const
+{
+  return Glib::ListHandle<const TreeViewColumn*>(gtk_tree_view_get_columns(const_cast<GtkTreeView*>(gobj())), Glib::OWNERSHIP_SHALLOW);
+}
+
+void TreeView::move_column_after(TreeViewColumn& column, TreeViewColumn& base_column)
+{
+  gtk_tree_view_move_column_after(gobj(), (column).gobj(), (base_column).gobj());
+}
+
+void TreeView::set_expander_column(TreeViewColumn& column)
+{
+  gtk_tree_view_set_expander_column(gobj(), (column).gobj());
+}
+
+TreeViewColumn* TreeView::get_expander_column()
+{
+  return Glib::wrap(gtk_tree_view_get_expander_column(gobj()));
+}
+
+const TreeViewColumn* TreeView::get_expander_column() const
+{
+  return Glib::wrap(gtk_tree_view_get_expander_column(const_cast<GtkTreeView*>(gobj())));
+}
+
+void TreeView::scroll_to_point(int tree_x, int tree_y)
+{
+  gtk_tree_view_scroll_to_point(gobj(), tree_x, tree_y);
+}
+
+void TreeView::row_activated(const TreeModel::Path& path, TreeViewColumn& column)
+{
+  gtk_tree_view_row_activated(gobj(), const_cast<GtkTreePath*>((path).gobj()), (column).gobj());
+}
+
+void TreeView::expand_all()
+{
+  gtk_tree_view_expand_all(gobj());
+}
+
+void TreeView::collapse_all()
+{
+  gtk_tree_view_collapse_all(gobj());
+}
+
+void TreeView::expand_to_path(const TreeModel::Path& path)
+{
+  gtk_tree_view_expand_to_path(gobj(), const_cast<GtkTreePath*>((path).gobj()));
+}
+
+bool TreeView::expand_row(const TreeModel::Path& path, bool open_all)
+{
+  return gtk_tree_view_expand_row(gobj(), const_cast<GtkTreePath*>((path).gobj()), static_cast<int>(open_all));
+}
+
+bool TreeView::collapse_row(const TreeModel::Path& path)
+{
+  return gtk_tree_view_collapse_row(gobj(), const_cast<GtkTreePath*>((path).gobj()));
+}
+
+bool TreeView::row_expanded(const TreeModel::Path& path)
+{
+  return gtk_tree_view_row_expanded(gobj(), const_cast<GtkTreePath*>((path).gobj()));
+}
+
+void TreeView::set_reorderable(bool reorderable)
+{
+  gtk_tree_view_set_reorderable(gobj(), static_cast<int>(reorderable));
+}
+
+bool TreeView::get_reorderable() const
+{
+  return gtk_tree_view_get_reorderable(const_cast<GtkTreeView*>(gobj()));
+}
+
+void TreeView::set_cursor(const TreeModel::Path& path, TreeViewColumn& focus_column, bool start_editing)
+{
+  gtk_tree_view_set_cursor(gobj(), const_cast<GtkTreePath*>((path).gobj()), (focus_column).gobj(), static_cast<int>(start_editing));
+}
+
+void TreeView::set_cursor(const TreeModel::Path& path, TreeViewColumn& focus_column, CellRenderer& focus_cell, bool start_editing)
+{
+  gtk_tree_view_set_cursor_on_cell(gobj(), const_cast<GtkTreePath*>((path).gobj()), (focus_column).gobj(), (focus_cell).gobj(), static_cast<int>(start_editing));
+}
+
+Glib::RefPtr<Gdk::Window> TreeView::get_bin_window()
+{
+
+  Glib::RefPtr<Gdk::Window> retvalue = Glib::wrap((GdkWindowObject*)(gtk_tree_view_get_bin_window(gobj())));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::RefPtr<const Gdk::Window> TreeView::get_bin_window() const
+{
+
+  Glib::RefPtr<const Gdk::Window> retvalue = Glib::wrap((GdkWindowObject*)(gtk_tree_view_get_bin_window(const_cast<GtkTreeView*>(gobj()))));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+void TreeView::get_cell_area(const TreeModel::Path& path, TreeViewColumn& column, Gdk::Rectangle& rect)
+{
+  gtk_tree_view_get_cell_area(gobj(), const_cast<GtkTreePath*>((path).gobj()), (column).gobj(), (rect).gobj());
+}
+
+void TreeView::get_background_area(const TreeModel::Path& path, TreeViewColumn& column, Gdk::Rectangle& rect)
+{
+  gtk_tree_view_get_background_area(gobj(), const_cast<GtkTreePath*>((path).gobj()), (column).gobj(), (rect).gobj());
+}
+
+void TreeView::get_visible_rect(Gdk::Rectangle& visible_rect)
+{
+  gtk_tree_view_get_visible_rect(gobj(), (visible_rect).gobj());
+}
+
+void TreeView::widget_to_tree_coords(int wx, int wy, int& tx, int& ty)
+{
+  gtk_tree_view_widget_to_tree_coords(gobj(), wx, wy, &tx, &ty);
+}
+
+void TreeView::tree_to_widget_coords(int tx, int ty, int& wx, int& wy)
+{
+  gtk_tree_view_tree_to_widget_coords(gobj(), tx, ty, &wx, &wy);
+}
+
+void TreeView::unset_rows_drag_source()
+{
+  gtk_tree_view_unset_rows_drag_source(gobj());
+}
+
+void TreeView::unset_rows_drag_dest()
+{
+  gtk_tree_view_unset_rows_drag_dest(gobj());
+}
+
+void TreeView::set_drag_dest_row(const TreeModel::Path& path, TreeViewDropPosition pos)
+{
+  gtk_tree_view_set_drag_dest_row(gobj(), const_cast<GtkTreePath*>((path).gobj()), ((GtkTreeViewDropPosition)(pos)));
+}
+
+Glib::RefPtr<Gdk::Pixmap> TreeView::create_row_drag_icon(const TreeModel::Path& path)
+{
+  return Glib::wrap((GdkPixmapObject*)(gtk_tree_view_create_row_drag_icon(gobj(), const_cast<GtkTreePath*>((path).gobj()))));
+}
+
+void TreeView::set_enable_search(bool enable_search)
+{
+  gtk_tree_view_set_enable_search(gobj(), static_cast<int>(enable_search));
+}
+
+bool TreeView::get_enable_search() const
+{
+  return gtk_tree_view_get_enable_search(const_cast<GtkTreeView*>(gobj()));
+}
+
+int TreeView::get_search_column() const
+{
+  return gtk_tree_view_get_search_column(const_cast<GtkTreeView*>(gobj()));
+}
+
+void TreeView::set_search_column(const TreeModelColumnBase& column)
+{
+  gtk_tree_view_set_search_column(gobj(), (column).index());
+}
+
+void TreeView::set_search_column(int column)
+{
+  gtk_tree_view_set_search_column(gobj(), column);
+}
+
+void TreeView::set_fixed_height_mode(bool enable)
+{
+  gtk_tree_view_set_fixed_height_mode(gobj(), static_cast<int>(enable));
+}
+
+bool TreeView::get_fixed_height_mode() const
+{
+  return gtk_tree_view_get_fixed_height_mode(const_cast<GtkTreeView*>(gobj()));
+}
+
+void TreeView::set_hover_selection(bool hover)
+{
+  gtk_tree_view_set_hover_selection(gobj(), static_cast<int>(hover));
+}
+
+bool TreeView::get_hover_selection() const
+{
+  return gtk_tree_view_get_hover_selection(const_cast<GtkTreeView*>(gobj()));
+}
+
+void TreeView::set_hover_expand(bool expand)
+{
+  gtk_tree_view_set_hover_expand(gobj(), static_cast<int>(expand));
+}
+
+bool TreeView::get_hover_expand() const
+{
+  return gtk_tree_view_get_hover_expand(const_cast<GtkTreeView*>(gobj()));
+}
+
+
+Glib::SignalProxy2< void,Adjustment*,Adjustment* > TreeView::signal_set_scroll_adjustments()
+{
+  return Glib::SignalProxy2< void,Adjustment*,Adjustment* >(this, &TreeView_signal_set_scroll_adjustments_info);
+}
+
+Glib::SignalProxy2< void,const TreeModel::Path&,TreeViewColumn* > TreeView::signal_row_activated()
+{
+  return Glib::SignalProxy2< void,const TreeModel::Path&,TreeViewColumn* >(this, &TreeView_signal_row_activated_info);
+}
+
+Glib::SignalProxy2< bool,const TreeModel::iterator&,const TreeModel::Path& > TreeView::signal_test_expand_row()
+{
+  return Glib::SignalProxy2< bool,const TreeModel::iterator&,const TreeModel::Path& >(this, &TreeView_signal_test_expand_row_info);
+}
+
+Glib::SignalProxy2< bool,const TreeModel::iterator&,const TreeModel::Path& > TreeView::signal_test_collapse_row()
+{
+  return Glib::SignalProxy2< bool,const TreeModel::iterator&,const TreeModel::Path& >(this, &TreeView_signal_test_collapse_row_info);
+}
+
+Glib::SignalProxy2< void,const TreeModel::iterator&,const TreeModel::Path& > TreeView::signal_row_expanded()
+{
+  return Glib::SignalProxy2< void,const TreeModel::iterator&,const TreeModel::Path& >(this, &TreeView_signal_row_expanded_info);
+}
+
+Glib::SignalProxy2< void,const TreeModel::iterator&,const TreeModel::Path& > TreeView::signal_row_collapsed()
+{
+  return Glib::SignalProxy2< void,const TreeModel::iterator&,const TreeModel::Path& >(this, &TreeView_signal_row_collapsed_info);
+}
+
+Glib::SignalProxy0< void > TreeView::signal_cursor_changed()
+{
+  return Glib::SignalProxy0< void >(this, &TreeView_signal_cursor_changed_info);
+}
+
+Glib::SignalProxy0< void > TreeView::signal_columns_changed()
+{
+  return Glib::SignalProxy0< void >(this, &TreeView_signal_columns_changed_info);
+}
+
+
+Glib::PropertyProxy< Glib::RefPtr<TreeModel> > TreeView::property_model() 
+{
+  return Glib::PropertyProxy< Glib::RefPtr<TreeModel> >(this, "model");
+}
+
+Glib::PropertyProxy_ReadOnly< Glib::RefPtr<TreeModel> > TreeView::property_model() const
+{
+  return Glib::PropertyProxy_ReadOnly< Glib::RefPtr<TreeModel> >(this, "model");
+}
+
+Glib::PropertyProxy<Adjustment*> TreeView::property_hadjustment() 
+{
+  return Glib::PropertyProxy<Adjustment*>(this, "hadjustment");
+}
+
+Glib::PropertyProxy_ReadOnly<Adjustment*> TreeView::property_hadjustment() const
+{
+  return Glib::PropertyProxy_ReadOnly<Adjustment*>(this, "hadjustment");
+}
+
+Glib::PropertyProxy<Adjustment*> TreeView::property_vadjustment() 
+{
+  return Glib::PropertyProxy<Adjustment*>(this, "vadjustment");
+}
+
+Glib::PropertyProxy_ReadOnly<Adjustment*> TreeView::property_vadjustment() const
+{
+  return Glib::PropertyProxy_ReadOnly<Adjustment*>(this, "vadjustment");
+}
+
+Glib::PropertyProxy<bool> TreeView::property_headers_visible() 
+{
+  return Glib::PropertyProxy<bool>(this, "headers-visible");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> TreeView::property_headers_visible() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "headers-visible");
+}
+
+Glib::PropertyProxy<bool> TreeView::property_headers_clickable() 
+{
+  return Glib::PropertyProxy<bool>(this, "headers-clickable");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> TreeView::property_headers_clickable() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "headers-clickable");
+}
+
+Glib::PropertyProxy<TreeViewColumn*> TreeView::property_expander_column() 
+{
+  return Glib::PropertyProxy<TreeViewColumn*>(this, "expander-column");
+}
+
+Glib::PropertyProxy_ReadOnly<TreeViewColumn*> TreeView::property_expander_column() const
+{
+  return Glib::PropertyProxy_ReadOnly<TreeViewColumn*>(this, "expander-column");
+}
+
+Glib::PropertyProxy<bool> TreeView::property_reorderable() 
+{
+  return Glib::PropertyProxy<bool>(this, "reorderable");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> TreeView::property_reorderable() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "reorderable");
+}
+
+Glib::PropertyProxy<bool> TreeView::property_rules_hint() 
+{
+  return Glib::PropertyProxy<bool>(this, "rules-hint");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> TreeView::property_rules_hint() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "rules-hint");
+}
+
+Glib::PropertyProxy<bool> TreeView::property_enable_search() 
+{
+  return Glib::PropertyProxy<bool>(this, "enable-search");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> TreeView::property_enable_search() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "enable-search");
+}
+
+Glib::PropertyProxy<int> TreeView::property_search_column() 
+{
+  return Glib::PropertyProxy<int>(this, "search-column");
+}
+
+Glib::PropertyProxy_ReadOnly<int> TreeView::property_search_column() const
+{
+  return Glib::PropertyProxy_ReadOnly<int>(this, "search-column");
+}
+
+Glib::PropertyProxy<bool> TreeView::property_fixed_height_mode() 
+{
+  return Glib::PropertyProxy<bool>(this, "fixed-height-mode");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> TreeView::property_fixed_height_mode() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "fixed-height-mode");
+}
+
+Glib::PropertyProxy<bool> TreeView::property_hover_selection() 
+{
+  return Glib::PropertyProxy<bool>(this, "hover-selection");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> TreeView::property_hover_selection() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "hover-selection");
+}
+
+Glib::PropertyProxy<bool> TreeView::property_hover_expand() 
+{
+  return Glib::PropertyProxy<bool>(this, "hover-expand");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> TreeView::property_hover_expand() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "hover-expand");
+}
+
+
+void Gtk::TreeView::on_set_scroll_adjustments(Adjustment* hadjustment, Adjustment* vadjustment)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->set_scroll_adjustments)
+    (*base->set_scroll_adjustments)(gobj(),(GtkAdjustment*)Glib::unwrap(hadjustment),(GtkAdjustment*)Glib::unwrap(vadjustment));
+}
+
+void Gtk::TreeView::on_row_activated(const TreeModel::Path& path, TreeViewColumn* column)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->row_activated)
+    (*base->row_activated)(gobj(),const_cast<GtkTreePath*>((path).gobj()),(GtkTreeViewColumn*)Glib::unwrap(column));
+}
+
+bool Gtk::TreeView::on_test_expand_row(const TreeModel::iterator& iter, const TreeModel::Path& path)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->test_expand_row)
+    return (*base->test_expand_row)(gobj(),const_cast<GtkTreeIter*>((iter).gobj()),const_cast<GtkTreePath*>((path).gobj()));
+
+  typedef bool RType;
+  return RType();
+}
+
+bool Gtk::TreeView::on_test_collapse_row(const TreeModel::iterator& iter, const TreeModel::Path& path)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->test_collapse_row)
+    return (*base->test_collapse_row)(gobj(),const_cast<GtkTreeIter*>((iter).gobj()),const_cast<GtkTreePath*>((path).gobj()));
+
+  typedef bool RType;
+  return RType();
+}
+
+void Gtk::TreeView::on_row_expanded(const TreeModel::iterator& iter, const TreeModel::Path& path)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->row_expanded)
+    (*base->row_expanded)(gobj(),const_cast<GtkTreeIter*>((iter).gobj()),const_cast<GtkTreePath*>((path).gobj()));
+}
+
+void Gtk::TreeView::on_row_collapsed(const TreeModel::iterator& iter, const TreeModel::Path& path)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->row_collapsed)
+    (*base->row_collapsed)(gobj(),const_cast<GtkTreeIter*>((iter).gobj()),const_cast<GtkTreePath*>((path).gobj()));
+}
+
+void Gtk::TreeView::on_cursor_changed()
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->cursor_changed)
+    (*base->cursor_changed)(gobj());
+}
+
+void Gtk::TreeView::on_columns_changed()
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->columns_changed)
+    (*base->columns_changed)(gobj());
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/treeview.h b/libs/gtkmm2/gtk/gtkmm/treeview.h
new file mode 100644
index 0000000000..41a2bb9b9e
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/treeview.h
@@ -0,0 +1,1774 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_TREEVIEW_H
+#define _GTKMM_TREEVIEW_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* Copyright(C) 2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <glibmm/listhandle.h>
+#include <gtkmm/container.h>
+#include <gtkmm/adjustment.h>
+#include <gdkmm/pixmap.h>
+#include <gtkmm/treeviewcolumn.h>
+#include <gtkmm/treeselection.h>
+#include <gtkmm/treemodelcolumn.h>
+#include <gtkmm/cellrenderer.h>
+#include <gtkmm/targetentry.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkTreeView GtkTreeView;
+typedef struct _GtkTreeViewClass GtkTreeViewClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class TreeView_Class; } // namespace Gtk
+namespace Gtk
+{
+
+
+/** @addtogroup gtkmmEnums Enums and Flags */
+
+/**
+ * @ingroup gtkmmEnums
+ */
+enum TreeViewDropPosition
+{
+  TREE_VIEW_DROP_BEFORE,
+  TREE_VIEW_DROP_AFTER,
+  TREE_VIEW_DROP_INTO_OR_BEFORE,
+  TREE_VIEW_DROP_INTO_OR_AFTER
+};
+
+} // namespace Gtk
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Gtk::TreeViewDropPosition> : public Glib::Value_Enum<Gtk::TreeViewDropPosition>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+class TreeView;
+
+namespace TreeView_Private
+{
+/* This helper function is not a member of TreeView just for the reason that
+ * there are compilers that have problems compiling it otherwise. E.g. in gcc
+ * 2.95.3 a compiler bug prevents member functions from refering to specialized
+ * member function templates and that's what we do here: In function
+ * _connect_auto_store_editable_signal_handler we build a slot from
+ * TreeView::_auto_store_on_cellrenderer_*_edited. (The latter must be member
+ * functions of TreeView since we connect them to signals and we want the
+ * connections to vanish when the TreeView dies, of course.)
+ */
+  template <class ColumnType> inline
+  void _connect_auto_store_editable_signal_handler(Gtk::TreeView* this_p, Gtk::CellRenderer* pCellRenderer, const Gtk::TreeModelColumn<ColumnType>& model_column);
+
+  template<class ColumnType> inline
+  void _auto_store_on_cellrenderer_text_edited_string(const Glib::ustring& path_string, const Glib::ustring& new_text, int model_column, Gtk::TreeView*);
+
+  template <class ColumnType> inline
+  void _auto_store_on_cellrenderer_text_edited_numerical(const Glib::ustring& path_string, const Glib::ustring& new_text, int model_column, Gtk::TreeView*); 
+  
+  template <class ColumnType> inline
+  void _auto_cell_data_func(Gtk::CellRenderer* cell, const Gtk::TreeModel::iterator& iter, int model_column, const Glib::ustring& format);
+}
+
+#endif //DOXYGEN_SHOULD_SKIP_THIS
+
+
+//class TreeViewColumn;
+class TreeModel;
+
+/** @defgroup TreeView TreeView Classes
+ * These classes are used with the Gtk::TreeView widget.
+ */
+
+/** The TreeView widget displays the model (Gtk::TreeModel) data and allows the user to interact with it.
+ * The View can show all of the model's columns, or just some, and it can show them in various ways.
+ * You must provide the TreeModel in the constructor, or with set_model().
+ *
+ * Add View columns with append_column(), append_column_editable(), insert_column(), or insert_column_editable().
+ *
+ * You can manipulate the selection by obtaining the @link Gtk::TreeSelection Gtk::TreeView::Selection@endlink from get_selection().
+ *
+ * @ingroup Widgets
+ * @ingroup Containers
+ * @ingroup TreeView
+ */
+
+class TreeView : public Container
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef TreeView CppObjectType;
+  typedef TreeView_Class CppClassType;
+  typedef GtkTreeView BaseObjectType;
+  typedef GtkTreeViewClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~TreeView();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class TreeView_Class;
+  static CppClassType treeview_class_;
+
+  // noncopyable
+  TreeView(const TreeView&);
+  TreeView& operator=(const TreeView&);
+
+protected:
+  explicit TreeView(const Glib::ConstructParams& construct_params);
+  explicit TreeView(GtkTreeView* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GtkTreeView*       gobj()       { return reinterpret_cast<GtkTreeView*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GtkTreeView* gobj() const { return reinterpret_cast<GtkTreeView*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+  virtual void on_set_scroll_adjustments(Adjustment* hadjustment, Adjustment* vadjustment);
+  virtual void on_row_activated(const TreeModel::Path& path, TreeViewColumn* column);
+  virtual bool on_test_expand_row(const TreeModel::iterator& iter, const TreeModel::Path& path);
+  virtual bool on_test_collapse_row(const TreeModel::iterator& iter, const TreeModel::Path& path);
+  virtual void on_row_expanded(const TreeModel::iterator& iter, const TreeModel::Path& path);
+  virtual void on_row_collapsed(const TreeModel::iterator& iter, const TreeModel::Path& path);
+  virtual void on_cursor_changed();
+  virtual void on_columns_changed();
+
+
+private:
+
+  
+public:
+  /**  A visible column in a Gtk::TreeView widget.
+   */
+  typedef TreeViewColumn Column;
+  
+  /** A selection object for Gtk::TreeView.
+   */
+  typedef TreeSelection Selection;
+  /**
+     Default constructor
+   */
+  TreeView();
+  /**
+     Constructor that binds to a TreeModel
+   */
+  explicit TreeView(const Glib::RefPtr<TreeModel>& model);
+
+  
+  /** Returns the model the the Gtk::TreeView is based on.  Returns <tt>0</tt> if the
+   * model is unset.
+   * @return A Gtk::TreeModel, or <tt>0</tt> if none is currently being used.
+   */
+  Glib::RefPtr<TreeModel> get_model();
+  
+  /** Returns the model the the Gtk::TreeView is based on.  Returns <tt>0</tt> if the
+   * model is unset.
+   * @return A Gtk::TreeModel, or <tt>0</tt> if none is currently being used.
+   */
+  Glib::RefPtr<const TreeModel> get_model() const;
+  
+  /** Sets the model for a Gtk::TreeView.  If the @a tree_view  already has a model
+   * set, it will remove it before setting the new model.  If @a model  is <tt>0</tt>, 
+   * then it will unset the old model.
+   * @param model The model.
+   */
+  void set_model(const Glib::RefPtr<TreeModel>& model);
+  
+  /** Gets the Gtk::TreeSelection associated with @a tree_view .
+   * @return A Gtk::TreeSelection object.
+   */
+  Glib::RefPtr<TreeSelection> get_selection();
+  
+  /** Gets the Gtk::TreeSelection associated with @a tree_view .
+   * @return A Gtk::TreeSelection object.
+   */
+  Glib::RefPtr<const TreeSelection> get_selection() const;
+  
+  /** Gets the Gtk::Adjustment currently being used for the horizontal aspect.
+   * @return A Gtk::Adjustment object, or <tt>0</tt> if none is currently being
+   * used.
+   */
+  Adjustment* get_hadjustment();
+  
+  /** Gets the Gtk::Adjustment currently being used for the horizontal aspect.
+   * @return A Gtk::Adjustment object, or <tt>0</tt> if none is currently being
+   * used.
+   */
+  const Adjustment* get_hadjustment() const;
+  
+  /** Sets the Gtk::Adjustment for the current horizontal aspect. See also unset_hadjustment().
+   * @param adjustment The Gtk::Adjustment to set.
+   */
+  void set_hadjustment(Adjustment& adjustment);
+  
+  /** This method removes the hadjustment.
+   * @see set_hadjustment().
+   */
+  void unset_hadjustment();
+  
+  
+  /** Gets the Gtk::Adjustment currently being used for the vertical aspect.
+   * @return A Gtk::Adjustment object, or <tt>0</tt> if none is currently being
+   * used.
+   */
+  Adjustment* get_vadjustment();
+  
+  /** Gets the Gtk::Adjustment currently being used for the vertical aspect.
+   * @return A Gtk::Adjustment object, or <tt>0</tt> if none is currently being
+   * used.
+   */
+  const Adjustment* get_vadjustment() const;
+  
+  /** Sets the Gtk::Adjustment for the current vertical aspect. See also unset_vadjustment().
+   * @param adjustment The Gtk::Adjustment to set.
+   */
+  void set_vadjustment(Adjustment& adjustment);
+  
+  /** This method removes the vadjustment.
+   * @see set_vadjustment().
+   */
+  void unset_vadjustment();
+  
+  
+  /** Returns <tt>true</tt> if the headers on the @a tree_view  are visible.
+   * @return Whether the headers are visible or not.
+   */
+  bool get_headers_visible() const;
+  
+  /** Sets the the visibility state of the headers.
+   * @param headers_visible <tt>true</tt> if the headers are visible.
+   */
+  void set_headers_visible(bool headers_visible);
+  
+  /** Resizes all columns to their optimal width. Only works after the
+   * treeview has been realized.
+   */
+  void columns_autosize();
+  
+  /** Allow the column title buttons to be clicked.
+   * @param setting <tt>true</tt> if the columns are clickable.
+   */
+  void set_headers_clickable(bool setting = true);
+  
+  /** This function tells GTK+ that the user interface for your
+   * application requires users to read across tree rows and associate
+   * cells with one another. By default, GTK+ will then render the tree
+   * with alternating row colors. Do <em>not</em> use it
+   * just because you prefer the appearance of the ruled tree; that's a
+   * question for the theme. Some themes will draw tree rows in
+   * alternating colors even when rules are turned off, and users who
+   * prefer that appearance all the time can choose those themes. You
+   * should call this function only as a <em>semantic</em>
+   * hint to the theme engine that your tree makes alternating colors
+   * useful from a functional standpoint (since it has lots of columns,
+   * generally).
+   * @param setting <tt>true</tt> if the tree requires reading across rows.
+   */
+  void set_rules_hint(bool setting = true);
+  
+  /** Gets the setting set by set_rules_hint().
+   * @return <tt>true</tt> if rules are useful for the user of this tree.
+   */
+  bool get_rules_hint() const;
+
+  
+  /** Appends @a column  to the list of columns. If @a tree_view  has "fixed_height"
+   * mode enabled, then @a column  must have its "sizing" property set to be
+   * GTK_TREE_VIEW_COLUMN_FIXED.
+   * @param column The Gtk::TreeViewColumn to add.
+   * @return The number of columns in @a tree_view  after appending.
+   */
+  int append_column(TreeViewColumn& column);
+
+  /** Appends a View column with the appropriate CellRenderer for the Model column.
+   *
+   * The CellRenderer can only be created automatically for some basic
+   * column types, such as Glib::ustring, int, double, bool, and Gdk::Pixbuf. 
+   * If the type is not supported then the following warning will be shown:
+   * GLib-GObject-WARNING **: unable to set property `text' of type
+   * `gchararray' from value of type `glibmm__CustomBoxed_t'.
+   *
+   * If the default formatting is not sufficient, or the numeric type is 
+   * not supported, then you could use append_column_numeric(). Or you 
+   * could create the TreeView::Column and/or CellRenderer
+   * manually and use TreeViewColumn::set_cell_data_func() to provide a callback 
+   * that converts the model value into a string representation with .
+   *
+   * @param title The text to be used in the title header of this column.
+   * @param model_column The column in the TreeModel that will be rendered by this View column.
+   * @result The number of columns in the View after appending.
+   */
+  template <class ColumnType> inline
+  int append_column(const Glib::ustring& title, const TreeModelColumn<ColumnType>& model_column);
+
+  /** Like append_column(), but only for numeric types, which will be displayed in the specified format.
+   * This convenience template uses TreeView::Column::set_cell_data_func(), so the numeric formatting will 
+   * be deactivated if you specify your own cell_data callback by calling set_cell_data_func() again.
+   *
+   * @param title The text to be used in the title header of this column.
+   * @param model_column The column in the TreeModel that will be rendered by this View column.
+   * @param format A printf-style format, such as "%d", used to create a text representation of the number.
+   * @result The number of columns in the View after appending.
+   */
+  template <class ColumnType> inline
+  int append_column_numeric(const Glib::ustring& title, const TreeModelColumn<ColumnType>& model_column, const Glib::ustring& format);
+  
+  //TODO: danielk suggested use of Glib::Value to simplify/improve this.
+  /** Appends a View column with the appropriate CellRenderer for the Model
+   * column.  The compiler will attempt to instantiate appropriate template
+   * code to automatically store user changes in the model.  To intercept the
+   * user's change and implement non-default logic, or if the compiler can't
+   * instantiate appropriate code for your model type, you could use
+   * append_column() and connect a signal handler to the CellRenderer.
+   *
+   * @see append_column_numeric_editable().
+   *
+   * @param title The text to be used in the title header of this column.
+   * @param model_column The column in the TreeModel that will be rendered by this View column.
+   * @result The number of columns in the View after appending.
+   */
+  template <class ColumnType> inline
+  int append_column_editable(const Glib::ustring& title, const TreeModelColumn<ColumnType>& model_column);
+
+  /** Like append_column_editable(), but only for numeric types, which will be displayed in the specified format.
+   * This convenience template uses TreeView::Column::set_cell_data_func(), so the numeric formatting will 
+   * be deactivated if you specify your own cell_data callback by calling set_cell_data_func() again.
+   *
+   * Note that the user's input will be interpreted as decimal (base 10), regardless of the @a format.
+   *
+   * @param title The text to be used in the title header of this column.
+   * @param model_column The column in the TreeModel that will be rendered by this View column.
+   * @param format A printf-style format, such as "%d", used to create a text representation of the number.
+   * @result The number of columns in the View after appending.
+   */
+  template <class ColumnType> inline
+  int append_column_numeric_editable(const Glib::ustring& title, const TreeModelColumn<ColumnType>& model_column, const Glib::ustring& format);
+
+  
+  /// Creates a View column containing the CellRenderer, and appends it.
+  int append_column(const Glib::ustring& title, CellRenderer& cell);
+
+  
+  /** Removes @a column  from @a tree_view .
+   * @param column The Gtk::TreeViewColumn to remove.
+   * @return The number of columns in @a tree_view  after removing.
+   */
+  int remove_column(TreeViewColumn& column);
+
+  /// Removes all View columns.
+  void remove_all_columns();
+
+  
+  /** This inserts the @a column  into the @a tree_view  at @a position .  If @a position  is
+   * -1, then the column is inserted at the end. If @a tree_view  has
+   * "fixed_height" mode enabled, then @a column  must have its "sizing" property
+   * set to be GTK_TREE_VIEW_COLUMN_FIXED.
+   * @param column The Gtk::TreeViewColumn to be inserted.
+   * @param position The position to insert @a column  in.
+   * @return The number of columns in @a tree_view  after insertion.
+   */
+  int insert_column(TreeViewColumn& column, int position);
+
+  /** Creates a View column containing the CellRenderer, and inserts it.
+   *
+   * @param title The text to be used in the title header of this column.
+   * @param cell The CellRenderer.
+   * @param position The position at which the CellRenderer should be inserted.
+   * @result The number of columns in the View after inserting.
+   */
+  int insert_column(const Glib::ustring& title, CellRenderer& cell, int position);
+
+  
+  /** Inserts a View column with the appropriate CellRenderer for the Model column.
+   *
+   * @param title The text to be used in the title header of this column.
+   * @param model_column The column in the TreeModel that will be rendered by this View column.
+   * @param position The position at which the CellRenderer should be inserted.
+   * @result The number of columns in the View after inserting.
+   */
+  template <class ColumnType> inline
+  int insert_column(const Glib::ustring& title, const TreeModelColumn<ColumnType>& model_column, int position);
+
+  /** Inserts a View column with the appropriate CellRenderer for the Model
+   * column.  The compiler will attempt to instantiate appropriate template
+   * code to automatically store user changes in the model.  To intercept the
+   * user's change and implement non-default logic, or if the compiler can't
+   * instantiate appropriate code for your model type, you should use
+   * append_column() and connect a signal handler to the CellRenderer.
+   *
+   * @param title The text to be used in the title header of this column.
+   * @param model_column The column in the TreeModel that will be rendered by this View column.
+   * @param position The position at which the CellRenderer should be inserted.
+   * @result The number of columns in the View after inserting.
+   */
+  template <class ColumnType> inline
+  int insert_column_editable(const Glib::ustring& title, const TreeModelColumn<ColumnType>& model_column, int position);
+
+  typedef TreeViewColumn::SlotCellData SlotCellData;
+  
+  /**
+   * Inserts a new column into the TreeView with the given cell
+   * renderer and a SlotCellData to set cell renderer attributes
+   * (normally using data from the model). 
+   *
+   * @param position Position to insert, -1 for append
+   * @param title column title
+   * @param cell cell renderer for column
+   * @param slot function to set attributes of cell renderer
+   * @return number of columns in the TreeView after the insert
+   */
+  int insert_column_with_data_func(int position, const Glib::ustring& title, CellRenderer& cell, const SlotCellData& slot);
+
+  
+  /** Gets the Gtk::TreeViewColumn at the given position in the #tree_view.
+   * @param n The position of the column, counting from 0.
+   * @return The Gtk::TreeViewColumn, or <tt>0</tt> if the position is outside the
+   * range of columns.
+   */
+  TreeViewColumn* get_column(int n);
+  
+  /** Gets the Gtk::TreeViewColumn at the given position in the #tree_view.
+   * @param n The position of the column, counting from 0.
+   * @return The Gtk::TreeViewColumn, or <tt>0</tt> if the position is outside the
+   * range of columns.
+   */
+  const TreeViewColumn* get_column(int n) const;
+
+  //The column index is of the view, not the model, so we do not need TreeViewColumn* get_column(TreeViewColumn& base_column).
+
+  /** Gets the CellRenderer for that column.
+    * You should dynamic_cast<> to the expected derived CellRenderer type.
+    * This assumes that the TreeViewColumn contains only one CellRenderer.
+    *
+    * @param n The position of the view column.
+    * @result The CellRenderer.
+    */
+  CellRenderer* get_column_cell_renderer(int n);
+
+ //TODO: Add TreeViewColumn* get_column_cell_renderer(TreeViewColumn& base_column); and a const one.
+
+
+  /** Gets the CellRenderer for that column.
+    * You should dynamic_cast<> to the expected derived CellRenderer type.
+    * This assumes that the TreeViewColumn contains only one CellRenderer.
+    *
+    * @param n The position of the view column.
+    * @result The CellRenderer.
+    */
+  const CellRenderer* get_column_cell_renderer(int n) const;
+
+  
+  /** Returns a list of all the Gtk::TreeViewColumn s currently in @a tree_view .
+   * @return A list of Gtk::TreeViewColumn s.
+   */
+  Glib::ListHandle<TreeViewColumn*> get_columns();
+  
+  /** Returns a list of all the Gtk::TreeViewColumn s currently in @a tree_view .
+   * @return A list of Gtk::TreeViewColumn s.
+   */
+  Glib::ListHandle<const TreeViewColumn*> get_columns() const;
+  
+  
+  /** Moves @a column  to be after to @a base_column .  See also move_column_to_start().
+   * @param column The Gtk::TreeViewColumn to be moved.
+   * @param base_column The Gtk::TreeViewColumn to be moved relative to.
+   */
+  void move_column_after(TreeViewColumn& column, TreeViewColumn& base_column);
+
+  /** This method moves column to the first position in the view.
+   *
+   * @param column The view column that will be moved
+   */
+  void move_column_to_start(TreeViewColumn& column);
+  
+  
+  /** Sets the column to draw the expander arrow at. It must be in the TreeView.  See also reset_expander_column().
+   * @param column The column to draw the expander arrow at.
+   */
+  void set_expander_column(TreeViewColumn& column);
+  
+  /** This method resets the expander arrow to the default - the first visible column.
+   * @see set_expander_column().  
+   */
+  void reset_expander_column();
+  
+  
+  /** Returns the column that is the current expander column.  This
+   * column has the expander arrow drawn next to it.
+   * @return The expander column.
+   */
+  TreeViewColumn* get_expander_column();
+  
+  /** Returns the column that is the current expander column.  This
+   * column has the expander arrow drawn next to it.
+   * @return The expander column.
+   */
+  const TreeViewColumn* get_expander_column() const;
+
+  /** For instance,
+   * bool on_column_drop(TreeView*, tree_view, TreeViewColumn* column, TreeViewColumn* prev_column, TreeViewColumn* next_column)
+   *
+   * This function is called on every column pair in turn at the beginning of a column drag to determine where a
+   * drop can take place. The arguments passed to the function are: the tree_view, the view Column being dragged,
+   * and the two view Columns determining the drop spot. If either of the view Column arguments for the drop spot
+   * are 0, then they indicate an edge.
+   */
+  typedef sigc::slot<bool, TreeView*, TreeViewColumn*,  TreeViewColumn*, TreeViewColumn*> SlotColumnDrop;
+
+  /** Sets a callback slot for determining where a column may be dropped when dragged.
+   * This function is called on every column pair in turn at the beginning of a column drag to determine where a
+   * drop can take place. The arguments passed to the function are: the tree_view, the view Column being dragged,
+   * and the two view Columns determining the drop spot. If either of the view Column arguments for the drop spot
+   * are 0, then they indicate an edge.
+   *
+   * See unset_column_drag_function().
+   *
+   * @param slot A callback function to determine which columns are reorderable.
+   */
+  void set_column_drag_function(const SlotColumnDrop& slot);
+  
+
+  /** See set_column_drag_function(). After this method has been called, the TreeView reverts to the default behavior of
+  * allowing all columns to be dropped everywhere.
+  */
+  void unset_column_drag_function();
+   
+  
+  /** Scrolls the tree view such that the top-left corner of the visible
+   * area is @a tree_x , @a tree_y , where @a tree_x  and @a tree_y  are specified
+   * in tree window coordinates.  The @a tree_view  must be realized before
+   * this function is called.  If it isn't, you probably want to be
+   * using scroll_to_cell().
+   * 
+   * If either @a tree_x  or @a tree_y  are -1, then that direction isn't scrolled.
+   * @param tree_x X coordinate of new top-left pixel of visible area, or -1.
+   * @param tree_y Y coordinate of new top-left pixel of visible area, or -1.
+   */
+  void scroll_to_point(int tree_x, int tree_y);
+
+  /** Moves the alignments of tree view to the position specified by @a column and @a path.
+   * @a row_align determines where the row is placed, and @a col_align determines where
+   * column is placed. Both are expected to be between 0.0 and 1.0. 0.0 means left/top
+   * alignment, 1.0 means right/bottom alignment, 0.5 means center.
+   *
+   * This function only works if the model is set, and @a path is a valid row on the model.
+   * If the model changes before the tree view is realized, the centered path will be
+   * modified to reflect this change.
+   *
+   * @param path The path of the row to move to.
+   * @param column The Gtk::TreeViewColumn to move horizontally to.
+   * @param row_align The vertical alignment of the row specified by @a path.
+   * @param col_align The horizontal alignment of the column specified by @a column.
+   */
+  void scroll_to_cell(const TreeModel::Path& path, TreeViewColumn& column, float row_align, float col_align);
+  
+
+  /** Moves the alignments of tree view to the position specified by @a column and @a path.
+   * The tree does the minimum amount of work to scroll the cell onto the screen. This means
+   * that the cell will be scrolled to the edge closest to it's current position. If the cell
+   * is currently visible on the screen, nothing is done.
+   *
+   * This function only works if the model is set, and @a path is a valid row on the model.
+   * If the model changes before the tree_view is realized, the centered path will be modified
+   * to reflect this change.
+   *
+   * @param path The path of the row to move to.
+   * @param column The Gtk::TreeViewColumn to move horizontally to.
+   */
+  void scroll_to_cell(const TreeModel::Path& path, TreeViewColumn& column);
+
+  /** Moves the alignments of tree view to the position specified by @a path.
+   * @a row_align determines where the row is placed, and is expected to be between 0.0
+   * and 1.0.  0.0 means top alignment, 1.0 means bottom alignment, 0.5 means center.
+   *
+   * This function only works if the model is set, and @a path is a valid row on the model.
+   * If the model changes before the tree view is realized, the centered path will be
+   * modified to reflect this change.
+   *
+   * @param path The path of the row to move to.
+   * @param row_align The vertical alignment of the row specified by @a path.
+   */
+  void scroll_to_row(const TreeModel::Path& path, float row_align);
+
+  /** Moves the alignments of tree view to the position specified by @a path.
+   * The tree does the minimum amount of work to scroll the row onto the screen. This means
+   * that the row will be scrolled to the edge closest to it's current position. If the row
+   * is currently visible on the screen, nothing is done.
+   *
+   * This function only works if the model is set, and @a path is a valid row on the model.
+   * If the model changes before the tree view is realized, the centered path will be
+   * modified to reflect this change.
+   *
+   * @param path The path of the row to move to.
+   */
+  void scroll_to_row(const TreeModel::Path& path);
+
+  /** Moves the alignments of tree view to the position specified by @a column.
+   * @a col_align determines where the column is placed, and is expected to be between 0.0
+   * and 1.0.  0.0 means left alignment, 1.0 means right alignment, 0.5 means center.
+   *
+   * This function only works if the model is set.  If the model changes before the tree
+   * view is realized, the centered path will be modified to reflect this change.
+   *
+   * @param column The Gtk::TreeViewColumn to move horizontally to.
+   * @param col_align The horizontal alignment of the column specified by @a column.
+   */
+  void scroll_to_column(TreeViewColumn& column, float col_align);
+
+  /** Moves the alignments of tree view to the position specified by @a column.
+   * The tree does the minimum amount of work to scroll the column onto the screen. This means
+   * that the column will be scrolled to the edge closest to it's current position. If the column
+   * is currently visible on the screen, nothing is done.
+   *
+   * This function only works if the model is set.  If the model changes before the
+   * tree view is realized, the centered path will be modified to reflect this change.
+   *
+   * @param column The Gtk::TreeViewColumn to move horizontally to.
+   */
+  void scroll_to_column(TreeViewColumn& column);
+
+  
+  /** Activates the cell determined by @a path  and @a column .
+   * @param path The Gtk::TreePath to be activated.
+   * @param column The Gtk::TreeViewColumn to be activated.
+   */
+  void row_activated(const TreeModel::Path& path,TreeViewColumn& column);
+  
+  /** Recursively expands all nodes in the @a tree_view .
+   */
+  void expand_all();
+  
+  /** Recursively collapses all visible, expanded nodes in @a tree_view .
+   */
+  void collapse_all();
+  
+  /** Expands the row at @a path . This will also expand all parent rows of
+   *  @a path  as necessary.
+   * 
+   * Since: 2.2
+   * @param path Path to a row.
+   */
+  void expand_to_path(const TreeModel::Path& path);
+  
+  /** Opens the row so its children are visible.
+   * @param path Path to a row.
+   * @param open_all Whether to recursively expand, or just expand immediate children.
+   * @return <tt>true</tt> if the row existed and had children.
+   */
+  bool expand_row(const TreeModel::Path& path, bool open_all);
+  
+  /** Collapses a row (hides its child rows, if they exist).
+   * @param path Path to a row in the @a tree_view .
+   * @return <tt>true</tt> if the row was collapsed.
+   */
+  bool collapse_row(const TreeModel::Path& path);
+
+  /** For example,
+   * void on_map_expanded_rows(TreeView* tree_view, const TreeModel::Path& path);
+   */
+  typedef sigc::slot<void, TreeView*, const TreeModel::Path&> SlotMapping;
+
+  /** Calls the callback slot on all expanded rows.
+   * @param slot A callback function to be called.
+   */  
+  void map_expanded_rows(const SlotMapping& slot);
+  
+
+  /** Returns <tt>true</tt> if the node pointed to by @a path  is expanded in @a tree_view .
+   * @param path A Gtk::TreePath to test expansion state.
+   * @return <tt>true</tt> if #path is expanded.
+   */
+  bool row_expanded(const TreeModel::Path& path);
+  
+  /** This function is a convenience function to allow you to reorder models that
+   * support the Gtk::DragSourceIface and the Gtk::DragDestIface.  Both
+   * Gtk::TreeStore and Gtk::ListStore support these.  If @a reorderable  is <tt>true</tt>, then
+   * the user can reorder the model by dragging and dropping rows.  The
+   * developer can listen to these changes by connecting to the model's
+   * row_inserted and row_deleted signals.
+   * 
+   * This function does not give you any degree of control over the order -- any
+   * reordering is allowed.  If more control is needed, you should probably
+   * handle drag and drop manually.
+   * @param reorderable <tt>true</tt>, if the tree can be reordered.
+   */
+  void set_reorderable(bool reorderable = true);
+  
+  /** Retrieves whether the user can reorder the tree via drag-and-drop. See
+   * set_reorderable().
+   * @return <tt>true</tt> if the tree can be reordered.
+   */
+  bool get_reorderable() const;
+
+  //TODO: Add set_cursor(path, ModelColumnBase&, start_editing)?
+  
+  /** Sets the current keyboard focus to be at @a path , and selects it.  This is
+   * useful when you want to focus the user's attention on a particular row. Focus is given to the column specified.
+   * Additionally, if @a start_editing  is
+   * <tt>true</tt>, then editing should be started in the specified cell.
+   * This function is often followed by Gtk::Widget::grab_focus( @a tree_view )
+   * in order to give keyboard focus to the widget.  Please note that editing
+   * can only happen when the widget is realized.
+   * @param path A Gtk::TreePath.
+   * @param focus_column A Gtk::TreeViewColumn.
+   * @param start_editing <tt>true</tt> if the specified cell should start being edited.
+   */
+  void set_cursor(const TreeModel::Path& path, TreeViewColumn& focus_column, bool start_editing = false);
+    
+  
+  /** Sets the current keyboard focus to be at @a path , and selects it.  This is
+   * useful when you want to focus the user's attention on a particular row.  If
+   *  @a focus_column  is not <tt>0</tt>, then focus is given to the column specified by
+   * it. If @a focus_column  and @a focus_cell  are not <tt>0</tt>, and @a focus_column 
+   * contains 2 or more editable or activatable cells, then focus is given to
+   * the cell specified by @a focus_cell . Additionally, if @a focus_column  is
+   * specified, and @a start_editing  is <tt>true</tt>, then editing should be started in
+   * the specified cell.  This function is often followed by
+   *  @a gtk_widget_grab_focus  ( @a tree_view ) in order to give keyboard focus to the
+   * widget.  Please note that editing can only happen when the widget is
+   * realized.
+   * 
+   * Since: 2.2
+   * @param path A Gtk::TreePath.
+   * @param focus_column A Gtk::TreeViewColumn, or <tt>0</tt>.
+   * @param focus_cell A Gtk::CellRenderer, or <tt>0</tt>.
+   * @param start_editing <tt>true</tt> if the specified cell should start being edited.
+   */
+  void set_cursor(const TreeModel::Path& path, TreeViewColumn& focus_column, CellRenderer& focus_cell, bool start_editing = false);
+
+ 
+  /** Sets the current keyboard focus to be at path , and selects it.
+   * This is useful when you want to focus the user's attention on a particular row.
+   * This function is often followed by Gtk::widget::grab_focus(tree_view)
+   * in order to give keyboard focus to the widget.
+   *
+   *  @param path A reference to cursor path.
+   */
+  void set_cursor(const TreeModel::Path& path);
+
+  /**  Fills in path and focus_column with the current path and focus column.
+   *
+   *  @param path A reference to be filled with the current cursor path
+   *  @param focus_column A reference to be filled with the current focus column
+   */
+  void get_cursor(TreeModel::Path& path, TreeViewColumn*& focus_column);
+
+/* Layout information */
+  
+  /** Returns the window that @a tree_view  renders to.  This is used primarily to
+   * compare to <tt>event->window</tt> to confirm that the event on
+   *  @a tree_view  is on the right window.
+   * @return A Gdk::Window, or <tt>0</tt> when @a tree_view  hasn't been realized yet.
+   */
+  Glib::RefPtr<Gdk::Window> get_bin_window();
+  
+  /** Returns the window that @a tree_view  renders to.  This is used primarily to
+   * compare to <tt>event->window</tt> to confirm that the event on
+   *  @a tree_view  is on the right window.
+   * @return A Gdk::Window, or <tt>0</tt> when @a tree_view  hasn't been realized yet.
+   */
+  Glib::RefPtr<const Gdk::Window> get_bin_window() const;
+
+  /** Finds the path at the point (x, y), relative to widget
+   * coordinates. It is primarily for things like popup menus.
+   *  
+   * @param x The x position to be identified
+   * @param y The y position to be identified
+   * @param path A reference to a TreeModel::Path to be filled in
+   * @param column A reference to a TreeViewColumn pointer to be filled in
+   * @param cell_x A reference where the X coordinate relative to the cell
+   *   can be placed
+   * @param cell_y A reference where the Y coordinate relative to the cell
+   *   can be placed
+   * @return true if a row exists at that coordinate.
+   */
+  bool get_path_at_pos(int x, int y, TreeModel::Path& path, TreeViewColumn*& column, int& cell_x, int& cell_y);
+  
+  /** Fills the bounding rectangle in tree window coordinates for the cell at the
+   * row specified by @a path  and the column specified by @a column .  If @a path  points to a path not currently displayed, the @a y  and @a height  fields
+   * of the rectangle will be filled with 0.  The sum of all cell rects does not cover the
+   * entire tree; there are extra pixels in between rows, for example. The
+   * returned rectangle is equivalent to the @a cell_area  passed to
+   * Gtk::CellRenderer::render().  This function is only valid if #tree_view is
+   * realized.
+   * @param path A Gtk::TreePath for the row.
+   * @param column A Gtk::TreeViewColumn for the column.
+   * @param rect Rectangle to fill with cell rect.
+   */
+  void get_cell_area(const TreeModel::Path& path, TreeViewColumn& column, Gdk::Rectangle&  rect);
+//We ignore the fact that one of the arguments can be 0 - it does not seem useful.
+
+  
+  /** Fills the bounding rectangle in tree window coordinates for the cell at the
+   * row specified by @a path  and the column specified by @a column .  The returned rectangle is equivalent to the
+   *  @a background_area  passed to Gtk::CellRenderer::render().  These background
+   * areas tile to cover the entire tree window (except for the area used for
+   * header buttons). Contrast with the @a cell_area , returned by
+   * get_cell_area(), which returns only the cell itself, excluding
+   * surrounding borders and the tree expander area.
+   * @param path A Gtk::TreePath for the row.
+   * @param column A Gtk::TreeViewColumn for the column.
+   * @param rect Rectangle to fill with cell background rect.
+   */
+  void get_background_area(const TreeModel::Path& path, TreeViewColumn& column, Gdk::Rectangle& rect);
+  //We ignore the fact that one of the arguments can be 0 - it does not seem useful.
+
+  
+  /** Fills @a visible_rect  with the currently-visible region of the
+   * buffer, in tree coordinates. Convert to widget coordinates with
+   * tree_to_widget_coords(). Tree coordinates start at
+   * 0,0 for row 0 of the tree, and cover the entire scrollable area of
+   * the tree.
+   * @param visible_rect Rectangle to fill.
+   */
+  void get_visible_rect(Gdk::Rectangle&  visible_rect);
+  
+  /** Converts widget coordinates to coordinates for the
+   * tree window (the full scrollable area of the tree).
+   * @param wx Widget X coordinate.
+   * @param wy Widget Y coordinate.
+   * @param tx Return location for tree X coordinate.
+   * @param ty Return location for tree Y coordinate.
+   */
+  void widget_to_tree_coords(int wx, int wy, int& tx, int& ty);
+  
+  /** Converts tree coordinates (coordinates in full scrollable area of the tree)
+   * to widget coordinates.
+   * @param tx Tree X coordinate.
+   * @param ty Tree Y coordinate.
+   * @param wx Return location for widget X coordinate.
+   * @param wy Return location for widget Y coordinate.
+   */
+  void tree_to_widget_coords(int tx, int ty, int& wx, int& wy);
+
+/* Drag-and-Drop support */
+  
+
+  /**
+   * Turns the TreeView into a drag source for automatic DND.
+   *
+   * @param targets Standard container of targets that the drag will support.
+   * @param start_button_mask Mask of allowed buttons to start drag.
+   * @param actions The bitmask of possible actions for a drag from this widget.
+   */
+  void enable_model_drag_source(const ArrayHandle_TargetEntry& targets,
+                                Gdk::ModifierType start_button_mask = Gdk::MODIFIER_MASK,
+                                Gdk::DragAction actions = Gdk::ACTION_COPY | Gdk::ACTION_MOVE);
+
+  // Uses the default "GTK_TREE_MODEL_ROW" target, which the TreeView can handle automatically.
+
+  /** Turns the TreeView into a drag source for automatic DND.
+   *
+   * @param start_button_mask Mask of allowed buttons to start drag.
+   * @param actions The bitmask of possible actions for a drag from this widget.
+   */
+  void enable_model_drag_source(Gdk::ModifierType start_button_mask = Gdk::MODIFIER_MASK,
+                                Gdk::DragAction actions = Gdk::ACTION_COPY | Gdk::ACTION_MOVE);                                                                                              
+
+  
+  /** Turns the TreeViewinto a drop destination for automatic DND.
+   *
+   * @param targets The table of targets that the drag will support.
+   * @param actions The bitmask of possible actions for a drag from this widget.
+   */ 
+  void enable_model_drag_dest(const ArrayHandle_TargetEntry& targets, Gdk::DragAction actions = Gdk::ACTION_COPY | Gdk::ACTION_MOVE);
+
+  /** Turns the TreeView into a drop destination for automatic DND.  This uses the default
+    *  "GTK_TREE_MODEL_ROW" target, which the TreeView can handle automatically.
+    *
+    * @param actions The bitmask of possible actions for a drag from this widget.
+   */ 
+  void enable_model_drag_dest(Gdk::DragAction actions = Gdk::ACTION_COPY | Gdk::ACTION_MOVE);
+
+  /** Undoes the effect of enable_model_drag_source()
+   */
+  
+  /** Undoes the effect of enable_model_drag_source().
+   */
+  void unset_rows_drag_source();
+
+  /** Undoes the effect of enable_model_drag_source()
+   */
+  
+  /** Undoes the effect of enable_model_drag_dest().
+   */
+  void unset_rows_drag_dest();
+
+
+  /* These are useful to implement your own custom stuff. */
+
+  /** Sets the row that is highlighted for feedback.
+   *
+   * @param path The path of the row to highlight
+   * @param pos Specifies whether to drop before, after or into the row
+   */
+  
+  /** Sets the row that is highlighted for feedback.
+   * @param path The path of the row to highlight, or <tt>0</tt>.
+   * @param pos Specifies whether to drop before, after or into the row.
+   */
+  void set_drag_dest_row(const TreeModel::Path& path, TreeViewDropPosition pos);
+    
+  /** Gets information about the row that is highlighted for feedback.
+   *
+   * @param path Return location for the path of the highlighted row
+   * @param pos Return location for the drop position
+   */
+  void get_drag_dest_row(TreeModel::Path& path, TreeViewDropPosition& pos) const;
+
+  /** Determines the destination row for a given position.
+   *
+   * @param drag_x The x position to determine the destination row for
+   * @param drag_y The y position to determine the destination row for
+   * @param path Return location for the path of the highlighted row
+   * @param pos Return location for the drop position
+   */
+  bool get_dest_row_at_pos(int drag_x, int drag_y, TreeModel::Path& path, TreeViewDropPosition& pos) const;
+
+  
+  /** Creates a Gdk::Pixmap representation of the row at @a path .  This image is used
+   * for a drag icon.
+   * @param path A Gtk::TreePath in @a tree_view .
+   * @return A newly-allocated pixmap of the drag icon.
+   */
+  Glib::RefPtr<Gdk::Pixmap> create_row_drag_icon(const TreeModel::Path& path);
+
+/* Interactive search */
+  
+  /** If @a enable_search  is set, then the user can type in text to search through
+   * the tree interactively.
+   * @param enable_search <tt>true</tt>, if the user can search interactively.
+   */
+  void set_enable_search(bool enable_search = true);
+  
+  /** Returns whether or not the tree allows interactive searching.
+   * @return Whether or not to let the user search interactively.
+   */
+  bool get_enable_search() const;
+  
+  /** Gets the column searched on by the interactive search code.
+   * @return The column the interactive search code searches in.
+   */
+  int get_search_column() const;
+  
+  /** Sets @a column  as the column where the interactive search code should
+   * search in.  Additionally, turns on interactive searching. Note that
+   *  @a column  refers to a column of the model.
+   * @param column The column of the model to search in.
+   */
+  void set_search_column(const TreeModelColumnBase& column);
+  
+  /** Sets @a column  as the column where the interactive search code should
+   * search in.  Additionally, turns on interactive searching. Note that
+   *  @a column  refers to a column of the model.
+   * @param column The column of the model to search in.
+   */
+  void set_search_column(int column);
+
+  ///void on_search_equal(const Glib::RefPtr<TreeModel>& model, int column, const Glib::ustring& key, const TreeModel::iterator& iter)
+  typedef sigc::slot<bool, const Glib::RefPtr<TreeModel>&, int, const Glib::ustring&, const TreeModel::iterator&> SlotSearchEqual;
+  //SlotSearchEqual get_search_equal_func();
+  
+  
+  /** Sets the compare function for the interactive search capabilities.
+   *
+   * @param slot The compare function to use during the search
+   */
+  void set_search_equal_func(const SlotSearchEqual& slot);
+  
+
+  /** Enables or disables the fixed height mode of @a tree_view . 
+   * Fixed height mode speeds up Gtk::TreeView by assuming that all 
+   * rows have the same height. 
+   * Only enable this option if all rows are the same height and all
+   * columns are of type Gtk::TREE_VIEW_COLUMN_FIXED.
+   * 
+   * Since: 2.6
+   * @param enable <tt>true</tt> to enable fixed height mode.
+   */
+  void set_fixed_height_mode(bool enable = true);
+  
+  /** Returns whether fixed height mode is turned on for @a tree_view .
+   * @return <tt>true</tt> if @a tree_view  is in fixed height mode
+   * 
+   * Since: 2.6.
+   */
+  bool get_fixed_height_mode() const;
+  
+  /** Enables of disables the hover selection mode of @a tree_view .
+   * Hover selection makes the selected row follow the pointer.
+   * Currently, this works only for the selection modes 
+   * Gtk::SELECTION_SINGLE and Gtk::SELECTION_BROWSE.
+   * 
+   * Since: 2.6
+   * @param hover <tt>true</tt> to enable hover selection mode.
+   */
+  void set_hover_selection(bool hover = true);
+  
+  /** Returns whether hover selection mode is turned on for @a tree_view .
+   * @return <tt>true</tt> if @a tree_view  is in hover selection mode
+   * 
+   * Since: 2.6.
+   */
+  bool get_hover_selection() const;
+  
+  /** Enables of disables the hover expansion mode of @a tree_view .
+   * Hover expansion makes rows expand or collaps if the pointer 
+   * moves over them.
+   * 
+   * Since: 2.6
+   * @param expand <tt>true</tt> to enable hover selection mode.
+   */
+  void set_hover_expand(bool expand = true);
+  
+  /** Returns whether hover expansion mode is turned on for @a tree_view .
+   * @return <tt>true</tt> if @a tree_view  is in hover expansion mode
+   * 
+   * Since: 2.6.
+   */
+  bool get_hover_expand() const;
+
+  /** For instance,
+   * void on_row_separator(const Gtk::TreeModel& model, const Gtk::TreeModel::iterator& iter);
+   */
+  typedef sigc::slot<bool, const Glib::RefPtr<TreeModel>&, const TreeModel::iterator&> SlotRowSeparator;
+  
+  void set_row_separator_func(const SlotRowSeparator& slot);
+  
+
+  Glib::SignalProxy2< void,Adjustment*,Adjustment* > signal_set_scroll_adjustments();
+
+  
+  Glib::SignalProxy2< void,const TreeModel::Path&,TreeViewColumn* > signal_row_activated();
+
+  
+  Glib::SignalProxy2< bool,const TreeModel::iterator&,const TreeModel::Path& > signal_test_expand_row();
+
+  
+  Glib::SignalProxy2< bool,const TreeModel::iterator&,const TreeModel::Path& > signal_test_collapse_row();
+
+  
+  Glib::SignalProxy2< void,const TreeModel::iterator&,const TreeModel::Path& > signal_row_expanded();
+
+  
+  Glib::SignalProxy2< void,const TreeModel::iterator&,const TreeModel::Path& > signal_row_collapsed();
+
+  
+  Glib::SignalProxy0< void > signal_cursor_changed();
+
+  
+  Glib::SignalProxy0< void > signal_columns_changed();
+
+
+  //Don't wrap these. They are keybinding signals, and their API broke for GTK+ 2.2.
+  
+  
+  /** The model for the tree view.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy< Glib::RefPtr<TreeModel> > property_model() ;
+
+/** The model for the tree view.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly< Glib::RefPtr<TreeModel> > property_model() const;
+
+  /** Horizontal Adjustment for the widget.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Adjustment*> property_hadjustment() ;
+
+/** Horizontal Adjustment for the widget.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Adjustment*> property_hadjustment() const;
+
+  /** Vertical Adjustment for the widget.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Adjustment*> property_vadjustment() ;
+
+/** Vertical Adjustment for the widget.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Adjustment*> property_vadjustment() const;
+
+  /** Show the column header buttons.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_headers_visible() ;
+
+/** Show the column header buttons.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_headers_visible() const;
+
+  /** Column headers respond to click events.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_headers_clickable() ;
+
+/** Column headers respond to click events.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_headers_clickable() const;
+
+  /** Set the column for the expander column.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<TreeViewColumn*> property_expander_column() ;
+
+/** Set the column for the expander column.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<TreeViewColumn*> property_expander_column() const;
+
+  /** View is reorderable.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_reorderable() ;
+
+/** View is reorderable.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_reorderable() const;
+
+  /** Set a hint to the theme engine to draw rows in alternating colors.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_rules_hint() ;
+
+/** Set a hint to the theme engine to draw rows in alternating colors.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_rules_hint() const;
+
+  /** View allows user to search through columns interactively.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_enable_search() ;
+
+/** View allows user to search through columns interactively.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_enable_search() const;
+
+  /** Model column to search through when searching through code.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<int> property_search_column() ;
+
+/** Model column to search through when searching through code.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<int> property_search_column() const;
+
+  /** Speeds up GtkTreeView by assuming that all rows have the same height.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_fixed_height_mode() ;
+
+/** Speeds up GtkTreeView by assuming that all rows have the same height.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_fixed_height_mode() const;
+
+  /** Whether the selection should follow the pointer.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_hover_selection() ;
+
+/** Whether the selection should follow the pointer.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_hover_selection() const;
+
+  /** Whether rows should be expanded/collapsed when the pointer moves over them.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_hover_expand() ;
+
+/** Whether rows should be expanded/collapsed when the pointer moves over them.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_hover_expand() const;
+
+
+  /// Get the treeview's model, but actually get the child model if it's a TreeModelFilter.
+  Glib::RefPtr<Gtk::TreeModel> _get_base_model();
+  
+protected:
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  template<class ColumnType> friend
+  void _auto_store_on_cellrenderer_text_edited_string(const Glib::ustring& path_string, const Glib::ustring& new_text, int model_column, Gtk::TreeView*);
+
+  template <class ColumnType> friend
+  void _auto_store_on_cellrenderer_text_edited_numerical(const Glib::ustring& path_string, const Glib::ustring& new_text, int model_column, Gtk::TreeView*);
+  
+  void _auto_store_on_cellrenderer_toggle_edited(const Glib::ustring& path_string, int model_column);
+
+  template<class ColumnType> friend
+  void TreeView_Private::_connect_auto_store_editable_signal_handler(TreeView*, CellRenderer*, const TreeModelColumn<ColumnType>&);
+
+#endif //DOXYGEN_SHOULD_SKIP_THIS
+
+
+};
+
+
+template <class ColumnType> inline
+int TreeView::append_column(const Glib::ustring& title, const TreeModelColumn<ColumnType>& model_column)
+{
+  // compilation will fail if there is no appropriate TreeViewColumn
+  // constructor for this model column type.
+  TreeViewColumn *const pViewColumn = Gtk::manage( new TreeViewColumn(title, model_column) );
+
+  return append_column(*pViewColumn);
+}
+
+//This is here because sigc::bind once did not work on all platforms, but now it does..
+#define GTKMM_HAVE_SIGC_BIND 1
+
+#ifdef GTKMM_HAVE_SIGC_BIND
+
+template <class ColumnType> inline
+int TreeView::append_column_numeric(const Glib::ustring& title, const TreeModelColumn<ColumnType>& model_column, const Glib::ustring& format)
+{
+  TreeViewColumn* const pViewColumn = Gtk::manage( new TreeViewColumn(title) );
+    
+  //Use a CellRendererText:
+  //We don't use TreeView::Column::append_column(model_column) to generate an appropriate CellRenderer, 
+  //because that uses set_renderer(), which renders the model value using the automatic glib "transformations" (number-string conversions). As well as being unnecessary here, those automatic conversions can't handle all numeric types.
+  CellRenderer* pCellRenderer = manage( new CellRendererText() );
+  pViewColumn->pack_start(*pCellRenderer);
+  
+
+  //Some compilers don't like us to give the pointer to a template function directly to sigc::ptr_fun():
+  typedef void (*type_fptr)(Gtk::CellRenderer* cell, const Gtk::TreeModel::iterator& iter, int model_column, const Glib::ustring& format);
+  type_fptr fptr = TreeView_Private::_auto_cell_data_func<ColumnType>;
+
+  //Connect a cell_data callback, to show the number's text representation in the specified format:
+  //We use sigc::bind<-1> twice here, instead of sigc::bind() once, because some compilers need the extra hint.
+  Gtk::TreeViewColumn::SlotCellData slot = sigc::bind<-1>(
+    sigc::bind<-1>( sigc::ptr_fun(fptr), format),
+    model_column.index()
+  );
+    
+  pViewColumn->set_cell_data_func(*pCellRenderer, slot);
+
+  return append_column(*pViewColumn);
+}
+
+#endif //GTKMM_HAVE_SIGC_BIND
+
+template <class ColumnType> inline
+int TreeView::append_column_numeric_editable(const Glib::ustring& title, const TreeModelColumn<ColumnType>& model_column, const Glib::ustring& format)
+{
+  int cols_count = append_column_numeric(title, model_column, format);
+  
+  //connect signal handlers for auto-storing of edited cell data
+  //Note: This will only work for base-10 (decimal) formatted numbers:
+  CellRenderer *const cell = get_column_cell_renderer(cols_count - 1);
+  if(cell)
+  {
+    TreeView_Private::_connect_auto_store_editable_signal_handler<ColumnType>(this, cell, model_column);
+  }
+   
+  return cols_count;
+}
+
+template <class ColumnType> inline
+int TreeView::append_column_editable(const Glib::ustring& title, const TreeModelColumn<ColumnType>& model_column)
+{
+  g_assert(model_column.type() != 0);
+
+  // compilation will fail if there is no appropriate TreeViewColumn
+  // constructor for this model column type.
+  TreeViewColumn *const pViewColumn = Gtk::manage( new TreeViewColumn(title, model_column) );
+
+  //connect signal handlers for auto-storing of edited cell data
+  CellRenderer* pCellRender = pViewColumn->get_first_cell_renderer();
+  TreeView_Private::_connect_auto_store_editable_signal_handler<ColumnType>(this, pCellRender, model_column);
+
+  return append_column(*pViewColumn);
+}
+
+template <class ColumnType> inline
+int TreeView::insert_column(const Glib::ustring& title, const TreeModelColumn<ColumnType>& model_column, int position)
+{
+  // compilation will fail if there is no appropriate TreeViewColumn
+  // constructor for this model column type.
+  TreeViewColumn *const pViewColumn = Gtk::manage( new TreeViewColumn(title, model_column) );
+
+  return insert_column(*pViewColumn, position);
+}
+
+template <class ColumnType> inline
+int TreeView::insert_column_editable(const Glib::ustring& title, const TreeModelColumn<ColumnType>& model_column, int position)
+{
+  // compilation will fail if there is no appropriate TreeViewColumn
+  // constructor for this model column type.
+  TreeViewColumn *const pViewColumn = Gtk::manage( new TreeViewColumn(title, model_column) );
+
+   //connect signal handlers for auto-storing of edited cell data
+  CellRenderer* pCellRender = pViewColumn->get_first_cell_renderer();
+  TreeView_Private::_connect_auto_store_editable_signal_handler(this, pCellRender, model_column);
+
+  return insert_column(*pViewColumn, position);
+}
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace TreeView_Private
+{
+
+//Template specializations, for different model column types:
+//TODO: Move these specializations into the .ccg file - I tried, but the int specialization was not used by the compiler. murrayc.
+
+#ifdef GTKMM_HAVE_SIGC_BIND
+
+//bool specialization:
+template<> inline
+void _connect_auto_store_editable_signal_handler(Gtk::TreeView* this_p, Gtk::CellRenderer* pCellRenderer,  const Gtk::TreeModelColumn<bool>& model_column)
+{
+  Gtk::CellRendererToggle* pCellToggle = dynamic_cast<Gtk::CellRendererToggle*>(pCellRenderer);
+  if(pCellToggle)
+  {
+    //Set the appropriate property,
+    pCellToggle->property_activatable() = true;
+  
+    //Connect to the appropriate signal, sending the model_column too,
+    pCellToggle->signal_toggled().connect(
+      sigc::bind<-1>( sigc::mem_fun(*this_p, &Gtk::TreeView::_auto_store_on_cellrenderer_toggle_edited), model_column.index()) );
+    //We use bind<1> instead of bind because some compilers need the extra hint.
+  }
+}
+
+//int specialization:
+template<> inline
+void _connect_auto_store_editable_signal_handler(Gtk::TreeView* this_p, Gtk::CellRenderer* pCellRenderer,  const Gtk::TreeModelColumn<int>& model_column)
+{
+  Gtk::CellRendererText* pCellText = dynamic_cast<Gtk::CellRendererText*>(pCellRenderer);
+  if(pCellText)
+  {
+    //Set the appropriate property,
+    pCellText->property_editable() = true;
+
+    //Some compilers don't like us to give the pointer to a template function directly to sigc::ptr_fun():
+    typedef void (*type_fptr)(const Glib::ustring& path_string, const Glib::ustring& new_text, int model_column, Gtk::TreeView* this_p);
+    type_fptr fptr = _auto_store_on_cellrenderer_text_edited_numerical<int>;
+
+    //Connect to the appropriate signal, sending the model_column too,
+    //We use bind<-1> twice here, instead of using bind() once, because some compilers need the extra hint.
+    pCellText->signal_edited().connect(
+      sigc::bind<-1>(
+        sigc::bind<-1>( sigc::ptr_fun(fptr), this_p),
+        model_column.index()
+      )
+    );
+
+  }
+}
+
+//unsigned int specialization:
+template<> inline
+void _connect_auto_store_editable_signal_handler(Gtk::TreeView* this_p, Gtk::CellRenderer* pCellRenderer,  const Gtk::TreeModelColumn<unsigned int>& model_column)
+{
+  Gtk::CellRendererText* pCellText = dynamic_cast<Gtk::CellRendererText*>(pCellRenderer);
+  if(pCellText)
+  {
+    //Set the appropriate property,
+    pCellText->property_editable() = true;
+
+    //Some compilers don't like us to give the pointer to a template function directly to sigc::ptr_fun():
+    typedef void (*type_fptr)(const Glib::ustring& path_string, const Glib::ustring& new_text, int model_column, Gtk::TreeView* this_p);
+    type_fptr fptr = _auto_store_on_cellrenderer_text_edited_numerical<unsigned int>;
+
+    //Connect to the appropriate signal, sending the model_column too,
+    //We use bind<-1> twice here, instead of using bind() once, because some compilers need the extra hint.
+    pCellText->signal_edited().connect(
+      sigc::bind<-1>(
+        sigc::bind<-1>( sigc::ptr_fun(fptr), this_p),
+        model_column.index()
+      )
+    );
+    
+  }
+}
+
+//long specialization:
+template<> inline
+void _connect_auto_store_editable_signal_handler(Gtk::TreeView* this_p, Gtk::CellRenderer* pCellRenderer,  const Gtk::TreeModelColumn<long>& model_column)
+{
+  Gtk::CellRendererText* pCellText = dynamic_cast<Gtk::CellRendererText*>(pCellRenderer);
+  if(pCellText)
+  {
+    //Set the appropriate property,
+    pCellText->property_editable() = true;
+     
+    //Some compilers don't like us to give the pointer to a template function directly to sigc::ptr_fun():
+    typedef void (*type_fptr)(const Glib::ustring& path_string, const Glib::ustring& new_text, int model_column, Gtk::TreeView* this_p);
+    type_fptr fptr = _auto_store_on_cellrenderer_text_edited_numerical<long>;
+
+    //Connect to the appropriate signal, sending the model_column too,
+    //We use bind<-1> twice here, instead of using bind() once, because some compilers need the extra hint.
+    pCellText->signal_edited().connect(
+      sigc::bind<-1>(
+        sigc::bind<-1>( sigc::ptr_fun(fptr), this_p),
+        model_column.index()
+      )
+    );
+    
+  }
+}
+
+//unsigned long specialization:
+template<> inline
+void _connect_auto_store_editable_signal_handler(Gtk::TreeView* this_p, Gtk::CellRenderer* pCellRenderer,  const Gtk::TreeModelColumn<unsigned long>& model_column)
+{
+  Gtk::CellRendererText* pCellText = dynamic_cast<Gtk::CellRendererText*>(pCellRenderer);
+  if(pCellText)
+  {
+    //Set the appropriate property,
+    pCellText->property_editable() = true;
+  
+    //Some compilers don't like us to give the pointer to a template function directly to sigc::ptr_fun():
+    typedef void (*type_fptr)(const Glib::ustring& path_string, const Glib::ustring& new_text, int model_column, Gtk::TreeView* this_p);
+    type_fptr fptr = _auto_store_on_cellrenderer_text_edited_numerical<unsigned long>;
+
+    //Connect to the appropriate signal, sending the model_column too,
+    //We use bind<-1> twice here, instead of using bind() once, because some compilers need the extra hint.
+    pCellText->signal_edited().connect(
+      sigc::bind<-1>(
+        sigc::bind<-1>( sigc::ptr_fun(fptr), this_p),
+        model_column.index()
+      )
+    );
+    
+  }
+}
+
+//float specialization:
+template<> inline
+void _connect_auto_store_editable_signal_handler(Gtk::TreeView* this_p, Gtk::CellRenderer* pCellRenderer,  const Gtk::TreeModelColumn<float>& model_column)
+{
+  Gtk::CellRendererText* pCellText = dynamic_cast<Gtk::CellRendererText*>(pCellRenderer);
+  if(pCellText)
+  {
+    //Set the appropriate property,
+    pCellText->property_editable() = true;
+
+    //Some compilers don't like us to give the pointer to a template function directly to sigc::ptr_fun():
+    typedef void (*type_fptr)(const Glib::ustring& path_string, const Glib::ustring& new_text, int model_column, Gtk::TreeView* this_p);
+    type_fptr fptr = _auto_store_on_cellrenderer_text_edited_numerical<float>;
+
+    //Connect to the appropriate signal, sending the model_column too,
+    //We use bind<-1> twice here, instead of using bind() once, because some compilers need the extra hint.
+    pCellText->signal_edited().connect(
+      sigc::bind<-1>(
+        sigc::bind<-1>( sigc::ptr_fun(fptr), this_p),
+        model_column.index()
+      )
+    );
+  }
+}
+
+//double specialization:
+template<> inline
+void _connect_auto_store_editable_signal_handler(Gtk::TreeView* this_p, Gtk::CellRenderer* pCellRenderer,  const Gtk::TreeModelColumn<double>& model_column)
+{
+  Gtk::CellRendererText* pCellText = dynamic_cast<Gtk::CellRendererText*>(pCellRenderer);
+  if(pCellText)
+  {
+    //Set the appropriate property,
+    pCellText->property_editable() = true;
+
+    //Some compilers don't like us to give the pointer to a template function directly to sigc::ptr_fun():
+    typedef void (*type_fptr)(const Glib::ustring& path_string, const Glib::ustring& new_text, int model_column, Gtk::TreeView* this_p);
+    type_fptr fptr = _auto_store_on_cellrenderer_text_edited_numerical<double>;
+
+    //Connect to the appropriate signal, sending the model_column too,
+    //We use bind<-1> twice here, instead of using bind() once, because some compilers need the extra hint.
+    pCellText->signal_edited().connect(
+      sigc::bind<-1>(
+        sigc::bind<-1>( sigc::ptr_fun(fptr), this_p),
+        model_column.index()
+      )
+    );
+  }
+}
+
+#endif //GTKMM_HAVE_SIGC_BIND
+
+} // namespace TreeView_Private
+#endif //DOXYGEN_SHOULD_SKIP_THIS
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace TreeView_Private
+{
+
+#ifdef GTKMM_HAVE_SIGC_BIND
+
+template <class ColumnType> inline
+void _connect_auto_store_editable_signal_handler(Gtk::TreeView* this_p, Gtk::CellRenderer* pCellRenderer,  const Gtk::TreeModelColumn<ColumnType>& model_column)
+{
+  g_assert(model_column.type() != 0);
+
+  //The different CellRenderers have different "edited" signals,
+  //and numerical values need to convert the text value to a number,
+  //so there are specializations for this tempate.
+
+  Gtk::CellRendererText* pCellText = dynamic_cast<Gtk::CellRendererText*>(pCellRenderer);
+
+  //Set the appropriate property,
+  //and connect to the appropriate signal, sending the model_column too,
+  if(pCellText)
+  {
+    pCellText->property_editable() = true;
+   
+    //Some compilers (IRIX MipsPro) don't like us to give the pointer to a template function directly to sigc::ptr_fun():
+    typedef void (*type_func)(const Glib::ustring&, const Glib::ustring&, int, Gtk::TreeView*);
+    type_func func = &(_auto_store_on_cellrenderer_text_edited_string<ColumnType>);
+    sigc::slot<void, const Glib::ustring&, const Glib::ustring&, int, Gtk::TreeView*> theslot  =
+      sigc::ptr_fun(func);
+
+    //We use bind<-1> twice here, instead of using bind() once, because some compilers need the extra hint.
+    pCellText->signal_edited().connect(
+      sigc::bind<-1>(
+        sigc::bind<-1>( theslot, this_p),
+        model_column.index()
+      )
+    );
+
+    
+  }
+}
+
+#endif //GTKMM_HAVE_SIGC_BIND
+
+template <class ColumnType> inline
+void _auto_store_on_cellrenderer_text_edited_string(const Glib::ustring& path_string, const Glib::ustring& new_text, int model_column, Gtk::TreeView* this_p)
+{
+  Gtk::TreePath path(path_string);
+
+  //Get the row from the path:
+  Glib::RefPtr<TreeModel> refModel = this_p->_get_base_model();
+  Gtk::TreeModel::iterator iter = refModel->get_iter(path);
+  if(iter)
+  {
+      //Store the user's new text in the model:
+      Gtk::TreeRow row = *iter;
+      row.set_value(model_column, (ColumnType)new_text);
+  }
+}
+
+template <class ColumnType> inline
+void _auto_store_on_cellrenderer_text_edited_numerical(const Glib::ustring& path_string, const Glib::ustring& new_text, int model_column, Gtk::TreeView* this_p)
+{
+  //This is used on numerical model columns:
+
+  Gtk::TreePath path(path_string);
+
+  //Get the row from the path:
+  Glib::RefPtr<TreeModel> refModel = this_p->_get_base_model();
+  Gtk::TreeModel::iterator iter = refModel->get_iter(path);
+  if(iter)
+  { 
+    //std::istringstream astream(new_text); //Put it in a stream.
+    //ColumnType new_value = ColumnType();
+    //new_value << astream; //Get it out of the stream as the numerical type.
+    
+    //Convert the text to a number, using the same logic used by GtkCellRendererText when it stores numbers.
+    char* pchEnd = 0;
+    ColumnType new_value = static_cast<ColumnType>( strtod(new_text.c_str(), &pchEnd) );
+
+    //Store the user's new text in the model:
+    Gtk::TreeRow row = *iter;
+    row.set_value(model_column, (ColumnType)new_value);
+  }
+}
+
+template <class ColumnType> inline
+void _auto_cell_data_func(Gtk::CellRenderer* cell, const Gtk::TreeModel::iterator& iter, int model_column, const Glib::ustring& format)
+{
+  Gtk::CellRendererText* pTextRenderer = dynamic_cast<Gtk::CellRendererText*>(cell);
+  if(!pTextRenderer)
+  {
+    g_warning("gtkmm: TextView: append_column_numeric() was used with a non-numeric type.");
+  }
+  else
+  {
+    if(iter)
+    {
+      //Get the value from the model.
+      Gtk::TreeModel::Row row = *iter;
+      ColumnType value = ColumnType();
+      row.get_value(model_column, value);
+      
+      //Convert it to a string representation:
+      char buff[20];
+      int used = g_snprintf(buff, sizeof(buff), format.c_str(), value); //value must be a numeric type.
+      if(used > 0)
+      {
+        //Show the text representation in the view:
+        pTextRenderer->property_text() = buff;
+      }
+    }
+  }
+}
+
+} // namespace TreeView_Private
+#endif //DOXYGEN_SHOULD_SKIP_THIS
+
+
+} // namespace Gtk
+
+
+namespace Glib
+{
+  /** @relates Gtk::TreeView
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gtk::TreeView* wrap(GtkTreeView* object, bool take_copy = false);
+}
+#endif /* _GTKMM_TREEVIEW_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/treeview_private.cc b/libs/gtkmm2/gtk/gtkmm/treeview_private.cc
new file mode 100644
index 0000000000..a18fce35f8
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/treeview_private.cc
@@ -0,0 +1,94 @@
+/* $Id$ */
+
+/* Copyright(C) 2001-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/treeview_private.h>
+#include <glibmm.h>
+
+
+namespace Gtk
+{
+
+namespace TreeView_Private
+{
+
+SignalProxy_CellData::SignalProxy_CellData(const SlotType& slot)
+:
+  slot_ (slot)
+{}
+
+SignalProxy_CellData::~SignalProxy_CellData()
+{}
+
+void SignalProxy_CellData::gtk_callback(GtkTreeViewColumn*, GtkCellRenderer* cell,
+                                        GtkTreeModel* model, GtkTreeIter* iter, void* data)
+{
+  SignalProxy_CellData *const self = static_cast<SignalProxy_CellData*>(data);
+
+  try
+  {
+    // use Slot::operator()
+    (self->slot_)(Glib::wrap(cell, false), TreeIter(model, iter));
+  }
+  catch(...)
+  {
+    Glib::exception_handlers_invoke();
+  }
+}
+
+void SignalProxy_CellData::gtk_callback_destroy(void* data)
+{
+  delete static_cast<SignalProxy_CellData*>(data);
+}
+
+
+
+SignalProxy_RowSeparator::SignalProxy_RowSeparator(const SlotType& slot)
+:
+  slot_ (slot)
+{}
+
+SignalProxy_RowSeparator::~SignalProxy_RowSeparator()
+{}
+
+gboolean SignalProxy_RowSeparator::gtk_callback(GtkTreeModel* model, GtkTreeIter* iter, void* data)
+{
+  SignalProxy_RowSeparator *const self = static_cast<SignalProxy_RowSeparator*>(data);
+
+  try
+  {
+    return (self->slot_)(Glib::wrap(model, true), Gtk::TreeIter(model, iter));
+  }
+  catch(...)
+  {
+    Glib::exception_handlers_invoke();
+  }
+
+  return 0; // arbitrary value
+}
+
+void SignalProxy_RowSeparator::gtk_callback_destroy(void* data)
+{
+  delete static_cast<SignalProxy_RowSeparator*>(data);
+}
+
+
+} // namespace TreeView_Private
+
+} // namespace Gtk
+
diff --git a/libs/gtkmm2/gtk/gtkmm/treeview_private.h b/libs/gtkmm2/gtk/gtkmm/treeview_private.h
new file mode 100644
index 0000000000..418abe3a69
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/treeview_private.h
@@ -0,0 +1,77 @@
+#ifndef _GTKMM_TREEVIEW_PRIVATE_H
+#define _GTKMM_TREEVIEW_PRIVATE_H
+/* $Id$ */
+
+
+/* treeview.h
+ *
+ * Copyright(C) 2001-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/treeviewcolumn.h>
+#include <gtkmm/treeview.h>
+
+namespace Gtk
+{
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace TreeView_Private
+{
+
+//This Signal Proxy allows the C++ coder to specify a sigc::slot instead of a static function.
+class SignalProxy_CellData
+{
+public:
+  typedef TreeViewColumn::SlotCellData SlotType;
+
+  SignalProxy_CellData(const SlotType& slot);
+  ~SignalProxy_CellData();
+
+  static void gtk_callback(GtkTreeViewColumn*, GtkCellRenderer* cell,
+                           GtkTreeModel* model, GtkTreeIter* iter, void* data);
+  static void gtk_callback_destroy(void* data);
+
+protected:
+  SlotType slot_;
+};
+
+//SignalProxy_RowSeparator:
+
+//This Signal Proxy allows the C++ coder to specify a sigc::slot instead of a static function.
+class SignalProxy_RowSeparator
+{
+public:
+  typedef TreeView::SlotRowSeparator SlotType;
+
+  SignalProxy_RowSeparator(const SlotType& slot);
+  ~SignalProxy_RowSeparator();
+
+  static gboolean gtk_callback(GtkTreeModel* model, GtkTreeIter* iter, void* data);
+  static void gtk_callback_destroy(void* data);
+
+protected:
+  SlotType slot_;
+};
+
+
+} /* namespace TreeView_Private */
+#endif //DOXYGEN_SHOULD_SKIP_THIS
+
+} /* namespace Gtk */
+
+
+#endif /* _GTKMM_TREEVIEW_PRIVATE_H */
diff --git a/libs/gtkmm2/gtk/gtkmm/treeviewcolumn.cc b/libs/gtkmm2/gtk/gtkmm/treeviewcolumn.cc
new file mode 100644
index 0000000000..9a726fd39b
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/treeviewcolumn.cc
@@ -0,0 +1,663 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/treeviewcolumn.h>
+#include <gtkmm/private/treeviewcolumn_p.h>
+
+#include <gtk/gtktypebuiltins.h>
+// -*- c++ -*-
+/* $Id$ */
+
+/* Copyright 2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtk/gtktreeviewcolumn.h>
+#include <gtkmm/treeview_private.h>
+
+namespace Gtk
+{
+
+// Only necessary because of the templated ctor, see .hg file.
+const Glib::Class& TreeViewColumn::class_init_()
+{
+  return treeviewcolumn_class_.init();
+}
+
+TreeViewColumn::TreeViewColumn(const Glib::ustring& title)
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Object(Glib::ConstructParams(treeviewcolumn_class_.init(), "title",title.c_str(), (char*) 0))
+{}
+
+TreeViewColumn::TreeViewColumn(const Glib::ustring& title, Gtk::CellRenderer& cell)
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Object(Glib::ConstructParams(treeviewcolumn_class_.init(), "title",title.c_str(), (char*) 0))
+{
+  //This is equivalent to _gtk_tree_view_column_new_with_attributes().
+  //You will also need to call add_atrribute(), or set_renderer() a few times.
+
+  pack_start(cell, true);
+}
+
+void TreeViewColumn::add_attribute(const Glib::PropertyProxy_Base& property,
+                                   const TreeModelColumnBase& column)
+{
+  gtk_tree_view_column_add_attribute(gobj(),
+      (GtkCellRenderer*) property.get_object()->gobj(), property.get_name(), column.index());
+}
+
+void TreeViewColumn::set_renderer(Gtk::CellRenderer& renderer, const TreeModelColumnBase& column)
+{
+  add_attribute(renderer._property_renderable(), column);
+}
+
+
+void TreeViewColumn::set_cell_data_func(CellRenderer& cell_renderer, const SlotCellData& slot)
+{
+  //Create a signal proxy. A pointer to this will be passed through the callback's data parameter.
+  //It will be deleted when TreeView_Private::SignalProxy_CellData::gtk_callback_destroy() is called.
+  TreeView_Private::SignalProxy_CellData* pSignalProxy = new TreeView_Private::SignalProxy_CellData(slot);
+
+  gtk_tree_view_column_set_cell_data_func(
+      gobj(), cell_renderer.gobj(),
+      &TreeView_Private::SignalProxy_CellData::gtk_callback, pSignalProxy,
+      &TreeView_Private::SignalProxy_CellData::gtk_callback_destroy);
+}
+
+void TreeViewColumn::unset_cell_data_func(CellRenderer& cell_renderer)
+{
+  gtk_tree_view_column_set_cell_data_func(gobj(), cell_renderer.gobj(), 0, 0, 0);
+}
+
+CellRenderer* TreeViewColumn::get_first_cell_renderer()
+{
+  typedef std::vector<Gtk::CellRenderer*> type_vecCellRenderers;
+  type_vecCellRenderers vecCellRenderers = get_cell_renderers();
+  if(!vecCellRenderers.empty())
+    return vecCellRenderers[0];
+  else
+    return 0;
+}
+
+const CellRenderer* TreeViewColumn::get_first_cell_renderer() const
+{
+  //Do some const_cast-ing to avoid repetition of code:
+  return const_cast<TreeViewColumn*>(this)->get_first_cell_renderer();
+}
+
+//deprecated:
+void TreeViewColumn::set_sort_column_id(const TreeModelColumnBase& sort_column)
+{
+  set_sort_column(sort_column);
+}
+
+//deprecated:
+void TreeViewColumn::set_sort_column_id(int sort_column_id)
+{
+  set_sort_column(sort_column_id);
+}  
+
+} // namespace Gtk
+
+
+namespace
+{
+
+const Glib::SignalProxyInfo TreeViewColumn_signal_clicked_info =
+{
+  "clicked",
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
+};
+
+} // anonymous namespace
+
+// static
+GType Glib::Value<Gtk::TreeViewColumnSizing>::value_type()
+{
+  return gtk_tree_view_column_sizing_get_type();
+}
+
+
+namespace Glib
+{
+
+Gtk::TreeViewColumn* wrap(GtkTreeViewColumn* object, bool take_copy)
+{
+  return dynamic_cast<Gtk::TreeViewColumn *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& TreeViewColumn_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &TreeViewColumn_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_tree_view_column_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void TreeViewColumn_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+  klass->clicked = &clicked_callback;
+}
+
+
+void TreeViewColumn_Class::clicked_callback(GtkTreeViewColumn* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_clicked();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->clicked)
+      (*base->clicked)(self);
+  }
+}
+
+
+Glib::ObjectBase* TreeViewColumn_Class::wrap_new(GObject* o)
+{
+  return manage(new TreeViewColumn((GtkTreeViewColumn*)(o)));
+
+}
+
+
+/* The implementation: */
+
+TreeViewColumn::TreeViewColumn(const Glib::ConstructParams& construct_params)
+:
+  Gtk::Object(construct_params)
+{
+  }
+
+TreeViewColumn::TreeViewColumn(GtkTreeViewColumn* castitem)
+:
+  Gtk::Object((GtkObject*)(castitem))
+{
+  }
+
+TreeViewColumn::~TreeViewColumn()
+{
+  destroy_();
+}
+
+TreeViewColumn::CppClassType TreeViewColumn::treeviewcolumn_class_; // initialize static member
+
+GType TreeViewColumn::get_type()
+{
+  return treeviewcolumn_class_.init().get_type();
+}
+
+GType TreeViewColumn::get_base_type()
+{
+  return gtk_tree_view_column_get_type();
+}
+
+
+TreeViewColumn::TreeViewColumn()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Object(Glib::ConstructParams(treeviewcolumn_class_.init()))
+{
+  }
+
+void TreeViewColumn::pack_start(CellRenderer& cell, bool expand)
+{
+  gtk_tree_view_column_pack_start(gobj(), (cell).gobj(), static_cast<int>(expand));
+}
+
+void TreeViewColumn::pack_end(CellRenderer& cell, bool expand)
+{
+  gtk_tree_view_column_pack_end(gobj(), (cell).gobj(), static_cast<int>(expand));
+}
+
+void TreeViewColumn::clear()
+{
+  gtk_tree_view_column_clear(gobj());
+}
+
+Glib::ListHandle<CellRenderer*> TreeViewColumn::get_cell_renderers()
+{
+  return Glib::ListHandle<CellRenderer*>(gtk_tree_view_column_get_cell_renderers(gobj()), Glib::OWNERSHIP_SHALLOW);
+}
+
+Glib::ListHandle<const CellRenderer*> TreeViewColumn::get_cell_renderers() const
+{
+  return Glib::ListHandle<const CellRenderer*>(gtk_tree_view_column_get_cell_renderers(const_cast<GtkTreeViewColumn*>(gobj())), Glib::OWNERSHIP_SHALLOW);
+}
+
+void TreeViewColumn::add_attribute(CellRenderer& cell_renderer, const Glib::ustring& attribute, int column)
+{
+  gtk_tree_view_column_add_attribute(gobj(), (cell_renderer).gobj(), attribute.c_str(), column);
+}
+
+void TreeViewColumn::clear_attributes(CellRenderer& cell_renderer)
+{
+  gtk_tree_view_column_clear_attributes(gobj(), (cell_renderer).gobj());
+}
+
+void TreeViewColumn::set_spacing(int spacing)
+{
+  gtk_tree_view_column_set_spacing(gobj(), spacing);
+}
+
+int TreeViewColumn::get_spacing() const
+{
+  return gtk_tree_view_column_get_spacing(const_cast<GtkTreeViewColumn*>(gobj()));
+}
+
+void TreeViewColumn::set_visible(bool visible)
+{
+  gtk_tree_view_column_set_visible(gobj(), static_cast<int>(visible));
+}
+
+bool TreeViewColumn::get_visible() const
+{
+  return gtk_tree_view_column_get_visible(const_cast<GtkTreeViewColumn*>(gobj()));
+}
+
+void TreeViewColumn::set_resizable(bool resizable)
+{
+  gtk_tree_view_column_set_resizable(gobj(), static_cast<int>(resizable));
+}
+
+bool TreeViewColumn::get_resizable() const
+{
+  return gtk_tree_view_column_get_resizable(const_cast<GtkTreeViewColumn*>(gobj()));
+}
+
+void TreeViewColumn::set_sizing(TreeViewColumnSizing type)
+{
+  gtk_tree_view_column_set_sizing(gobj(), ((GtkTreeViewColumnSizing)(type)));
+}
+
+TreeViewColumnSizing TreeViewColumn::get_sizing()
+{
+  return ((TreeViewColumnSizing)(gtk_tree_view_column_get_sizing(gobj())));
+}
+
+int TreeViewColumn::get_width() const
+{
+  return gtk_tree_view_column_get_width(const_cast<GtkTreeViewColumn*>(gobj()));
+}
+
+int TreeViewColumn::get_fixed_width() const
+{
+  return gtk_tree_view_column_get_fixed_width(const_cast<GtkTreeViewColumn*>(gobj()));
+}
+
+void TreeViewColumn::set_fixed_width(int fixed_width)
+{
+  gtk_tree_view_column_set_fixed_width(gobj(), fixed_width);
+}
+
+void TreeViewColumn::set_min_width(int min_width)
+{
+  gtk_tree_view_column_set_min_width(gobj(), min_width);
+}
+
+int TreeViewColumn::get_min_width() const
+{
+  return gtk_tree_view_column_get_min_width(const_cast<GtkTreeViewColumn*>(gobj()));
+}
+
+void TreeViewColumn::set_max_width(int max_width)
+{
+  gtk_tree_view_column_set_max_width(gobj(), max_width);
+}
+
+int TreeViewColumn::get_max_width() const
+{
+  return gtk_tree_view_column_get_max_width(const_cast<GtkTreeViewColumn*>(gobj()));
+}
+
+void TreeViewColumn::clicked()
+{
+  gtk_tree_view_column_clicked(gobj());
+}
+
+void TreeViewColumn::set_title(const Glib::ustring& title)
+{
+  gtk_tree_view_column_set_title(gobj(), title.c_str());
+}
+
+Glib::ustring TreeViewColumn::get_title() const
+{
+  return Glib::convert_const_gchar_ptr_to_ustring(gtk_tree_view_column_get_title(const_cast<GtkTreeViewColumn*>(gobj())));
+}
+
+void TreeViewColumn::set_expand(bool expand)
+{
+  gtk_tree_view_column_set_expand(gobj(), static_cast<int>(expand));
+}
+
+bool TreeViewColumn::get_expand() const
+{
+  return gtk_tree_view_column_get_expand(const_cast<GtkTreeViewColumn*>(gobj()));
+}
+
+void TreeViewColumn::set_clickable(bool clickable)
+{
+  gtk_tree_view_column_set_clickable(gobj(), static_cast<int>(clickable));
+}
+
+bool TreeViewColumn::get_clickable() const
+{
+  return gtk_tree_view_column_get_clickable(const_cast<GtkTreeViewColumn*>(gobj()));
+}
+
+void TreeViewColumn::set_widget(Gtk::Widget& widget)
+{
+  gtk_tree_view_column_set_widget(gobj(), (widget).gobj());
+}
+
+Widget* TreeViewColumn::get_widget()
+{
+  return Glib::wrap(gtk_tree_view_column_get_widget(gobj()));
+}
+
+const Widget* TreeViewColumn::get_widget() const
+{
+  return Glib::wrap(gtk_tree_view_column_get_widget(const_cast<GtkTreeViewColumn*>(gobj())));
+}
+
+void TreeViewColumn::set_alignment(float xalign)
+{
+  gtk_tree_view_column_set_alignment(gobj(), xalign);
+}
+
+void TreeViewColumn::set_alignment(AlignmentEnum xalign)
+{
+  gtk_tree_view_column_set_alignment(gobj(), _gtkmm_align_float_from_enum(xalign));
+}
+
+float TreeViewColumn::get_alignment() const
+{
+  return gtk_tree_view_column_get_alignment(const_cast<GtkTreeViewColumn*>(gobj()));
+}
+
+void TreeViewColumn::set_reorderable(bool reorderable)
+{
+  gtk_tree_view_column_set_reorderable(gobj(), static_cast<int>(reorderable));
+}
+
+bool TreeViewColumn::get_reorderable() const
+{
+  return gtk_tree_view_column_get_reorderable(const_cast<GtkTreeViewColumn*>(gobj()));
+}
+
+void TreeViewColumn::set_sort_column(const TreeModelColumnBase& sort_column_id)
+{
+  gtk_tree_view_column_set_sort_column_id(gobj(), (sort_column_id).index());
+}
+
+void TreeViewColumn::set_sort_column(int sort_column_id)
+{
+  gtk_tree_view_column_set_sort_column_id(gobj(), sort_column_id);
+}
+
+int TreeViewColumn::get_sort_column_id() const
+{
+  return gtk_tree_view_column_get_sort_column_id(const_cast<GtkTreeViewColumn*>(gobj()));
+}
+
+void TreeViewColumn::set_sort_indicator(bool setting)
+{
+  gtk_tree_view_column_set_sort_indicator(gobj(), static_cast<int>(setting));
+}
+
+bool TreeViewColumn::get_sort_indicator() const
+{
+  return gtk_tree_view_column_get_sort_indicator(const_cast<GtkTreeViewColumn*>(gobj()));
+}
+
+void TreeViewColumn::set_sort_order(SortType order)
+{
+  gtk_tree_view_column_set_sort_order(gobj(), ((GtkSortType)(order)));
+}
+
+SortType TreeViewColumn::get_sort_order() const
+{
+  return ((SortType)(gtk_tree_view_column_get_sort_order(const_cast<GtkTreeViewColumn*>(gobj()))));
+}
+
+void TreeViewColumn::cell_set_cell_data(const Glib::RefPtr<TreeModel>& tree_model, const TreeModel::iterator& iter, bool is_expander, bool is_expanded)
+{
+  gtk_tree_view_column_cell_set_cell_data(gobj(), Glib::unwrap(tree_model), const_cast<GtkTreeIter*>((iter).gobj()), static_cast<int>(is_expander), static_cast<int>(is_expanded));
+}
+
+void TreeViewColumn::cell_get_size(Gdk::Rectangle& cell_area, int& x_offset, int& y_offset, int& width, int& height) const
+{
+  gtk_tree_view_column_cell_get_size(const_cast<GtkTreeViewColumn*>(gobj()), (cell_area).gobj(), &x_offset, &y_offset, &width, &height);
+}
+
+bool TreeViewColumn::cell_is_visible() const
+{
+  return gtk_tree_view_column_cell_is_visible(const_cast<GtkTreeViewColumn*>(gobj()));
+}
+
+void TreeViewColumn::focus_cell(CellRenderer& cell)
+{
+  gtk_tree_view_column_focus_cell(gobj(), (cell).gobj());
+}
+
+bool TreeViewColumn::get_cell_position(const CellRenderer& cell_renderer, int& start_pos, int& width) const
+{
+  return gtk_tree_view_column_cell_get_position(const_cast<GtkTreeViewColumn*>(gobj()), const_cast<GtkCellRenderer*>((cell_renderer).gobj()), &start_pos, &width);
+}
+
+
+Glib::SignalProxy0< void > TreeViewColumn::signal_clicked()
+{
+  return Glib::SignalProxy0< void >(this, &TreeViewColumn_signal_clicked_info);
+}
+
+
+Glib::PropertyProxy<bool> TreeViewColumn::property_visible() 
+{
+  return Glib::PropertyProxy<bool>(this, "visible");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> TreeViewColumn::property_visible() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "visible");
+}
+
+Glib::PropertyProxy_ReadOnly<int> TreeViewColumn::property_width() const
+{
+  return Glib::PropertyProxy_ReadOnly<int>(this, "width");
+}
+
+Glib::PropertyProxy<TreeViewColumnSizing> TreeViewColumn::property_sizing() 
+{
+  return Glib::PropertyProxy<TreeViewColumnSizing>(this, "sizing");
+}
+
+Glib::PropertyProxy_ReadOnly<TreeViewColumnSizing> TreeViewColumn::property_sizing() const
+{
+  return Glib::PropertyProxy_ReadOnly<TreeViewColumnSizing>(this, "sizing");
+}
+
+Glib::PropertyProxy<int> TreeViewColumn::property_fixed_width() 
+{
+  return Glib::PropertyProxy<int>(this, "fixed-width");
+}
+
+Glib::PropertyProxy_ReadOnly<int> TreeViewColumn::property_fixed_width() const
+{
+  return Glib::PropertyProxy_ReadOnly<int>(this, "fixed-width");
+}
+
+Glib::PropertyProxy<int> TreeViewColumn::property_min_width() 
+{
+  return Glib::PropertyProxy<int>(this, "min-width");
+}
+
+Glib::PropertyProxy_ReadOnly<int> TreeViewColumn::property_min_width() const
+{
+  return Glib::PropertyProxy_ReadOnly<int>(this, "min-width");
+}
+
+Glib::PropertyProxy<int> TreeViewColumn::property_max_width() 
+{
+  return Glib::PropertyProxy<int>(this, "max-width");
+}
+
+Glib::PropertyProxy_ReadOnly<int> TreeViewColumn::property_max_width() const
+{
+  return Glib::PropertyProxy_ReadOnly<int>(this, "max-width");
+}
+
+Glib::PropertyProxy<Glib::ustring> TreeViewColumn::property_title() 
+{
+  return Glib::PropertyProxy<Glib::ustring>(this, "title");
+}
+
+Glib::PropertyProxy_ReadOnly<Glib::ustring> TreeViewColumn::property_title() const
+{
+  return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "title");
+}
+
+Glib::PropertyProxy<bool> TreeViewColumn::property_expand() 
+{
+  return Glib::PropertyProxy<bool>(this, "expand");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> TreeViewColumn::property_expand() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "expand");
+}
+
+Glib::PropertyProxy<bool> TreeViewColumn::property_clickable() 
+{
+  return Glib::PropertyProxy<bool>(this, "clickable");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> TreeViewColumn::property_clickable() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "clickable");
+}
+
+Glib::PropertyProxy<Widget*> TreeViewColumn::property_widget() 
+{
+  return Glib::PropertyProxy<Widget*>(this, "widget");
+}
+
+Glib::PropertyProxy_ReadOnly<Widget*> TreeViewColumn::property_widget() const
+{
+  return Glib::PropertyProxy_ReadOnly<Widget*>(this, "widget");
+}
+
+Glib::PropertyProxy<float> TreeViewColumn::property_alignment() 
+{
+  return Glib::PropertyProxy<float>(this, "alignment");
+}
+
+Glib::PropertyProxy_ReadOnly<float> TreeViewColumn::property_alignment() const
+{
+  return Glib::PropertyProxy_ReadOnly<float>(this, "alignment");
+}
+
+Glib::PropertyProxy<bool> TreeViewColumn::property_reorderable() 
+{
+  return Glib::PropertyProxy<bool>(this, "reorderable");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> TreeViewColumn::property_reorderable() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "reorderable");
+}
+
+Glib::PropertyProxy<bool> TreeViewColumn::property_sort_indicator() 
+{
+  return Glib::PropertyProxy<bool>(this, "sort-indicator");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> TreeViewColumn::property_sort_indicator() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "sort-indicator");
+}
+
+Glib::PropertyProxy<SortType> TreeViewColumn::property_sort_order() 
+{
+  return Glib::PropertyProxy<SortType>(this, "sort-order");
+}
+
+Glib::PropertyProxy_ReadOnly<SortType> TreeViewColumn::property_sort_order() const
+{
+  return Glib::PropertyProxy_ReadOnly<SortType>(this, "sort-order");
+}
+
+
+void Gtk::TreeViewColumn::on_clicked()
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->clicked)
+    (*base->clicked)(gobj());
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/treeviewcolumn.h b/libs/gtkmm2/gtk/gtkmm/treeviewcolumn.h
new file mode 100644
index 0000000000..e4b7ef9296
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/treeviewcolumn.h
@@ -0,0 +1,868 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_TREEVIEWCOLUMN_H
+#define _GTKMM_TREEVIEWCOLUMN_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* Copyright(C) 2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/object.h>
+#include <gtkmm/treeiter.h>
+#include <gtkmm/widget.h>
+#include <gdkmm/window.h>
+#include <gtkmm/treemodel.h>
+#include <glibmm/listhandle.h>
+#include <gtkmm/cellrenderer_generation.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkTreeViewColumn GtkTreeViewColumn;
+typedef struct _GtkTreeViewColumnClass GtkTreeViewColumnClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class TreeViewColumn_Class; } // namespace Gtk
+namespace Gtk
+{
+
+
+/** @addtogroup gtkmmEnums Enums and Flags */
+
+/**
+ * @ingroup gtkmmEnums
+ */
+enum TreeViewColumnSizing
+{
+  TREE_VIEW_COLUMN_GROW_ONLY,
+  TREE_VIEW_COLUMN_AUTOSIZE,
+  TREE_VIEW_COLUMN_FIXED
+};
+
+} // namespace Gtk
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Gtk::TreeViewColumnSizing> : public Glib::Value_Enum<Gtk::TreeViewColumnSizing>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{
+
+
+/** Typedefed as Gtk::TreeView::Column.
+ * This is a visible column in a Gtk::TreeView widget. It determines the geometry, type.
+ *
+ * @ingroup TreeView
+*/
+
+class TreeViewColumn : public Gtk::Object
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef TreeViewColumn CppObjectType;
+  typedef TreeViewColumn_Class CppClassType;
+  typedef GtkTreeViewColumn BaseObjectType;
+  typedef GtkTreeViewColumnClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~TreeViewColumn();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class TreeViewColumn_Class;
+  static CppClassType treeviewcolumn_class_;
+
+  // noncopyable
+  TreeViewColumn(const TreeViewColumn&);
+  TreeViewColumn& operator=(const TreeViewColumn&);
+
+protected:
+  explicit TreeViewColumn(const Glib::ConstructParams& construct_params);
+  explicit TreeViewColumn(GtkTreeViewColumn* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GtkTreeViewColumn*       gobj()       { return reinterpret_cast<GtkTreeViewColumn*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GtkTreeViewColumn* gobj() const { return reinterpret_cast<GtkTreeViewColumn*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+  virtual void on_clicked();
+
+
+private:
+
+  
+public:
+  typedef TreeViewColumn Column;
+
+  TreeViewColumn();
+
+  explicit TreeViewColumn(const Glib::ustring& title);
+  TreeViewColumn(const Glib::ustring& title, CellRenderer& cell);
+
+  /** Create a default view column for the given model column type.
+   */
+  template<class T_ModelColumnType>
+  TreeViewColumn(const Glib::ustring& title, const TreeModelColumn<T_ModelColumnType>& column);
+
+  
+  /** Packs the @a cell  into the beginning of the column. If @a expand  is <tt>false</tt>, then
+   * the @a cell  is allocated no more space than it needs. Any unused space is divided
+   * evenly between cells for which @a expand  is <tt>true</tt>.
+   * @param cell The Gtk::CellRenderer.
+   * @param expand <tt>true</tt> if @a cell  is to be given extra space allocated to @a tree_column .
+   */
+  void pack_start(CellRenderer& cell, bool expand = true);
+  
+  /** Adds the @a cell  to end of the column. If @a expand  is <tt>false</tt>, then the @a cell 
+   * is allocated no more space than it needs. Any unused space is divided
+   * evenly between cells for which @a expand  is <tt>true</tt>.
+   * @param cell The Gtk::CellRenderer.
+   * @param expand <tt>true</tt> if @a cell  is to be given extra space allocated to @a tree_column .
+   */
+  void pack_end(CellRenderer& cell, bool expand = true);
+
+  /** Creates an appropriate CellRenderer for the @a column, and packs that cell into the beginning of the column.
+   * If @a expand  is <tt>false</tt>, then
+   * the cell is allocated no more space than it needs. Any unused space is divided
+   * evenly between cells for which @a expand is <tt>true</tt>.
+   *
+   * You can use get_first_cell_renderer() or get_cell_renderers() to access the generated CellRenderer.
+   *
+   * @param column The model column that will be rendered by the view cell.
+   * @param expand <tt>true</tt> if the cell is to be given extra space allocated to the view column.
+   */
+  template<class T_ModelColumnType>
+  void pack_start(const TreeModelColumn<T_ModelColumnType>& column, bool expand = true);
+
+  /** Creates an appropriate CellRenderer for the @a column, and packs that cell at the end of the column.
+   * If @a expand  is <tt>false</tt>, then
+   * the cell is allocated no more space than it needs. Any unused space is divided
+   * evenly between cells for which @a expand is <tt>true</tt>.
+   *
+   * You can use get_first_cell_renderer() or get_cell_renderers() to access the generated CellRenderer.
+   *
+   * @param column The model column that will be rendered by the view cell.
+   * @param expand <tt>true</tt> if the cell is to be given extra space allocated to the view column.
+   */
+  template<class T_ModelColumnType>
+  void pack_end(const TreeModelColumn<T_ModelColumnType>& column, bool expand = true);
+
+  
+  /** Unsets all the mappings on all renderers on the @a tree_column .
+   */
+  void clear();
+
+  /** Gets the CellRenderer for the column.
+    * You should dynamic_cast<> to the expected derived CellRenderer type.
+    * This assumes that the TreeViewColumn contains only one CellRenderer.
+    */
+  CellRenderer* get_first_cell_renderer();
+
+  /** Gets the CellRenderer for the column.
+    * You should dynamic_cast<> to the expected derived CellRenderer type.
+    * This assumes that the TreeViewColumn contains only one CellRenderer.
+    */
+  const CellRenderer* get_first_cell_renderer() const;
+
+  
+  /** Returns a list of all the cell renderers in the column,
+   * in no particular order.
+   * @return A list of Gtk::CellRenderers.
+   */
+  Glib::ListHandle<CellRenderer*> get_cell_renderers();
+  
+  /** Returns a list of all the cell renderers in the column,
+   * in no particular order.
+   * @return A list of Gtk::CellRenderers.
+   */
+  Glib::ListHandle<const CellRenderer*> get_cell_renderers() const;
+
+  
+  /** Adds an attribute mapping to the list in @a tree_column .  The @a column  is the
+   * column of the model to get a value from, and the @a attribute  is the
+   * parameter on @a cell_renderer  to be set from the value. So for example
+   * if column 2 of the model contains strings, you could have the
+   * "text" attribute of a Gtk::CellRendererText get its values from
+   * column 2.
+   * @param cell_renderer The Gtk::CellRenderer to set attributes on.
+   * @param attribute An attribute on the renderer.
+   * @param column The column position on the model to get the attribute from.
+   */
+  void add_attribute(CellRenderer& cell_renderer, const Glib::ustring& attribute, int column);
+
+  void add_attribute(const Glib::PropertyProxy_Base& property, const TreeModelColumnBase& column);
+  
+
+  /** Associate a view CellRenderer with a model column, so that the CellRenderer renders the data in the model column.
+   *
+   * @param renderer The view cell renderer which will render the model column.
+   * @param column The model column to be renderered by this view.
+   */
+  void set_renderer(Gtk::CellRenderer& renderer, const TreeModelColumnBase& column);
+
+ // _WRAP_METHOD(void set_attributes(CellRenderer& cell_renderer, ...), )
+
+  /** For instance,
+   * void on_cell_data(Gtk::CellRenderer* cell, const Gtk::TreeModel::iterator& iter);
+   *
+   * This function is used instead of the standard attributes mapping for setting the column value, and should set the
+   * value of the column's cell renderer as appropriate.
+   */
+  typedef sigc::slot<void, CellRenderer*, const Gtk::TreeModel::iterator&> SlotCellData;
+
+  /** Sets the slot callback to use for the column.
+   * This callback function is used instead of the standard attributes mapping for setting the column value, and should set the
+   * value of the column's cell renderer as appropriate.
+   *
+   * See also unset_cell_data_func().
+   *
+   * @param cell_renderer A Gtk::CellRenderer
+   * @param slot The callback slot to use. Create this with sigc::mem_fun(), or sigc::ptr_fun().
+   */  
+  void set_cell_data_func(CellRenderer& cell_renderer, const SlotCellData& slot);
+
+  /** Removes a previously set callback slot. See set_cell_data_func().
+   */ 
+  void unset_cell_data_func(CellRenderer& cell_renderer);
+
+  
+  /** Clears all existing attributes previously set with
+   * set_attributes().
+   * @param cell_renderer A Gtk::CellRenderer to clear the attribute mapping on.
+   */
+  void clear_attributes(CellRenderer& cell_renderer);
+  
+  /** Sets the spacing field of @a tree_column , which is the number of pixels to
+   * place between cell renderers packed into it.
+   * @param spacing Distance between cell renderers in pixels.
+   */
+  void set_spacing(int spacing);
+  
+  /** Returns the spacing of @a tree_column .
+   * @return The spacing of @a tree_column .
+   */
+  int get_spacing() const;
+  
+  /** Sets the visibility of @a tree_column .
+   * @param visible <tt>true</tt> if the @a tree_column  is visible.
+   */
+  void set_visible(bool visible = true);
+  
+  /** Returns <tt>true</tt> if @a tree_column  is visible.
+   * @return Whether the column is visible or not.  If it is visible, then
+   * the tree will show the column.
+   */
+  bool get_visible() const;
+  
+  /** If @a resizable  is <tt>true</tt>, then the user can explicitly resize the column by
+   * grabbing the outer edge of the column button.  If resizable is <tt>true</tt> and
+   * sizing mode of the column is Gtk::TREE_VIEW_COLUMN_AUTOSIZE, then the sizing
+   * mode is changed to Gtk::TREE_VIEW_COLUMN_GROW_ONLY.
+   * @param resizable <tt>true</tt>, if the column can be resized.
+   */
+  void set_resizable(bool resizable = true);
+  
+  /** Returns <tt>true</tt> if the @a tree_column  can be resized by the end user.
+   * @return <tt>true</tt>, if the @a tree_column  can be resized.
+   */
+  bool get_resizable() const;
+  
+  /** Sets the growth behavior of @a tree_column  to @a type .
+   * @param type The Gtk::TreeViewColumnSizing.
+   */
+  void set_sizing(TreeViewColumnSizing type);
+  
+  /** Returns the current type of @a tree_column .
+   * @return The type of @a tree_column .
+   */
+  TreeViewColumnSizing get_sizing();
+  
+  /** Returns the current size of @a tree_column  in pixels.
+   * @return The current width of @a tree_column .
+   */
+  int get_width() const;
+  
+  /** Gets the fixed width of the column.  This value is only meaning may not be
+   * the actual width of the column on the screen, just what is requested.
+   * @return The fixed width of the column.
+   */
+  int get_fixed_width() const;
+  
+  /** Sets the size of the column in pixels.  This is meaningful only if the sizing
+   * type is Gtk::TREE_VIEW_COLUMN_FIXED.  The size of the column is clamped to
+   * the min/max width for the column.  Please note that the min/max width of the
+   * column doesn't actually affect the "fixed_width" property of the widget, just
+   * the actual size when displayed.
+   * @param fixed_width The size to set @a tree_column  to. Must be greater than 0.
+   */
+  void set_fixed_width(int fixed_width);
+  
+  /** Sets the minimum width of the @a tree_column .  If @a min_width  is -1, then the
+   * minimum width is unset.
+   * @param min_width The minimum width of the column in pixels, or -1.
+   */
+  void set_min_width(int min_width);
+  
+  /** Returns the minimum width in pixels of the @a tree_column , or -1 if no minimum
+   * width is set.
+   * @return The minimum width of the @a tree_column .
+   */
+  int get_min_width() const;
+  
+  /** Sets the maximum width of the @a tree_column .  If @a max_width  is -1, then the
+   * maximum width is unset.  Note, the column can actually be wider than max
+   * width if it's the last column in a view.  In this case, the column expands to
+   * fill any extra space.
+   * @param max_width The maximum width of the column in pixels, or -1.
+   */
+  void set_max_width(int max_width);
+  
+  /** Returns the maximum width in pixels of the @a tree_column , or -1 if no maximum
+   * width is set.
+   * @return The maximum width of the @a tree_column .
+   */
+  int get_max_width() const;
+  
+  /** Emits the "clicked" signal on the column.  This function will only work if
+   *  @a tree_column  is clickable.
+   */
+  void clicked();
+
+  
+  /** Sets the title of the @a tree_column .  If a custom widget has been set, then
+   * this value is ignored.
+   * @param title The title of the @a tree_column .
+   */
+  void set_title(const Glib::ustring& title);
+  
+  /** Returns the title of the widget.
+   * @return The title of the column. This string should not be
+   * modified or freed.
+   */
+  Glib::ustring get_title() const;
+
+  
+  /** Sets the column to take available extra space.  This space is shared equally
+   * amongst all columns that have the expand set to <tt>true</tt>.  If no column has this
+   * option set, then the last column gets all extra space.  By default, every
+   * column is created with this <tt>false</tt>.
+   * 
+   * Since: 2.4
+   */
+  void set_expand(bool expand = true);
+  
+  /** Return <tt>true</tt> if the column expands to take any available space.
+   * @return <tt>true</tt>, if the column expands
+   * 
+   * Since: 2.4.
+   */
+  bool get_expand() const;
+
+  
+  /** Sets the header to be active if @a active  is <tt>true</tt>.  When the header is active,
+   * then it can take keyboard focus, and can be clicked.
+   * @param clickable <tt>true</tt> if the header is active.
+   */
+  void set_clickable(bool clickable = true);
+  
+  /** Returns <tt>true</tt> if the user can click on the header for the column.
+   * @return <tt>true</tt> if user can click the column header.
+   */
+  bool get_clickable() const;
+  
+  /** Sets the widget in the header to be @a widget .  If widget is <tt>0</tt>, then the
+   * header button is set with a Gtk::Label set to the title of @a tree_column .
+   * @param widget A child Gtk::Widget, or <tt>0</tt>.
+   */
+  void set_widget(Gtk::Widget& widget);
+  
+  /** Returns the Gtk::Widget in the button on the column header.  If a custom
+   * widget has not been set then <tt>0</tt> is returned.
+   * @return The Gtk::Widget in the column header, or <tt>0</tt>.
+   */
+  Widget* get_widget();
+  
+  /** Returns the Gtk::Widget in the button on the column header.  If a custom
+   * widget has not been set then <tt>0</tt> is returned.
+   * @return The Gtk::Widget in the column header, or <tt>0</tt>.
+   */
+  const Widget* get_widget() const;
+
+  
+  /** Sets the alignment of the title or custom widget inside the column header.
+   * The alignment determines its location inside the button -- 0.0 for left, 0.5
+   * for center, 1.0 for right.
+   * @param xalign The alignment, which is between [0.0 and 1.0] inclusive.
+   */
+  void set_alignment(float xalign);
+  
+  /** Sets the alignment of the title or custom widget inside the column header.
+   * The alignment determines its location inside the button -- 0.0 for left, 0.5
+   * for center, 1.0 for right.
+   * @param xalign The alignment, which is between [0.0 and 1.0] inclusive.
+   */
+  void set_alignment(AlignmentEnum xalign);
+
+  
+  /** Returns the current x alignment of @a tree_column .  This value can range
+   * between 0.0 and 1.0.
+   * @return The current alignent of @a tree_column .
+   */
+  float get_alignment() const;
+  
+  /** If @a reorderable  is <tt>true</tt>, then the column can be reordered by the end user
+   * dragging the header.
+   * @param reorderable <tt>true</tt>, if the column can be reordered.
+   */
+  void set_reorderable(bool reorderable = true);
+  
+  /** Returns <tt>true</tt> if the @a tree_column  can be reordered by the user.
+   * @return <tt>true</tt> if the @a tree_column  can be reordered by the user.
+   */
+  bool get_reorderable() const;
+
+  
+  /** Sets the logical @a sort_column_id  that this column sorts on when this column 
+   * is selected for sorting.  Doing so makes the column header clickable.
+   * @param sort_column_id The @a sort_column_id  of the model to sort on.
+   */
+  void set_sort_column(const TreeModelColumnBase& sort_column_id);
+  
+  /** Sets the logical @a sort_column_id  that this column sorts on when this column 
+   * is selected for sorting.  Doing so makes the column header clickable.
+   * @param sort_column_id The @a sort_column_id  of the model to sort on.
+   */
+  void set_sort_column(int sort_column_id);
+
+  #ifndef GTKMM_DISABLE_DEPRECATED
+  /** @deprecated Use set_sort_column() instead.
+   */
+  void set_sort_column_id(const TreeModelColumnBase& sort_column_id);
+
+  /** @deprecated Use set_sort_column() instead.
+   */
+  void set_sort_column_id(int sort_column_id);
+  #endif //GTKMM_DISABLE_DEPRECATED
+  
+  
+  /** Gets the logical @a sort_column_id  that the model sorts on when this
+   * column is selected for sorting.
+   * See set_sort_column_id().
+   * @return The current @a sort_column_id  for this column, or -1 if
+   * this column can't be used for sorting.
+   */
+  int get_sort_column_id() const;
+  
+  /** Call this function with a @a setting  of <tt>true</tt> to display an arrow in
+   * the header button indicating the column is sorted. Call
+   * set_sort_order() to change the direction of
+   * the arrow.
+   * @param setting <tt>true</tt> to display an indicator that the column is sorted.
+   */
+  void set_sort_indicator(bool setting);
+  
+  /** Gets the value set by set_sort_indicator().
+   * @return Whether the sort indicator arrow is displayed.
+   */
+  bool get_sort_indicator() const;
+  
+  /** Changes the appearance of the sort indicator. 
+   * 
+   * This <em>does not</em> actually sort the model.  Use
+   * set_sort_column_id() if you want automatic sorting
+   * support.  This function is primarily for custom sorting behavior, and should
+   * be used in conjunction with gtk_tree_sortable_set_sort_column() to do
+   * that. For custom models, the mechanism will vary. 
+   * 
+   * The sort indicator changes direction to indicate normal sort or reverse sort.
+   * Note that you must have the sort indicator enabled to see anything when 
+   * calling this function; see set_sort_indicator().
+   * @param order Sort order that the sort indicator should indicate.
+   */
+  void set_sort_order(SortType order);
+  
+  /** Gets the value set by set_sort_order().
+   * @return The sort order the sort indicator is indicating.
+   */
+  SortType get_sort_order() const;
+
+
+  /** Sets the cell renderer based on the @a tree_model  and @a iter .  That is, for
+   * every attribute mapping in @a tree_column , it will get a value from the set
+   * column on the @a iter , and use that value to set the attribute on the cell
+   * renderer.  This is used primarily by the Gtk::TreeView.
+   * @param tree_model The Gtk::TreeModel to to get the cell renderers attributes from.
+   * @param iter The Gtk::TreeIter to to get the cell renderer's attributes from.
+   * @param is_expander <tt>true</tt>, if the row has children.
+   * @param is_expanded <tt>true</tt>, if the row has visible children.
+   */
+  void cell_set_cell_data(const Glib::RefPtr<TreeModel>& tree_model, const TreeModel::iterator& iter, bool is_expander, bool is_expanded);
+  
+  /** Obtains the width and height needed to render the column.  This is used
+   * primarily by the Gtk::TreeView.
+   * @param cell_area The area a cell in the column will be allocated.
+   * @param x_offset Location to return x offset of a cell relative to @a cell_area .
+   * @param y_offset Location to return y offset of a cell relative to @a cell_area .
+   * @param width Location to return width needed to render a cell.
+   * @param height Location to return height needed to render a cell.
+   */
+  void cell_get_size(Gdk::Rectangle& cell_area, int& x_offset, int& y_offset, int& width, int& height) const;
+  
+  /** Returns <tt>true</tt> if any of the cells packed into the @a tree_column  are visible.
+   * For this to be meaningful, you must first initialize the cells with
+   * cell_set_cell_data()
+   * @return <tt>true</tt>, if any of the cells packed into the @a tree_column  are currently visible.
+   */
+  bool cell_is_visible() const;
+  
+  /** Sets the current keyboard focus to be at @a cell , if the column contains
+   * 2 or more editable and activatable cells.
+   * 
+   * Since: 2.2
+   * @param cell A Gtk::CellRenderer.
+   */
+  void focus_cell(CellRenderer& cell);
+
+  
+  /** Obtains the horizontal position and size of a cell in a column. If the
+   * cell is not found in the column, @a start_pos  and @a width  are not changed and
+   * <tt>false</tt> is returned.
+   * @param cell_renderer A Gtk::CellRenderer.
+   * @param start_pos Return location for the horizontal position of @a cell  within
+   *  @a tree_column .
+   * @param width Return location for the width of @a cell .
+   * @return <tt>true</tt> if @a cell  belongs to @a tree_column .
+   */
+  bool get_cell_position(const CellRenderer& cell_renderer, int& start_pos, int& width) const;
+
+  
+  Glib::SignalProxy0< void > signal_clicked();
+
+
+  /** Whether to display the column.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_visible() ;
+
+/** Whether to display the column.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_visible() const;
+
+  /** Current width of the column.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<int> property_width() const;
+
+
+  /** Resize mode of the column.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<TreeViewColumnSizing> property_sizing() ;
+
+/** Resize mode of the column.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<TreeViewColumnSizing> property_sizing() const;
+
+  /** Current fixed width of the column.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<int> property_fixed_width() ;
+
+/** Current fixed width of the column.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<int> property_fixed_width() const;
+
+  /** Minimum allowed width of the column.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<int> property_min_width() ;
+
+/** Minimum allowed width of the column.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<int> property_min_width() const;
+
+  /** Maximum allowed width of the column.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<int> property_max_width() ;
+
+/** Maximum allowed width of the column.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<int> property_max_width() const;
+
+  /** Title to appear in column header.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Glib::ustring> property_title() ;
+
+/** Title to appear in column header.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Glib::ustring> property_title() const;
+
+  /** Column gets share of extra width allocated to the widget.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_expand() ;
+
+/** Column gets share of extra width allocated to the widget.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_expand() const;
+
+  /** Whether the header can be clicked.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_clickable() ;
+
+/** Whether the header can be clicked.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_clickable() const;
+
+  /** Widget to put in column header button instead of column title.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Widget*> property_widget() ;
+
+/** Widget to put in column header button instead of column title.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Widget*> property_widget() const;
+
+  /** X Alignment of the column header text or widget.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<float> property_alignment() ;
+
+/** X Alignment of the column header text or widget.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<float> property_alignment() const;
+
+  /** Whether the column can be reordered around the headers.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_reorderable() ;
+
+/** Whether the column can be reordered around the headers.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_reorderable() const;
+
+  /** Whether to show a sort indicator.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_sort_indicator() ;
+
+/** Whether to show a sort indicator.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_sort_indicator() const;
+
+  /** Sort direction the sort indicator should indicate.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<SortType> property_sort_order() ;
+
+/** Sort direction the sort indicator should indicate.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<SortType> property_sort_order() const;
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+private:
+  // Only necessary because of the templated ctor, see below.
+  static const Glib::Class& class_init_();
+#endif //DOXYGEN_SHOULD_SKIP_THIS
+
+
+};
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+template<class T_ModelColumnType>
+void TreeViewColumn::pack_start(const TreeModelColumn<T_ModelColumnType>& column, bool expand)
+{
+  //Generate appropriate Renderer for the column:
+  CellRenderer* pCellRenderer = manage( CellRenderer_Generation::generate_cellrenderer<T_ModelColumnType>() );
+
+  //Use the renderer:
+  pack_start(*pCellRenderer, expand);
+  set_renderer(*pCellRenderer, column);
+}
+
+template<class T_ModelColumnType>
+void TreeViewColumn::pack_end(const TreeModelColumn<T_ModelColumnType>& column, bool expand)
+{
+  //Generate appropriate Renderer for the column:
+  CellRenderer* pCellRenderer= manage( CellRenderer_Generation::generate_cellrenderer<T_ModelColumnType>() );
+
+  //Use the renderer:
+  pack_end(*pCellRenderer, expand);
+  set_renderer(*pCellRenderer, column);
+}
+
+
+template <class T_ModelColumnType>
+TreeViewColumn::TreeViewColumn(const Glib::ustring& title,
+                               const TreeModelColumn<T_ModelColumnType>& column)
+:
+  Glib::ObjectBase(0), // not (yet) a custom class
+  Gtk::Object(Glib::ConstructParams(class_init_(), "title", title.c_str(), (char*) 0))
+{
+  pack_start(column, true /* expand */);
+}
+
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+} // namespace Gtk
+
+
+namespace Glib
+{
+  /** @relates Gtk::TreeViewColumn
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gtk::TreeViewColumn* wrap(GtkTreeViewColumn* object, bool take_copy = false);
+}
+#endif /* _GTKMM_TREEVIEWCOLUMN_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/uimanager.cc b/libs/gtkmm2/gtk/gtkmm/uimanager.cc
new file mode 100644
index 0000000000..89088a1474
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/uimanager.cc
@@ -0,0 +1,581 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/uimanager.h>
+#include <gtkmm/private/uimanager_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* Copyright 2003 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtk/gtkuimanager.h>
+
+
+namespace Gtk
+{
+
+typedef UIManager::ui_merge_id ui_merge_id; //Help gmmproc so that it does not need to add the full type name for the return type.
+
+UIManager::ui_merge_id UIManager::add_ui_from_string(const Glib::ustring& buffer)
+{
+  GError *error = 0;
+  guint retvalue = gtk_ui_manager_add_ui_from_string(gobj(), buffer.c_str(), buffer.size(), &(error));
+  if(error) ::Glib::Error::throw_exception(error);
+  return retvalue;
+}
+
+void UIManager::add_ui_separator(ui_merge_id merge_id, const Glib::ustring& path, const Glib::ustring& name, UIManagerItemType type, bool top)
+{
+  gtk_ui_manager_add_ui(gobj(), merge_id, path.c_str(), name.c_str(), 0 /* See C docs */, ((GtkUIManagerItemType)(type)), static_cast<int>(top));
+}
+
+
+} // namespace Gtk
+
+
+namespace
+{
+
+void UIManager_signal_add_widget_callback(GtkUIManager* self, GtkWidget* p0,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,Widget* > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(Glib::wrap(p0)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+}
+
+const Glib::SignalProxyInfo UIManager_signal_add_widget_info =
+{
+  "add_widget",
+  (GCallback) &UIManager_signal_add_widget_callback,
+  (GCallback) &UIManager_signal_add_widget_callback
+};
+
+
+const Glib::SignalProxyInfo UIManager_signal_actions_changed_info =
+{
+  "actions_changed",
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
+};
+
+
+void UIManager_signal_connect_proxy_callback(GtkUIManager* self, GtkAction* p0,GtkWidget* p1,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,const Glib::RefPtr<Action>&,Widget* > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(Glib::wrap(p0, true)
+, Glib::wrap(p1)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+}
+
+const Glib::SignalProxyInfo UIManager_signal_connect_proxy_info =
+{
+  "connect_proxy",
+  (GCallback) &UIManager_signal_connect_proxy_callback,
+  (GCallback) &UIManager_signal_connect_proxy_callback
+};
+
+
+void UIManager_signal_disconnect_proxy_callback(GtkUIManager* self, GtkAction* p0,GtkWidget* p1,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,const Glib::RefPtr<Action>&,Widget* > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(Glib::wrap(p0, true)
+, Glib::wrap(p1)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+}
+
+const Glib::SignalProxyInfo UIManager_signal_disconnect_proxy_info =
+{
+  "disconnect_proxy",
+  (GCallback) &UIManager_signal_disconnect_proxy_callback,
+  (GCallback) &UIManager_signal_disconnect_proxy_callback
+};
+
+
+void UIManager_signal_pre_activate_callback(GtkUIManager* self, GtkAction* p0,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,const Glib::RefPtr<Action>& > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(Glib::wrap(p0, true)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+}
+
+const Glib::SignalProxyInfo UIManager_signal_pre_activate_info =
+{
+  "pre_activate",
+  (GCallback) &UIManager_signal_pre_activate_callback,
+  (GCallback) &UIManager_signal_pre_activate_callback
+};
+
+
+void UIManager_signal_post_activate_callback(GtkUIManager* self, GtkAction* p0,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,const Glib::RefPtr<Action>& > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(Glib::wrap(p0, true)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+}
+
+const Glib::SignalProxyInfo UIManager_signal_post_activate_info =
+{
+  "post_activate",
+  (GCallback) &UIManager_signal_post_activate_callback,
+  (GCallback) &UIManager_signal_post_activate_callback
+};
+
+} // anonymous namespace
+
+// static
+GType Glib::Value<Gtk::UIManagerItemType>::value_type()
+{
+  return gtk_ui_manager_item_type_get_type();
+}
+
+
+namespace Glib
+{
+
+Glib::RefPtr<Gtk::UIManager> wrap(GtkUIManager* object, bool take_copy)
+{
+  return Glib::RefPtr<Gtk::UIManager>( dynamic_cast<Gtk::UIManager*> (Glib::wrap_auto ((GObject*)(object), take_copy)) );
+  //We use dynamic_cast<> in case of multiple inheritance.
+}
+
+} /* namespace Glib */
+
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& UIManager_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &UIManager_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_ui_manager_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void UIManager_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+  klass->add_widget = &add_widget_callback;
+  klass->actions_changed = &actions_changed_callback;
+}
+
+
+void UIManager_Class::add_widget_callback(GtkUIManager* self, GtkWidget* p0)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_add_widget(Glib::wrap(p0)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->add_widget)
+      (*base->add_widget)(self, p0);
+  }
+}
+
+void UIManager_Class::actions_changed_callback(GtkUIManager* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_actions_changed();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->actions_changed)
+      (*base->actions_changed)(self);
+  }
+}
+
+
+Glib::ObjectBase* UIManager_Class::wrap_new(GObject* object)
+{
+  return new UIManager((GtkUIManager*)object);
+}
+
+
+/* The implementation: */
+
+GtkUIManager* UIManager::gobj_copy()
+{
+  reference();
+  return gobj();
+}
+
+UIManager::UIManager(const Glib::ConstructParams& construct_params)
+:
+  Glib::Object(construct_params)
+{}
+
+UIManager::UIManager(GtkUIManager* castitem)
+:
+  Glib::Object((GObject*)(castitem))
+{}
+
+UIManager::~UIManager()
+{}
+
+
+UIManager::CppClassType UIManager::uimanager_class_; // initialize static member
+
+GType UIManager::get_type()
+{
+  return uimanager_class_.init().get_type();
+}
+
+GType UIManager::get_base_type()
+{
+  return gtk_ui_manager_get_type();
+}
+
+
+UIManager::UIManager()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Glib::Object(Glib::ConstructParams(uimanager_class_.init()))
+{
+  }
+
+Glib::RefPtr<UIManager> UIManager::create()
+{
+  return Glib::RefPtr<UIManager>( new UIManager() );
+}
+void UIManager::set_add_tearoffs(bool add_tearoffs)
+{
+  gtk_ui_manager_set_add_tearoffs(gobj(), static_cast<int>(add_tearoffs));
+}
+
+bool UIManager::get_add_tearoffs() const
+{
+  return gtk_ui_manager_get_add_tearoffs(const_cast<GtkUIManager*>(gobj()));
+}
+
+void UIManager::insert_action_group(const Glib::RefPtr<ActionGroup>& action_group, int pos)
+{
+  gtk_ui_manager_insert_action_group(gobj(), Glib::unwrap(action_group), pos);
+}
+
+void UIManager::remove_action_group(const Glib::RefPtr<ActionGroup>& action_group)
+{
+  gtk_ui_manager_remove_action_group(gobj(), Glib::unwrap(action_group));
+}
+
+Glib::ListHandle< Glib::RefPtr<ActionGroup> > UIManager::get_action_groups()
+{
+  return Glib::ListHandle< Glib::RefPtr<ActionGroup> >(gtk_ui_manager_get_action_groups(gobj()), Glib::OWNERSHIP_SHALLOW);
+}
+
+Glib::ListHandle< Glib::RefPtr<const ActionGroup> > UIManager::get_action_groups() const
+{
+  return Glib::ListHandle< Glib::RefPtr<const ActionGroup> >(gtk_ui_manager_get_action_groups(const_cast<GtkUIManager*>(gobj())), Glib::OWNERSHIP_SHALLOW);
+}
+
+Glib::RefPtr<AccelGroup> UIManager::get_accel_group()
+{
+
+  Glib::RefPtr<AccelGroup> retvalue = Glib::wrap(gtk_ui_manager_get_accel_group(gobj()));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::RefPtr<const AccelGroup> UIManager::get_accel_group() const
+{
+
+  Glib::RefPtr<const AccelGroup> retvalue = Glib::wrap(gtk_ui_manager_get_accel_group(const_cast<GtkUIManager*>(gobj())));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Widget* UIManager::get_widget(const Glib::ustring& path)
+{
+  return Glib::wrap(gtk_ui_manager_get_widget(gobj(), path.c_str()));
+}
+
+const Widget* UIManager::get_widget(const Glib::ustring& path) const
+{
+  return Glib::wrap(gtk_ui_manager_get_widget(const_cast<GtkUIManager*>(gobj()), path.c_str()));
+}
+
+Glib::SListHandle<Widget*> UIManager::get_toplevels(UIManagerItemType types)
+{
+  return Glib::SListHandle<Widget*>(gtk_ui_manager_get_toplevels(gobj(), ((GtkUIManagerItemType)(types))), Glib::OWNERSHIP_SHALLOW);
+}
+
+Glib::SListHandle<const Widget*> UIManager::get_toplevels(UIManagerItemType types) const
+{
+  return Glib::SListHandle<const Widget*>(gtk_ui_manager_get_toplevels(const_cast<GtkUIManager*>(gobj()), ((GtkUIManagerItemType)(types))), Glib::OWNERSHIP_SHALLOW);
+}
+
+Glib::RefPtr<Action> UIManager::get_action(const Glib::ustring& path)
+{
+
+  Glib::RefPtr<Action> retvalue = Glib::wrap(gtk_ui_manager_get_action(gobj(), path.c_str()));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::RefPtr<const Action> UIManager::get_action(const Glib::ustring& path) const
+{
+
+  Glib::RefPtr<const Action> retvalue = Glib::wrap(gtk_ui_manager_get_action(const_cast<GtkUIManager*>(gobj()), path.c_str()));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+ui_merge_id UIManager::add_ui_from_file(const Glib::ustring& filename)
+{
+  GError *error = 0;
+  ui_merge_id retvalue = gtk_ui_manager_add_ui_from_file(gobj(), filename.c_str(), &(error));
+  if(error) ::Glib::Error::throw_exception(error);
+  return retvalue;
+}
+
+void UIManager::add_ui(ui_merge_id merge_id, const Glib::ustring& path, const Glib::ustring& name, const Glib::ustring& action, UIManagerItemType type, bool top)
+{
+  gtk_ui_manager_add_ui(gobj(), merge_id, path.c_str(), name.c_str(), action.c_str(), ((GtkUIManagerItemType)(type)), static_cast<int>(top));
+}
+
+void UIManager::remove_ui(ui_merge_id merge_id)
+{
+  gtk_ui_manager_remove_ui(gobj(), merge_id);
+}
+
+Glib::ustring UIManager::get_ui() const
+{
+  return Glib::convert_return_gchar_ptr_to_ustring(gtk_ui_manager_get_ui(const_cast<GtkUIManager*>(gobj())));
+}
+
+void UIManager::ensure_update()
+{
+  gtk_ui_manager_ensure_update(gobj());
+}
+
+ui_merge_id UIManager::new_merge_id()
+{
+  return gtk_ui_manager_new_merge_id(gobj());
+}
+
+
+Glib::SignalProxy1< void,Widget* > UIManager::signal_add_widget()
+{
+  return Glib::SignalProxy1< void,Widget* >(this, &UIManager_signal_add_widget_info);
+}
+
+Glib::SignalProxy0< void > UIManager::signal_actions_changed()
+{
+  return Glib::SignalProxy0< void >(this, &UIManager_signal_actions_changed_info);
+}
+
+Glib::SignalProxy2< void,const Glib::RefPtr<Action>&,Widget* > UIManager::signal_connect_proxy()
+{
+  return Glib::SignalProxy2< void,const Glib::RefPtr<Action>&,Widget* >(this, &UIManager_signal_connect_proxy_info);
+}
+
+Glib::SignalProxy2< void,const Glib::RefPtr<Action>&,Widget* > UIManager::signal_disconnect_proxy()
+{
+  return Glib::SignalProxy2< void,const Glib::RefPtr<Action>&,Widget* >(this, &UIManager_signal_disconnect_proxy_info);
+}
+
+Glib::SignalProxy1< void,const Glib::RefPtr<Action>& > UIManager::signal_pre_activate()
+{
+  return Glib::SignalProxy1< void,const Glib::RefPtr<Action>& >(this, &UIManager_signal_pre_activate_info);
+}
+
+Glib::SignalProxy1< void,const Glib::RefPtr<Action>& > UIManager::signal_post_activate()
+{
+  return Glib::SignalProxy1< void,const Glib::RefPtr<Action>& >(this, &UIManager_signal_post_activate_info);
+}
+
+
+Glib::PropertyProxy<bool> UIManager::property_add_tearoffs() 
+{
+  return Glib::PropertyProxy<bool>(this, "add-tearoffs");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> UIManager::property_add_tearoffs() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "add-tearoffs");
+}
+
+Glib::PropertyProxy_ReadOnly<Glib::ustring> UIManager::property_ui() const
+{
+  return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "ui");
+}
+
+
+void Gtk::UIManager::on_add_widget(Widget* widget)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->add_widget)
+    (*base->add_widget)(gobj(),(GtkWidget*)Glib::unwrap(widget));
+}
+
+void Gtk::UIManager::on_actions_changed()
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->actions_changed)
+    (*base->actions_changed)(gobj());
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/uimanager.h b/libs/gtkmm2/gtk/gtkmm/uimanager.h
new file mode 100644
index 0000000000..3adec8c251
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/uimanager.h
@@ -0,0 +1,505 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_UIMANAGER_H
+#define _GTKMM_UIMANAGER_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* Copyright (C) 2003 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/widget.h>
+#include <gtkmm/action.h>
+#include <gtkmm/actiongroup.h>
+#include <gtkmm/uimanager.h>
+ 
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkUIManager GtkUIManager;
+typedef struct _GtkUIManagerClass GtkUIManagerClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class UIManager_Class; } // namespace Gtk
+namespace Gtk
+{
+
+/** @addtogroup gtkmmEnums Enums and Flags */
+
+/**
+ * @ingroup gtkmmEnums
+ * @par Bitwise operators:
+ * <tt>%UIManagerItemType operator|(UIManagerItemType, UIManagerItemType)</tt><br>
+ * <tt>%UIManagerItemType operator&(UIManagerItemType, UIManagerItemType)</tt><br>
+ * <tt>%UIManagerItemType operator^(UIManagerItemType, UIManagerItemType)</tt><br>
+ * <tt>%UIManagerItemType operator~(UIManagerItemType)</tt><br>
+ * <tt>%UIManagerItemType& operator|=(UIManagerItemType&, UIManagerItemType)</tt><br>
+ * <tt>%UIManagerItemType& operator&=(UIManagerItemType&, UIManagerItemType)</tt><br>
+ * <tt>%UIManagerItemType& operator^=(UIManagerItemType&, UIManagerItemType)</tt><br>
+ */
+enum UIManagerItemType
+{
+  UI_MANAGER_AUTO = 0,
+  UI_MANAGER_MENUBAR = 1 << 0,
+  UI_MANAGER_MENU = 1 << 1,
+  UI_MANAGER_TOOLBAR = 1 << 2,
+  UI_MANAGER_PLACEHOLDER = 1 << 3,
+  UI_MANAGER_POPUP = 1 << 4,
+  UI_MANAGER_MENUITEM = 1 << 5,
+  UI_MANAGER_TOOLITEM = 1 << 6,
+  UI_MANAGER_SEPARATOR = 1 << 7,
+  UI_MANAGER_ACCELERATOR = 1 << 8
+};
+
+/** @ingroup gtkmmEnums */
+inline UIManagerItemType operator|(UIManagerItemType lhs, UIManagerItemType rhs)
+  { return static_cast<UIManagerItemType>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs)); }
+
+/** @ingroup gtkmmEnums */
+inline UIManagerItemType operator&(UIManagerItemType lhs, UIManagerItemType rhs)
+  { return static_cast<UIManagerItemType>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs)); }
+
+/** @ingroup gtkmmEnums */
+inline UIManagerItemType operator^(UIManagerItemType lhs, UIManagerItemType rhs)
+  { return static_cast<UIManagerItemType>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs)); }
+
+/** @ingroup gtkmmEnums */
+inline UIManagerItemType operator~(UIManagerItemType flags)
+  { return static_cast<UIManagerItemType>(~static_cast<unsigned>(flags)); }
+
+/** @ingroup gtkmmEnums */
+inline UIManagerItemType& operator|=(UIManagerItemType& lhs, UIManagerItemType rhs)
+  { return (lhs = static_cast<UIManagerItemType>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs))); }
+
+/** @ingroup gtkmmEnums */
+inline UIManagerItemType& operator&=(UIManagerItemType& lhs, UIManagerItemType rhs)
+  { return (lhs = static_cast<UIManagerItemType>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs))); }
+
+/** @ingroup gtkmmEnums */
+inline UIManagerItemType& operator^=(UIManagerItemType& lhs, UIManagerItemType rhs)
+  { return (lhs = static_cast<UIManagerItemType>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs))); }
+
+} // namespace Gtk
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Gtk::UIManagerItemType> : public Glib::Value_Flags<Gtk::UIManagerItemType>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{
+
+
+class UIManager : public Glib::Object
+{
+  
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+public:
+  typedef UIManager CppObjectType;
+  typedef UIManager_Class CppClassType;
+  typedef GtkUIManager BaseObjectType;
+  typedef GtkUIManagerClass BaseClassType;
+
+private:  friend class UIManager_Class;
+  static CppClassType uimanager_class_;
+
+private:
+  // noncopyable
+  UIManager(const UIManager&);
+  UIManager& operator=(const UIManager&);
+
+protected:
+  explicit UIManager(const Glib::ConstructParams& construct_params);
+  explicit UIManager(GtkUIManager* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+  virtual ~UIManager();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GObject.
+  GtkUIManager*       gobj()       { return reinterpret_cast<GtkUIManager*>(gobject_); }
+
+  ///Provides access to the underlying C GObject.
+  const GtkUIManager* gobj() const { return reinterpret_cast<GtkUIManager*>(gobject_); }
+
+  ///Provides access to the underlying C instance. The caller is responsible for unrefing it. Use when directly setting fields in structs.
+  GtkUIManager* gobj_copy();
+
+private:
+
+protected:
+  UIManager();
+
+public:
+  
+  static Glib::RefPtr<UIManager> create();
+
+
+  /** Sets the "add_tearoffs" property, which controls whether menus 
+   * generated by this Gtk::UIManager will have tearoff menu items. 
+   * 
+   * Note that this only affects regular menus. Generated popup 
+   * menus never have tearoff menu items.
+   * 
+   * Since: 2.4
+   * @param add_tearoffs Whether tearoff menu items are added.
+   */
+  void set_add_tearoffs(bool add_tearoffs = true);
+  
+  /** Returns whether menus generated by this Gtk::UIManager
+   * will have tearoff menu items.
+   * @return Whether tearoff menu items are added
+   * 
+   * Since: 2.4.
+   */
+  bool get_add_tearoffs() const;
+  
+  /** Inserts an action group into the list of action groups associated 
+   * with @a self . Actions in earlier groups hide actions with the same 
+   * name in later groups. 
+   * 
+   * Since: 2.4
+   * @param action_group The action group to be inserted.
+   * @param pos The position at which the group will be inserted.
+   */
+  void insert_action_group(const Glib::RefPtr<ActionGroup>& action_group, int pos = 0);
+  
+  /** Removes an action group from the list of action groups associated 
+   * with @a self .
+   * 
+   * Since: 2.4
+   * @param action_group The action group to be removed.
+   */
+  void remove_action_group(const Glib::RefPtr<ActionGroup>& action_group);
+
+  
+  /** Returns the list of action groups associated with @a self .
+   * @return A G::List of action groups. The list is owned by GTK+ 
+   * and should not be modified.
+   * 
+   * Since: 2.4.
+   */
+  Glib::ListHandle< Glib::RefPtr<ActionGroup> > get_action_groups();
+  
+  /** Returns the list of action groups associated with @a self .
+   * @return A G::List of action groups. The list is owned by GTK+ 
+   * and should not be modified.
+   * 
+   * Since: 2.4.
+   */
+  Glib::ListHandle< Glib::RefPtr<const ActionGroup> > get_action_groups() const;
+  
+  
+  /** Returns the Gtk::AccelGroup associated with @a self .
+   * @return The Gtk::AccelGroup.
+   * 
+   * Since: 2.4.
+   */
+  Glib::RefPtr<AccelGroup> get_accel_group();
+  
+  /** Returns the Gtk::AccelGroup associated with @a self .
+   * @return The Gtk::AccelGroup.
+   * 
+   * Since: 2.4.
+   */
+  Glib::RefPtr<const AccelGroup> get_accel_group() const;
+  
+  /** Looks up a widget by following a path. 
+   * The path consists of the names specified in the XML description of the UI. 
+   * separated by '/'. Elements which don't have a name or action attribute in 
+   * the XML (e.g. &lt;popup&gt;) can be addressed by their XML element name 
+   * (e.g. "popup"). The root element ("/ui") can be omitted in the path.
+   * 
+   * Note that the widget found by following a path that ends in a &lt;menu&gt;
+   * element is the menuitem to which the menu is attached, not the menu itself.
+   * @param path A path.
+   * @return The widget found by following the path, or <tt>0</tt> if no widget
+   * was found.
+   * 
+   * Since: 2.4.
+   */
+  Widget* get_widget(const Glib::ustring& path);
+  
+  /** Looks up a widget by following a path. 
+   * The path consists of the names specified in the XML description of the UI. 
+   * separated by '/'. Elements which don't have a name or action attribute in 
+   * the XML (e.g. &lt;popup&gt;) can be addressed by their XML element name 
+   * (e.g. "popup"). The root element ("/ui") can be omitted in the path.
+   * 
+   * Note that the widget found by following a path that ends in a &lt;menu&gt;
+   * element is the menuitem to which the menu is attached, not the menu itself.
+   * @param path A path.
+   * @return The widget found by following the path, or <tt>0</tt> if no widget
+   * was found.
+   * 
+   * Since: 2.4.
+   */
+  const Widget* get_widget(const Glib::ustring& path) const;
+
+  
+  /** Obtains a list of all toplevel widgets of the requested types.
+   * @param types Specifies the types of toplevel widgets to include. Allowed
+   * types are Gtk::UI_MANAGER_MENUBAR, Gtk::UI_MANAGER_TOOLBAR and
+   * Gtk::UI_MANAGER_POPUP.
+   * @return A newly-allocated of all toplevel widgets of the requested 
+   * types. 
+   * 
+   * Since: 2.4.
+   */
+  Glib::SListHandle<Widget*> get_toplevels(UIManagerItemType types);
+  
+  /** Obtains a list of all toplevel widgets of the requested types.
+   * @param types Specifies the types of toplevel widgets to include. Allowed
+   * types are Gtk::UI_MANAGER_MENUBAR, Gtk::UI_MANAGER_TOOLBAR and
+   * Gtk::UI_MANAGER_POPUP.
+   * @return A newly-allocated of all toplevel widgets of the requested 
+   * types. 
+   * 
+   * Since: 2.4.
+   */
+  Glib::SListHandle<const Widget*> get_toplevels(UIManagerItemType types) const;
+                 
+  
+  /** Looks up an action by following a path. See gtk_ui_manager_get_widget()
+   * for more information about paths.
+   * @param path A path.
+   * @return The action whose proxy widget is found by following the path, 
+   * or <tt>0</tt> if no widget was found.
+   * 
+   * Since: 2.4.
+   */
+  Glib::RefPtr<Action> get_action(const Glib::ustring& path);
+  
+  /** Looks up an action by following a path. See gtk_ui_manager_get_widget()
+   * for more information about paths.
+   * @param path A path.
+   * @return The action whose proxy widget is found by following the path, 
+   * or <tt>0</tt> if no widget was found.
+   * 
+   * Since: 2.4.
+   */
+  Glib::RefPtr<const Action> get_action(const Glib::ustring& path) const;
+
+  typedef guint ui_merge_id;
+    
+  /** Parses a string containing a UI definition and
+   * merges it with the current contents. An enclosing &lt;ui&gt;
+   * element is added if it is missing.
+   *
+   * @param buffer the string to parse
+   * @result  The merge id for the merged UI. The merge id can be used to unmerge the UI with remove_ui(). If an error occurred, the return value is 0.
+   * @throws exception
+   * Since: 2.4
+   */ 
+  ui_merge_id add_ui_from_string(const Glib::ustring& buffer);
+  
+  
+  /** Parses a file containing a UI definition and 
+   * merges it with the current contents of @a self .
+   * @param filename The name of the file to parse.
+   * @return The merge id for the merged UI. The merge id can be used
+   * to unmerge the UI with gtk_ui_manager_remove_ui(). If an error occurred,
+   * the return value is 0.
+   * 
+   * Since: 2.4.
+   */
+  ui_merge_id add_ui_from_file(const Glib::ustring& filename);
+
+//TODO: Is top=true a good default?
+
+  
+  /** Adds a UI element to the current contents of @a self .
+   * 
+   * If @a type  is Gtk::UI_MANAGER_AUTO, GTK+ inserts a menuitem, toolitem or
+   * separator if such an element can be inserted at the place determined by
+   *  @a path . Otherwise @a type  must indicate an element that can be inserted at
+   * the place determined by @a path .
+   * 
+   *  @a see  add_ui_separator().
+   * 
+   * Since: 2.4
+   * @param merge_id The merge id for the merged UI, see gtk_ui_manager_new_merge_id().
+   * @param path A path.
+   * @param name The name for the added UI element.
+   * @param action The name of the action to be proxied, if this is not a separator.
+   * @param type The type of UI element to add.
+   * @param top If <tt>true</tt>, the UI element is added before its siblings, otherwise it
+   * is added after its siblings.
+   */
+  void add_ui(ui_merge_id merge_id, const Glib::ustring& path, const Glib::ustring& name, const Glib::ustring& action, UIManagerItemType type = Gtk::UI_MANAGER_AUTO, bool top = true);
+
+  /** Adds a separator UI element to the current contents.
+   *
+   * If @a type  is Gtk::UI_MANAGER_AUTO, GTK+ inserts a menuitem, toolitem or
+   * separator if such an element can be inserted at the place determined by
+   *  @a path . Otherwise @a type  must indicate an element that can be inserted at
+   * the place determined by @a path.
+   *
+   * @see add_ui().
+   *
+   * Since: 2.4
+   * @param merge_id The merge id for the merged UI, see gtk_ui_manager_new_merge_id().
+   * @param path A path.
+   * @param name The name for the added UI element.
+   * @param type The type of UI element to add.
+   * @param top If <tt>true</tt>, the UI element is added before its siblings, otherwise it
+   * is added after its siblings.
+   */
+  void add_ui_separator(ui_merge_id merge_id, const Glib::ustring& path, const Glib::ustring& name = "", UIManagerItemType type = Gtk::UI_MANAGER_AUTO, bool top = true);
+  
+  
+  /** Unmerges the part of @a self &lt;!-- --&gt;s content identified by @a merge_id .
+   * 
+   * Since: 2.4
+   * @param merge_id A merge id as returned by gtk_ui_manager_add_ui_from_string().
+   */
+  void remove_ui(ui_merge_id merge_id);
+  
+  /** Creates a UI definition of the merged UI.
+   * @return A newly allocated string containing an XML representation of 
+   * the merged UI.
+   * 
+   * Since: 2.4.
+   */
+  Glib::ustring get_ui() const;
+  
+  /** Makes sure that all pending updates to the UI have been completed.
+   * 
+   * This may occasionally be necessary, since Gtk::UIManager updates the 
+   * UI in an idle function. A typical example where this function is
+   * useful is to enforce that the menubar and toolbar have been added to 
+   * the main window before showing it:
+   * @code
+   * 
+   * gtk_container_add (GTK_CONTAINER (window), vbox); 
+   * g_signal_connect (merge, "add_widget", 
+   * G_CALLBACK (add_widget), vbox);
+   * gtk_ui_manager_add_ui_from_file (merge, "my-menus");
+   * gtk_ui_manager_add_ui_from_file (merge, "my-toolbars");
+   * gtk_ui_manager_ensure_update (merge);  
+   * gtk_widget_show (window);
+   * 
+   * @endcode
+   * 
+   * Since: 2.4
+   */
+  void ensure_update();
+  
+  /** Returns an unused merge id, suitable for use with 
+   * gtk_ui_manager_add_ui().
+   * @return An unused merge id.
+   * 
+   * Since: 2.4.
+   */
+  ui_merge_id new_merge_id();
+
+
+  Glib::SignalProxy1< void,Widget* > signal_add_widget();
+
+  
+  Glib::SignalProxy0< void > signal_actions_changed();
+
+  
+  Glib::SignalProxy2< void,const Glib::RefPtr<Action>&,Widget* > signal_connect_proxy();
+
+  
+  Glib::SignalProxy2< void,const Glib::RefPtr<Action>&,Widget* > signal_disconnect_proxy();
+
+  
+  Glib::SignalProxy1< void,const Glib::RefPtr<Action>& > signal_pre_activate();
+
+  
+  Glib::SignalProxy1< void,const Glib::RefPtr<Action>& > signal_post_activate();
+
+
+  /** Whether tearoff menu items should be added to menus.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_add_tearoffs() ;
+
+/** Whether tearoff menu items should be added to menus.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_add_tearoffs() const;
+
+  /** An XML string describing the merged UI.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Glib::ustring> property_ui() const;
+
+
+public:
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+  virtual void on_add_widget(Widget* widget);
+  virtual void on_actions_changed();
+
+
+};
+
+} // namespace Gtk
+
+
+namespace Glib
+{
+  /** @relates Gtk::UIManager
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Glib::RefPtr<Gtk::UIManager> wrap(GtkUIManager* object, bool take_copy = false);
+}
+
+
+#endif /* _GTKMM_UIMANAGER_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/viewport.cc b/libs/gtkmm2/gtk/gtkmm/viewport.cc
new file mode 100644
index 0000000000..c06abb80aa
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/viewport.cc
@@ -0,0 +1,297 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/viewport.h>
+#include <gtkmm/private/viewport_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* 
+ *
+ * Copyright 2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/viewport.h>
+#include <gtkmm/adjustment.h>
+#include <gtk/gtkviewport.h>
+
+
+namespace
+{
+
+void Viewport_signal_set_scroll_adjustments_callback(GtkViewport* self, GtkAdjustment* p0,GtkAdjustment* p1,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,Gtk::Adjustment*,Gtk::Adjustment* > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(Glib::wrap(p0)
+, Glib::wrap(p1)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+}
+
+const Glib::SignalProxyInfo Viewport_signal_set_scroll_adjustments_info =
+{
+  "set_scroll_adjustments",
+  (GCallback) &Viewport_signal_set_scroll_adjustments_callback,
+  (GCallback) &Viewport_signal_set_scroll_adjustments_callback
+};
+
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Gtk::Viewport* wrap(GtkViewport* object, bool take_copy)
+{
+  return dynamic_cast<Gtk::Viewport *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& Viewport_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &Viewport_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_viewport_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void Viewport_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+  klass->set_scroll_adjustments = &set_scroll_adjustments_callback;
+}
+
+
+void Viewport_Class::set_scroll_adjustments_callback(GtkViewport* self, GtkAdjustment* p0, GtkAdjustment* p1)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_set_scroll_adjustments(Glib::wrap(p0)
+, Glib::wrap(p1)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->set_scroll_adjustments)
+      (*base->set_scroll_adjustments)(self, p0, p1);
+  }
+}
+
+
+Glib::ObjectBase* Viewport_Class::wrap_new(GObject* o)
+{
+  return manage(new Viewport((GtkViewport*)(o)));
+
+}
+
+
+/* The implementation: */
+
+Viewport::Viewport(const Glib::ConstructParams& construct_params)
+:
+  Gtk::Bin(construct_params)
+{
+  }
+
+Viewport::Viewport(GtkViewport* castitem)
+:
+  Gtk::Bin((GtkBin*)(castitem))
+{
+  }
+
+Viewport::~Viewport()
+{
+  destroy_();
+}
+
+Viewport::CppClassType Viewport::viewport_class_; // initialize static member
+
+GType Viewport::get_type()
+{
+  return viewport_class_.init().get_type();
+}
+
+GType Viewport::get_base_type()
+{
+  return gtk_viewport_get_type();
+}
+
+
+Viewport::Viewport(Adjustment& hadjustment, Adjustment& vadjustment)
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Bin(Glib::ConstructParams(viewport_class_.init(), "hadjustment", (hadjustment).gobj(), "vadjustment", (vadjustment).gobj(), (char*) 0))
+{
+  }
+
+Gtk::Adjustment* Viewport::get_hadjustment()
+{
+  return Glib::wrap(gtk_viewport_get_hadjustment(gobj()));
+}
+
+const Gtk::Adjustment* Viewport::get_hadjustment() const
+{
+  return Glib::wrap(gtk_viewport_get_hadjustment(const_cast<GtkViewport*>(gobj())));
+}
+
+Gtk::Adjustment* Viewport::get_vadjustment()
+{
+  return Glib::wrap(gtk_viewport_get_vadjustment(gobj()));
+}
+
+const Gtk::Adjustment* Viewport::get_vadjustment() const
+{
+  return Glib::wrap(gtk_viewport_get_vadjustment(const_cast<GtkViewport*>(gobj())));
+}
+
+void Viewport::set_hadjustment(Gtk::Adjustment* adjustment)
+{
+  gtk_viewport_set_hadjustment(gobj(), (GtkAdjustment*)Glib::unwrap(adjustment));
+}
+
+void Viewport::set_hadjustment(Gtk::Adjustment& adjustment)
+{
+  gtk_viewport_set_hadjustment(gobj(), (adjustment).gobj());
+}
+
+void Viewport::set_vadjustment(Gtk::Adjustment* adjustment)
+{
+  gtk_viewport_set_vadjustment(gobj(), (GtkAdjustment*)Glib::unwrap(adjustment));
+}
+
+void Viewport::set_vadjustment(Gtk::Adjustment& adjustment)
+{
+  gtk_viewport_set_vadjustment(gobj(), (adjustment).gobj());
+}
+
+void Viewport::set_shadow_type(ShadowType type)
+{
+  gtk_viewport_set_shadow_type(gobj(), ((GtkShadowType)(type)));
+}
+
+ShadowType Viewport::get_shadow_type() const
+{
+  return ((ShadowType)(gtk_viewport_get_shadow_type(const_cast<GtkViewport*>(gobj()))));
+}
+
+
+Glib::SignalProxy2< void,Gtk::Adjustment*,Gtk::Adjustment* > Viewport::signal_set_scroll_adjustments()
+{
+  return Glib::SignalProxy2< void,Gtk::Adjustment*,Gtk::Adjustment* >(this, &Viewport_signal_set_scroll_adjustments_info);
+}
+
+
+Glib::PropertyProxy<Gtk::Adjustment*> Viewport::property_hadjustment() 
+{
+  return Glib::PropertyProxy<Gtk::Adjustment*>(this, "hadjustment");
+}
+
+Glib::PropertyProxy_ReadOnly<Gtk::Adjustment*> Viewport::property_hadjustment() const
+{
+  return Glib::PropertyProxy_ReadOnly<Gtk::Adjustment*>(this, "hadjustment");
+}
+
+Glib::PropertyProxy<Gtk::Adjustment*> Viewport::property_vadjustment() 
+{
+  return Glib::PropertyProxy<Gtk::Adjustment*>(this, "vadjustment");
+}
+
+Glib::PropertyProxy_ReadOnly<Gtk::Adjustment*> Viewport::property_vadjustment() const
+{
+  return Glib::PropertyProxy_ReadOnly<Gtk::Adjustment*>(this, "vadjustment");
+}
+
+Glib::PropertyProxy<ShadowType> Viewport::property_shadow_type() 
+{
+  return Glib::PropertyProxy<ShadowType>(this, "shadow-type");
+}
+
+Glib::PropertyProxy_ReadOnly<ShadowType> Viewport::property_shadow_type() const
+{
+  return Glib::PropertyProxy_ReadOnly<ShadowType>(this, "shadow-type");
+}
+
+
+void Gtk::Viewport::on_set_scroll_adjustments(Gtk::Adjustment* hadjustment, Gtk::Adjustment* vadjustment)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->set_scroll_adjustments)
+    (*base->set_scroll_adjustments)(gobj(),(GtkAdjustment*)Glib::unwrap(hadjustment),(GtkAdjustment*)Glib::unwrap(vadjustment));
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/viewport.h b/libs/gtkmm2/gtk/gtkmm/viewport.h
new file mode 100644
index 0000000000..42d429c15d
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/viewport.h
@@ -0,0 +1,231 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_VIEWPORT_H
+#define _GTKMM_VIEWPORT_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* viewport.h
+ * 
+ * Copyright (C) 2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/bin.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkViewport GtkViewport;
+typedef struct _GtkViewportClass GtkViewportClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class Viewport_Class; } // namespace Gtk
+namespace Gtk {
+class Adjustment;
+
+/** An adapter which makes widgets scrollable.
+ * 
+ * @ingroup Widgets
+ * @ingroup Containers
+ */
+
+class Viewport : public Bin
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Viewport CppObjectType;
+  typedef Viewport_Class CppClassType;
+  typedef GtkViewport BaseObjectType;
+  typedef GtkViewportClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~Viewport();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class Viewport_Class;
+  static CppClassType viewport_class_;
+
+  // noncopyable
+  Viewport(const Viewport&);
+  Viewport& operator=(const Viewport&);
+
+protected:
+  explicit Viewport(const Glib::ConstructParams& construct_params);
+  explicit Viewport(GtkViewport* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GtkViewport*       gobj()       { return reinterpret_cast<GtkViewport*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GtkViewport* gobj() const { return reinterpret_cast<GtkViewport*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+  virtual void on_set_scroll_adjustments(Gtk::Adjustment* hadjustment, Gtk::Adjustment* vadjustment);
+
+
+private:
+
+public:
+
+  explicit Viewport(Adjustment& hadjustment, Adjustment& vadjustment);
+
+
+  /** Returns the horizontal adjustment of the viewport.
+   * @return The horizontal adjustment of @a viewport .
+   */
+  Gtk::Adjustment* get_hadjustment();
+  
+  /** Returns the horizontal adjustment of the viewport.
+   * @return The horizontal adjustment of @a viewport .
+   */
+  const Gtk::Adjustment* get_hadjustment() const;
+
+  
+  /** Returns the vertical adjustment of the viewport.
+   * @return The vertical adjustment of @a viewport .
+   */
+  Gtk::Adjustment* get_vadjustment();
+  
+  /** Returns the vertical adjustment of the viewport.
+   * @return The vertical adjustment of @a viewport .
+   */
+  const Gtk::Adjustment* get_vadjustment() const;
+
+  
+  /** Sets the horizontal adjustment of the viewport.
+   * @param adjustment A Gtk::Adjustment.
+   */
+  void set_hadjustment(Gtk::Adjustment* adjustment=0);
+  
+  /** Sets the horizontal adjustment of the viewport.
+   * @param adjustment A Gtk::Adjustment.
+   */
+  void set_hadjustment(Gtk::Adjustment& adjustment);
+
+  
+  /** Sets the vertical adjustment of the viewport.
+   * @param adjustment A Gtk::Adjustment.
+   */
+  void set_vadjustment(Gtk::Adjustment* adjustment=0);
+  
+  /** Sets the vertical adjustment of the viewport.
+   * @param adjustment A Gtk::Adjustment.
+   */
+  void set_vadjustment(Gtk::Adjustment& adjustment);
+
+  
+  /** Sets the shadow type of the viewport.
+   * @param type The new shadow type.
+   */
+  void set_shadow_type(ShadowType type);
+
+  
+  /** Gets the shadow type of the Gtk::Viewport. See
+   * set_shadow_type().
+   * @return The shadow type.
+   */
+  ShadowType get_shadow_type() const;
+
+  
+  Glib::SignalProxy2< void,Gtk::Adjustment*,Gtk::Adjustment* > signal_set_scroll_adjustments();
+
+
+  /** The GtkAdjustment that determines the values of the horizontal position for this viewport.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Gtk::Adjustment*> property_hadjustment() ;
+
+/** The GtkAdjustment that determines the values of the horizontal position for this viewport.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Gtk::Adjustment*> property_hadjustment() const;
+
+  /** The GtkAdjustment that determines the values of the vertical position for this viewport.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Gtk::Adjustment*> property_vadjustment() ;
+
+/** The GtkAdjustment that determines the values of the vertical position for this viewport.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Gtk::Adjustment*> property_vadjustment() const;
+
+  /** Determines how the shadowed box around the viewport is drawn.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<ShadowType> property_shadow_type() ;
+
+/** Determines how the shadowed box around the viewport is drawn.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<ShadowType> property_shadow_type() const;
+
+
+};
+
+}  /* namespace Gtk */
+
+
+namespace Glib
+{
+  /** @relates Gtk::Viewport
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gtk::Viewport* wrap(GtkViewport* object, bool take_copy = false);
+}
+#endif /* _GTKMM_VIEWPORT_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/widget.cc b/libs/gtkmm2/gtk/gtkmm/widget.cc
new file mode 100644
index 0000000000..eabf1ed4a8
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/widget.cc
@@ -0,0 +1,7088 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/widget.h>
+#include <gtkmm/private/widget_p.h>
+
+#include <gtk/gtktypebuiltins.h>
+// -*- c++ -*-
+/* $Id$ */
+
+/* Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/adjustment.h>
+#include <gtkmm/window.h>
+#include <gtkmm/accelgroup.h>
+#include <gtkmm/settings.h>
+#include <gtkmm/style.h>
+#include <gtkmm/container.h>
+#include <gtkmm/selectiondata_private.h>
+#include <gtk/gtkdnd.h>
+#include <gtk/gtkselection.h>
+#include <gtk/gtkwidget.h>
+#include <gtk/gtkcontainer.h>
+#include <gtk/gtkmain.h>
+
+
+namespace //anonymous
+{
+
+//These signal callbacks are custom implemented, so that we can create a temporary SelectionData instance.
+//To do this, we used the optional custom_c_callback paramater to _WRAP_SIGNAL() in the .hg file.
+void Widget_signal_drag_data_get_callback(GtkWidget* self, GdkDragContext* p0,GtkSelectionData* p1,guint p2,guint p3,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,const Glib::RefPtr<Gdk::DragContext>&,SelectionData&,guint,guint > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+      {
+        SelectionData_WithoutOwnership temp_instance(p1);
+        (*static_cast<SlotType*>(slot))( Glib::wrap(p0, true), temp_instance, p2, p3 );
+      }
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+}
+
+void Widget_signal_selection_get_callback(GtkWidget* self, GtkSelectionData* p0,guint p1,guint p2,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void, SelectionData&, guint, guint > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+      {
+        SelectionData_WithoutOwnership temp_instance(p0);
+        (*static_cast<SlotType*>(slot))( temp_instance, p1, p2 );
+      }
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+}
+
+
+} //anonymous
+
+namespace Gtk
+{
+
+//These default handler callbacks are custom implemented, so that we can create a temporary SelectionData instance.
+//To do this, we used the optional custom_c_callback paramater to _WRAP_SIGNAL() in the .hg file.
+void Widget_Class::selection_get_callback(GtkWidget* self, GtkSelectionData* p0, guint p1, guint p2)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      SelectionData_WithoutOwnership temp_instance(p0);
+      obj->on_selection_get(temp_instance, p1, p2);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->selection_get)
+      (*base->selection_get)(self, p0, p1, p2);
+  }
+}
+
+void Widget_Class::drag_data_get_callback(GtkWidget* self, GdkDragContext* p0, GtkSelectionData* p1, guint p2, guint p3)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      SelectionData_WithoutOwnership temp_instance(p1);
+      obj->on_drag_data_get(Glib::wrap(p0, true), temp_instance, p2, p3);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->drag_data_get)
+      (*base->drag_data_get)(self, p0, p1, p2, p3);
+  }
+}
+
+Widget::~Widget()
+{}
+
+bool Widget::intersect(const Gdk::Rectangle& area) const
+{
+  return gtk_widget_intersect(
+      const_cast<GtkWidget*>(gobj()), const_cast<GdkRectangle*>(area.gobj()), 0);
+}
+
+void Widget::unset_name()
+{
+  gtk_widget_set_name(gobj(), 0);
+}
+
+void Widget::unset_composite_name()
+{
+  gtk_widget_set_composite_name(gobj(), 0);
+}
+
+void Widget::realize_if_needed()
+{
+  if(!is_realized())
+    realize();
+}
+
+void Widget::add_modal_grab()
+{
+  gtk_grab_add(gobj());
+}
+
+void Widget::remove_modal_grab()
+{
+  gtk_grab_remove(gobj());
+}
+
+Widget* Widget::get_current_modal_grab()
+{
+  return Glib::wrap(gtk_grab_get_current());
+}
+
+void Widget::path(Glib::ustring& path_arg, Glib::ustring& path_reversed)
+{
+  guint path_length = 0;
+  Glib::ScopedPtr<gchar> path_ptr;
+  Glib::ScopedPtr<gchar> rpath_ptr;
+
+  gtk_widget_path(gobj(), &path_length, path_ptr.addr(), rpath_ptr.addr());
+
+  path_arg.assign(path_ptr.get(), path_ptr.get() + path_length);
+  path_reversed.assign(rpath_ptr.get(), rpath_ptr.get() + path_length);
+}
+
+void Widget::class_path(Glib::ustring& path_arg, Glib::ustring& path_reversed)
+{
+  guint path_length = 0;
+  Glib::ScopedPtr<gchar> path_ptr;
+  Glib::ScopedPtr<gchar> rpath_ptr;
+
+  gtk_widget_class_path(gobj(), &path_length, path_ptr.addr(), rpath_ptr.addr());
+
+  path_arg.assign(path_ptr.get(), path_ptr.get() + path_length);
+  path_reversed.assign(rpath_ptr.get(), rpath_ptr.get() + path_length);
+}
+
+void Widget::modify_bg_pixmap(StateType state, const Glib::ustring& pixmap_name)
+{
+  const Glib::RefPtr<RcStyle> modifier_style = get_modifier_style();
+  modifier_style->set_bg_pixmap_name(state, pixmap_name);
+  modify_style(modifier_style);
+}
+
+void Widget::unset_fg(StateType state)
+{
+  gtk_widget_modify_fg(gobj(), static_cast<GtkStateType>(int(state)), 0);
+}
+
+void Widget::unset_bg(StateType state)
+{
+  gtk_widget_modify_bg(gobj(), static_cast<GtkStateType>(int(state)), 0);
+}
+
+void Widget::unset_text(StateType state)
+{
+  gtk_widget_modify_text(gobj(), static_cast<GtkStateType>(int(state)), 0);
+}
+
+void Widget::unset_base(StateType state)
+{
+  gtk_widget_modify_base(gobj(), static_cast<GtkStateType>(int(state)), 0);
+}
+
+void Widget::unset_font()
+{
+  gtk_widget_modify_font(gobj(), 0);
+}
+
+bool Widget::is_toplevel() const
+  { return GTK_WIDGET_TOPLEVEL(gobj()); }
+
+bool Widget::has_no_window() const
+  { return GTK_WIDGET_NO_WINDOW(gobj()); }
+
+bool Widget::is_realized() const
+  { return GTK_WIDGET_REALIZED(gobj()); }
+
+bool Widget::is_mapped() const
+  { return GTK_WIDGET_MAPPED(gobj()); }
+
+bool Widget::is_visible() const
+  { return GTK_WIDGET_VISIBLE(gobj()); }
+
+bool Widget::is_drawable() const
+  { return GTK_WIDGET_DRAWABLE(gobj()); }
+
+bool Widget::sensitive() const
+  { return GTK_WIDGET_SENSITIVE(gobj()); }
+
+bool Widget::parent_sensitive() const
+  { return GTK_WIDGET_PARENT_SENSITIVE(gobj()); }
+
+bool Widget::is_sensitive() const
+  { return GTK_WIDGET_IS_SENSITIVE(gobj()); }
+
+bool Widget::can_focus() const
+  { return GTK_WIDGET_CAN_FOCUS(gobj()); }
+
+bool Widget::has_focus() const
+  { return GTK_WIDGET_HAS_FOCUS(gobj()); }
+
+bool Widget::can_default() const
+  { return GTK_WIDGET_CAN_DEFAULT(gobj()); }
+
+bool Widget::has_default() const
+  { return GTK_WIDGET_HAS_DEFAULT(gobj()); }
+
+bool Widget::has_grab() const
+  { return GTK_WIDGET_HAS_GRAB(gobj()); }
+
+bool Widget::rc_style() const
+  { return GTK_WIDGET_RC_STYLE(gobj()); }
+
+bool Widget::is_composite_child() const
+  { return GTK_WIDGET_COMPOSITE_CHILD(gobj()); }
+
+bool Widget::app_paintable() const
+  { return GTK_WIDGET_APP_PAINTABLE(gobj()); }
+
+bool Widget::receives_default() const
+  { return GTK_WIDGET_RECEIVES_DEFAULT(gobj()); }
+
+bool Widget::double_buffered() const
+  { return GTK_WIDGET_DOUBLE_BUFFERED(gobj()); }
+
+WidgetFlags Widget::get_flags() const
+  { return static_cast<WidgetFlags>(GTK_WIDGET_FLAGS(gobj())); }
+
+void Widget::set_flags(WidgetFlags flags)
+  { GTK_WIDGET_SET_FLAGS(gobj(), static_cast<guint32>(flags)); }
+
+void Widget::unset_flags(WidgetFlags flags)
+  { GTK_WIDGET_UNSET_FLAGS(gobj(), static_cast<guint32>(flags)); }
+
+int Widget::get_width() const
+  { return gobj()->allocation.width; }
+
+int Widget::get_height() const
+  { return gobj()->allocation.height; }
+
+
+void Widget::drag_dest_set(DestDefaults flags, Gdk::DragAction actions)
+{
+  gtk_drag_dest_set(gobj(), (GtkDestDefaults)flags, 0, 0, (GdkDragAction)actions);
+}
+
+void Widget::drag_dest_set(const ArrayHandle_TargetEntry& targets,
+                           DestDefaults flags, Gdk::DragAction actions)
+{
+  // I've used Gdk::ACTION_COPY as the default, because Gdk::ACTION_DEFAULT means that
+  // it's never a drag destination, so it would seem like this method didn't work. murrayc.
+  gtk_drag_dest_set(
+      gobj(), (GtkDestDefaults)flags,
+      targets.data(), targets.size(), (GdkDragAction)actions);
+}
+
+void Widget::drag_source_set(const ArrayHandle_TargetEntry& targets,
+                             Gdk::ModifierType start_button_mask, Gdk::DragAction actions)
+{
+  // I've used Gdk::MODIFIER_MASK as the default, because it seems
+  // to mean 'whatever is possible in the context'. murrayc.
+  gtk_drag_source_set(
+      gobj(), (GdkModifierType)start_button_mask,
+      targets.data(), targets.size(), (GdkDragAction)actions);
+}
+
+Widget* Widget::drag_get_source_widget(const Glib::RefPtr<Gdk::DragContext>& context) //static
+{
+  return Glib::wrap( gtk_drag_get_source_widget(Glib::unwrap(context)) );
+}
+
+void Widget::drag_set_as_icon(const Glib::RefPtr<Gdk::DragContext>& context, int hot_x, int hot_y)
+{
+  gtk_drag_set_icon_widget(Glib::unwrap(context), gobj(), hot_x, hot_y);
+}
+
+void Widget_Class::hierarchy_changed_callback_custom(GtkWidget* self, GtkWidget* p0)
+{
+  //GTKMM_LIFECYCLE
+  //Don't call wrap() on a GTK+ instance whose gtkmm instance has been deleted - just call the original C callback.
+  bool gtkmm_child_already_deleted = Glib::_gobject_cppinstance_already_deleted((GObject*)p0);
+
+  if(!gtkmm_child_already_deleted)
+  {
+    //Call the regular, generated callback:
+    Widget_Class::hierarchy_changed_callback(self, p0);
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    //Call the original underlying C function:
+    if(base && base->hierarchy_changed)
+      (*base->hierarchy_changed)(self, p0);
+  }
+}
+
+void Widget_Class::parent_set_callback_custom(GtkWidget* self, GtkWidget* p0)
+{
+  //GTKMM_LIFECYCLE
+  //Don't call wrap() on a GTK+ instance whose gtkmm instance has been deleted - just call the original C callback.
+  bool gtkmm_p0_already_deleted = Glib::_gobject_cppinstance_already_deleted((GObject*)p0);
+
+  if(!gtkmm_p0_already_deleted)
+  {
+    //Call the regular, generated callback:
+    Widget_Class::parent_set_callback(self, p0);
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    //Call the original underlying C function:
+    if(base && base->parent_set)
+      (*base->parent_set)(self, p0);
+  }
+}
+
+void Widget_Class::dispose_vfunc_callback(GObject* self)
+{
+  //Avoid disposal. See also Window_Class::dispose_vfunc_callback().
+
+  #ifdef GLIBMM_DEBUG_REFCOUNTING
+  g_warning("Widget_Class::dispose_vfunc_callback(): gobject_: %p\n", (void*)self);
+  //if(self)
+   //g_warning("  gtypename: %s\n", G_OBJECT_TYPE_NAME(self));
+  #endif
+  
+  Widget *const obj = dynamic_cast<Widget*>(
+      Glib::ObjectBase::_get_current_wrapper(self));
+
+  // This function might be invoked recursively because we're triggering
+  // several signal emissions, particularly signal_hide().  Therefore we
+  // have to test for cpp_destruction_in_progress_ at this point.
+
+  if(obj && !obj->_cpp_destruction_is_in_progress()) //When it should really be destroyed, we zero gobj_.
+  { 
+    GtkWidget *const pWidget = obj->gobj();
+    g_return_if_fail(pWidget == GTK_WIDGET(self));
+
+    // Abort dispose if the widget isn't managed, in order to prevent
+    // the nasty self-destroying behaviour of GTK+.  This applies to
+    // any widget inside a GtkContainer on gtk_container_destroy()
+    // See also Window_Class::dispose_vfunc_callback().
+  
+    if(obj->referenced_) //Not managed
+    { 
+      // GTKMM_LIFECYCLE
+      // Remove the widget from its parent container so that it
+      // won't be destroyed later by gtk_container_destroy().
+      if(pWidget->parent)
+      {
+        // Normally, we would have to ref the child widget because
+        // gtk_container_remove() unrefs it.  But since we only remove
+        // non-managed objects here, the container just releases the
+        // reference it has acquired before in gtk_container_add().
+
+        #ifdef GLIBMM_DEBUG_REFCOUNTING
+        g_warning("Widget_Class::dispose_vfunc_callback(): removing gobject_: %p from parent: %p", (void*)self, (void*)pWidget->parent);
+        #endif
+  
+        gtk_container_remove(GTK_CONTAINER(pWidget->parent), pWidget);
+
+        #ifdef GLIBMM_DEBUG_REFCOUNTING
+        g_warning("Widget_Class::dispose_vfunc_callback(): after removing from parent.");
+        #endif
+      }
+
+      #ifdef GLIBMM_DEBUG_REFCOUNTING
+      g_warning("Widget_Class::dispose_vfunc_callback(): before gtk_widget_hide().");
+      #endif
+        
+      // Now hide the widget.  The C++ object must _not_ be accessed anymore
+      // after this call, because a signal_hide() handler might delete it.
+      gtk_widget_hide(pWidget);
+
+      #ifdef GLIBMM_DEBUG_REFCOUNTING
+      g_warning("Widget_Class::dispose_vfunc_callback(): after gtk_widget_hide().");
+      #endif
+      
+      // GTKMM_LIFECYCLE
+      return; // Prevent calling of normal C dispose vfunc (see below)
+    }
+
+    #ifdef GLIBMM_DEBUG_REFCOUNTING
+    g_warning("Widget_Class::dispose_vfunc_callback(): unreferenced: before gtk_widget_hide().");
+    #endif
+    
+    // Always hide widgets on gtk_object_destroy(), regardless of whether
+    // the widget is managed or not.  This is done for consistency so that
+    // connecting to signal_hide() is guaranteed to work.
+    gtk_widget_hide(pWidget);
+
+    #ifdef GLIBMM_DEBUG_REFCOUNTING
+    g_warning("Widget_Class::dispose_vfunc_callback(): unreferenced:  after gtk_widget_hide().");
+    #endif
+  }
+
+  GObjectClass *const base = static_cast<GObjectClass*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)));
+
+  #ifdef GLIBMM_DEBUG_REFCOUNTING
+  g_warning("Widget_Class::dispose_vfunc_callback(): before calling base->dispose.");
+  #endif
+        
+  if(base->dispose)
+    (*base->dispose)(self);
+
+  #ifdef GLIBMM_DEBUG_REFCOUNTING
+  g_warning("Widget_Class::dispose_vfunc_callback(): after calling base->dispose.");
+  #endif
+}
+
+
+void Widget::unset_style()
+{
+  gtk_widget_set_style(gobj(), 0 /* See GTK+ docs */);
+}
+
+Glib::ustring Widget::drag_dest_find_target(const Glib::RefPtr<Gdk::DragContext>& context) const
+{
+  return Gdk::AtomString::to_cpp_type(gtk_drag_dest_find_target(const_cast<GtkWidget*>(gobj()), Glib::unwrap(context), 0 /* See GTK+ docs */));
+}
+
+void Widget::unset_shape_combine_mask()
+{            
+  gtk_widget_shape_combine_mask(gobj(), 0, 0, 0); /* See GTK+ docs */
+}
+
+void Widget::draw_insertion_cursor(Glib::RefPtr<Gdk::Drawable> drawable, const Gdk::Rectangle& area, const Gdk::Rectangle& location, bool is_primary, TextDirection direction, bool draw_arrow)
+{
+  gtk_draw_insertion_cursor(gobj(), drawable->gobj(), const_cast<GdkRectangle*>(area.gobj()), const_cast<GdkRectangle*>(location.gobj()), is_primary, (GtkTextDirection)direction, draw_arrow);
+}
+
+Requisition Widget::size_request() const
+{
+  Requisition requisition;
+  gtk_widget_size_request(const_cast<GtkWidget*>(gobj()), (GtkRequisition*)(&requisition));
+  return requisition;
+}
+
+
+} // namespace Gtk
+
+
+namespace
+{
+
+const Glib::SignalProxyInfo Widget_signal_show_info =
+{
+  "show",
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
+};
+
+
+const Glib::SignalProxyInfo Widget_signal_hide_info =
+{
+  "hide",
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
+};
+
+
+const Glib::SignalProxyInfo Widget_signal_map_info =
+{
+  "map",
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
+};
+
+
+const Glib::SignalProxyInfo Widget_signal_unmap_info =
+{
+  "unmap",
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
+};
+
+
+const Glib::SignalProxyInfo Widget_signal_realize_info =
+{
+  "realize",
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
+};
+
+
+const Glib::SignalProxyInfo Widget_signal_unrealize_info =
+{
+  "unrealize",
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
+};
+
+
+void Widget_signal_size_request_callback(GtkWidget* self, GtkRequisition* p0,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,Requisition* > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))((Requisition*)(p0)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+}
+
+const Glib::SignalProxyInfo Widget_signal_size_request_info =
+{
+  "size_request",
+  (GCallback) &Widget_signal_size_request_callback,
+  (GCallback) &Widget_signal_size_request_callback
+};
+
+
+void Widget_signal_size_allocate_callback(GtkWidget* self, GtkAllocation* p0,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,Allocation& > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))((Allocation&)(Glib::wrap(p0))
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+}
+
+const Glib::SignalProxyInfo Widget_signal_size_allocate_info =
+{
+  "size_allocate",
+  (GCallback) &Widget_signal_size_allocate_callback,
+  (GCallback) &Widget_signal_size_allocate_callback
+};
+
+
+void Widget_signal_state_changed_callback(GtkWidget* self, GtkStateType p0,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,Gtk::StateType > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(((Gtk::StateType)(p0))
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+}
+
+const Glib::SignalProxyInfo Widget_signal_state_changed_info =
+{
+  "state_changed",
+  (GCallback) &Widget_signal_state_changed_callback,
+  (GCallback) &Widget_signal_state_changed_callback
+};
+
+
+void Widget_signal_parent_changed_callback(GtkWidget* self, GtkWidget* p0,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,Widget* > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(Glib::wrap(p0)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+}
+
+const Glib::SignalProxyInfo Widget_signal_parent_changed_info =
+{
+  "parent_set",
+  (GCallback) &Widget_signal_parent_changed_callback,
+  (GCallback) &Widget_signal_parent_changed_callback
+};
+
+
+void Widget_signal_hierarchy_changed_callback(GtkWidget* self, GtkWidget* p0,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,Widget* > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(Glib::wrap(p0)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+}
+
+const Glib::SignalProxyInfo Widget_signal_hierarchy_changed_info =
+{
+  "hierarchy_changed",
+  (GCallback) &Widget_signal_hierarchy_changed_callback,
+  (GCallback) &Widget_signal_hierarchy_changed_callback
+};
+
+
+void Widget_signal_style_changed_callback(GtkWidget* self, GtkStyle* p0,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,const Glib::RefPtr<Style>& > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(Glib::wrap(p0, true)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+}
+
+const Glib::SignalProxyInfo Widget_signal_style_changed_info =
+{
+  "style_set",
+  (GCallback) &Widget_signal_style_changed_callback,
+  (GCallback) &Widget_signal_style_changed_callback
+};
+
+
+void Widget_signal_direction_changed_callback(GtkWidget* self, GtkTextDirection p0,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,TextDirection > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(((TextDirection)(p0))
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+}
+
+const Glib::SignalProxyInfo Widget_signal_direction_changed_info =
+{
+  "direction_changed",
+  (GCallback) &Widget_signal_direction_changed_callback,
+  (GCallback) &Widget_signal_direction_changed_callback
+};
+
+
+void Widget_signal_grab_notify_callback(GtkWidget* self, gboolean p0,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,bool > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(p0
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+}
+
+const Glib::SignalProxyInfo Widget_signal_grab_notify_info =
+{
+  "grab_notify",
+  (GCallback) &Widget_signal_grab_notify_callback,
+  (GCallback) &Widget_signal_grab_notify_callback
+};
+
+
+void Widget_signal_child_notify_callback(GtkWidget* self, GParamSpec* p0,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,GParamSpec* > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(p0);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+}
+
+const Glib::SignalProxyInfo Widget_signal_child_notify_info =
+{
+  "child_notify",
+  (GCallback) &Widget_signal_child_notify_callback,
+  (GCallback) &Widget_signal_child_notify_callback
+};
+
+
+gboolean Widget_signal_mnemonic_activate_callback(GtkWidget* self, gboolean p0,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< bool,bool > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        return static_cast<int>((*static_cast<SlotType*>(slot))(p0
+));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+gboolean Widget_signal_mnemonic_activate_notify_callback(GtkWidget* self, gboolean p0, void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,bool > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(p0
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+const Glib::SignalProxyInfo Widget_signal_mnemonic_activate_info =
+{
+  "mnemonic_activate",
+  (GCallback) &Widget_signal_mnemonic_activate_callback,
+  (GCallback) &Widget_signal_mnemonic_activate_notify_callback
+};
+
+
+const Glib::SignalProxyInfo Widget_signal_grab_focus_info =
+{
+  "grab_focus",
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
+  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
+};
+
+
+gboolean Widget_signal_focus_callback(GtkWidget* self, GtkDirectionType p0,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< bool,DirectionType > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        return static_cast<int>((*static_cast<SlotType*>(slot))(((DirectionType)(p0))
+));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+gboolean Widget_signal_focus_notify_callback(GtkWidget* self, GtkDirectionType p0, void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,DirectionType > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(((DirectionType)(p0))
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+const Glib::SignalProxyInfo Widget_signal_focus_info =
+{
+  "focus",
+  (GCallback) &Widget_signal_focus_callback,
+  (GCallback) &Widget_signal_focus_notify_callback
+};
+
+
+gboolean Widget_signal_event_callback(GtkWidget* self, GdkEvent* p0,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< bool,GdkEvent* > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        return static_cast<int>((*static_cast<SlotType*>(slot))(p0));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+gboolean Widget_signal_event_notify_callback(GtkWidget* self, GdkEvent* p0, void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,GdkEvent* > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(p0);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+const Glib::SignalProxyInfo Widget_signal_event_info =
+{
+  "event",
+  (GCallback) &Widget_signal_event_callback,
+  (GCallback) &Widget_signal_event_notify_callback
+};
+
+
+void Widget_signal_event_after_callback(GtkWidget* self, GdkEvent* p0,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,GdkEvent* > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(p0);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+}
+
+const Glib::SignalProxyInfo Widget_signal_event_after_info =
+{
+  "event_after",
+  (GCallback) &Widget_signal_event_after_callback,
+  (GCallback) &Widget_signal_event_after_callback
+};
+
+
+gboolean Widget_signal_button_press_event_callback(GtkWidget* self, GdkEventButton* p0,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< bool,GdkEventButton* > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        return static_cast<int>((*static_cast<SlotType*>(slot))(p0));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+gboolean Widget_signal_button_press_event_notify_callback(GtkWidget* self, GdkEventButton* p0, void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,GdkEventButton* > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(p0);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+const Glib::SignalProxyInfo Widget_signal_button_press_event_info =
+{
+  "button_press_event",
+  (GCallback) &Widget_signal_button_press_event_callback,
+  (GCallback) &Widget_signal_button_press_event_notify_callback
+};
+
+
+gboolean Widget_signal_button_release_event_callback(GtkWidget* self, GdkEventButton* p0,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< bool,GdkEventButton* > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        return static_cast<int>((*static_cast<SlotType*>(slot))(p0));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+gboolean Widget_signal_button_release_event_notify_callback(GtkWidget* self, GdkEventButton* p0, void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,GdkEventButton* > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(p0);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+const Glib::SignalProxyInfo Widget_signal_button_release_event_info =
+{
+  "button_release_event",
+  (GCallback) &Widget_signal_button_release_event_callback,
+  (GCallback) &Widget_signal_button_release_event_notify_callback
+};
+
+
+gboolean Widget_signal_scroll_event_callback(GtkWidget* self, GdkEventScroll* p0,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< bool,GdkEventScroll* > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        return static_cast<int>((*static_cast<SlotType*>(slot))(p0));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+gboolean Widget_signal_scroll_event_notify_callback(GtkWidget* self, GdkEventScroll* p0, void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,GdkEventScroll* > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(p0);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+const Glib::SignalProxyInfo Widget_signal_scroll_event_info =
+{
+  "scroll_event",
+  (GCallback) &Widget_signal_scroll_event_callback,
+  (GCallback) &Widget_signal_scroll_event_notify_callback
+};
+
+
+gboolean Widget_signal_motion_notify_event_callback(GtkWidget* self, GdkEventMotion* p0,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< bool,GdkEventMotion* > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        return static_cast<int>((*static_cast<SlotType*>(slot))(p0));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+gboolean Widget_signal_motion_notify_event_notify_callback(GtkWidget* self, GdkEventMotion* p0, void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,GdkEventMotion* > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(p0);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+const Glib::SignalProxyInfo Widget_signal_motion_notify_event_info =
+{
+  "motion_notify_event",
+  (GCallback) &Widget_signal_motion_notify_event_callback,
+  (GCallback) &Widget_signal_motion_notify_event_notify_callback
+};
+
+
+gboolean Widget_signal_delete_event_callback(GtkWidget* self, GdkEventAny* p0,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< bool,GdkEventAny* > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        return static_cast<int>((*static_cast<SlotType*>(slot))(p0));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+gboolean Widget_signal_delete_event_notify_callback(GtkWidget* self, GdkEventAny* p0, void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,GdkEventAny* > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(p0);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+const Glib::SignalProxyInfo Widget_signal_delete_event_info =
+{
+  "delete_event",
+  (GCallback) &Widget_signal_delete_event_callback,
+  (GCallback) &Widget_signal_delete_event_notify_callback
+};
+
+
+gboolean Widget_signal_expose_event_callback(GtkWidget* self, GdkEventExpose* p0,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< bool,GdkEventExpose* > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        return static_cast<int>((*static_cast<SlotType*>(slot))(p0));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+gboolean Widget_signal_expose_event_notify_callback(GtkWidget* self, GdkEventExpose* p0, void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,GdkEventExpose* > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(p0);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+const Glib::SignalProxyInfo Widget_signal_expose_event_info =
+{
+  "expose_event",
+  (GCallback) &Widget_signal_expose_event_callback,
+  (GCallback) &Widget_signal_expose_event_notify_callback
+};
+
+
+gboolean Widget_signal_key_press_event_callback(GtkWidget* self, GdkEventKey* p0,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< bool,GdkEventKey* > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        return static_cast<int>((*static_cast<SlotType*>(slot))(p0));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+gboolean Widget_signal_key_press_event_notify_callback(GtkWidget* self, GdkEventKey* p0, void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,GdkEventKey* > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(p0);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+const Glib::SignalProxyInfo Widget_signal_key_press_event_info =
+{
+  "key_press_event",
+  (GCallback) &Widget_signal_key_press_event_callback,
+  (GCallback) &Widget_signal_key_press_event_notify_callback
+};
+
+
+gboolean Widget_signal_key_release_event_callback(GtkWidget* self, GdkEventKey* p0,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< bool,GdkEventKey* > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        return static_cast<int>((*static_cast<SlotType*>(slot))(p0));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+gboolean Widget_signal_key_release_event_notify_callback(GtkWidget* self, GdkEventKey* p0, void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,GdkEventKey* > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(p0);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+const Glib::SignalProxyInfo Widget_signal_key_release_event_info =
+{
+  "key_release_event",
+  (GCallback) &Widget_signal_key_release_event_callback,
+  (GCallback) &Widget_signal_key_release_event_notify_callback
+};
+
+
+gboolean Widget_signal_enter_notify_event_callback(GtkWidget* self, GdkEventCrossing* p0,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< bool,GdkEventCrossing* > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        return static_cast<int>((*static_cast<SlotType*>(slot))(p0));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+gboolean Widget_signal_enter_notify_event_notify_callback(GtkWidget* self, GdkEventCrossing* p0, void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,GdkEventCrossing* > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(p0);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+const Glib::SignalProxyInfo Widget_signal_enter_notify_event_info =
+{
+  "enter_notify_event",
+  (GCallback) &Widget_signal_enter_notify_event_callback,
+  (GCallback) &Widget_signal_enter_notify_event_notify_callback
+};
+
+
+gboolean Widget_signal_leave_notify_event_callback(GtkWidget* self, GdkEventCrossing* p0,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< bool,GdkEventCrossing* > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        return static_cast<int>((*static_cast<SlotType*>(slot))(p0));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+gboolean Widget_signal_leave_notify_event_notify_callback(GtkWidget* self, GdkEventCrossing* p0, void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,GdkEventCrossing* > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(p0);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+const Glib::SignalProxyInfo Widget_signal_leave_notify_event_info =
+{
+  "leave_notify_event",
+  (GCallback) &Widget_signal_leave_notify_event_callback,
+  (GCallback) &Widget_signal_leave_notify_event_notify_callback
+};
+
+
+gboolean Widget_signal_configure_event_callback(GtkWidget* self, GdkEventConfigure* p0,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< bool,GdkEventConfigure* > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        return static_cast<int>((*static_cast<SlotType*>(slot))(p0));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+gboolean Widget_signal_configure_event_notify_callback(GtkWidget* self, GdkEventConfigure* p0, void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,GdkEventConfigure* > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(p0);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+const Glib::SignalProxyInfo Widget_signal_configure_event_info =
+{
+  "configure_event",
+  (GCallback) &Widget_signal_configure_event_callback,
+  (GCallback) &Widget_signal_configure_event_notify_callback
+};
+
+
+gboolean Widget_signal_focus_in_event_callback(GtkWidget* self, GdkEventFocus* p0,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< bool,GdkEventFocus* > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        return static_cast<int>((*static_cast<SlotType*>(slot))(p0));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+gboolean Widget_signal_focus_in_event_notify_callback(GtkWidget* self, GdkEventFocus* p0, void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,GdkEventFocus* > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(p0);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+const Glib::SignalProxyInfo Widget_signal_focus_in_event_info =
+{
+  "focus_in_event",
+  (GCallback) &Widget_signal_focus_in_event_callback,
+  (GCallback) &Widget_signal_focus_in_event_notify_callback
+};
+
+
+gboolean Widget_signal_focus_out_event_callback(GtkWidget* self, GdkEventFocus* p0,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< bool,GdkEventFocus* > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        return static_cast<int>((*static_cast<SlotType*>(slot))(p0));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+gboolean Widget_signal_focus_out_event_notify_callback(GtkWidget* self, GdkEventFocus* p0, void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,GdkEventFocus* > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(p0);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+const Glib::SignalProxyInfo Widget_signal_focus_out_event_info =
+{
+  "focus_out_event",
+  (GCallback) &Widget_signal_focus_out_event_callback,
+  (GCallback) &Widget_signal_focus_out_event_notify_callback
+};
+
+
+gboolean Widget_signal_map_event_callback(GtkWidget* self, GdkEventAny* p0,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< bool,GdkEventAny* > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        return static_cast<int>((*static_cast<SlotType*>(slot))(p0));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+gboolean Widget_signal_map_event_notify_callback(GtkWidget* self, GdkEventAny* p0, void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,GdkEventAny* > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(p0);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+const Glib::SignalProxyInfo Widget_signal_map_event_info =
+{
+  "map_event",
+  (GCallback) &Widget_signal_map_event_callback,
+  (GCallback) &Widget_signal_map_event_notify_callback
+};
+
+
+gboolean Widget_signal_unmap_event_callback(GtkWidget* self, GdkEventAny* p0,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< bool,GdkEventAny* > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        return static_cast<int>((*static_cast<SlotType*>(slot))(p0));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+gboolean Widget_signal_unmap_event_notify_callback(GtkWidget* self, GdkEventAny* p0, void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,GdkEventAny* > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(p0);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+const Glib::SignalProxyInfo Widget_signal_unmap_event_info =
+{
+  "unmap_event",
+  (GCallback) &Widget_signal_unmap_event_callback,
+  (GCallback) &Widget_signal_unmap_event_notify_callback
+};
+
+
+gboolean Widget_signal_property_notify_event_callback(GtkWidget* self, GdkEventProperty* p0,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< bool,GdkEventProperty* > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        return static_cast<int>((*static_cast<SlotType*>(slot))(p0));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+gboolean Widget_signal_property_notify_event_notify_callback(GtkWidget* self, GdkEventProperty* p0, void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,GdkEventProperty* > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(p0);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+const Glib::SignalProxyInfo Widget_signal_property_notify_event_info =
+{
+  "property_notify_event",
+  (GCallback) &Widget_signal_property_notify_event_callback,
+  (GCallback) &Widget_signal_property_notify_event_notify_callback
+};
+
+
+gboolean Widget_signal_selection_clear_event_callback(GtkWidget* self, GdkEventSelection* p0,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< bool,GdkEventSelection* > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        return static_cast<int>((*static_cast<SlotType*>(slot))(p0));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+gboolean Widget_signal_selection_clear_event_notify_callback(GtkWidget* self, GdkEventSelection* p0, void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,GdkEventSelection* > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(p0);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+const Glib::SignalProxyInfo Widget_signal_selection_clear_event_info =
+{
+  "selection_clear_event",
+  (GCallback) &Widget_signal_selection_clear_event_callback,
+  (GCallback) &Widget_signal_selection_clear_event_notify_callback
+};
+
+
+gboolean Widget_signal_selection_request_event_callback(GtkWidget* self, GdkEventSelection* p0,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< bool,GdkEventSelection* > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        return static_cast<int>((*static_cast<SlotType*>(slot))(p0));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+gboolean Widget_signal_selection_request_event_notify_callback(GtkWidget* self, GdkEventSelection* p0, void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,GdkEventSelection* > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(p0);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+const Glib::SignalProxyInfo Widget_signal_selection_request_event_info =
+{
+  "selection_request_event",
+  (GCallback) &Widget_signal_selection_request_event_callback,
+  (GCallback) &Widget_signal_selection_request_event_notify_callback
+};
+
+
+gboolean Widget_signal_selection_notify_event_callback(GtkWidget* self, GdkEventSelection* p0,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< bool,GdkEventSelection* > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        return static_cast<int>((*static_cast<SlotType*>(slot))(p0));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+gboolean Widget_signal_selection_notify_event_notify_callback(GtkWidget* self, GdkEventSelection* p0, void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,GdkEventSelection* > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(p0);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+const Glib::SignalProxyInfo Widget_signal_selection_notify_event_info =
+{
+  "selection_notify_event",
+  (GCallback) &Widget_signal_selection_notify_event_callback,
+  (GCallback) &Widget_signal_selection_notify_event_notify_callback
+};
+
+
+gboolean Widget_signal_proximity_in_event_callback(GtkWidget* self, GdkEventProximity* p0,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< bool,GdkEventProximity* > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        return static_cast<int>((*static_cast<SlotType*>(slot))(p0));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+gboolean Widget_signal_proximity_in_event_notify_callback(GtkWidget* self, GdkEventProximity* p0, void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,GdkEventProximity* > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(p0);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+const Glib::SignalProxyInfo Widget_signal_proximity_in_event_info =
+{
+  "proximity_in_event",
+  (GCallback) &Widget_signal_proximity_in_event_callback,
+  (GCallback) &Widget_signal_proximity_in_event_notify_callback
+};
+
+
+gboolean Widget_signal_proximity_out_event_callback(GtkWidget* self, GdkEventProximity* p0,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< bool,GdkEventProximity* > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        return static_cast<int>((*static_cast<SlotType*>(slot))(p0));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+gboolean Widget_signal_proximity_out_event_notify_callback(GtkWidget* self, GdkEventProximity* p0, void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,GdkEventProximity* > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(p0);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+const Glib::SignalProxyInfo Widget_signal_proximity_out_event_info =
+{
+  "proximity_out_event",
+  (GCallback) &Widget_signal_proximity_out_event_callback,
+  (GCallback) &Widget_signal_proximity_out_event_notify_callback
+};
+
+
+gboolean Widget_signal_visibility_notify_event_callback(GtkWidget* self, GdkEventVisibility* p0,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< bool,GdkEventVisibility* > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        return static_cast<int>((*static_cast<SlotType*>(slot))(p0));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+gboolean Widget_signal_visibility_notify_event_notify_callback(GtkWidget* self, GdkEventVisibility* p0, void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,GdkEventVisibility* > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(p0);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+const Glib::SignalProxyInfo Widget_signal_visibility_notify_event_info =
+{
+  "visibility_notify_event",
+  (GCallback) &Widget_signal_visibility_notify_event_callback,
+  (GCallback) &Widget_signal_visibility_notify_event_notify_callback
+};
+
+
+gboolean Widget_signal_client_event_callback(GtkWidget* self, GdkEventClient* p0,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< bool,GdkEventClient* > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        return static_cast<int>((*static_cast<SlotType*>(slot))(p0));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+gboolean Widget_signal_client_event_notify_callback(GtkWidget* self, GdkEventClient* p0, void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,GdkEventClient* > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(p0);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+const Glib::SignalProxyInfo Widget_signal_client_event_info =
+{
+  "client_event",
+  (GCallback) &Widget_signal_client_event_callback,
+  (GCallback) &Widget_signal_client_event_notify_callback
+};
+
+
+gboolean Widget_signal_no_expose_event_callback(GtkWidget* self, GdkEventAny* p0,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< bool,GdkEventAny* > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        return static_cast<int>((*static_cast<SlotType*>(slot))(p0));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+gboolean Widget_signal_no_expose_event_notify_callback(GtkWidget* self, GdkEventAny* p0, void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,GdkEventAny* > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(p0);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+const Glib::SignalProxyInfo Widget_signal_no_expose_event_info =
+{
+  "no_expose_event",
+  (GCallback) &Widget_signal_no_expose_event_callback,
+  (GCallback) &Widget_signal_no_expose_event_notify_callback
+};
+
+
+gboolean Widget_signal_window_state_event_callback(GtkWidget* self, GdkEventWindowState* p0,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< bool,GdkEventWindowState* > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        return static_cast<int>((*static_cast<SlotType*>(slot))(p0));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+gboolean Widget_signal_window_state_event_notify_callback(GtkWidget* self, GdkEventWindowState* p0, void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,GdkEventWindowState* > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(p0);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+const Glib::SignalProxyInfo Widget_signal_window_state_event_info =
+{
+  "window_state_event",
+  (GCallback) &Widget_signal_window_state_event_callback,
+  (GCallback) &Widget_signal_window_state_event_notify_callback
+};
+
+
+const Glib::SignalProxyInfo Widget_signal_selection_get_info =
+{
+  "selection_get",
+  (GCallback) &Widget_signal_selection_get_callback,
+  (GCallback) &Widget_signal_selection_get_callback
+};
+
+
+void Widget_signal_selection_received_callback(GtkWidget* self, GtkSelectionData* p0,guint p1,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,const SelectionData&,guint > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(SelectionData_WithoutOwnership(p0)
+, p1);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+}
+
+const Glib::SignalProxyInfo Widget_signal_selection_received_info =
+{
+  "selection_received",
+  (GCallback) &Widget_signal_selection_received_callback,
+  (GCallback) &Widget_signal_selection_received_callback
+};
+
+
+void Widget_signal_drag_begin_callback(GtkWidget* self, GdkDragContext* p0,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,const Glib::RefPtr<Gdk::DragContext>& > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(Glib::wrap(p0, true)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+}
+
+const Glib::SignalProxyInfo Widget_signal_drag_begin_info =
+{
+  "drag_begin",
+  (GCallback) &Widget_signal_drag_begin_callback,
+  (GCallback) &Widget_signal_drag_begin_callback
+};
+
+
+void Widget_signal_drag_end_callback(GtkWidget* self, GdkDragContext* p0,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,const Glib::RefPtr<Gdk::DragContext>& > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(Glib::wrap(p0, true)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+}
+
+const Glib::SignalProxyInfo Widget_signal_drag_end_info =
+{
+  "drag_end",
+  (GCallback) &Widget_signal_drag_end_callback,
+  (GCallback) &Widget_signal_drag_end_callback
+};
+
+
+const Glib::SignalProxyInfo Widget_signal_drag_data_get_info =
+{
+  "drag_data_get",
+  (GCallback) &Widget_signal_drag_data_get_callback,
+  (GCallback) &Widget_signal_drag_data_get_callback
+};
+
+
+void Widget_signal_drag_data_delete_callback(GtkWidget* self, GdkDragContext* p0,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,const Glib::RefPtr<Gdk::DragContext>& > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(Glib::wrap(p0, true)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+}
+
+const Glib::SignalProxyInfo Widget_signal_drag_data_delete_info =
+{
+  "drag_data_delete",
+  (GCallback) &Widget_signal_drag_data_delete_callback,
+  (GCallback) &Widget_signal_drag_data_delete_callback
+};
+
+
+void Widget_signal_drag_leave_callback(GtkWidget* self, GdkDragContext* p0,guint p1,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,const Glib::RefPtr<Gdk::DragContext>&,guint > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(Glib::wrap(p0, true)
+, p1);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+}
+
+const Glib::SignalProxyInfo Widget_signal_drag_leave_info =
+{
+  "drag_leave",
+  (GCallback) &Widget_signal_drag_leave_callback,
+  (GCallback) &Widget_signal_drag_leave_callback
+};
+
+
+gboolean Widget_signal_drag_motion_callback(GtkWidget* self, GdkDragContext* p0,gint p1,gint p2,guint p3,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< bool,const Glib::RefPtr<Gdk::DragContext>&,int,int,guint > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        return static_cast<int>((*static_cast<SlotType*>(slot))(Glib::wrap(p0, true)
+, p1
+, p2
+, p3));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+gboolean Widget_signal_drag_motion_notify_callback(GtkWidget* self, GdkDragContext* p0,gint p1,gint p2,guint p3, void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,const Glib::RefPtr<Gdk::DragContext>&,int,int,guint > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(Glib::wrap(p0, true)
+, p1
+, p2
+, p3);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+const Glib::SignalProxyInfo Widget_signal_drag_motion_info =
+{
+  "drag_motion",
+  (GCallback) &Widget_signal_drag_motion_callback,
+  (GCallback) &Widget_signal_drag_motion_notify_callback
+};
+
+
+gboolean Widget_signal_drag_drop_callback(GtkWidget* self, GdkDragContext* p0,gint p1,gint p2,guint p3,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< bool,const Glib::RefPtr<Gdk::DragContext>&,int,int,guint > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        return static_cast<int>((*static_cast<SlotType*>(slot))(Glib::wrap(p0, true)
+, p1
+, p2
+, p3));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+gboolean Widget_signal_drag_drop_notify_callback(GtkWidget* self, GdkDragContext* p0,gint p1,gint p2,guint p3, void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,const Glib::RefPtr<Gdk::DragContext>&,int,int,guint > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(Glib::wrap(p0, true)
+, p1
+, p2
+, p3);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+const Glib::SignalProxyInfo Widget_signal_drag_drop_info =
+{
+  "drag_drop",
+  (GCallback) &Widget_signal_drag_drop_callback,
+  (GCallback) &Widget_signal_drag_drop_notify_callback
+};
+
+
+void Widget_signal_drag_data_received_callback(GtkWidget* self, GdkDragContext* p0,gint p1,gint p2,GtkSelectionData* p3,guint p4,guint p5,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,const Glib::RefPtr<Gdk::DragContext>&,int,int,const SelectionData&,guint,guint > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(Glib::wrap(p0, true)
+, p1
+, p2
+, SelectionData_WithoutOwnership(p3)
+, p4, p5);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+}
+
+const Glib::SignalProxyInfo Widget_signal_drag_data_received_info =
+{
+  "drag_data_received",
+  (GCallback) &Widget_signal_drag_data_received_callback,
+  (GCallback) &Widget_signal_drag_data_received_callback
+};
+
+
+AtkObject* Widget_signal_get_accessible_callback(GtkWidget* self, void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< Glib::RefPtr<Atk::Object> > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        return Glib::unwrap((*static_cast<SlotType*>(slot))());
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+
+  typedef AtkObject* RType;
+  return RType();
+}
+
+AtkObject* Widget_signal_get_accessible_notify_callback(GtkWidget* self,  void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+
+  typedef AtkObject* RType;
+  return RType();
+}
+
+const Glib::SignalProxyInfo Widget_signal_get_accessible_info =
+{
+  "get_accessible",
+  (GCallback) &Widget_signal_get_accessible_callback,
+  (GCallback) &Widget_signal_get_accessible_notify_callback
+};
+
+
+void Widget_signal_screen_changed_callback(GtkWidget* self, GdkScreen* p0,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,const Glib::RefPtr<Gdk::Screen>& > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(Glib::wrap(p0, true)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+}
+
+const Glib::SignalProxyInfo Widget_signal_screen_changed_info =
+{
+  "screen_changed",
+  (GCallback) &Widget_signal_screen_changed_callback,
+  (GCallback) &Widget_signal_screen_changed_callback
+};
+
+} // anonymous namespace
+
+// static
+GType Glib::Value<Gtk::DestDefaults>::value_type()
+{
+  return gtk_dest_defaults_get_type();
+}
+
+// static
+GType Glib::Value<Gtk::WidgetFlags>::value_type()
+{
+  return gtk_widget_flags_get_type();
+}
+
+// static
+GType Glib::Value<Gtk::WidgetHelpType>::value_type()
+{
+  return gtk_widget_help_type_get_type();
+}
+
+
+namespace Glib
+{
+
+Gtk::Widget* wrap(GtkWidget* object, bool take_copy)
+{
+  return dynamic_cast<Gtk::Widget *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& Widget_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &Widget_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_widget_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  Atk::Implementor::add_interface(get_type());
+  }
+
+  return *this;
+}
+
+void Widget_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+    reinterpret_cast<GObjectClass*>(klass)->dispose = &dispose_vfunc_callback;
+    klass->dispatch_child_properties_changed = &dispatch_child_properties_changed_vfunc_callback;
+  klass->show_all = &show_all_vfunc_callback;
+  klass->hide_all = &hide_all_vfunc_callback;
+  klass->get_accessible = &get_accessible_vfunc_callback;
+  klass->show = &show_callback;
+  klass->hide = &hide_callback;
+  klass->map = &map_callback;
+  klass->unmap = &unmap_callback;
+  klass->realize = &realize_callback;
+  klass->unrealize = &unrealize_callback;
+  klass->size_request = &size_request_callback;
+  klass->size_allocate = &size_allocate_callback;
+  klass->state_changed = &state_changed_callback;
+  klass->parent_set = &parent_set_callback;
+  klass->hierarchy_changed = &hierarchy_changed_callback;
+  klass->style_set = &style_set_callback;
+  klass->direction_changed = &direction_changed_callback;
+  klass->grab_notify = &grab_notify_callback;
+  klass->child_notify = &child_notify_callback;
+  klass->mnemonic_activate = &mnemonic_activate_callback;
+  klass->grab_focus = &grab_focus_callback;
+  klass->focus = &focus_callback;
+  klass->event = &event_callback;
+  klass->button_press_event = &button_press_event_callback;
+  klass->button_release_event = &button_release_event_callback;
+  klass->scroll_event = &scroll_event_callback;
+  klass->motion_notify_event = &motion_notify_event_callback;
+  klass->delete_event = &delete_event_callback;
+  klass->expose_event = &expose_event_callback;
+  klass->key_press_event = &key_press_event_callback;
+  klass->key_release_event = &key_release_event_callback;
+  klass->enter_notify_event = &enter_notify_event_callback;
+  klass->leave_notify_event = &leave_notify_event_callback;
+  klass->configure_event = &configure_event_callback;
+  klass->focus_in_event = &focus_in_event_callback;
+  klass->focus_out_event = &focus_out_event_callback;
+  klass->map_event = &map_event_callback;
+  klass->unmap_event = &unmap_event_callback;
+  klass->property_notify_event = &property_notify_event_callback;
+  klass->selection_clear_event = &selection_clear_event_callback;
+  klass->selection_request_event = &selection_request_event_callback;
+  klass->selection_notify_event = &selection_notify_event_callback;
+  klass->proximity_in_event = &proximity_in_event_callback;
+  klass->proximity_out_event = &proximity_out_event_callback;
+  klass->visibility_notify_event = &visibility_notify_event_callback;
+  klass->client_event = &client_event_callback;
+  klass->no_expose_event = &no_expose_event_callback;
+  klass->window_state_event = &window_state_event_callback;
+  klass->selection_get = &selection_get_callback;
+  klass->selection_received = &selection_received_callback;
+  klass->drag_begin = &drag_begin_callback;
+  klass->drag_end = &drag_end_callback;
+  klass->drag_data_get = &drag_data_get_callback;
+  klass->drag_data_delete = &drag_data_delete_callback;
+  klass->drag_leave = &drag_leave_callback;
+  klass->drag_motion = &drag_motion_callback;
+  klass->drag_drop = &drag_drop_callback;
+  klass->drag_data_received = &drag_data_received_callback;
+  klass->get_accessible = &get_accessible_callback;
+  klass->screen_changed = &screen_changed_callback;
+    klass->hierarchy_changed = &hierarchy_changed_callback_custom;
+      klass->parent_set = &parent_set_callback_custom;
+  }
+
+void Widget_Class::dispatch_child_properties_changed_vfunc_callback(GtkWidget* self, guint n_pspecs, GParamSpec** pspecs)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->dispatch_child_properties_changed_vfunc(n_pspecs, pspecs);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->dispatch_child_properties_changed)
+      (*base->dispatch_child_properties_changed)(self, n_pspecs, pspecs);
+  }
+}
+
+void Widget_Class::show_all_vfunc_callback(GtkWidget* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->show_all_vfunc();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->show_all)
+      (*base->show_all)(self);
+  }
+}
+
+void Widget_Class::hide_all_vfunc_callback(GtkWidget* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->hide_all_vfunc();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->hide_all)
+      (*base->hide_all)(self);
+  }
+}
+
+AtkObject* Widget_Class::get_accessible_vfunc_callback(GtkWidget* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return Glib::unwrap(obj->get_accessible_vfunc());
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->get_accessible)
+      return (*base->get_accessible)(self);
+  }
+
+  typedef AtkObject* RType;
+  return RType();
+}
+
+
+void Widget_Class::show_callback(GtkWidget* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_show();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->show)
+      (*base->show)(self);
+  }
+}
+
+void Widget_Class::hide_callback(GtkWidget* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_hide();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->hide)
+      (*base->hide)(self);
+  }
+}
+
+void Widget_Class::map_callback(GtkWidget* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_map();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->map)
+      (*base->map)(self);
+  }
+}
+
+void Widget_Class::unmap_callback(GtkWidget* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_unmap();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->unmap)
+      (*base->unmap)(self);
+  }
+}
+
+void Widget_Class::realize_callback(GtkWidget* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_realize();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->realize)
+      (*base->realize)(self);
+  }
+}
+
+void Widget_Class::unrealize_callback(GtkWidget* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_unrealize();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->unrealize)
+      (*base->unrealize)(self);
+  }
+}
+
+void Widget_Class::size_request_callback(GtkWidget* self, GtkRequisition* p0)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_size_request((Requisition*)(p0)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->size_request)
+      (*base->size_request)(self, p0);
+  }
+}
+
+void Widget_Class::size_allocate_callback(GtkWidget* self, GtkAllocation* p0)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_size_allocate((Allocation&)(Glib::wrap(p0))
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->size_allocate)
+      (*base->size_allocate)(self, p0);
+  }
+}
+
+void Widget_Class::state_changed_callback(GtkWidget* self, GtkStateType p0)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_state_changed(((Gtk::StateType)(p0))
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->state_changed)
+      (*base->state_changed)(self, p0);
+  }
+}
+
+void Widget_Class::parent_set_callback(GtkWidget* self, GtkWidget* p0)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_parent_changed(Glib::wrap(p0)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->parent_set)
+      (*base->parent_set)(self, p0);
+  }
+}
+
+void Widget_Class::hierarchy_changed_callback(GtkWidget* self, GtkWidget* p0)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_hierarchy_changed(Glib::wrap(p0)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->hierarchy_changed)
+      (*base->hierarchy_changed)(self, p0);
+  }
+}
+
+void Widget_Class::style_set_callback(GtkWidget* self, GtkStyle* p0)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_style_changed(Glib::wrap(p0, true)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->style_set)
+      (*base->style_set)(self, p0);
+  }
+}
+
+void Widget_Class::direction_changed_callback(GtkWidget* self, GtkTextDirection p0)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_direction_changed(((TextDirection)(p0))
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->direction_changed)
+      (*base->direction_changed)(self, p0);
+  }
+}
+
+void Widget_Class::grab_notify_callback(GtkWidget* self, gboolean p0)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_grab_notify(p0
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->grab_notify)
+      (*base->grab_notify)(self, p0);
+  }
+}
+
+void Widget_Class::child_notify_callback(GtkWidget* self, GParamSpec* p0)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_child_notify(p0);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->child_notify)
+      (*base->child_notify)(self, p0);
+  }
+}
+
+gboolean Widget_Class::mnemonic_activate_callback(GtkWidget* self, gboolean p0)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return static_cast<int>(obj->on_mnemonic_activate(p0
+));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->mnemonic_activate)
+      return (*base->mnemonic_activate)(self, p0);
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+void Widget_Class::grab_focus_callback(GtkWidget* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_grab_focus();
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->grab_focus)
+      (*base->grab_focus)(self);
+  }
+}
+
+gboolean Widget_Class::focus_callback(GtkWidget* self, GtkDirectionType p0)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return static_cast<int>(obj->on_focus(((DirectionType)(p0))
+));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->focus)
+      return (*base->focus)(self, p0);
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+gboolean Widget_Class::event_callback(GtkWidget* self, GdkEvent* p0)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return static_cast<int>(obj->on_event(p0));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->event)
+      return (*base->event)(self, p0);
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+gboolean Widget_Class::button_press_event_callback(GtkWidget* self, GdkEventButton* p0)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return static_cast<int>(obj->on_button_press_event(p0));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->button_press_event)
+      return (*base->button_press_event)(self, p0);
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+gboolean Widget_Class::button_release_event_callback(GtkWidget* self, GdkEventButton* p0)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return static_cast<int>(obj->on_button_release_event(p0));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->button_release_event)
+      return (*base->button_release_event)(self, p0);
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+gboolean Widget_Class::scroll_event_callback(GtkWidget* self, GdkEventScroll* p0)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return static_cast<int>(obj->on_scroll_event(p0));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->scroll_event)
+      return (*base->scroll_event)(self, p0);
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+gboolean Widget_Class::motion_notify_event_callback(GtkWidget* self, GdkEventMotion* p0)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return static_cast<int>(obj->on_motion_notify_event(p0));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->motion_notify_event)
+      return (*base->motion_notify_event)(self, p0);
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+gboolean Widget_Class::delete_event_callback(GtkWidget* self, GdkEventAny* p0)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return static_cast<int>(obj->on_delete_event(p0));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->delete_event)
+      return (*base->delete_event)(self, p0);
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+gboolean Widget_Class::expose_event_callback(GtkWidget* self, GdkEventExpose* p0)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return static_cast<int>(obj->on_expose_event(p0));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->expose_event)
+      return (*base->expose_event)(self, p0);
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+gboolean Widget_Class::key_press_event_callback(GtkWidget* self, GdkEventKey* p0)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return static_cast<int>(obj->on_key_press_event(p0));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->key_press_event)
+      return (*base->key_press_event)(self, p0);
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+gboolean Widget_Class::key_release_event_callback(GtkWidget* self, GdkEventKey* p0)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return static_cast<int>(obj->on_key_release_event(p0));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->key_release_event)
+      return (*base->key_release_event)(self, p0);
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+gboolean Widget_Class::enter_notify_event_callback(GtkWidget* self, GdkEventCrossing* p0)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return static_cast<int>(obj->on_enter_notify_event(p0));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->enter_notify_event)
+      return (*base->enter_notify_event)(self, p0);
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+gboolean Widget_Class::leave_notify_event_callback(GtkWidget* self, GdkEventCrossing* p0)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return static_cast<int>(obj->on_leave_notify_event(p0));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->leave_notify_event)
+      return (*base->leave_notify_event)(self, p0);
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+gboolean Widget_Class::configure_event_callback(GtkWidget* self, GdkEventConfigure* p0)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return static_cast<int>(obj->on_configure_event(p0));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->configure_event)
+      return (*base->configure_event)(self, p0);
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+gboolean Widget_Class::focus_in_event_callback(GtkWidget* self, GdkEventFocus* p0)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return static_cast<int>(obj->on_focus_in_event(p0));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->focus_in_event)
+      return (*base->focus_in_event)(self, p0);
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+gboolean Widget_Class::focus_out_event_callback(GtkWidget* self, GdkEventFocus* p0)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return static_cast<int>(obj->on_focus_out_event(p0));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->focus_out_event)
+      return (*base->focus_out_event)(self, p0);
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+gboolean Widget_Class::map_event_callback(GtkWidget* self, GdkEventAny* p0)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return static_cast<int>(obj->on_map_event(p0));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->map_event)
+      return (*base->map_event)(self, p0);
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+gboolean Widget_Class::unmap_event_callback(GtkWidget* self, GdkEventAny* p0)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return static_cast<int>(obj->on_unmap_event(p0));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->unmap_event)
+      return (*base->unmap_event)(self, p0);
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+gboolean Widget_Class::property_notify_event_callback(GtkWidget* self, GdkEventProperty* p0)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return static_cast<int>(obj->on_property_notify_event(p0));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->property_notify_event)
+      return (*base->property_notify_event)(self, p0);
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+gboolean Widget_Class::selection_clear_event_callback(GtkWidget* self, GdkEventSelection* p0)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return static_cast<int>(obj->on_selection_clear_event(p0));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->selection_clear_event)
+      return (*base->selection_clear_event)(self, p0);
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+gboolean Widget_Class::selection_request_event_callback(GtkWidget* self, GdkEventSelection* p0)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return static_cast<int>(obj->on_selection_request_event(p0));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->selection_request_event)
+      return (*base->selection_request_event)(self, p0);
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+gboolean Widget_Class::selection_notify_event_callback(GtkWidget* self, GdkEventSelection* p0)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return static_cast<int>(obj->on_selection_notify_event(p0));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->selection_notify_event)
+      return (*base->selection_notify_event)(self, p0);
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+gboolean Widget_Class::proximity_in_event_callback(GtkWidget* self, GdkEventProximity* p0)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return static_cast<int>(obj->on_proximity_in_event(p0));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->proximity_in_event)
+      return (*base->proximity_in_event)(self, p0);
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+gboolean Widget_Class::proximity_out_event_callback(GtkWidget* self, GdkEventProximity* p0)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return static_cast<int>(obj->on_proximity_out_event(p0));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->proximity_out_event)
+      return (*base->proximity_out_event)(self, p0);
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+gboolean Widget_Class::visibility_notify_event_callback(GtkWidget* self, GdkEventVisibility* p0)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return static_cast<int>(obj->on_visibility_notify_event(p0));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->visibility_notify_event)
+      return (*base->visibility_notify_event)(self, p0);
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+gboolean Widget_Class::client_event_callback(GtkWidget* self, GdkEventClient* p0)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return static_cast<int>(obj->on_client_event(p0));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->client_event)
+      return (*base->client_event)(self, p0);
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+gboolean Widget_Class::no_expose_event_callback(GtkWidget* self, GdkEventAny* p0)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return static_cast<int>(obj->on_no_expose_event(p0));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->no_expose_event)
+      return (*base->no_expose_event)(self, p0);
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+gboolean Widget_Class::window_state_event_callback(GtkWidget* self, GdkEventWindowState* p0)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return static_cast<int>(obj->on_window_state_event(p0));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->window_state_event)
+      return (*base->window_state_event)(self, p0);
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+void Widget_Class::selection_received_callback(GtkWidget* self, GtkSelectionData* p0, guint p1)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_selection_received(SelectionData_WithoutOwnership(p0)
+, p1);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->selection_received)
+      (*base->selection_received)(self, p0, p1);
+  }
+}
+
+void Widget_Class::drag_begin_callback(GtkWidget* self, GdkDragContext* p0)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_drag_begin(Glib::wrap(p0, true)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->drag_begin)
+      (*base->drag_begin)(self, p0);
+  }
+}
+
+void Widget_Class::drag_end_callback(GtkWidget* self, GdkDragContext* p0)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_drag_end(Glib::wrap(p0, true)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->drag_end)
+      (*base->drag_end)(self, p0);
+  }
+}
+
+void Widget_Class::drag_data_delete_callback(GtkWidget* self, GdkDragContext* p0)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_drag_data_delete(Glib::wrap(p0, true)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->drag_data_delete)
+      (*base->drag_data_delete)(self, p0);
+  }
+}
+
+void Widget_Class::drag_leave_callback(GtkWidget* self, GdkDragContext* p0, guint p1)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_drag_leave(Glib::wrap(p0, true)
+, p1);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->drag_leave)
+      (*base->drag_leave)(self, p0, p1);
+  }
+}
+
+gboolean Widget_Class::drag_motion_callback(GtkWidget* self, GdkDragContext* p0, gint p1, gint p2, guint p3)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return static_cast<int>(obj->on_drag_motion(Glib::wrap(p0, true)
+, p1
+, p2
+, p3));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->drag_motion)
+      return (*base->drag_motion)(self, p0, p1, p2, p3);
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+gboolean Widget_Class::drag_drop_callback(GtkWidget* self, GdkDragContext* p0, gint p1, gint p2, guint p3)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return static_cast<int>(obj->on_drag_drop(Glib::wrap(p0, true)
+, p1
+, p2
+, p3));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->drag_drop)
+      return (*base->drag_drop)(self, p0, p1, p2, p3);
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+void Widget_Class::drag_data_received_callback(GtkWidget* self, GdkDragContext* p0, gint p1, gint p2, GtkSelectionData* p3, guint p4, guint p5)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_drag_data_received(Glib::wrap(p0, true)
+, p1
+, p2
+, SelectionData_WithoutOwnership(p3)
+, p4, p5);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->drag_data_received)
+      (*base->drag_data_received)(self, p0, p1, p2, p3, p4, p5);
+  }
+}
+
+AtkObject* Widget_Class::get_accessible_callback(GtkWidget* self)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return Glib::unwrap(obj->on_get_accessible());
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->get_accessible)
+      return (*base->get_accessible)(self);
+  }
+
+  typedef AtkObject* RType;
+  return RType();
+}
+
+void Widget_Class::screen_changed_callback(GtkWidget* self, GdkScreen* p0)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_screen_changed(Glib::wrap(p0, true)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->screen_changed)
+      (*base->screen_changed)(self, p0);
+  }
+}
+
+
+Glib::ObjectBase* Widget_Class::wrap_new(GObject* o)
+{
+  return manage(new Widget((GtkWidget*)(o)));
+
+}
+
+
+/* The implementation: */
+
+Widget::Widget(const Glib::ConstructParams& construct_params)
+:
+  Gtk::Object(construct_params)
+{
+  }
+
+Widget::Widget(GtkWidget* castitem)
+:
+  Gtk::Object((GtkObject*)(castitem))
+{
+  }
+
+Widget::CppClassType Widget::widget_class_; // initialize static member
+
+GType Widget::get_type()
+{
+  return widget_class_.init().get_type();
+}
+
+GType Widget::get_base_type()
+{
+  return gtk_widget_get_type();
+}
+
+
+bool Widget::set_scroll_adjustments(Adjustment& hadjustment, Adjustment& vadjustment)
+{
+  return gtk_widget_set_scroll_adjustments(gobj(), (hadjustment).gobj(), (vadjustment).gobj());
+}
+
+void Widget::show()
+{
+  gtk_widget_show(gobj());
+}
+
+void Widget::show_now()
+{
+  gtk_widget_show_now(gobj());
+}
+
+void Widget::hide()
+{
+  gtk_widget_hide(gobj());
+}
+
+void Widget::show_all()
+{
+  gtk_widget_show_all(gobj());
+}
+
+void Widget::hide_all()
+{
+  gtk_widget_hide_all(gobj());
+}
+
+void Widget::queue_draw()
+{
+  gtk_widget_queue_draw(gobj());
+}
+
+void Widget::queue_draw_area(int x, int y, int width, int height)
+{
+  gtk_widget_queue_draw_area(gobj(), x, y, width, height);
+}
+
+void Widget::queue_resize()
+{
+  gtk_widget_queue_resize(gobj());
+}
+
+void Widget::size_request(const Requisition& requisition)
+{
+  gtk_widget_size_request(gobj(), (GtkRequisition*)(&requisition));
+}
+
+void Widget::size_allocate(const Allocation& allocation)
+{
+  gtk_widget_size_allocate(gobj(), (GtkAllocation*)(allocation.gobj()));
+}
+
+void Widget::add_accelerator(const Glib::ustring& accel_signal, const Glib::RefPtr<AccelGroup>& accel_group, guint accel_key, Gdk::ModifierType accel_mods, AccelFlags accel_flags)
+{
+  gtk_widget_add_accelerator(gobj(), accel_signal.c_str(), Glib::unwrap(accel_group), accel_key, ((GdkModifierType)(accel_mods)), ((GtkAccelFlags)(accel_flags)));
+}
+
+bool Widget::remove_accelerator(const Glib::RefPtr<AccelGroup>& accel_group, guint accel_key, Gdk::ModifierType accel_mods)
+{
+  return gtk_widget_remove_accelerator(gobj(), Glib::unwrap(accel_group), accel_key, ((GdkModifierType)(accel_mods)));
+}
+
+void Widget::set_accel_path(const Glib::ustring& accel_path, const Glib::RefPtr<AccelGroup>& accel_group)
+{
+  gtk_widget_set_accel_path(gobj(), accel_path.c_str(), Glib::unwrap(accel_group));
+}
+
+bool Widget::mnemonic_activate(bool group_cycling)
+{
+  return gtk_widget_mnemonic_activate(gobj(), static_cast<int>(group_cycling));
+}
+
+bool Widget::event(GdkEvent* event)
+{
+  return gtk_widget_event(gobj(), event);
+}
+
+int Widget::send_expose(GdkEvent* event)
+{
+  return gtk_widget_send_expose(gobj(), event);
+}
+
+bool Widget::activate()
+{
+  return gtk_widget_activate(gobj());
+}
+
+void Widget::reparent(Widget & new_parent)
+{
+  gtk_widget_reparent(gobj(), (new_parent).gobj());
+}
+
+bool Widget::intersect(const Gdk::Rectangle& area, Gdk::Rectangle& intersection) const
+{
+  return gtk_widget_intersect(const_cast<GtkWidget*>(gobj()), const_cast<GdkRectangle*>(area.gobj()), (intersection).gobj());
+}
+
+Gdk::Region Widget::region_intersect(const Gdk::Region& region) const
+{
+  return Gdk::Region(gtk_widget_region_intersect(const_cast<GtkWidget*>(gobj()), const_cast<GdkRegion*>((region).gobj())));
+}
+
+void Widget::freeze_child_notify()
+{
+  gtk_widget_freeze_child_notify(gobj());
+}
+
+void Widget::child_notify(const Glib::ustring& child_property)
+{
+  gtk_widget_child_notify(gobj(), child_property.c_str());
+}
+
+void Widget::thaw_child_notify()
+{
+  gtk_widget_thaw_child_notify(gobj());
+}
+
+bool Widget::is_focus() const
+{
+  return gtk_widget_is_focus(const_cast<GtkWidget*>(gobj()));
+}
+
+void Widget::grab_focus()
+{
+  gtk_widget_grab_focus(gobj());
+}
+
+void Widget::grab_default()
+{
+  gtk_widget_grab_default(gobj());
+}
+
+void Widget::set_name(const Glib::ustring& name)
+{
+  gtk_widget_set_name(gobj(), name.c_str());
+}
+
+Glib::ustring Widget::get_name() const
+{
+  return Glib::convert_const_gchar_ptr_to_ustring(gtk_widget_get_name(const_cast<GtkWidget*>(gobj())));
+}
+
+void Widget::set_state(Gtk::StateType state)
+{
+  gtk_widget_set_state(gobj(), ((GtkStateType)(state)));
+}
+
+void Widget::set_sensitive(bool sensitive)
+{
+  gtk_widget_set_sensitive(gobj(), static_cast<int>(sensitive));
+}
+
+void Widget::set_app_paintable(bool app_paintable)
+{
+  gtk_widget_set_app_paintable(gobj(), static_cast<int>(app_paintable));
+}
+
+void Widget::set_double_buffered(bool double_buffered)
+{
+  gtk_widget_set_double_buffered(gobj(), static_cast<int>(double_buffered));
+}
+
+void Widget::set_redraw_on_allocate(bool redraw_on_allocate)
+{
+  gtk_widget_set_redraw_on_allocate(gobj(), static_cast<int>(redraw_on_allocate));
+}
+
+void Widget::set_child_visible(bool is_visible)
+{
+  gtk_widget_set_child_visible(gobj(), static_cast<int>(is_visible));
+}
+
+bool Widget::get_child_visible() const
+{
+  return gtk_widget_get_child_visible(const_cast<GtkWidget*>(gobj()));
+}
+
+Container* Widget::get_parent()
+{
+  return Glib::wrap((GtkContainer*)(gtk_widget_get_parent(gobj())));
+}
+
+const Container* Widget::get_parent() const
+{
+  return Glib::wrap((GtkContainer*)(gtk_widget_get_parent(const_cast<GtkWidget*>(gobj()))));
+}
+
+Glib::RefPtr<Gdk::Window> Widget::get_parent_window()
+{
+
+  Glib::RefPtr<Gdk::Window> retvalue = Glib::wrap((GdkWindowObject*)(gtk_widget_get_parent_window(gobj())));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::RefPtr<const Gdk::Window> Widget::get_parent_window() const
+{
+
+  Glib::RefPtr<const Gdk::Window> retvalue = Glib::wrap((GdkWindowObject*)(gtk_widget_get_parent_window(const_cast<GtkWidget*>(gobj()))));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+void Widget::set_parent_window(const Glib::RefPtr<const Gdk::Window>& parent_window)
+{
+  gtk_widget_set_parent_window(gobj(), const_cast<GdkWindow*>(Glib::unwrap<Gdk::Window>(parent_window)));
+}
+
+bool Widget::child_focus(DirectionType direction)
+{
+  return gtk_widget_child_focus(gobj(), ((GtkDirectionType)(direction)));
+}
+
+void Widget::set_size_request(int width, int height)
+{
+  gtk_widget_set_size_request(gobj(), width, height);
+}
+
+void Widget::get_size_request(int& width, int& height) const
+{
+  gtk_widget_get_size_request(const_cast<GtkWidget*>(gobj()), &width, &height);
+}
+
+void Widget::set_events(Gdk::EventMask events)
+{
+  gtk_widget_set_events(gobj(), events);
+}
+
+void Widget::add_events(Gdk::EventMask events)
+{
+  gtk_widget_add_events(gobj(), events);
+}
+
+void Widget::set_extension_events(Gdk::ExtensionMode mode)
+{
+  gtk_widget_set_extension_events(gobj(), ((GdkExtensionMode)(mode)));
+}
+
+Gdk::ExtensionMode Widget::get_extension_events() const
+{
+  return ((Gdk::ExtensionMode)(gtk_widget_get_extension_events(const_cast<GtkWidget*>(gobj()))));
+}
+
+Container* Widget::get_toplevel()
+{
+  return Glib::wrap((GtkContainer*)(gtk_widget_get_toplevel(gobj())));
+}
+
+const Container* Widget::get_toplevel() const
+{
+  return Glib::wrap((GtkContainer*)(gtk_widget_get_toplevel(const_cast<GtkWidget*>(gobj()))));
+}
+
+Widget* Widget::get_ancestor(GType widget_type)
+{
+  return Glib::wrap(gtk_widget_get_ancestor(gobj(), widget_type));
+}
+
+const Widget* Widget::get_ancestor(GType widget_type) const
+{
+  return Glib::wrap(gtk_widget_get_ancestor(const_cast<GtkWidget*>(gobj()), widget_type));
+}
+
+Glib::RefPtr<Gdk::Colormap> Widget::get_colormap()
+{
+
+  Glib::RefPtr<Gdk::Colormap> retvalue = Glib::wrap(gtk_widget_get_colormap(gobj()));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::RefPtr<Gdk::Visual> Widget::get_visual()
+{
+
+  Glib::RefPtr<Gdk::Visual> retvalue = Glib::wrap(gtk_widget_get_visual(gobj()));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::RefPtr<Gdk::Screen> Widget::get_screen()
+{
+
+  Glib::RefPtr<Gdk::Screen> retvalue = Glib::wrap(gtk_widget_get_screen(gobj()));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::RefPtr<const Gdk::Screen> Widget::get_screen() const
+{
+
+  Glib::RefPtr<const Gdk::Screen> retvalue = Glib::wrap(gtk_widget_get_screen(const_cast<GtkWidget*>(gobj())));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+bool Widget::has_screen() const
+{
+  return gtk_widget_has_screen(const_cast<GtkWidget*>(gobj()));
+}
+
+Glib::RefPtr<Gdk::Display> Widget::get_display()
+{
+
+  Glib::RefPtr<Gdk::Display> retvalue = Glib::wrap(gtk_widget_get_display(gobj()));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::RefPtr<const Gdk::Display> Widget::get_display() const
+{
+
+  Glib::RefPtr<const Gdk::Display> retvalue = Glib::wrap(gtk_widget_get_display(const_cast<GtkWidget*>(gobj())));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::RefPtr<Gdk::Window> Widget::get_root_window()
+{
+
+  Glib::RefPtr<Gdk::Window> retvalue = Glib::wrap((GdkWindowObject*)(gtk_widget_get_root_window(gobj())));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::RefPtr<const Gdk::Window> Widget::get_root_window() const
+{
+
+  Glib::RefPtr<const Gdk::Window> retvalue = Glib::wrap((GdkWindowObject*)(gtk_widget_get_root_window(const_cast<GtkWidget*>(gobj()))));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::RefPtr<Settings> Widget::get_settings()
+{
+
+  Glib::RefPtr<Settings> retvalue = Glib::wrap(gtk_widget_get_settings(gobj()));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::RefPtr<Clipboard> Widget::get_clipboard(const Glib::ustring& selection)
+{
+
+  Glib::RefPtr<Clipboard> retvalue = Glib::wrap(gtk_widget_get_clipboard(gobj(), Gdk::AtomString::to_c_type(selection)));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::RefPtr<const Clipboard> Widget::get_clipboard(const Glib::ustring& selection) const
+{
+
+  Glib::RefPtr<const Clipboard> retvalue = Glib::wrap(gtk_widget_get_clipboard(const_cast<GtkWidget*>(gobj()), Gdk::AtomString::to_c_type(selection)));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::RefPtr<Atk::Object> Widget::get_accessible()
+{
+
+  Glib::RefPtr<Atk::Object> retvalue = Glib::wrap(gtk_widget_get_accessible(gobj()));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+void Widget::set_colormap(const Glib::RefPtr<const Gdk::Colormap> & colormap)
+{
+  gtk_widget_set_colormap(gobj(), const_cast<GdkColormap*>(Glib::unwrap<Gdk::Colormap>(colormap)));
+}
+
+Gdk::EventMask Widget::get_events() const
+{
+  return static_cast<Gdk::EventMask>(gtk_widget_get_events(const_cast<GtkWidget*>(gobj())));
+}
+
+void Widget::get_pointer(int & x, int & y) const
+{
+  gtk_widget_get_pointer(const_cast<GtkWidget*>(gobj()), &x, &y);
+}
+
+bool Widget::is_ancestor(Widget & ancestor) const
+{
+  return gtk_widget_is_ancestor(const_cast<GtkWidget*>(gobj()), (ancestor).gobj());
+}
+
+bool Widget::translate_coordinates(Widget& dest_widget, int src_x, int src_y, int& dest_x, int& dest_y)
+{
+  return gtk_widget_translate_coordinates(gobj(), (dest_widget).gobj(), src_x, src_y, &dest_x, &dest_y);
+}
+
+void Widget::set_style(const Glib::RefPtr<Style>& style)
+{
+  gtk_widget_set_style(gobj(), Glib::unwrap(style));
+}
+
+void Widget::ensure_style()
+{
+  gtk_widget_ensure_style(gobj());
+}
+
+Glib::RefPtr<Style> Widget::get_style()
+{
+
+  Glib::RefPtr<Style> retvalue = Glib::wrap(gtk_widget_get_style(gobj()));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::RefPtr<const Style> Widget::get_style() const
+{
+
+  Glib::RefPtr<const Style> retvalue = Glib::wrap(gtk_widget_get_style(const_cast<GtkWidget*>(gobj())));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+void Widget::modify_style(const Glib::RefPtr<RcStyle>& style)
+{
+  gtk_widget_modify_style(gobj(), Glib::unwrap(style));
+}
+
+Glib::RefPtr<RcStyle> Widget::get_modifier_style()
+{
+
+  Glib::RefPtr<RcStyle> retvalue = Glib::wrap(gtk_widget_get_modifier_style(gobj()));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::RefPtr<const RcStyle> Widget::get_modifier_style() const
+{
+
+  Glib::RefPtr<const RcStyle> retvalue = Glib::wrap(gtk_widget_get_modifier_style(const_cast<GtkWidget*>(gobj())));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+void Widget::modify_fg(StateType state, const Gdk::Color& color)
+{
+  gtk_widget_modify_fg(gobj(), ((GtkStateType)(state)), (color).gobj());
+}
+
+void Widget::modify_bg(StateType state, const Gdk::Color& color)
+{
+  gtk_widget_modify_bg(gobj(), ((GtkStateType)(state)), (color).gobj());
+}
+
+void Widget::modify_text(StateType state, const Gdk::Color& color)
+{
+  gtk_widget_modify_text(gobj(), ((GtkStateType)(state)), (color).gobj());
+}
+
+void Widget::modify_base(StateType state, const Gdk::Color& color)
+{
+  gtk_widget_modify_base(gobj(), ((GtkStateType)(state)), (color).gobj());
+}
+
+void Widget::modify_font(const Pango::FontDescription& font_desc)
+{
+  gtk_widget_modify_font(gobj(), const_cast<PangoFontDescription*>((font_desc).gobj()));
+}
+
+Glib::RefPtr<Pango::Context> Widget::create_pango_context()
+{
+  return Glib::wrap(gtk_widget_create_pango_context(gobj()));
+}
+
+Glib::RefPtr<Pango::Context> Widget::get_pango_context()
+{
+
+  Glib::RefPtr<Pango::Context> retvalue = Glib::wrap(gtk_widget_get_pango_context(gobj()));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::RefPtr<Pango::Layout> Widget::create_pango_layout(const Glib::ustring& text)
+{
+  return Glib::wrap(gtk_widget_create_pango_layout(gobj(), text.c_str()));
+}
+
+Glib::RefPtr<Gdk::Pixbuf> Widget::render_icon(const StockID& stock_id, IconSize size, const Glib::ustring& detail)
+{
+  return Glib::wrap(gtk_widget_render_icon(gobj(), (stock_id).get_c_str(), static_cast<GtkIconSize>(int(size)), detail.c_str()));
+}
+
+void Widget::set_composite_name(const Glib::ustring& name)
+{
+  gtk_widget_set_composite_name(gobj(), name.c_str());
+}
+
+Glib::ustring Widget::get_composite_name() const
+{
+  return Glib::convert_return_gchar_ptr_to_ustring(gtk_widget_get_composite_name(const_cast<GtkWidget*>(gobj())));
+}
+
+void Widget::reset_rc_styles()
+{
+  gtk_widget_reset_rc_styles(gobj());
+}
+
+void Widget::push_colormap(const Glib::RefPtr<const Gdk::Colormap>& cmap)
+{
+  gtk_widget_push_colormap(const_cast<GdkColormap*>(Glib::unwrap<Gdk::Colormap>(cmap)));
+}
+
+void Widget::pop_colormap()
+{
+  gtk_widget_pop_colormap();
+}
+
+void Widget::push_composite_child()
+{
+  gtk_widget_push_composite_child();
+}
+
+void Widget::pop_composite_child()
+{
+  gtk_widget_pop_composite_child();
+}
+
+void Widget::set_default_colormap(const Glib::RefPtr<const Gdk::Colormap>& colormap)
+{
+  gtk_widget_set_default_colormap(const_cast<GdkColormap*>(Glib::unwrap<Gdk::Colormap>(colormap)));
+}
+
+Glib::RefPtr<Style> Widget::get_default_style()
+{
+
+  Glib::RefPtr<Style> retvalue = Glib::wrap(gtk_widget_get_default_style());
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::RefPtr<Gdk::Colormap> Widget::get_default_colormap()
+{
+
+  Glib::RefPtr<Gdk::Colormap> retvalue = Glib::wrap(gtk_widget_get_default_colormap());
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::RefPtr<Gdk::Visual> Widget::get_default_visual()
+{
+
+  Glib::RefPtr<Gdk::Visual> retvalue = Glib::wrap(gtk_widget_get_default_visual());
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+void Widget::set_direction(TextDirection dir)
+{
+  gtk_widget_set_direction(gobj(), ((GtkTextDirection)(dir)));
+}
+
+TextDirection Widget::get_direction()
+{
+  return ((TextDirection)(gtk_widget_get_direction(gobj())));
+}
+
+void Widget::set_default_direction(TextDirection dir)
+{
+  gtk_widget_set_default_direction(((GtkTextDirection)(dir)));
+}
+
+TextDirection Widget::get_default_direction()
+{
+  return ((TextDirection)(gtk_widget_get_default_direction()));
+}
+
+void Widget::shape_combine_mask(const Glib::RefPtr<const Gdk::Bitmap>& shape_mask, int offset_x, int offset_y)
+{
+  gtk_widget_shape_combine_mask(gobj(), const_cast<GdkBitmap*>(Glib::unwrap<Gdk::Bitmap>(shape_mask)), offset_x, offset_y);
+}
+
+void Widget::reset_shapes()
+{
+  gtk_widget_reset_shapes(gobj());
+}
+
+Glib::ListHandle<Widget*> Widget::list_mnemonic_labels()
+{
+  return Glib::ListHandle<Widget*>(gtk_widget_list_mnemonic_labels(gobj()), Glib::OWNERSHIP_SHALLOW);
+}
+
+Glib::ListHandle<const Widget*> Widget::list_mnemonic_labels() const
+{
+  return Glib::ListHandle<const Widget*>(gtk_widget_list_mnemonic_labels(const_cast<GtkWidget*>(gobj())), Glib::OWNERSHIP_SHALLOW);
+}
+
+void Widget::add_mnemonic_label(Widget& label)
+{
+  gtk_widget_add_mnemonic_label(gobj(), (label).gobj());
+}
+
+void Widget::remove_mnemonic_label(Widget& label)
+{
+  gtk_widget_remove_mnemonic_label(gobj(), (label).gobj());
+}
+
+void Widget::drag_get_data(const Glib::RefPtr<Gdk::DragContext>& context, Glib::ustring& target, guint32 time)
+{
+  gtk_drag_get_data(gobj(), Glib::unwrap(context), Gdk::AtomString::to_c_type(target), time);
+}
+
+void Widget::drag_highlight()
+{
+  gtk_drag_highlight(gobj());
+}
+
+void Widget::drag_unhighlight()
+{
+  gtk_drag_unhighlight(gobj());
+}
+
+void Widget::drag_dest_set_proxy(const Glib::RefPtr<Gdk::Window>& proxy_window, Gdk::DragProtocol protocol, bool use_coordinates)
+{
+  gtk_drag_dest_set_proxy(gobj(), Glib::unwrap(proxy_window), ((GdkDragProtocol)(protocol)), static_cast<int>(use_coordinates));
+}
+
+void Widget::drag_dest_unset()
+{
+  gtk_drag_dest_unset(gobj());
+}
+
+Glib::ustring Widget::drag_dest_find_target(const Glib::RefPtr<Gdk::DragContext>& context, const Glib::RefPtr<TargetList>& target_list) const
+{
+  return Gdk::AtomString::to_cpp_type(gtk_drag_dest_find_target(const_cast<GtkWidget*>(gobj()), Glib::unwrap(context), const_cast<GtkTargetList*>(Glib::unwrap(target_list))));
+}
+
+Glib::RefPtr<TargetList> Widget::drag_dest_get_target_list()
+{
+
+  Glib::RefPtr<TargetList> retvalue = Glib::wrap(gtk_drag_dest_get_target_list(gobj()));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::RefPtr<const TargetList> Widget::drag_dest_get_target_list() const
+{
+
+  Glib::RefPtr<const TargetList> retvalue = Glib::wrap(gtk_drag_dest_get_target_list(const_cast<GtkWidget*>(gobj())));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+void Widget::drag_dest_set_target_list(const Glib::RefPtr<TargetList>& target_list)
+{
+  gtk_drag_dest_set_target_list(gobj(), const_cast<GtkTargetList*>(Glib::unwrap(target_list)));
+}
+
+void Widget::drag_dest_add_text_targets()
+{
+  gtk_drag_dest_add_text_targets(gobj());
+}
+
+void Widget::drag_dest_add_image_targets()
+{
+  gtk_drag_dest_add_image_targets(gobj());
+}
+
+void Widget::drag_dest_add_uri_targets()
+{
+  gtk_drag_dest_add_uri_targets(gobj());
+}
+
+void Widget::drag_source_unset()
+{
+  gtk_drag_source_unset(gobj());
+}
+
+void Widget::drag_source_set_icon(const Glib::RefPtr<Gdk::Colormap>& colormap, const Glib::RefPtr<Gdk::Pixmap>& pixmap, const Glib::RefPtr<Gdk::Bitmap>& mask)
+{
+  gtk_drag_source_set_icon(gobj(), Glib::unwrap(colormap), Glib::unwrap(pixmap), Glib::unwrap(mask));
+}
+
+void Widget::drag_source_set_icon(const Glib::RefPtr<Gdk::Pixbuf>& pixbuf)
+{
+  gtk_drag_source_set_icon_pixbuf(gobj(), Glib::unwrap(pixbuf));
+}
+
+void Widget::drag_source_set_icon(const StockID& stock_id)
+{
+  gtk_drag_source_set_icon_stock(gobj(), (stock_id).get_c_str());
+}
+
+void Widget::drag_source_add_text_targets()
+{
+  gtk_drag_source_add_text_targets(gobj());
+}
+
+void Widget::drag_source_add_uri_targets()
+{
+  gtk_drag_source_add_uri_targets(gobj());
+}
+
+void Widget::drag_source_add_image_targets()
+{
+  gtk_drag_source_add_image_targets(gobj());
+}
+
+Glib::RefPtr<Gdk::DragContext> Widget::drag_begin(const Glib::RefPtr<TargetList>& targets, Gdk::DragAction actions, int button, GdkEvent* event)
+{
+
+  Glib::RefPtr<Gdk::DragContext> retvalue = Glib::wrap(gtk_drag_begin(gobj(), const_cast<GtkTargetList*>(Glib::unwrap(targets)), ((GdkDragAction)(actions)), button, event), true);
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+bool Widget::drag_check_threshold(int start_x, int start_y, int current_x, int current_y)
+{
+  return gtk_drag_check_threshold(gobj(), start_x, start_y, current_x, current_y);
+}
+
+void Widget::queue_resize_no_redraw()
+{
+  gtk_widget_queue_resize_no_redraw(gobj());
+}
+
+bool Widget::get_no_show_all() const
+{
+  return gtk_widget_get_no_show_all(const_cast<GtkWidget*>(gobj()));
+}
+
+void Widget::set_no_show_all(bool no_show_all)
+{
+  gtk_widget_set_no_show_all(gobj(), static_cast<int>(no_show_all));
+}
+
+void Widget::set_parent(Widget& parent)
+{
+  gtk_widget_set_parent(gobj(), (parent).gobj());
+}
+
+void Widget::unparent()
+{
+  gtk_widget_unparent(gobj());
+}
+
+Gtk::StateType Widget::get_state() const
+{
+  return static_cast<StateType>(gobj()->state);
+}
+
+Gtk::StateType Widget::get_saved_state() const
+{
+  return static_cast<StateType>(gobj()->saved_state);
+}
+
+Requisition Widget::get_requisition() const
+{
+  return (Requisition)(gobj()->requisition);
+}
+
+Allocation Widget::get_allocation() const
+{
+  return (Allocation)(Glib::wrap(&gobj()->allocation));
+}
+
+Glib::RefPtr<Gdk::Window> Widget::get_window()
+{
+  Glib::RefPtr<Gdk::Window> ref_ptr(Glib::wrap((GdkWindowObject*)(gobj()->window)));
+
+  if(ref_ptr)
+    ref_ptr->reference();
+
+  return ref_ptr;
+}
+
+Glib::RefPtr<const Gdk::Window> Widget::get_window() const
+{
+  Glib::RefPtr<const Gdk::Window> ref_ptr(Glib::wrap((GdkWindowObject*)(gobj()->window)));
+
+  if(ref_ptr)
+    ref_ptr->reference();
+
+  return ref_ptr;
+}
+
+Widget::Widget()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Object(Glib::ConstructParams(widget_class_.init()))
+{
+  }
+
+void Widget::map()
+{
+  gtk_widget_map(gobj());
+}
+
+void Widget::unmap()
+{
+  gtk_widget_unmap(gobj());
+}
+
+void Widget::realize()
+{
+  gtk_widget_realize(gobj());
+}
+
+void Widget::unrealize()
+{
+  gtk_widget_unrealize(gobj());
+}
+
+void Widget::get_child_requisition(Requisition& requisition) const
+{
+  gtk_widget_get_child_requisition(const_cast<GtkWidget*>(gobj()), (GtkRequisition*)(&requisition));
+}
+
+void Widget::get_style_property_value(const Glib::ustring& the_property_name, Glib::ValueBase& value) const
+{
+  gtk_widget_style_get_property(const_cast<GtkWidget*>(gobj()), the_property_name.c_str(), (value).gobj());
+}
+
+void Widget::set_allocation(const Allocation& value)
+{
+  gobj()->allocation = (GtkAllocation)(*(value.gobj()));
+}
+
+void Widget::set_window(const Glib::RefPtr<Gdk::Window>& value)
+{
+  Glib::RefPtr<Gdk::Window> valueOld(Glib::wrap((GdkWindowObject*)(gobj()->window))); //Take possession of the old one, unref-ing it in the destructor.
+
+  if(value)
+    value->reference(); //Ref once for the recipient.
+
+  gobj()->window = Glib::unwrap(value);
+}
+
+
+Glib::SignalProxy0< void > Widget::signal_show()
+{
+  return Glib::SignalProxy0< void >(this, &Widget_signal_show_info);
+}
+
+Glib::SignalProxy0< void > Widget::signal_hide()
+{
+  return Glib::SignalProxy0< void >(this, &Widget_signal_hide_info);
+}
+
+Glib::SignalProxy0< void > Widget::signal_map()
+{
+  return Glib::SignalProxy0< void >(this, &Widget_signal_map_info);
+}
+
+Glib::SignalProxy0< void > Widget::signal_unmap()
+{
+  return Glib::SignalProxy0< void >(this, &Widget_signal_unmap_info);
+}
+
+Glib::SignalProxy0< void > Widget::signal_realize()
+{
+  return Glib::SignalProxy0< void >(this, &Widget_signal_realize_info);
+}
+
+Glib::SignalProxy0< void > Widget::signal_unrealize()
+{
+  return Glib::SignalProxy0< void >(this, &Widget_signal_unrealize_info);
+}
+
+Glib::SignalProxy1< void,Requisition* > Widget::signal_size_request()
+{
+  return Glib::SignalProxy1< void,Requisition* >(this, &Widget_signal_size_request_info);
+}
+
+Glib::SignalProxy1< void,Allocation& > Widget::signal_size_allocate()
+{
+  return Glib::SignalProxy1< void,Allocation& >(this, &Widget_signal_size_allocate_info);
+}
+
+Glib::SignalProxy1< void,Gtk::StateType > Widget::signal_state_changed()
+{
+  return Glib::SignalProxy1< void,Gtk::StateType >(this, &Widget_signal_state_changed_info);
+}
+
+Glib::SignalProxy1< void,Widget* > Widget::signal_parent_changed()
+{
+  return Glib::SignalProxy1< void,Widget* >(this, &Widget_signal_parent_changed_info);
+}
+
+Glib::SignalProxy1< void,Widget* > Widget::signal_hierarchy_changed()
+{
+  return Glib::SignalProxy1< void,Widget* >(this, &Widget_signal_hierarchy_changed_info);
+}
+
+Glib::SignalProxy1< void,const Glib::RefPtr<Style>& > Widget::signal_style_changed()
+{
+  return Glib::SignalProxy1< void,const Glib::RefPtr<Style>& >(this, &Widget_signal_style_changed_info);
+}
+
+Glib::SignalProxy1< void,TextDirection > Widget::signal_direction_changed()
+{
+  return Glib::SignalProxy1< void,TextDirection >(this, &Widget_signal_direction_changed_info);
+}
+
+Glib::SignalProxy1< void,bool > Widget::signal_grab_notify()
+{
+  return Glib::SignalProxy1< void,bool >(this, &Widget_signal_grab_notify_info);
+}
+
+Glib::SignalProxy1< void,GParamSpec* > Widget::signal_child_notify()
+{
+  return Glib::SignalProxy1< void,GParamSpec* >(this, &Widget_signal_child_notify_info);
+}
+
+Glib::SignalProxy1< bool,bool > Widget::signal_mnemonic_activate()
+{
+  return Glib::SignalProxy1< bool,bool >(this, &Widget_signal_mnemonic_activate_info);
+}
+
+Glib::SignalProxy0< void > Widget::signal_grab_focus()
+{
+  return Glib::SignalProxy0< void >(this, &Widget_signal_grab_focus_info);
+}
+
+Glib::SignalProxy1< bool,DirectionType > Widget::signal_focus()
+{
+  return Glib::SignalProxy1< bool,DirectionType >(this, &Widget_signal_focus_info);
+}
+
+Glib::SignalProxy1< bool,GdkEvent* > Widget::signal_event()
+{
+  return Glib::SignalProxy1< bool,GdkEvent* >(this, &Widget_signal_event_info);
+}
+
+Glib::SignalProxy1< void,GdkEvent* > Widget::signal_event_after()
+{
+  return Glib::SignalProxy1< void,GdkEvent* >(this, &Widget_signal_event_after_info);
+}
+
+Glib::SignalProxy1< bool,GdkEventButton* > Widget::signal_button_press_event()
+{
+  return Glib::SignalProxy1< bool,GdkEventButton* >(this, &Widget_signal_button_press_event_info);
+}
+
+Glib::SignalProxy1< bool,GdkEventButton* > Widget::signal_button_release_event()
+{
+  return Glib::SignalProxy1< bool,GdkEventButton* >(this, &Widget_signal_button_release_event_info);
+}
+
+Glib::SignalProxy1< bool,GdkEventScroll* > Widget::signal_scroll_event()
+{
+  return Glib::SignalProxy1< bool,GdkEventScroll* >(this, &Widget_signal_scroll_event_info);
+}
+
+Glib::SignalProxy1< bool,GdkEventMotion* > Widget::signal_motion_notify_event()
+{
+  return Glib::SignalProxy1< bool,GdkEventMotion* >(this, &Widget_signal_motion_notify_event_info);
+}
+
+Glib::SignalProxy1< bool,GdkEventAny* > Widget::signal_delete_event()
+{
+  return Glib::SignalProxy1< bool,GdkEventAny* >(this, &Widget_signal_delete_event_info);
+}
+
+Glib::SignalProxy1< bool,GdkEventExpose* > Widget::signal_expose_event()
+{
+  return Glib::SignalProxy1< bool,GdkEventExpose* >(this, &Widget_signal_expose_event_info);
+}
+
+Glib::SignalProxy1< bool,GdkEventKey* > Widget::signal_key_press_event()
+{
+  return Glib::SignalProxy1< bool,GdkEventKey* >(this, &Widget_signal_key_press_event_info);
+}
+
+Glib::SignalProxy1< bool,GdkEventKey* > Widget::signal_key_release_event()
+{
+  return Glib::SignalProxy1< bool,GdkEventKey* >(this, &Widget_signal_key_release_event_info);
+}
+
+Glib::SignalProxy1< bool,GdkEventCrossing* > Widget::signal_enter_notify_event()
+{
+  return Glib::SignalProxy1< bool,GdkEventCrossing* >(this, &Widget_signal_enter_notify_event_info);
+}
+
+Glib::SignalProxy1< bool,GdkEventCrossing* > Widget::signal_leave_notify_event()
+{
+  return Glib::SignalProxy1< bool,GdkEventCrossing* >(this, &Widget_signal_leave_notify_event_info);
+}
+
+Glib::SignalProxy1< bool,GdkEventConfigure* > Widget::signal_configure_event()
+{
+  return Glib::SignalProxy1< bool,GdkEventConfigure* >(this, &Widget_signal_configure_event_info);
+}
+
+Glib::SignalProxy1< bool,GdkEventFocus* > Widget::signal_focus_in_event()
+{
+  return Glib::SignalProxy1< bool,GdkEventFocus* >(this, &Widget_signal_focus_in_event_info);
+}
+
+Glib::SignalProxy1< bool,GdkEventFocus* > Widget::signal_focus_out_event()
+{
+  return Glib::SignalProxy1< bool,GdkEventFocus* >(this, &Widget_signal_focus_out_event_info);
+}
+
+Glib::SignalProxy1< bool,GdkEventAny* > Widget::signal_map_event()
+{
+  return Glib::SignalProxy1< bool,GdkEventAny* >(this, &Widget_signal_map_event_info);
+}
+
+Glib::SignalProxy1< bool,GdkEventAny* > Widget::signal_unmap_event()
+{
+  return Glib::SignalProxy1< bool,GdkEventAny* >(this, &Widget_signal_unmap_event_info);
+}
+
+Glib::SignalProxy1< bool,GdkEventProperty* > Widget::signal_property_notify_event()
+{
+  return Glib::SignalProxy1< bool,GdkEventProperty* >(this, &Widget_signal_property_notify_event_info);
+}
+
+Glib::SignalProxy1< bool,GdkEventSelection* > Widget::signal_selection_clear_event()
+{
+  return Glib::SignalProxy1< bool,GdkEventSelection* >(this, &Widget_signal_selection_clear_event_info);
+}
+
+Glib::SignalProxy1< bool,GdkEventSelection* > Widget::signal_selection_request_event()
+{
+  return Glib::SignalProxy1< bool,GdkEventSelection* >(this, &Widget_signal_selection_request_event_info);
+}
+
+Glib::SignalProxy1< bool,GdkEventSelection* > Widget::signal_selection_notify_event()
+{
+  return Glib::SignalProxy1< bool,GdkEventSelection* >(this, &Widget_signal_selection_notify_event_info);
+}
+
+Glib::SignalProxy1< bool,GdkEventProximity* > Widget::signal_proximity_in_event()
+{
+  return Glib::SignalProxy1< bool,GdkEventProximity* >(this, &Widget_signal_proximity_in_event_info);
+}
+
+Glib::SignalProxy1< bool,GdkEventProximity* > Widget::signal_proximity_out_event()
+{
+  return Glib::SignalProxy1< bool,GdkEventProximity* >(this, &Widget_signal_proximity_out_event_info);
+}
+
+Glib::SignalProxy1< bool,GdkEventVisibility* > Widget::signal_visibility_notify_event()
+{
+  return Glib::SignalProxy1< bool,GdkEventVisibility* >(this, &Widget_signal_visibility_notify_event_info);
+}
+
+Glib::SignalProxy1< bool,GdkEventClient* > Widget::signal_client_event()
+{
+  return Glib::SignalProxy1< bool,GdkEventClient* >(this, &Widget_signal_client_event_info);
+}
+
+Glib::SignalProxy1< bool,GdkEventAny* > Widget::signal_no_expose_event()
+{
+  return Glib::SignalProxy1< bool,GdkEventAny* >(this, &Widget_signal_no_expose_event_info);
+}
+
+Glib::SignalProxy1< bool,GdkEventWindowState* > Widget::signal_window_state_event()
+{
+  return Glib::SignalProxy1< bool,GdkEventWindowState* >(this, &Widget_signal_window_state_event_info);
+}
+
+Glib::SignalProxy3< void,SelectionData&,guint,guint > Widget::signal_selection_get()
+{
+  return Glib::SignalProxy3< void,SelectionData&,guint,guint >(this, &Widget_signal_selection_get_info);
+}
+
+Glib::SignalProxy2< void,const SelectionData&,guint > Widget::signal_selection_received()
+{
+  return Glib::SignalProxy2< void,const SelectionData&,guint >(this, &Widget_signal_selection_received_info);
+}
+
+Glib::SignalProxy1< void,const Glib::RefPtr<Gdk::DragContext>& > Widget::signal_drag_begin()
+{
+  return Glib::SignalProxy1< void,const Glib::RefPtr<Gdk::DragContext>& >(this, &Widget_signal_drag_begin_info);
+}
+
+Glib::SignalProxy1< void,const Glib::RefPtr<Gdk::DragContext>& > Widget::signal_drag_end()
+{
+  return Glib::SignalProxy1< void,const Glib::RefPtr<Gdk::DragContext>& >(this, &Widget_signal_drag_end_info);
+}
+
+Glib::SignalProxy4< void,const Glib::RefPtr<Gdk::DragContext>&,SelectionData&,guint,guint > Widget::signal_drag_data_get()
+{
+  return Glib::SignalProxy4< void,const Glib::RefPtr<Gdk::DragContext>&,SelectionData&,guint,guint >(this, &Widget_signal_drag_data_get_info);
+}
+
+Glib::SignalProxy1< void,const Glib::RefPtr<Gdk::DragContext>& > Widget::signal_drag_data_delete()
+{
+  return Glib::SignalProxy1< void,const Glib::RefPtr<Gdk::DragContext>& >(this, &Widget_signal_drag_data_delete_info);
+}
+
+Glib::SignalProxy2< void,const Glib::RefPtr<Gdk::DragContext>&,guint > Widget::signal_drag_leave()
+{
+  return Glib::SignalProxy2< void,const Glib::RefPtr<Gdk::DragContext>&,guint >(this, &Widget_signal_drag_leave_info);
+}
+
+Glib::SignalProxy4< bool,const Glib::RefPtr<Gdk::DragContext>&,int,int,guint > Widget::signal_drag_motion()
+{
+  return Glib::SignalProxy4< bool,const Glib::RefPtr<Gdk::DragContext>&,int,int,guint >(this, &Widget_signal_drag_motion_info);
+}
+
+Glib::SignalProxy4< bool,const Glib::RefPtr<Gdk::DragContext>&,int,int,guint > Widget::signal_drag_drop()
+{
+  return Glib::SignalProxy4< bool,const Glib::RefPtr<Gdk::DragContext>&,int,int,guint >(this, &Widget_signal_drag_drop_info);
+}
+
+Glib::SignalProxy6< void,const Glib::RefPtr<Gdk::DragContext>&,int,int,const SelectionData&,guint,guint > Widget::signal_drag_data_received()
+{
+  return Glib::SignalProxy6< void,const Glib::RefPtr<Gdk::DragContext>&,int,int,const SelectionData&,guint,guint >(this, &Widget_signal_drag_data_received_info);
+}
+
+Glib::SignalProxy0< Glib::RefPtr<Atk::Object> > Widget::signal_get_accessible()
+{
+  return Glib::SignalProxy0< Glib::RefPtr<Atk::Object> >(this, &Widget_signal_get_accessible_info);
+}
+
+Glib::SignalProxy1< void,const Glib::RefPtr<Gdk::Screen>& > Widget::signal_screen_changed()
+{
+  return Glib::SignalProxy1< void,const Glib::RefPtr<Gdk::Screen>& >(this, &Widget_signal_screen_changed_info);
+}
+
+
+Glib::PropertyProxy<Glib::ustring> Widget::property_name() 
+{
+  return Glib::PropertyProxy<Glib::ustring>(this, "name");
+}
+
+Glib::PropertyProxy_ReadOnly<Glib::ustring> Widget::property_name() const
+{
+  return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "name");
+}
+
+Glib::PropertyProxy<Container*> Widget::property_parent() 
+{
+  return Glib::PropertyProxy<Container*>(this, "parent");
+}
+
+Glib::PropertyProxy_ReadOnly<Container*> Widget::property_parent() const
+{
+  return Glib::PropertyProxy_ReadOnly<Container*>(this, "parent");
+}
+
+Glib::PropertyProxy<int> Widget::property_width_request() 
+{
+  return Glib::PropertyProxy<int>(this, "width-request");
+}
+
+Glib::PropertyProxy_ReadOnly<int> Widget::property_width_request() const
+{
+  return Glib::PropertyProxy_ReadOnly<int>(this, "width-request");
+}
+
+Glib::PropertyProxy<int> Widget::property_height_request() 
+{
+  return Glib::PropertyProxy<int>(this, "height-request");
+}
+
+Glib::PropertyProxy_ReadOnly<int> Widget::property_height_request() const
+{
+  return Glib::PropertyProxy_ReadOnly<int>(this, "height-request");
+}
+
+Glib::PropertyProxy<bool> Widget::property_visible() 
+{
+  return Glib::PropertyProxy<bool>(this, "visible");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> Widget::property_visible() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "visible");
+}
+
+Glib::PropertyProxy<bool> Widget::property_sensitive() 
+{
+  return Glib::PropertyProxy<bool>(this, "sensitive");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> Widget::property_sensitive() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "sensitive");
+}
+
+Glib::PropertyProxy<bool> Widget::property_app_paintable() 
+{
+  return Glib::PropertyProxy<bool>(this, "app-paintable");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> Widget::property_app_paintable() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "app-paintable");
+}
+
+Glib::PropertyProxy<bool> Widget::property_can_focus() 
+{
+  return Glib::PropertyProxy<bool>(this, "can-focus");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> Widget::property_can_focus() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "can-focus");
+}
+
+Glib::PropertyProxy<bool> Widget::property_has_focus() 
+{
+  return Glib::PropertyProxy<bool>(this, "has-focus");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> Widget::property_has_focus() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "has-focus");
+}
+
+Glib::PropertyProxy<bool> Widget::property_can_default() 
+{
+  return Glib::PropertyProxy<bool>(this, "can-default");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> Widget::property_can_default() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "can-default");
+}
+
+Glib::PropertyProxy<bool> Widget::property_has_default() 
+{
+  return Glib::PropertyProxy<bool>(this, "has-default");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> Widget::property_has_default() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "has-default");
+}
+
+Glib::PropertyProxy<bool> Widget::property_receives_default() 
+{
+  return Glib::PropertyProxy<bool>(this, "receives-default");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> Widget::property_receives_default() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "receives-default");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> Widget::property_composite_child() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "composite-child");
+}
+
+Glib::PropertyProxy< Glib::RefPtr<Style> > Widget::property_style() 
+{
+  return Glib::PropertyProxy< Glib::RefPtr<Style> >(this, "style");
+}
+
+Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Style> > Widget::property_style() const
+{
+  return Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Style> >(this, "style");
+}
+
+Glib::PropertyProxy<Gdk::EventMask> Widget::property_events() 
+{
+  return Glib::PropertyProxy<Gdk::EventMask>(this, "events");
+}
+
+Glib::PropertyProxy_ReadOnly<Gdk::EventMask> Widget::property_events() const
+{
+  return Glib::PropertyProxy_ReadOnly<Gdk::EventMask>(this, "events");
+}
+
+Glib::PropertyProxy<Gdk::ExtensionMode> Widget::property_extension_events() 
+{
+  return Glib::PropertyProxy<Gdk::ExtensionMode>(this, "extension-events");
+}
+
+Glib::PropertyProxy_ReadOnly<Gdk::ExtensionMode> Widget::property_extension_events() const
+{
+  return Glib::PropertyProxy_ReadOnly<Gdk::ExtensionMode>(this, "extension-events");
+}
+
+
+void Gtk::Widget::on_show()
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->show)
+    (*base->show)(gobj());
+}
+
+void Gtk::Widget::on_hide()
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->hide)
+    (*base->hide)(gobj());
+}
+
+void Gtk::Widget::on_map()
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->map)
+    (*base->map)(gobj());
+}
+
+void Gtk::Widget::on_unmap()
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->unmap)
+    (*base->unmap)(gobj());
+}
+
+void Gtk::Widget::on_realize()
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->realize)
+    (*base->realize)(gobj());
+}
+
+void Gtk::Widget::on_unrealize()
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->unrealize)
+    (*base->unrealize)(gobj());
+}
+
+void Gtk::Widget::on_size_request(Requisition* requisition)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->size_request)
+    (*base->size_request)(gobj(),(GtkRequisition*)(requisition));
+}
+
+void Gtk::Widget::on_size_allocate(Allocation& allocation)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->size_allocate)
+    (*base->size_allocate)(gobj(),(GtkAllocation*)(allocation.gobj()));
+}
+
+void Gtk::Widget::on_state_changed(Gtk::StateType previous_state)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->state_changed)
+    (*base->state_changed)(gobj(),((GtkStateType)(previous_state)));
+}
+
+void Gtk::Widget::on_parent_changed(Widget* previous_parent)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->parent_set)
+    (*base->parent_set)(gobj(),(GtkWidget*)Glib::unwrap(previous_parent));
+}
+
+void Gtk::Widget::on_hierarchy_changed(Widget* previous_toplevel)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->hierarchy_changed)
+    (*base->hierarchy_changed)(gobj(),(GtkWidget*)Glib::unwrap(previous_toplevel));
+}
+
+void Gtk::Widget::on_style_changed(const Glib::RefPtr<Style>& previous_style)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->style_set)
+    (*base->style_set)(gobj(),Glib::unwrap(previous_style));
+}
+
+void Gtk::Widget::on_direction_changed(TextDirection direction)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->direction_changed)
+    (*base->direction_changed)(gobj(),((GtkTextDirection)(direction)));
+}
+
+void Gtk::Widget::on_grab_notify(bool was_grabbed)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->grab_notify)
+    (*base->grab_notify)(gobj(),static_cast<int>(was_grabbed));
+}
+
+void Gtk::Widget::on_child_notify(GParamSpec* pspec)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->child_notify)
+    (*base->child_notify)(gobj(),pspec);
+}
+
+bool Gtk::Widget::on_mnemonic_activate(bool group_cycling)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->mnemonic_activate)
+    return (*base->mnemonic_activate)(gobj(),static_cast<int>(group_cycling));
+
+  typedef bool RType;
+  return RType();
+}
+
+void Gtk::Widget::on_grab_focus()
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->grab_focus)
+    (*base->grab_focus)(gobj());
+}
+
+bool Gtk::Widget::on_focus(DirectionType direction)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->focus)
+    return (*base->focus)(gobj(),((GtkDirectionType)(direction)));
+
+  typedef bool RType;
+  return RType();
+}
+
+bool Gtk::Widget::on_event(GdkEvent* event)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->event)
+    return (*base->event)(gobj(),event);
+
+  typedef bool RType;
+  return RType();
+}
+
+bool Gtk::Widget::on_button_press_event(GdkEventButton* event)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->button_press_event)
+    return (*base->button_press_event)(gobj(),event);
+
+  typedef bool RType;
+  return RType();
+}
+
+bool Gtk::Widget::on_button_release_event(GdkEventButton* event)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->button_release_event)
+    return (*base->button_release_event)(gobj(),event);
+
+  typedef bool RType;
+  return RType();
+}
+
+bool Gtk::Widget::on_scroll_event(GdkEventScroll* event)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->scroll_event)
+    return (*base->scroll_event)(gobj(),event);
+
+  typedef bool RType;
+  return RType();
+}
+
+bool Gtk::Widget::on_motion_notify_event(GdkEventMotion* event)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->motion_notify_event)
+    return (*base->motion_notify_event)(gobj(),event);
+
+  typedef bool RType;
+  return RType();
+}
+
+bool Gtk::Widget::on_delete_event(GdkEventAny* event)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->delete_event)
+    return (*base->delete_event)(gobj(),event);
+
+  typedef bool RType;
+  return RType();
+}
+
+bool Gtk::Widget::on_expose_event(GdkEventExpose* event)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->expose_event)
+    return (*base->expose_event)(gobj(),event);
+
+  typedef bool RType;
+  return RType();
+}
+
+bool Gtk::Widget::on_key_press_event(GdkEventKey* event)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->key_press_event)
+    return (*base->key_press_event)(gobj(),event);
+
+  typedef bool RType;
+  return RType();
+}
+
+bool Gtk::Widget::on_key_release_event(GdkEventKey* event)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->key_release_event)
+    return (*base->key_release_event)(gobj(),event);
+
+  typedef bool RType;
+  return RType();
+}
+
+bool Gtk::Widget::on_enter_notify_event(GdkEventCrossing* event)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->enter_notify_event)
+    return (*base->enter_notify_event)(gobj(),event);
+
+  typedef bool RType;
+  return RType();
+}
+
+bool Gtk::Widget::on_leave_notify_event(GdkEventCrossing* event)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->leave_notify_event)
+    return (*base->leave_notify_event)(gobj(),event);
+
+  typedef bool RType;
+  return RType();
+}
+
+bool Gtk::Widget::on_configure_event(GdkEventConfigure* event)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->configure_event)
+    return (*base->configure_event)(gobj(),event);
+
+  typedef bool RType;
+  return RType();
+}
+
+bool Gtk::Widget::on_focus_in_event(GdkEventFocus* event)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->focus_in_event)
+    return (*base->focus_in_event)(gobj(),event);
+
+  typedef bool RType;
+  return RType();
+}
+
+bool Gtk::Widget::on_focus_out_event(GdkEventFocus* event)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->focus_out_event)
+    return (*base->focus_out_event)(gobj(),event);
+
+  typedef bool RType;
+  return RType();
+}
+
+bool Gtk::Widget::on_map_event(GdkEventAny* event)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->map_event)
+    return (*base->map_event)(gobj(),event);
+
+  typedef bool RType;
+  return RType();
+}
+
+bool Gtk::Widget::on_unmap_event(GdkEventAny* event)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->unmap_event)
+    return (*base->unmap_event)(gobj(),event);
+
+  typedef bool RType;
+  return RType();
+}
+
+bool Gtk::Widget::on_property_notify_event(GdkEventProperty* event)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->property_notify_event)
+    return (*base->property_notify_event)(gobj(),event);
+
+  typedef bool RType;
+  return RType();
+}
+
+bool Gtk::Widget::on_selection_clear_event(GdkEventSelection* event)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->selection_clear_event)
+    return (*base->selection_clear_event)(gobj(),event);
+
+  typedef bool RType;
+  return RType();
+}
+
+bool Gtk::Widget::on_selection_request_event(GdkEventSelection* event)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->selection_request_event)
+    return (*base->selection_request_event)(gobj(),event);
+
+  typedef bool RType;
+  return RType();
+}
+
+bool Gtk::Widget::on_selection_notify_event(GdkEventSelection* event)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->selection_notify_event)
+    return (*base->selection_notify_event)(gobj(),event);
+
+  typedef bool RType;
+  return RType();
+}
+
+bool Gtk::Widget::on_proximity_in_event(GdkEventProximity* event)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->proximity_in_event)
+    return (*base->proximity_in_event)(gobj(),event);
+
+  typedef bool RType;
+  return RType();
+}
+
+bool Gtk::Widget::on_proximity_out_event(GdkEventProximity* event)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->proximity_out_event)
+    return (*base->proximity_out_event)(gobj(),event);
+
+  typedef bool RType;
+  return RType();
+}
+
+bool Gtk::Widget::on_visibility_notify_event(GdkEventVisibility* event)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->visibility_notify_event)
+    return (*base->visibility_notify_event)(gobj(),event);
+
+  typedef bool RType;
+  return RType();
+}
+
+bool Gtk::Widget::on_client_event(GdkEventClient* event)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->client_event)
+    return (*base->client_event)(gobj(),event);
+
+  typedef bool RType;
+  return RType();
+}
+
+bool Gtk::Widget::on_no_expose_event(GdkEventAny* event)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->no_expose_event)
+    return (*base->no_expose_event)(gobj(),event);
+
+  typedef bool RType;
+  return RType();
+}
+
+bool Gtk::Widget::on_window_state_event(GdkEventWindowState* event)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->window_state_event)
+    return (*base->window_state_event)(gobj(),event);
+
+  typedef bool RType;
+  return RType();
+}
+
+void Gtk::Widget::on_selection_get(SelectionData& selection_data, guint info, guint time)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->selection_get)
+    (*base->selection_get)(gobj(),(selection_data).gobj(),info,time);
+}
+
+void Gtk::Widget::on_selection_received(const SelectionData& selection_data, guint time)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->selection_received)
+    (*base->selection_received)(gobj(),const_cast<GtkSelectionData*>((selection_data).gobj()),time);
+}
+
+void Gtk::Widget::on_drag_begin(const Glib::RefPtr<Gdk::DragContext>& context)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->drag_begin)
+    (*base->drag_begin)(gobj(),Glib::unwrap(context));
+}
+
+void Gtk::Widget::on_drag_end(const Glib::RefPtr<Gdk::DragContext>& context)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->drag_end)
+    (*base->drag_end)(gobj(),Glib::unwrap(context));
+}
+
+void Gtk::Widget::on_drag_data_get(const Glib::RefPtr<Gdk::DragContext>& context, SelectionData& selection_data, guint info, guint time)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->drag_data_get)
+    (*base->drag_data_get)(gobj(),Glib::unwrap(context),(selection_data).gobj(),info,time);
+}
+
+void Gtk::Widget::on_drag_data_delete(const Glib::RefPtr<Gdk::DragContext>& context)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->drag_data_delete)
+    (*base->drag_data_delete)(gobj(),Glib::unwrap(context));
+}
+
+void Gtk::Widget::on_drag_leave(const Glib::RefPtr<Gdk::DragContext>& context, guint time)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->drag_leave)
+    (*base->drag_leave)(gobj(),Glib::unwrap(context),time);
+}
+
+bool Gtk::Widget::on_drag_motion(const Glib::RefPtr<Gdk::DragContext>& context, int x, int y, guint time)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->drag_motion)
+    return (*base->drag_motion)(gobj(),Glib::unwrap(context),x,y,time);
+
+  typedef bool RType;
+  return RType();
+}
+
+bool Gtk::Widget::on_drag_drop(const Glib::RefPtr<Gdk::DragContext>& context, int x, int y, guint time)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->drag_drop)
+    return (*base->drag_drop)(gobj(),Glib::unwrap(context),x,y,time);
+
+  typedef bool RType;
+  return RType();
+}
+
+void Gtk::Widget::on_drag_data_received(const Glib::RefPtr<Gdk::DragContext>& context, int x, int y, const SelectionData& selection_data, guint info, guint time)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->drag_data_received)
+    (*base->drag_data_received)(gobj(),Glib::unwrap(context),x,y,const_cast<GtkSelectionData*>((selection_data).gobj()),info,time);
+}
+
+Glib::RefPtr<Atk::Object> Gtk::Widget::on_get_accessible()
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->get_accessible)
+    return Glib::wrap((*base->get_accessible)(gobj()), true);
+
+  typedef Glib::RefPtr<Atk::Object> RType;
+  return RType();
+}
+
+void Gtk::Widget::on_screen_changed(const Glib::RefPtr<Gdk::Screen>& previous_screen)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->screen_changed)
+    (*base->screen_changed)(gobj(),Glib::unwrap(previous_screen));
+}
+
+
+void Gtk::Widget::dispatch_child_properties_changed_vfunc(guint p1, GParamSpec** p2) 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->dispatch_child_properties_changed)
+    (*base->dispatch_child_properties_changed)(gobj(),p1,p2);
+}
+
+void Gtk::Widget::show_all_vfunc() 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->show_all)
+    (*base->show_all)(gobj());
+}
+
+void Gtk::Widget::hide_all_vfunc() 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->hide_all)
+    (*base->hide_all)(gobj());
+}
+
+Glib::RefPtr<Atk::Object> Gtk::Widget::get_accessible_vfunc() 
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->get_accessible)
+    return Glib::wrap((*base->get_accessible)(gobj()));
+
+  typedef Glib::RefPtr<Atk::Object> RType;
+  return RType();
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/widget.h b/libs/gtkmm2/gtk/gtkmm/widget.h
new file mode 100644
index 0000000000..36877d402d
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/widget.h
@@ -0,0 +1,2666 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_WIDGET_H
+#define _GTKMM_WIDGET_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* Copyright (C) 2002, 2003 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+ 
+#include <pangomm/context.h>
+#include <pangomm/layout.h>
+#include <atkmm/object.h>
+#include <atkmm/implementor.h>
+#include <gdkmm/event.h>
+#include <gdkmm/types.h>
+#include <gdkmm/window.h>
+#include <gdkmm/dragcontext.h>
+#include <gdkmm/pixbuf.h>
+#include <gdkmm/screen.h>
+#include <gtkmm/enums.h>
+#include <gdkmm/display.h>
+//#include <gtkmm/style.h>
+#include <gtkmm/targetlist.h>
+#include <gtkmm/rc.h>
+#include <gtkmm/object.h>
+#include <gtkmm/clipboard.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+extern "C"
+{
+typedef struct _GtkTargetEntry GtkTargetEntry;
+}
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkWidget GtkWidget;
+typedef struct _GtkWidgetClass GtkWidgetClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class Widget_Class; } // namespace Gtk
+namespace Gtk
+{
+
+
+/** @addtogroup gtkmmEnums Enums and Flags */
+
+/**
+ * @ingroup gtkmmEnums
+ * @par Bitwise operators:
+ * <tt>%DestDefaults operator|(DestDefaults, DestDefaults)</tt><br>
+ * <tt>%DestDefaults operator&(DestDefaults, DestDefaults)</tt><br>
+ * <tt>%DestDefaults operator^(DestDefaults, DestDefaults)</tt><br>
+ * <tt>%DestDefaults operator~(DestDefaults)</tt><br>
+ * <tt>%DestDefaults& operator|=(DestDefaults&, DestDefaults)</tt><br>
+ * <tt>%DestDefaults& operator&=(DestDefaults&, DestDefaults)</tt><br>
+ * <tt>%DestDefaults& operator^=(DestDefaults&, DestDefaults)</tt><br>
+ */
+enum DestDefaults
+{
+  DEST_DEFAULT_MOTION = 1 << 0,
+  DEST_DEFAULT_HIGHLIGHT = 1 << 1,
+  DEST_DEFAULT_DROP = 1 << 2,
+  DEST_DEFAULT_ALL = 0x07
+};
+
+/** @ingroup gtkmmEnums */
+inline DestDefaults operator|(DestDefaults lhs, DestDefaults rhs)
+  { return static_cast<DestDefaults>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs)); }
+
+/** @ingroup gtkmmEnums */
+inline DestDefaults operator&(DestDefaults lhs, DestDefaults rhs)
+  { return static_cast<DestDefaults>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs)); }
+
+/** @ingroup gtkmmEnums */
+inline DestDefaults operator^(DestDefaults lhs, DestDefaults rhs)
+  { return static_cast<DestDefaults>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs)); }
+
+/** @ingroup gtkmmEnums */
+inline DestDefaults operator~(DestDefaults flags)
+  { return static_cast<DestDefaults>(~static_cast<unsigned>(flags)); }
+
+/** @ingroup gtkmmEnums */
+inline DestDefaults& operator|=(DestDefaults& lhs, DestDefaults rhs)
+  { return (lhs = static_cast<DestDefaults>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs))); }
+
+/** @ingroup gtkmmEnums */
+inline DestDefaults& operator&=(DestDefaults& lhs, DestDefaults rhs)
+  { return (lhs = static_cast<DestDefaults>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs))); }
+
+/** @ingroup gtkmmEnums */
+inline DestDefaults& operator^=(DestDefaults& lhs, DestDefaults rhs)
+  { return (lhs = static_cast<DestDefaults>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs))); }
+
+} // namespace Gtk
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Gtk::DestDefaults> : public Glib::Value_Flags<Gtk::DestDefaults>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{
+
+/**
+ * @ingroup gtkmmEnums
+ * @par Bitwise operators:
+ * <tt>%WidgetFlags operator|(WidgetFlags, WidgetFlags)</tt><br>
+ * <tt>%WidgetFlags operator&(WidgetFlags, WidgetFlags)</tt><br>
+ * <tt>%WidgetFlags operator^(WidgetFlags, WidgetFlags)</tt><br>
+ * <tt>%WidgetFlags operator~(WidgetFlags)</tt><br>
+ * <tt>%WidgetFlags& operator|=(WidgetFlags&, WidgetFlags)</tt><br>
+ * <tt>%WidgetFlags& operator&=(WidgetFlags&, WidgetFlags)</tt><br>
+ * <tt>%WidgetFlags& operator^=(WidgetFlags&, WidgetFlags)</tt><br>
+ */
+enum WidgetFlags
+{
+  TOPLEVEL = 1 << 4,
+  NO_WINDOW = 1 << 5,
+  REALIZED = 1 << 6,
+  MAPPED = 1 << 7,
+  VISIBLE = 1 << 8,
+  SENSITIVE = 1 << 9,
+  PARENT_SENSITIVE = 1 << 10,
+  CAN_FOCUS = 1 << 11,
+  HAS_FOCUS = 1 << 12,
+  CAN_DEFAULT = 1 << 13,
+  HAS_DEFAULT = 1 << 14,
+  HAS_GRAB = 1 << 15,
+  RC_STYLE = 1 << 16,
+  COMPOSITE_CHILD = 1 << 17,
+  NO_REPARENT = 1 << 18,
+  APP_PAINTABLE = 1 << 19,
+  RECEIVES_DEFAULT = 1 << 20,
+  DOUBLE_BUFFERED = 1 << 21,
+  NO_SHOW_ALL = 1 << 22
+};
+
+/** @ingroup gtkmmEnums */
+inline WidgetFlags operator|(WidgetFlags lhs, WidgetFlags rhs)
+  { return static_cast<WidgetFlags>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs)); }
+
+/** @ingroup gtkmmEnums */
+inline WidgetFlags operator&(WidgetFlags lhs, WidgetFlags rhs)
+  { return static_cast<WidgetFlags>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs)); }
+
+/** @ingroup gtkmmEnums */
+inline WidgetFlags operator^(WidgetFlags lhs, WidgetFlags rhs)
+  { return static_cast<WidgetFlags>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs)); }
+
+/** @ingroup gtkmmEnums */
+inline WidgetFlags operator~(WidgetFlags flags)
+  { return static_cast<WidgetFlags>(~static_cast<unsigned>(flags)); }
+
+/** @ingroup gtkmmEnums */
+inline WidgetFlags& operator|=(WidgetFlags& lhs, WidgetFlags rhs)
+  { return (lhs = static_cast<WidgetFlags>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs))); }
+
+/** @ingroup gtkmmEnums */
+inline WidgetFlags& operator&=(WidgetFlags& lhs, WidgetFlags rhs)
+  { return (lhs = static_cast<WidgetFlags>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs))); }
+
+/** @ingroup gtkmmEnums */
+inline WidgetFlags& operator^=(WidgetFlags& lhs, WidgetFlags rhs)
+  { return (lhs = static_cast<WidgetFlags>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs))); }
+
+} // namespace Gtk
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Gtk::WidgetFlags> : public Glib::Value_Flags<Gtk::WidgetFlags>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{
+
+/**
+ * @ingroup gtkmmEnums
+ */
+enum WidgetHelpType
+{
+  WIDGET_HELP_TOOLTIP,
+  WIDGET_HELP_WHATS_THIS
+};
+
+} // namespace Gtk
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Gtk::WidgetHelpType> : public Glib::Value_Enum<Gtk::WidgetHelpType>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{
+
+
+class Style;
+class AccelGroup;
+class Adjustment;
+class Window;
+class Container;
+class Settings;
+
+typedef GtkRequisition Requisition;
+
+// Gtk::Allocation is a typedef of Gdk::Rectangle because GtkAllocation is
+// a typedef of GdkRectangle.
+typedef Gdk::Rectangle Allocation;
+
+
+/** @defgroup Widgets Widgets
+ */
+
+/** Abstract Widget (Base class for all widgets)
+ *
+ * As the base class of all widgets this contains all of the properties
+ * and methods common to all widgets.  It is an abstract class that
+ * can not be instantiated.
+ *
+ * Important part of widgets are the *_event signals and virtual methods
+ * that every widget have. Those are events coming directly from gdk and
+ * thus also from XLib. By overriding those virtual methods you can
+ * trap everything a widget can ever do.
+ * In order to capture events from a widget, the event mask must
+ * first be set with ().
+ *
+ * Only widgets with a Gdk::Window on the server side are allowed to
+ * capture events.  Widgets in the Gtk::Misc group for example lack
+ * a Gdk::Window.
+ */
+
+class Widget
+: public Object,
+  public Atk::Implementor
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Widget CppObjectType;
+  typedef Widget_Class CppClassType;
+  typedef GtkWidget BaseObjectType;
+  typedef GtkWidgetClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~Widget();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class Widget_Class;
+  static CppClassType widget_class_;
+
+  // noncopyable
+  Widget(const Widget&);
+  Widget& operator=(const Widget&);
+
+protected:
+  explicit Widget(const Glib::ConstructParams& construct_params);
+  explicit Widget(GtkWidget* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GtkWidget*       gobj()       { return reinterpret_cast<GtkWidget*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GtkWidget* gobj() const { return reinterpret_cast<GtkWidget*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+  virtual void on_show();
+  virtual void on_hide();
+  virtual void on_map();
+  virtual void on_unmap();
+  virtual void on_realize();
+  virtual void on_unrealize();
+  virtual void on_size_request(Requisition* requisition);
+  virtual void on_size_allocate(Allocation& allocation);
+  virtual void on_state_changed(Gtk::StateType previous_state);
+  virtual void on_parent_changed(Widget* previous_parent);
+  virtual void on_hierarchy_changed(Widget* previous_toplevel);
+  virtual void on_style_changed(const Glib::RefPtr<Style>& previous_style);
+  virtual void on_direction_changed(TextDirection direction);
+  virtual void on_grab_notify(bool was_grabbed);
+  virtual void on_child_notify(GParamSpec* pspec);
+  virtual bool on_mnemonic_activate(bool group_cycling);
+  virtual void on_grab_focus();
+  virtual bool on_focus(DirectionType direction);
+  virtual bool on_event(GdkEvent* event);
+  virtual bool on_button_press_event(GdkEventButton* event);
+  virtual bool on_button_release_event(GdkEventButton* event);
+  virtual bool on_scroll_event(GdkEventScroll* event);
+  virtual bool on_motion_notify_event(GdkEventMotion* event);
+  virtual bool on_delete_event(GdkEventAny* event);
+  virtual bool on_expose_event(GdkEventExpose* event);
+  virtual bool on_key_press_event(GdkEventKey* event);
+  virtual bool on_key_release_event(GdkEventKey* event);
+  virtual bool on_enter_notify_event(GdkEventCrossing* event);
+  virtual bool on_leave_notify_event(GdkEventCrossing* event);
+  virtual bool on_configure_event(GdkEventConfigure* event);
+  virtual bool on_focus_in_event(GdkEventFocus* event);
+  virtual bool on_focus_out_event(GdkEventFocus* event);
+  virtual bool on_map_event(GdkEventAny* event);
+  virtual bool on_unmap_event(GdkEventAny* event);
+  virtual bool on_property_notify_event(GdkEventProperty* event);
+  virtual bool on_selection_clear_event(GdkEventSelection* event);
+  virtual bool on_selection_request_event(GdkEventSelection* event);
+  virtual bool on_selection_notify_event(GdkEventSelection* event);
+  virtual bool on_proximity_in_event(GdkEventProximity* event);
+  virtual bool on_proximity_out_event(GdkEventProximity* event);
+  virtual bool on_visibility_notify_event(GdkEventVisibility* event);
+  virtual bool on_client_event(GdkEventClient* event);
+  virtual bool on_no_expose_event(GdkEventAny* event);
+  virtual bool on_window_state_event(GdkEventWindowState* event);
+  virtual void on_selection_get(SelectionData& selection_data, guint info, guint time);
+  virtual void on_selection_received(const SelectionData& selection_data, guint time);
+  virtual void on_drag_begin(const Glib::RefPtr<Gdk::DragContext>& context);
+  virtual void on_drag_end(const Glib::RefPtr<Gdk::DragContext>& context);
+  virtual void on_drag_data_get(const Glib::RefPtr<Gdk::DragContext>& context, SelectionData& selection_data, guint info, guint time);
+  virtual void on_drag_data_delete(const Glib::RefPtr<Gdk::DragContext>& context);
+  virtual void on_drag_leave(const Glib::RefPtr<Gdk::DragContext>& context, guint time);
+  virtual bool on_drag_motion(const Glib::RefPtr<Gdk::DragContext>& context, int x, int y, guint time);
+  virtual bool on_drag_drop(const Glib::RefPtr<Gdk::DragContext>& context, int x, int y, guint time);
+  virtual void on_drag_data_received(const Glib::RefPtr<Gdk::DragContext>& context, int x, int y, const SelectionData& selection_data, guint info, guint time);
+  virtual Glib::RefPtr<Atk::Object> on_get_accessible();
+  virtual void on_screen_changed(const Glib::RefPtr<Gdk::Screen>& previous_screen);
+
+
+private:
+
+  
+public:
+  friend class Main;
+  
+
+  /** For widgets that support scrolling, sets the scroll adjustments and
+   * returns <tt>true</tt>.  For widgets that don't support scrolling, does
+   * nothing and returns <tt>false</tt>. Widgets that don't support scrolling
+   * can be scrolled by placing them in a Gtk::Viewport, which does
+   * support scrolling.
+   * @param hadjustment An adjustment for horizontal scrolling, or <tt>0</tt>.
+   * @param vadjustment An adjustment for vertical scrolling, or <tt>0</tt>.
+   * @return <tt>true</tt> if the widget supports scrolling.
+   */
+  bool set_scroll_adjustments(Adjustment& hadjustment, Adjustment& vadjustment);
+
+  
+  /** Flags a widget to be displayed. Any widget that isn't shown will
+   * not appear on the screen. If you want to show all the widgets in a
+   * container, it's easier to call show_all() on the
+   * container, instead of individually showing the widgets.
+   * 
+   * Remember that you have to show the containers containing a widget,
+   * in addition to the widget itself, before it will appear onscreen.
+   * 
+   * When a toplevel container is shown, it is immediately realized and
+   * mapped; other shown widgets are realized and mapped when their
+   * toplevel container is realized and mapped.
+   */
+  void show();
+  
+  /** Shows a widget. If the widget is an unmapped toplevel widget
+   * (i.e. a Gtk::Window that has not yet been shown), enter the main
+   * loop and wait for the window to actually be mapped. Be careful;
+   * because the main loop is running, anything can happen during
+   * this function.
+   */
+  void show_now();
+  
+  /** Reverses the effects of show(), causing the widget to be
+   * hidden (invisible to the user).
+   */
+  void hide();
+
+  
+  /** Recursively shows a widget, and any child widgets (if the widget is
+   * a container).
+   */
+  void show_all();
+
+  
+  /** Recursively hides a widget and any child widgets.
+   */
+  void hide_all();
+
+
+/* QUEUE DRAWS */
+
+  
+  /** Equivalent to calling queue_draw_area() for the
+   * entire area of a widget.
+   */
+  void queue_draw();
+  
+  /** Invalidates the rectangular area of @a widget  defined by @a x , @a y ,
+   *  @a width  and @a height  by calling gdk_window_invalidate_rect() on the
+   * widget's window and all its child windows.  Once the main loop
+   * becomes idle (after the current batch of events has been processed,
+   * roughly), the window will receive expose events for the union of
+   * all regions that have been invalidated.
+   * 
+   * Normally you would only use this function in widget
+   * implementations. You might also use it, or
+   * gdk_window_invalidate_rect() directly, to schedule a redraw of a
+   * Gtk::DrawingArea or some portion thereof.
+   * 
+   * Frequently you can just call gdk_window_invalidate_rect() or
+   * gdk_window_invalidate_region() instead of this function. Those
+   * functions will invalidate only a single window, instead of the
+   * widget and all its children.
+   * 
+   * The advantage of adding to the invalidated region compared to
+   * simply drawing immediately is efficiency; using an invalid region
+   * ensures that you only have to redraw one time.
+   * @param x X coordinate of upper-left corner of rectangle to redraw.
+   * @param y Y coordinate of upper-left corner of rectangle to redraw.
+   * @param width Width of region to draw.
+   * @param height Height of region to draw.
+   */
+  void queue_draw_area(int x, int y, int width, int height);
+  
+  /** This function is only for use in widget implementations.
+   * Flags a widget to have its size renegotiated; should
+   * be called when a widget for some reason has a new size request.
+   * For example, when you change the text in a Gtk::Label, Gtk::Label
+   * queues a resize to ensure there's enough space for the new text.
+   */
+  void queue_resize();
+
+  /** This function is typically used when implementing a Gtk::Container
+   * subclass.  Obtains the preferred size of a widget. The container
+   * uses this information to arrange its child widgets and decide what
+   * size allocations to give them with size_allocate().
+   * 
+   * You can also call this function from an application, with some
+   * caveats. Most notably, getting a size request requires the widget
+   * to be associated with a screen, because font information may be
+   * needed. Multihead-aware applications should keep this in mind.
+   * 
+   * Also remember that the size request is not necessarily the size
+   * a widget will actually be allocated.
+   * 
+   * See also get_child_requisition().
+   * @result A Gtk::Requisition.
+   */
+  Requisition size_request() const;
+  
+  
+  //Deprecated, because the Requisition should be an output parameter. This could never have been used.
+  
+  /** This function is typically used when implementing a Gtk::Container
+   * subclass.  Obtains the preferred size of a widget. The container
+   * uses this information to arrange its child widgets and decide what
+   * size allocations to give them with size_allocate().
+   * 
+   * You can also call this function from an application, with some
+   * caveats. Most notably, getting a size request requires the widget
+   * to be associated with a screen, because font information may be
+   * needed. Multihead-aware applications should keep this in mind.
+   * 
+   * Also remember that the size request is not necessarily the size
+   * a widget will actually be allocated.
+   * 
+   * See also get_child_requisition().
+   * @param requisition A Gtk::Requisition to be filled in.
+   */
+  void size_request(const Requisition& requisition);
+
+  
+  /** This function is only used by Gtk::Container subclasses, to assign a size
+   * and position to their child widgets.
+   * @param allocation Position and size to be allocated to @a widget .
+   */
+  void size_allocate(const Allocation& allocation);
+
+
+  /** Installs an accelerator for this @a widget  in @a accel_group  that causes
+   *  @a accel_signal  to be emitted if the accelerator is activated.
+   * The @a accel_group  needs to be added to the widget's toplevel via
+   * Gtk::Window::add_accel_group(), and the signal must be of type G::RUN_ACTION.
+   * Accelerators added through this function are not user changeable during
+   * runtime. If you want to support accelerators that can be changed by the
+   * user, use gtk_accel_map_add_entry() and set_accel_path() or
+   * Gtk::MenuItem::set_accel_path() instead.
+   * @param accel_signal Widget signal to emit on accelerator activation.
+   * @param accel_group Accel group for this widget, added to its toplevel.
+   * @param accel_key GDK keyval of the accelerator.
+   * @param accel_mods Modifier key combination of the accelerator.
+   * @param accel_flags Flag accelerators, e.g. Gtk::ACCEL_VISIBLE.
+   */
+  void add_accelerator(const Glib::ustring& accel_signal, const Glib::RefPtr<AccelGroup>& accel_group,
+               guint accel_key, Gdk::ModifierType accel_mods, AccelFlags accel_flags);
+
+  
+  /** Removes an accelerator from @a widget , previously installed with
+   * add_accelerator().
+   * @param accel_group Accel group for this widget.
+   * @param accel_key GDK keyval of the accelerator.
+   * @param accel_mods Modifier key combination of the accelerator.
+   * @return Whether an accelerator was installed and could be removed.
+   */
+  bool remove_accelerator(const Glib::RefPtr<AccelGroup>& accel_group,
+               guint accel_key, Gdk::ModifierType accel_mods);
+  
+  /** Given an accelerator group, @a accel_group , and an accelerator path,
+   *  @a accel_path , sets up an accelerator in @a accel_group  so whenever the
+   * key binding that is defined for @a accel_path  is pressed, @a widget 
+   * will be activated.  This removes any accelerators (for any
+   * accelerator group) installed by previous calls to
+   * set_accel_path(). Associating accelerators with
+   * paths allows them to be modified by the user and the modifications
+   * to be saved for future use. (See gtk_accel_map_save().)
+   * 
+   * This function is a low level function that would most likely
+   * be used by a menu creation system like Gtk::ItemFactory. If you
+   * use Gtk::ItemFactory, setting up accelerator paths will be done
+   * automatically.
+   * 
+   * Even when you you aren't using Gtk::ItemFactory, if you only want to
+   * set up accelerators on menu items Gtk::MenuItem::set_accel_path()
+   * provides a somewhat more convenient interface.
+   * @param accel_path Path used to look up the the accelerator.
+   * @param accel_group A Gtk::AccelGroup.
+   */
+  void set_accel_path(const Glib::ustring& accel_path,
+                                   const Glib::RefPtr<AccelGroup>& accel_group);
+
+  //GList* gtk_widget_list_accel_closures();
+
+  //TODO: Or maybe it is useless: gboolean gtk_widget_can_activate_accel(GtkWidget *widget, guint signal_id)
+  
+  
+  bool mnemonic_activate(bool group_cycling);
+
+  //TODO: Use C++ type
+  
+  /** Rarely-used function. This function is used to emit
+   * the event signals on a widget (those signals should never
+   * be emitted without using this function to do so).
+   * If you want to synthesize an event though, don't use this function;
+   * instead, use gtk_main_do_event() so the event will behave as if
+   * it were in the event queue. Don't synthesize expose events; instead,
+   * use gdk_window_invalidate_rect() to invalidate a region of the
+   * window.
+   * @param event A Gdk::Event.
+   * @return Return from the event signal emission (<tt>true</tt> if the event was handled).
+   */
+  bool event(GdkEvent* event);
+  
+  /** Very rarely-used function. This function is used to emit
+   * an expose event signals on a widget. This function is not
+   * normally used directly. The only time it is used is when
+   * propagating an expose event to a child NO_WINDOW widget, and
+   * that is normally done using Gtk::Container::propagate_expose().
+   * 
+   * If you want to force an area of a window to be redrawn, 
+   * use gdk_window_invalidate_rect() or gdk_window_invalidate_region().
+   * To cause the redraw to be done immediately, follow that call
+   * with a call to gdk_window_process_updates().
+   * @param event A expose Gdk::Event.
+   * @return Return from the event signal emission (<tt>true</tt> if the event was handled).
+   */
+  int send_expose(GdkEvent* event);
+  
+  /** For widgets that can be "activated" (buttons, menu items, etc.)
+   * this function activates them. Activation is what happens when you
+   * press Enter on a widget during key navigation. If @a widget  isn't 
+   * activatable, the function returns <tt>false</tt>.
+   * @return <tt>true</tt> if the widget was activatable.
+   */
+  bool activate();
+
+  
+  /** Moves a widget from one Gtk::Container to another, handling reference
+   * count issues to avoid destroying the widget.
+   * @param new_parent A Gtk::Container to move the widget into.
+   */
+  void reparent(Widget & new_parent);
+
+  bool intersect(const Gdk::Rectangle& area) const;
+  
+  /** Computes the intersection of a @a widget 's area and @a area , storing
+   * the intersection in @a intersection , and returns <tt>true</tt> if there was
+   * an intersection.  @a intersection  may be <tt>0</tt> if you're only
+   * interested in whether there was an intersection.
+   * @param area A rectangle.
+   * @param intersection Rectangle to store intersection of @a widget  and @a area .
+   * @return <tt>true</tt> if there was an intersection.
+   */
+  bool intersect(const Gdk::Rectangle& area, Gdk::Rectangle& intersection) const;
+
+  
+  /** Computes the intersection of a @a widget 's area and @a region , returning
+   * the intersection. The result may be empty, use gdk_region_empty() to
+   * check.
+   * @param region A Gdk::Region, in the same coordinate system as 
+   *  @a widget -&gt;allocation. That is, relative to @a widget -&gt;window
+   * for NO_WINDOW widgets; relative to the parent window
+   * of @a widget -&gt;window for widgets with their own window.
+   * @return A newly allocated region holding the intersection of @a widget 
+   * and @a region . The coordinates of the return value are
+   * relative to @a widget -&gt;window for NO_WINDOW widgets, and
+   * relative to the parent window of @a widget -&gt;window for
+   * widgets with their own window.
+   */
+  Gdk::Region region_intersect(const Gdk::Region& region) const;
+
+  
+  /** Stops emission of "child-notify" signals on @a widget . The signals are
+   * queued until thaw_child_notify() is called on @a widget . 
+   * 
+   * This is the analogue of Glib::object_freeze_notify() for child properties.
+   */
+  void freeze_child_notify();
+  
+  /** Emits a "child-notify" signal for the 
+   * child property @a child_property  
+   * on @a widget .
+   * 
+   * This is the analogue of Glib::object_notify() for child properties.
+   * @param child_property The name of a child property installed on the 
+   * class of @a widget &lt;!-- --&gt;'s parent.
+   */
+  void	child_notify(const Glib::ustring& child_property);
+  
+  /** Reverts the effect of a previous call to freeze_child_notify().
+   * This causes all queued "child-notify" signals on @a widget  to be emitted.
+   */
+  void	thaw_child_notify();
+
+  
+  /** Determines if the widget is the focus widget within its
+   * toplevel. (This does not mean that the HAS_FOCUS flag is
+   * necessarily set; HAS_FOCUS will only be set if the
+   * toplevel widget additionally has the global input focus.)
+   * @return <tt>true</tt> if the widget is the focus widget.
+   */
+  bool is_focus() const;
+  
+  /** Causes @a widget  to have the keyboard focus for the Gtk::Window it's
+   * inside. @a widget  must be a focusable widget, such as a Gtk::Entry;
+   * something like Gtk::Frame won't work. (More precisely, it must have the
+   * Gtk::CAN_FOCUS flag set.)
+   */
+  void	grab_focus();
+  
+  /** Causes @a widget  to become the default widget. @a widget  must have the
+   * Gtk::CAN_DEFAULT flag set; typically you have to set this flag
+   * yourself by calling <tt>GTK_WIDGET_SET_FLAGS ( @a widget ,
+   * GTK_CAN_DEFAULT)</tt>.  The default widget is activated when the user
+   * presses Enter in a window.  Default widgets must be activatable,
+   * that is, activate() should affect them.
+   */
+  void	grab_default();
+
+  /** Block events to everything else than this widget and its children. This
+   * way you can get modal behaviour (usually not recommended). One practical
+   * example could be when implementing a key-binding widget that needs
+   * exclusive access to the key combination that the user presses next.
+   *
+   * Calls to add_modal_grab should be paired with calls to remove_modal_grab.
+   */
+  void add_modal_grab();
+
+  /** Remove the modal grab of the widget in case it was previously grabbed.
+   */
+  void remove_modal_grab();
+
+  /** Retrieve the widget which is currently grabbing all events.
+   */
+  static Widget* get_current_modal_grab();
+
+  
+  /** Widgets can be named, which allows you to refer to them from a
+   * gtkrc file. You can apply a style to widgets with a particular name
+   * in the gtkrc file. See the documentation for gtkrc files (on the
+   * same page as the docs for Gtk::RcStyle).
+   * 
+   * Note that widget names are separated by periods in paths (see 
+   * path()), so names with embedded periods may cause confusion.
+   * @param name Name for the widget.
+   */
+  void set_name(const Glib::ustring& name);
+  void unset_name();
+  
+  /** Retrieves the name of a widget. See set_name() for the
+   * significance of widget names.
+   * @return Name of the widget. This string is owned by GTK+ and
+   * should not be modified or freed.
+   */
+  Glib::ustring get_name() const;
+
+  
+  /** This function is for use in widget implementations. Sets the state
+   * of a widget (insensitive, prelighted, etc.) Usually you should set
+   * the state using wrapper functions such as set_sensitive().
+   * @param state New state for @a widget .
+   */
+  void set_state(Gtk::StateType state);
+  
+  /** Sets the sensitivity of a widget. A widget is sensitive if the user
+   * can interact with it. Insensitive widgets are "grayed out" and the
+   * user can't interact with them. Insensitive widgets are known as
+   * "inactive", "disabled", or "ghosted" in some other toolkits.
+   * @param sensitive <tt>true</tt> to make the widget sensitive.
+   */
+  void set_sensitive(bool sensitive = true);
+  
+  void set_app_paintable(bool app_paintable = true);
+  
+  /** Widgets are double buffered by default; you can use this function
+   * to turn off the buffering. "Double buffered" simply means that
+   * gdk_window_begin_paint_region() and gdk_window_end_paint() are called
+   * automatically around expose events sent to the
+   * widget. gdk_window_begin_paint() diverts all drawing to a widget's
+   * window to an offscreen buffer, and gdk_window_end_paint() draws the
+   * buffer to the screen. The result is that users see the window
+   * update in one smooth step, and don't see individual graphics
+   * primitives being rendered.
+   * 
+   * In very simple terms, double buffered widgets don't flicker,
+   * so you would only use this function to turn off double buffering
+   * if you had special needs and really knew what you were doing.
+   * @param double_buffered <tt>true</tt> to double-buffer a widget.
+   */
+  void set_double_buffered(bool double_buffered = true);
+
+  
+  /** Sets whether a when a widgets size allocation changes, the entire
+   * widget is queued for drawing. By default, this setting is <tt>true</tt> and
+   * the entire widget is redrawn on every size change. If your widget
+   * leaves the upper left unchanged when made bigger, turning this
+   * setting on will improve performance.
+   * 
+   * Note that for NO_WINDOW widgets setting this flag to <tt>false</tt> turns
+   * off all allocation on resizing: the widget will not even redraw if
+   * its position changes; this is to allow containers that don't draw
+   * anything to avoid excess invalidations. If you set this flag on a
+   * NO_WINDOW widget that <em>does</em> draw on @a widget -&gt;window, 
+   * you are responsible for invalidating both the old and new allocation 
+   * of the widget when the widget is moved and responsible for invalidating
+   * regions newly when the widget increases size.
+   * @param redraw_on_allocate If <tt>true</tt>, the entire widget will be redrawn
+   * when it is allocated to a new size. Otherwise, only the
+   * new portion of the widget will be redrawn.
+   */
+  void set_redraw_on_allocate(bool redraw_on_allocate = true);
+
+  
+  /** Sets whether @a widget  should be mapped along with its when its parent
+   * is mapped and @a widget  has been shown with show(). 
+   * 
+   * The child visibility can be set for widget before it is added to
+   * a container with set_parent(), to avoid mapping
+   * children unnecessary before immediately unmapping them. However
+   * it will be reset to its default state of <tt>true</tt> when the widget
+   * is removed from a container.
+   * 
+   * Note that changing the child visibility of a widget does not
+   * queue a resize on the widget. Most of the time, the size of
+   * a widget is computed from all visible children, whether or
+   * not they are mapped. If this is not the case, the container
+   * can queue a resize itself.
+   * 
+   * This function is only useful for container implementations and
+   * never should be called by an application.
+   * @param is_visible If <tt>true</tt>, @a widget  should be mapped along with its parent.
+   */
+  void set_child_visible(bool is_visible = true);
+  
+  /** Gets the value set with set_child_visible().
+   * If you feel a need to use this function, your code probably
+   * needs reorganization. 
+   * 
+   * This function is only useful for container implementations and
+   * never should be called by an application.
+   * @return <tt>true</tt> if the widget is mapped with the parent.
+   */
+  bool get_child_visible() const;
+
+  
+  /** Returns the parent container of @a widget .
+   * @return The parent container of @a widget , or <tt>0</tt>.
+   */
+  Container* get_parent();
+  
+  /** Returns the parent container of @a widget .
+   * @return The parent container of @a widget , or <tt>0</tt>.
+   */
+  const Container* get_parent() const;
+
+  
+  /** Gets @a widget 's parent window.
+   * @return The parent window of @a widget .
+   */
+  Glib::RefPtr<Gdk::Window> get_parent_window();
+  
+  /** Gets @a widget 's parent window.
+   * @return The parent window of @a widget .
+   */
+  Glib::RefPtr<const Gdk::Window> get_parent_window() const;
+  
+  /** Sets a non default parent window for @a widget .
+   * @param parent_window The new parent window.
+   */
+  void set_parent_window(const Glib::RefPtr<const Gdk::Window>& parent_window);
+
+  
+  /** This function is used by custom widget implementations; if you're
+   * writing an app, you'd use grab_focus() to move the focus
+   * to a particular widget, and Gtk::Container::set_focus_chain() to
+   * change the focus tab order. So you may want to investigate those
+   * functions instead.
+   * 
+   * child_focus() is called by containers as the user moves
+   * around the window using keyboard shortcuts. @a direction  indicates
+   * what kind of motion is taking place (up, down, left, right, tab
+   * forward, tab backward).  child_focus() invokes the
+   * "focus" signal on Gtk::Widget; widgets override the default handler
+   * for this signal in order to implement appropriate focus behavior.
+   * 
+   * The "focus" default handler for a widget should return <tt>true</tt> if
+   * moving in @a direction  left the focus on a focusable location inside
+   * that widget, and <tt>false</tt> if moving in @a direction  moved the focus
+   * outside the widget. If returning <tt>true</tt>, widgets normally
+   * call grab_focus() to place the focus accordingly;
+   * if returning <tt>false</tt>, they don't modify the current focus location.
+   * 
+   * This function replaces gtk_container_focus() from GTK+ 1.2.  It was
+   * necessary to check that the child was visible, sensitive, and
+   * focusable before calling
+   * gtk_container_focus(). child_focus() returns <tt>false</tt> if
+   * the widget is not currently in a focusable state, so there's no
+   * need for those checks.
+   * @param direction Direction of focus movement.
+   * @return <tt>true</tt> if focus ended up inside @a widget .
+   */
+  bool child_focus(DirectionType direction);
+
+  
+  /** Sets the minimum size of a widget; that is, the widget's size
+   * request will be @a width  by @a height . You can use this function to
+   * force a widget to be either larger or smaller than it normally
+   * would be.
+   * 
+   * In most cases, Gtk::Window::set_default_size() is a better choice for
+   * toplevel windows than this function; setting the default size will
+   * still allow users to shrink the window. Setting the size request
+   * will force them to leave the window at least as large as the size
+   * request. When dealing with window sizes,
+   * Gtk::Window::set_geometry_hints() can be a useful function as well.
+   * 
+   * Note the inherent danger of setting any fixed size - themes,
+   * translations into other languages, different fonts, and user action
+   * can all change the appropriate size for a given widget. So, it's
+   * basically impossible to hardcode a size that will always be
+   * correct.
+   * 
+   * The size request of a widget is the smallest size a widget can
+   * accept while still functioning well and drawing itself correctly.
+   * However in some strange cases a widget may be allocated less than
+   * its requested size, and in many cases a widget may be allocated more
+   * space than it requested.
+   * 
+   * If the size request in a given direction is -1 (unset), then
+   * the "natural" size request of the widget will be used instead.
+   * 
+   * Widgets can't actually be allocated a size less than 1 by 1, but
+   * you can pass 0,0 to this function to mean "as small as possible."
+   * @param width Width @a widget  should request, or -1 to unset.
+   * @param height Height @a widget  should request, or -1 to unset.
+   */
+  void set_size_request(int width = -1, int  height = -1);
+  
+  /** Gets the size request that was explicitly set for the widget using
+   * set_size_request().  A value of -1 stored in @a width  or
+   *  @a height  indicates that that dimension has not been set explicitly
+   * and the natural requisition of the widget will be used intead. See
+   * set_size_request(). To get the size a widget will
+   * actually use, call size_request() instead of
+   * this function.
+   * @param width Return location for width, or <tt>0</tt>.
+   * @param height Return location for height, or <tt>0</tt>.
+   */
+  void get_size_request(int& width, int& height) const;
+
+  
+  /** Sets the event mask (see Gdk::EventMask) for a widget. The event
+   * mask determines which events a widget will receive. Keep in mind
+   * that different widgets have different default event masks, and by
+   * changing the event mask you may disrupt a widget's functionality,
+   * so be careful. This function must be called while a widget is
+   * unrealized. Consider add_events() for widgets that are
+   * already realized, or if you want to preserve the existing event
+   * mask. This function can't be used with Gtk::NO_WINDOW widgets;
+   * to get events on those widgets, place them inside a Gtk::EventBox
+   * and receive events on the event box.
+   * @param events Event mask.
+   */
+  void set_events(Gdk::EventMask events);
+  
+  /** Adds the events in the bitfield @a events  to the event mask for
+   *  @a widget . See set_events() for details.
+   * @param events An event mask, see Gdk::EventMask.
+   */
+  void add_events(Gdk::EventMask events);
+  
+  /** Sets the extension events mask to @a mode . See Gdk::ExtensionMode
+   * and gdk_input_set_extension_events().
+   * @param mode Bitfield of extension events to receive.
+   */
+  void set_extension_events(Gdk::ExtensionMode mode);
+
+  
+  /** Retrieves the extension events the widget will receive; see
+   * gdk_input_set_extension_events().
+   * @return Extension events for @a widget .
+   */
+  Gdk::ExtensionMode get_extension_events() const;
+
+  
+  /** This function returns the topmost widget in the container hierarchy
+   *  @a widget  is a part of. If @a widget  has no parent widgets, it will be
+   * returned as the topmost widget. No reference will be added to the
+   * returned widget; it should not be unreferenced.
+   * 
+   * Note the difference in behavior vs. get_ancestor();
+   * <tt>gtk_widget_get_ancestor (widget, GTK_TYPE_WINDOW)</tt> 
+   * would return
+   * <tt>0</tt> if @a widget  wasn't inside a toplevel window, and if the
+   * window was inside a Gtk::Window-derived widget which was in turn
+   * inside the toplevel Gtk::Window. While the second case may
+   * seem unlikely, it actually happens when a Gtk::Plug is embedded
+   * inside a Gtk::Socket within the same application.
+   * 
+   * To reliably find the toplevel Gtk::Window, use
+   * get_toplevel() and check if the T::OPLEVEL flags
+   * is set on the result.
+   * @code
+   * GtkWidget *toplevel = gtk_widget_get_toplevel (widget);
+   * if (GTK_WIDGET_TOPLEVEL (toplevel))
+   * {
+   * [ Perform action on toplevel. ]
+   * }
+   * @endcode
+   * @return The topmost ancestor of @a widget , or @a widget  itself if there's no ancestor.
+   */
+  Container* get_toplevel();
+  
+  /** This function returns the topmost widget in the container hierarchy
+   *  @a widget  is a part of. If @a widget  has no parent widgets, it will be
+   * returned as the topmost widget. No reference will be added to the
+   * returned widget; it should not be unreferenced.
+   * 
+   * Note the difference in behavior vs. get_ancestor();
+   * <tt>gtk_widget_get_ancestor (widget, GTK_TYPE_WINDOW)</tt> 
+   * would return
+   * <tt>0</tt> if @a widget  wasn't inside a toplevel window, and if the
+   * window was inside a Gtk::Window-derived widget which was in turn
+   * inside the toplevel Gtk::Window. While the second case may
+   * seem unlikely, it actually happens when a Gtk::Plug is embedded
+   * inside a Gtk::Socket within the same application.
+   * 
+   * To reliably find the toplevel Gtk::Window, use
+   * get_toplevel() and check if the T::OPLEVEL flags
+   * is set on the result.
+   * @code
+   * GtkWidget *toplevel = gtk_widget_get_toplevel (widget);
+   * if (GTK_WIDGET_TOPLEVEL (toplevel))
+   * {
+   * [ Perform action on toplevel. ]
+   * }
+   * @endcode
+   * @return The topmost ancestor of @a widget , or @a widget  itself if there's no ancestor.
+   */
+  const Container* get_toplevel() const;
+
+  
+  /** Gets the first ancestor of @a widget  with type @a widget_type . For example,
+   * <tt>gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)</tt> gets the 
+   * first Gtk::Box that's
+   * an ancestor of @a widget . No reference will be added to the returned widget;
+   * it should not be unreferenced. See note about checking for a toplevel
+   * Gtk::Window in the docs for get_toplevel().
+   * 
+   * Note that unlike is_ancestor(), get_ancestor() 
+   * considers @a widget  to be an ancestor of itself.
+   * @param widget_type Ancestor type.
+   * @return The ancestor widget, or <tt>0</tt> if not found.
+   */
+  Widget* get_ancestor(GType widget_type);
+  
+  /** Gets the first ancestor of @a widget  with type @a widget_type . For example,
+   * <tt>gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)</tt> gets the 
+   * first Gtk::Box that's
+   * an ancestor of @a widget . No reference will be added to the returned widget;
+   * it should not be unreferenced. See note about checking for a toplevel
+   * Gtk::Window in the docs for get_toplevel().
+   * 
+   * Note that unlike is_ancestor(), get_ancestor() 
+   * considers @a widget  to be an ancestor of itself.
+   * @param widget_type Ancestor type.
+   * @return The ancestor widget, or <tt>0</tt> if not found.
+   */
+  const Widget* get_ancestor(GType widget_type) const;
+
+  
+  /** Gets the colormap that will be used to render @a widget . No reference will
+   * be added to the returned colormap; it should not be unreferenced.
+   * @return The colormap used by @a widget .
+   */
+  Glib::RefPtr<Gdk::Colormap> get_colormap();
+
+  
+  /** Gets the visual that will be used to render @a widget .
+   * @return The visual for @a widget .
+   */
+  Glib::RefPtr<Gdk::Visual> get_visual();
+
+  
+  /** Get the Gdk::Screen from the toplevel window associated with
+   * this widget. This function can only be called after the widget
+   * has been added to a widget hierarchy with a Gtk::Window
+   * at the top.
+   * 
+   * In general, you should only create screen specific
+   * resources when a widget has been realized, and you should
+   * free those resources when the widget is unrealized.
+   * @return The Gdk::Screen for the toplevel for this widget.
+   * 
+   * Since: 2.2.
+   */
+  Glib::RefPtr<Gdk::Screen> get_screen();
+  
+  /** Get the Gdk::Screen from the toplevel window associated with
+   * this widget. This function can only be called after the widget
+   * has been added to a widget hierarchy with a Gtk::Window
+   * at the top.
+   * 
+   * In general, you should only create screen specific
+   * resources when a widget has been realized, and you should
+   * free those resources when the widget is unrealized.
+   * @return The Gdk::Screen for the toplevel for this widget.
+   * 
+   * Since: 2.2.
+   */
+  Glib::RefPtr<const Gdk::Screen> get_screen() const;
+
+  
+  /** Checks whether there is a Gdk::Screen is associated with
+   * this widget. All toplevel widgets have an associated
+   * screen, and all widgets added into a heirarchy with a toplevel
+   * window at the top.
+   * @return <tt>true</tt> if there is a Gdk::Screen associcated
+   * with the widget.
+   * 
+   * Since: 2.2.
+   */
+  bool has_screen() const;
+
+  
+  /** Get the Gdk::Display for the toplevel window associated with
+   * this widget. This function can only be called after the widget
+   * has been added to a widget hierarchy with a Gtk::Window at the top.
+   * 
+   * In general, you should only create display specific
+   * resources when a widget has been realized, and you should
+   * free those resources when the widget is unrealized.
+   * @return The Gdk::Display for the toplevel for this widget.
+   * 
+   * Since: 2.2.
+   */
+  Glib::RefPtr<Gdk::Display> get_display();
+  
+  /** Get the Gdk::Display for the toplevel window associated with
+   * this widget. This function can only be called after the widget
+   * has been added to a widget hierarchy with a Gtk::Window at the top.
+   * 
+   * In general, you should only create display specific
+   * resources when a widget has been realized, and you should
+   * free those resources when the widget is unrealized.
+   * @return The Gdk::Display for the toplevel for this widget.
+   * 
+   * Since: 2.2.
+   */
+  Glib::RefPtr<const Gdk::Display> get_display() const;
+
+  
+  /** Get the root window where this widget is located. This function can
+   * only be called after the widget has been added to a widget
+   * heirarchy with Gtk::Window at the top.
+   * 
+   * The root window is useful for such purposes as creating a popup
+   * Gdk::Window associated with the window. In general, you should only
+   * create display specific resources when a widget has been realized,
+   * and you should free those resources when the widget is unrealized.
+   * @return The Gdk::Window root window for the toplevel for this widget.
+   * 
+   * Since: 2.2.
+   */
+  Glib::RefPtr<Gdk::Window> get_root_window();
+  
+  /** Get the root window where this widget is located. This function can
+   * only be called after the widget has been added to a widget
+   * heirarchy with Gtk::Window at the top.
+   * 
+   * The root window is useful for such purposes as creating a popup
+   * Gdk::Window associated with the window. In general, you should only
+   * create display specific resources when a widget has been realized,
+   * and you should free those resources when the widget is unrealized.
+   * @return The Gdk::Window root window for the toplevel for this widget.
+   * 
+   * Since: 2.2.
+   */
+  Glib::RefPtr<const Gdk::Window> get_root_window() const;
+  
+  
+  /** Gets the settings object holding the settings (global property
+   * settings, RC file information, etc) used for this widget.
+   * 
+   * Note that this function can only be called when the Gtk::Widget
+   * is attached to a toplevel, since the settings object is specific
+   * to a particular Gdk::Screen.
+   * @return The relevant Gtk::Settings object.
+   */
+  Glib::RefPtr<Settings> get_settings();
+
+  
+  /** Returns the clipboard object for the given selection to
+   * be used with @a widget . @a widget  must have a Gdk::Display
+   * associated with it, so must be attached to a toplevel
+   * window.
+   * @param selection A Gdk::Atom which identifies the clipboard
+   * to use. Gdk::SELECTION_CLIPBOARD gives the
+   * default clipboard. Another common value
+   * is Gdk::SELECTION_PRIMARY, which gives
+   * the primary X selection.
+   * @return The appropriate clipboard object. If no
+   * clipboard already exists, a new one will
+   * be created. Once a clipboard object has
+   * been created, it is persistent for all time.
+   * 
+   * Since: 2.2.
+   */
+  Glib::RefPtr<Clipboard> get_clipboard(const Glib::ustring& selection);
+  
+  /** Returns the clipboard object for the given selection to
+   * be used with @a widget . @a widget  must have a Gdk::Display
+   * associated with it, so must be attached to a toplevel
+   * window.
+   * @param selection A Gdk::Atom which identifies the clipboard
+   * to use. Gdk::SELECTION_CLIPBOARD gives the
+   * default clipboard. Another common value
+   * is Gdk::SELECTION_PRIMARY, which gives
+   * the primary X selection.
+   * @return The appropriate clipboard object. If no
+   * clipboard already exists, a new one will
+   * be created. Once a clipboard object has
+   * been created, it is persistent for all time.
+   * 
+   * Since: 2.2.
+   */
+  Glib::RefPtr<const Clipboard> get_clipboard(const Glib::ustring& selection) const;
+
+  //TODO: This probably needs a special conversion to do an extra ref (take_copy=true) for the returned instance:
+  
+  Glib::RefPtr<Atk::Object> get_accessible();
+
+  
+  /** Sets the colormap for the widget to the given value. Widget must not
+   * have been previously realized. This probably should only be used
+   * from an <tt>init()</tt> function (i.e. from the constructor 
+   * for the widget).
+   * @param colormap A colormap.
+   */
+  void set_colormap(const Glib::RefPtr<const Gdk::Colormap> &colormap);
+  
+  /** Returns the event mask for the widget (a bitfield containing flags
+   * from the Gdk::EventMask enumeration). These are the events that the widget
+   * will receive.
+   * @return Event mask for @a widget .
+   */
+  Gdk::EventMask get_events() const;
+  
+  /** Obtains the location of the mouse pointer in widget coordinates.
+   * Widget coordinates are a bit odd; for historical reasons, they are
+   * defined as @a widget -&gt;window coordinates for widgets that are not
+   * Gtk::NO_WINDOW widgets, and are relative to @a widget -&gt;allocation.x,
+   *  @a widget -&gt;allocation.y for widgets that are Gtk::NO_WINDOW widgets.
+   * @param x Return location for the X coordinate, or <tt>0</tt>.
+   * @param y Return location for the Y coordinate, or <tt>0</tt>.
+   */
+  void get_pointer(int &x, int &y) const;
+  
+  /** Determines whether @a widget  is somewhere inside @a ancestor , possibly with
+   * intermediate containers.
+   * @param ancestor Another Gtk::Widget.
+   * @return <tt>true</tt> if @a ancestor  contains @a widget  as a child, grandchild, great grandchild, etc.
+   */
+  bool is_ancestor(Widget &ancestor) const;
+
+  
+  /** Translate coordinates relative to @a src_widget 's allocation to coordinates
+   * relative to @a dest_widget 's allocations. In order to perform this
+   * operation, both widgets must be realized, and must share a common
+   * toplevel.
+   * @param dest_widget A Gtk::Widget.
+   * @param src_x X position relative to @a src_widget .
+   * @param src_y Y position relative to @a src_widget .
+   * @param dest_x Location to store X position relative to @a dest_widget .
+   * @param dest_y Location to store Y position relative to @a dest_widget .
+   * @return <tt>false</tt> if either widget was not realized, or there
+   * was no common ancestor. In this case, nothing is stored in
+   * * @a dest_x  and * @a dest_y . Otherwise <tt>true</tt>.
+   */
+  bool translate_coordinates(Widget& dest_widget,
+					       int src_x, int src_y,
+					       int& dest_x, int& dest_y);
+
+/* STYLE */
+  
+  /** Sets the Gtk::Style for a widget ( @a widget -&gt;style). You probably don't
+   * want to use this function; it interacts badly with themes, because
+   * themes work by replacing the Gtk::Style. Instead, use
+   * modify_style().
+   * @param style A Gtk::Style.
+   */
+  void set_style(const Glib::RefPtr<Style>& style);
+  void unset_style();
+
+  
+  /** Ensures that @a widget  has a style ( @a widget -&gt;style). Not a very useful
+   * function; most of the time, if you want the style, the widget is
+   * realized, and realized widgets are guaranteed to have a style
+   * already.
+   */
+  void ensure_style();
+  
+  /** Simply an accessor function that returns @a widget -&gt;style.
+   * @return The widget's Gtk::Style.
+   */
+  Glib::RefPtr<Style> get_style();
+  
+  /** Simply an accessor function that returns @a widget -&gt;style.
+   * @return The widget's Gtk::Style.
+   */
+  Glib::RefPtr<const Style> get_style() const;
+  
+  /** Modifies style values on the widget. Modifications made using this
+   * technique take precedence over style values set via an RC file,
+   * however, they will be overriden if a style is explicitely set on
+   * the widget using set_style(). The Gtk::RcStyle structure
+   * is designed so each field can either be set or unset, so it is
+   * possible, using this function, to modify some style values and
+   * leave the others unchanged.
+   * 
+   * Note that modifications made with this function are not cumulative
+   * with previous calls to modify_style() or with such
+   * functions as modify_fg(). If you wish to retain
+   * previous values, you must first call get_modifier_style(),
+   * make your modifications to the returned style, then call
+   * modify_style() with that style. On the other hand,
+   * if you first call modify_style(), subsequent calls
+   * to such functions modify_fg() will have a cumulative
+   * effect with the initial modifications.
+   * @param style The Gtk::RcStyle holding the style modifications.
+   */
+  void modify_style(const Glib::RefPtr<RcStyle>& style);
+  
+  /** Returns the current modifier style for the widget. (As set by
+   * modify_style().) If no style has previously set, a new
+   * Gtk::RcStyle will be created with all values unset, and set as the
+   * modifier style for the widget. If you make changes to this rc
+   * style, you must call modify_style(), passing in the
+   * returned rc style, to make sure that your changes take effect.
+   * 
+   * Caution: passing the style back to modify_style() will
+   * normally end up destroying it, because modify_style() copies
+   * the passed-in style and sets the copy as the new modifier style,
+   * thus dropping any reference to the old modifier style. Add a reference
+   * to the modifier style if you want to keep it alive.
+   * @return The modifier style for the widget. This rc style is
+   * owned by the widget. If you want to keep a pointer to value this
+   * around, you must add a refcount using Gtk::RcStyle::ref().
+   */
+  Glib::RefPtr<RcStyle> get_modifier_style();
+  
+  /** Returns the current modifier style for the widget. (As set by
+   * modify_style().) If no style has previously set, a new
+   * Gtk::RcStyle will be created with all values unset, and set as the
+   * modifier style for the widget. If you make changes to this rc
+   * style, you must call modify_style(), passing in the
+   * returned rc style, to make sure that your changes take effect.
+   * 
+   * Caution: passing the style back to modify_style() will
+   * normally end up destroying it, because modify_style() copies
+   * the passed-in style and sets the copy as the new modifier style,
+   * thus dropping any reference to the old modifier style. Add a reference
+   * to the modifier style if you want to keep it alive.
+   * @return The modifier style for the widget. This rc style is
+   * owned by the widget. If you want to keep a pointer to value this
+   * around, you must add a refcount using Gtk::RcStyle::ref().
+   */
+  Glib::RefPtr<const RcStyle> get_modifier_style() const;
+
+  // we need custom documentation because modify_* can take a NULL pointer
+  // (which we wrap with unset_*)
+  /** Sets the foreground color for a widget in a particular state.
+   * All other style values are left untouched. See also modify_style() and
+   * unset_fg().
+   *
+   * @param state The state for which to set the foreground color.
+   * @param color The color to assign (does not need to be allocated).
+   */
+  
+  /** Sets the foreground color for a widget in a particular state.  All
+   * other style values are left untouched. See also
+   * modify_style().
+   * @param state The state for which to set the foreground color.
+   * @param color The color to assign (does not need to be allocated).
+   */
+  void modify_fg(StateType state, const Gdk::Color& color);
+
+
+  /** Sets the background color for a widget in a particular state.
+   * All other style values are left untouched. See also modify_style() and
+   * unset_bg().
+   *
+   * @param state The state for which to set the background color.
+   * @param color The color to assign (does not need to be allocated).
+   */
+  
+  /** Sets the background color for a widget in a particular state.  All
+   * other style values are left untouched. See also
+   * modify_style().
+   * @param state The state for which to set the background color.
+   * @param color The color to assign (does not need to be allocated).
+   */
+  void modify_bg(StateType state, const Gdk::Color& color);
+
+  // TODO: Document this, and perhaps add unset_bg_pixmap
+  void modify_bg_pixmap(StateType state, const Glib::ustring& pixmap_name);
+
+  /** Sets the text color for a widget in a particular state.
+   * All other style values are left untouched. The text color is the
+   * foreground color used along with the base color (see modify_base() ) for
+   * widgets such as Gtk::Entry and Gtk::TextView. See also modify_style() and
+   * unset_text().
+   *
+   * @param state The state for which to set the text color.
+   * @param color The color to assign (does not need to be allocated).
+   */
+  
+  /** Sets the text color for a widget in a particular state.  All other
+   * style values are left untouched. The text color is the foreground
+   * color used along with the base color (see modify_base())
+   * for widgets such as Gtk::Entry and Gtk::TextView. See also
+   * modify_style().
+   * @param state The state for which to set the text color.
+   * @param color The color to assign (does not need to be allocated).
+   */
+  void modify_text(StateType state, const Gdk::Color& color);
+
+  /** Sets the base color for a widget in a particular state.
+   * All other style values are left untouched. The base color is the
+   * background color used along with the text color (see modify_text() ) for
+   * widgets such as Gtk::Entry and Gtk::TextView. See also modify_style() and
+   * unset_base().
+   *
+   * @param state The state for which to set the text color.
+   * @param color The color to assign (does not need to be allocated).
+   */
+  
+  /** Sets the base color for a widget in a particular state.
+   * All other style values are left untouched. The base color
+   * is the background color used along with the text color
+   * (see modify_text()) for widgets such as Gtk::Entry
+   * and Gtk::TextView. See also modify_style().
+   * @param state The state for which to set the base color.
+   * @param color The color to assign (does not need to be allocated).
+   */
+  void modify_base(StateType state, const Gdk::Color& color);
+
+  /** Sets the font to use for a widget.
+   * All other style values are left untouched. See also modify_style() and
+   * unset_font().
+   */
+  
+  /** Sets the font to use for a widget.  All other style values are left
+   * untouched. See also modify_style().
+   * @param font_desc The font description to use.
+   */
+  void modify_font(const Pango::FontDescription& font_desc);
+
+  /** Undo the effect of previous calls to modify_fg() for a particular state.
+   * All other style values are left untouched. See also modify_style().
+   */
+  void unset_fg(StateType state);
+  
+  /** Undo the effect of previous calls to modify_bg() for a particular state.
+   * All other style values are left untouched. See also modify_style().
+   */
+  void unset_bg(StateType state);
+
+  /** Undo the effect of previous calls to modify_text() for a particular state.
+   * All other style values are left untouched. See also modify_style().
+   */
+  void unset_text(StateType state);
+
+  /** Undo the effect of previous calls to modify_base() for a particular state.
+   * All other style values are left untouched. See also modify_style().
+   */
+  void unset_base(StateType state);
+
+  /** Undo the effect of previous calls to modify_font() for a particular state.
+   * All other style values are left untouched. See also modify_style().
+   */
+  void unset_font();
+
+  //The parameter name is "the_property_name" to avoid a warning because there is a method with the "property_name" name.
+  template <class PropertyType>
+  void get_style_property(const Glib::ustring& the_property_name, PropertyType& value) const;
+
+  
+  /** Creates a new Pango::Context with the appropriate colormap,
+   * font description, and base direction for drawing text for
+   * this widget. See also get_pango_context().
+   * @return The new Pango::Context.
+   */
+  Glib::RefPtr<Pango::Context> create_pango_context();
+  
+  /** Gets a Pango::Context with the appropriate colormap, font description
+   * and base direction for this widget. Unlike the context returned
+   * by create_pango_context(), this context is owned by
+   * the widget (it can be used until the screen for the widget changes
+   * or the widget is removed from its toplevel), and will be updated to
+   * match any changes to the widget's attributes.
+   * 
+   * If you create and keep a Pango::Layout using this context, you must
+   * deal with changes to the context by calling pango_layout_context_changed()
+   * on the layout in response to the ::style-set and ::direction-changed signals
+   * for the widget.
+   * @return The Pango::Context for the widget.
+   */
+  Glib::RefPtr<Pango::Context> get_pango_context();
+  
+  /** Creates a new Pango::Layout with the appropriate colormap,
+   * font description, and base direction for drawing text for
+   * this widget.
+   * 
+   * If you keep a Pango::Layout created in this way around, in order
+   * notify the layout of changes to the base direction or font of this
+   * widget, you must call pango_layout_context_changed() in response to
+   * the ::style-set and ::direction-changed signals for the widget.
+   * @param text Text to set on the layout (can be <tt>0</tt>).
+   * @return The new Pango::Layout.
+   */
+  Glib::RefPtr<Pango::Layout> create_pango_layout(const Glib::ustring& text);
+
+  
+  /** A convenience function that uses the theme engine and RC file
+   * settings for @a widget  to look up @a stock_id  and render it to
+   * a pixbuf. @a stock_id  should be a stock icon ID such as
+   * Gtk::STOCK_OPEN or Gtk::STOCK_OK. @a size  should be a size
+   * such as Gtk::ICON_SIZE_MENU. @a detail  should be a string that
+   * identifies the widget or code doing the rendering, so that
+   * theme engines can special-case rendering for that widget or code.
+   * 
+   * The pixels in the returned Gdk::Pixbuf are shared with the rest of
+   * the application and should not be modified. The pixbuf should be freed
+   * after use with Glib::object_unref().
+   * @param stock_id A stock ID.
+   * @param size A stock size. A size of (GtkIconSize)-1 means render at 
+   * the size of the source and don't scale (if there are multiple 
+   * source sizes, GTK+ picks one of the available sizes).
+   * @param detail Render detail to pass to theme engine.
+   * @return A new pixbuf, or <tt>0</tt> if the stock ID wasn't known.
+   */
+  Glib::RefPtr<Gdk::Pixbuf> render_icon(const StockID& stock_id, IconSize size, const Glib::ustring& detail = Glib::ustring());
+
+  
+  /** Sets a widgets composite name. The widget must be
+   * a composite child of its parent; see push_composite_child().
+   * @param name The name to set.
+   */
+  void set_composite_name(const Glib::ustring& name);
+  void unset_composite_name();
+  
+  /** Obtains the composite name of a widget.
+   * @return The composite name of @a widget , or <tt>0</tt> if @a widget  is not
+   * a composite child. The string should not be freed when it is no 
+   * longer needed.
+   */
+  Glib::ustring get_composite_name() const;
+
+  
+  void reset_rc_styles();
+
+
+  // PUSH/POP - these are used to create widgets.  Hidden arguments to override the defaults.
+  
+  /** Pushes @a cmap  onto a global stack of colormaps; the topmost
+   * colormap on the stack will be used to create all widgets.
+   * Remove @a cmap  with pop_colormap(). There's little
+   * reason to use this function.
+   * @param cmap A Gdk::Colormap.
+   */
+  static void push_colormap(const Glib::RefPtr<const Gdk::Colormap>& cmap);
+  
+  /** Removes a colormap pushed with push_colormap().
+   */
+  static void pop_colormap();
+
+  
+  /** Makes all newly-created widgets as composite children until
+   * the corresponding pop_composite_child() call.
+   * 
+   * A composite child is a child that's an implementation detail of the
+   * container it's inside and should not be visible to people using the
+   * container. Composite children aren't treated differently by GTK (but
+   * see Gtk::Container::foreach() vs. Gtk::Container::forall()), but e.g. GUI 
+   * builders might want to treat them in a different way.
+   * 
+   * Here is a simple example:
+   * @code
+   * gtk_widget_push_composite_child (&lt;!-- --&gt;);
+   * scrolled_window->hscrollbar = gtk_hscrollbar_new (hadjustment);
+   * gtk_widget_set_composite_name (scrolled_window->hscrollbar, "hscrollbar");
+   * gtk_widget_pop_composite_child (&lt;!-- --&gt;);
+   * gtk_widget_set_parent (scrolled_window->hscrollbar, 
+   * GTK_WIDGET (scrolled_window));
+   * g_object_ref (scrolled_window->hscrollbar);
+   * @endcode
+   */
+  static void push_composite_child();
+  
+  /** Cancels the effect of a previous call to push_composite_child().
+   */
+  static void pop_composite_child();
+
+
+/* DEFAULTS */
+
+  
+  /** Sets the default colormap to use when creating widgets.
+   * push_colormap() is a better function to use if
+   * you only want to affect a few widgets, rather than all widgets.
+   * @param colormap A Gdk::Colormap.
+   */
+  static void set_default_colormap(const Glib::RefPtr<const Gdk::Colormap>& colormap);
+  
+  /** Returns the default style used by all widgets initially.
+   * @return The default style. This Gtk::Style object is owned by GTK+ and
+   * should not be modified or freed.
+   */
+  static Glib::RefPtr<Style> get_default_style();
+  
+  /** Obtains the default colormap used to create widgets.
+   * @return Default widget colormap.
+   */
+  static Glib::RefPtr<Gdk::Colormap> get_default_colormap();
+  
+  /** Obtains the visual of the default colormap. Not really useful;
+   * used to be useful before gdk_colormap_get_visual() existed.
+   * @return Visual of the default colormap.
+   */
+  static Glib::RefPtr<Gdk::Visual> get_default_visual();
+
+
+/* Directionality of Text */
+
+  
+  /** Sets the reading direction on a particular widget. This direction
+   * controls the primary direction for widgets containing text,
+   * and also the direction in which the children of a container are
+   * packed. The ability to set the direction is present in order
+   * so that correct localization into languages with right-to-left
+   * reading directions can be done. Generally, applications will
+   * let the default reading direction present, except for containers
+   * where the containers are arranged in an order that is explicitely
+   * visual rather than logical (such as buttons for text justification).
+   * 
+   * If the direction is set to Gtk::TEXT_DIR_NONE, then the value
+   * set by set_default_direction() will be used.
+   * @param dir The new direction.
+   */
+  void set_direction(TextDirection dir);
+  
+  /** Gets the reading direction for a particular widget. See
+   * set_direction().
+   * @return The reading direction for the widget.
+   */
+  TextDirection get_direction();
+  
+  /** Sets the default reading direction for widgets where the
+   * direction has not been explicitly set by set_direction().
+   * @param dir The new default direction. This cannot be
+   * Gtk::TEXT_DIR_NONE.
+   */
+  static void set_default_direction(TextDirection dir);
+  
+  /** Obtains the current default reading direction. See
+   * set_default_direction().
+   * @return The current default direction.
+   */
+  static TextDirection get_default_direction();
+
+
+/* Shape masking */
+  
+  /** Sets a shape for this widget's GDK window. This allows for
+   * transparent windows etc., see gdk_window_shape_combine_mask()
+   * for more information.
+   * @param shape_mask Shape to be added.
+   * @param offset_x X position of shape mask with respect to @a window .
+   * @param offset_y Y position of shape mask with respect to @a window .
+   */
+  void shape_combine_mask(const Glib::RefPtr<const Gdk::Bitmap>& shape_mask, int offset_x, int offset_y);
+  void unset_shape_combine_mask();
+
+
+  // must be realized 
+  
+  /** Recursively resets the shape on this widget and its descendants.
+   */
+  void reset_shapes();
+
+/* Paths */
+  /// Compute a widget's path of the form "GtkWindow.MyLabel"
+  void path(Glib::ustring& path, Glib::ustring& path_reversed);
+  void class_path(Glib::ustring& path, Glib::ustring& path_reversed);
+  
+
+  /** Returns a newly allocated list of the widgets, normally labels, for 
+   * which this widget is a the target of a mnemonic (see for example, 
+   * Gtk::Label::set_mnemonic_widget()).
+   * 
+   * The widgets in the list are not individually referenced. If you
+   * want to iterate through the list and perform actions involving
+   * callbacks that might destroy the widgets, you
+   * <em>must</em> call <tt>g_list_foreach (result,
+   * (GFunc)g_object_ref, <tt>0</tt>)</tt> first, and then unref all the
+   * widgets afterwards.
+   * @return The list of mnemonic labels; free this list
+   * with Glib::list_free() when you are done with it.
+   * 
+   * Since: 2.4.
+   */
+  Glib::ListHandle<Widget*> list_mnemonic_labels();
+ 
+  /** Returns a newly allocated list of the widgets, normally labels, for 
+   * which this widget is a the target of a mnemonic (see for example, 
+   * Gtk::Label::set_mnemonic_widget()).
+   * 
+   * The widgets in the list are not individually referenced. If you
+   * want to iterate through the list and perform actions involving
+   * callbacks that might destroy the widgets, you
+   * <em>must</em> call <tt>g_list_foreach (result,
+   * (GFunc)g_object_ref, <tt>0</tt>)</tt> first, and then unref all the
+   * widgets afterwards.
+   * @return The list of mnemonic labels; free this list
+   * with Glib::list_free() when you are done with it.
+   * 
+   * Since: 2.4.
+   */
+  Glib::ListHandle<const Widget*> list_mnemonic_labels() const;
+ 
+  /** Adds a widget to the list of mnemonic labels for
+   * this widget. (See list_mnemonic_labels()). Note the
+   * list of mnemonic labels for the widget is cleared when the
+   * widget is destroyed, so the caller must make sure to update
+   * it's internal state at this point as well, by using a connection
+   * to the ::destroy signal or a weak notifier.
+   * 
+   * Since: 2.4
+   * @param label A Gtk::Widget that acts as a mnemonic label for @a widget .
+   */
+  void add_mnemonic_label(Widget& label);
+ 
+  /** Removes a widget from the list of mnemonic labels for
+   * this widget. (See list_mnemonic_labels()). The widget
+   * must have previously been added to the list with
+   * add_mnemonic_label().
+   * 
+   * Since: 2.4
+   * @param label A Gtk::Widget that was previously set as a mnemnic label for
+   *  @a widget  with add_mnemonic_label().
+   */
+  void remove_mnemonic_label(Widget& label);
+           
+
+  //TODO: Should drag_get_data() be const?
+  
+  void drag_get_data(const Glib::RefPtr<Gdk::DragContext>& context, Glib::ustring& target, guint32 time);		
+  
+  void drag_highlight();
+  
+  void drag_unhighlight();
+
+  void drag_dest_set(DestDefaults flags = DestDefaults(0), Gdk::DragAction actions = Gdk::DragAction(0));
+  void drag_dest_set(const ArrayHandle_TargetEntry& targets, DestDefaults flags = DEST_DEFAULT_ALL, Gdk::DragAction actions = Gdk::ACTION_COPY);
+  
+
+  void drag_dest_set_proxy(const Glib::RefPtr<Gdk::Window>& proxy_window, Gdk::DragProtocol protocol, bool use_coordinates);
+  
+  void drag_dest_unset();
+  
+  /** Looks for a match between @a context -&gt;targets and the
+   *  @a dest_target_list , returning the first matching target, otherwise
+   * returning Gdk::NONE. @a dest_target_list  should usually be the return
+   * value from gtk_drag_dest_get_target_list(), but some widgets may
+   * have different valid targets for different parts of the widget; in
+   * that case, they will have to implement a drag_motion handler that
+   * passes the correct target list to this function.
+   * @param context Drag context.
+   * @param target_list List of droppable targets.
+   * @return First target that the source offers and the dest can accept, or Gdk::NONE.
+   */
+  Glib::ustring drag_dest_find_target(const Glib::RefPtr<Gdk::DragContext>& context, const Glib::RefPtr<TargetList>& target_list) const;
+  Glib::ustring drag_dest_find_target(const Glib::RefPtr<Gdk::DragContext>& context) const;
+
+  
+  /** Returns the list of targets this widget can accept from
+   * drag-and-drop.
+   * @return The Gtk::TargetList, or <tt>0</tt> if none.
+   */
+  Glib::RefPtr<TargetList> drag_dest_get_target_list();
+  
+  /** Returns the list of targets this widget can accept from
+   * drag-and-drop.
+   * @return The Gtk::TargetList, or <tt>0</tt> if none.
+   */
+  Glib::RefPtr<const TargetList> drag_dest_get_target_list() const;
+  
+  /** Sets the target types that this widget can accept from drag-and-drop.
+   * The widget must first be made into a drag destination with
+   * gtk_drag_dest_set().
+   * @param target_list List of droppable targets, or <tt>0</tt> for none.
+   */
+  void drag_dest_set_target_list(const Glib::RefPtr<TargetList>& target_list);
+
+  
+  /** Add the text targets supported by Gtk::Selection to
+   * the target list of the drag destination. The targets
+   * are added with @a info  = 0. If you need another value, 
+   * use gtk_target_list_add_text_targets() and
+   * gtk_drag_dest_set_target_list().
+   * 
+   * Since: 2.6
+   * @param widget A Gtk::Widget that's a drag destination.
+   */
+  void drag_dest_add_text_targets();  
+  
+  /** Add the image targets supported by Gtk::Selection to
+   * the target list of the drag destination. The targets
+   * are added with @a info  = 0. If you need another value, 
+   * use gtk_target_list_add_image_targets() and
+   * gtk_drag_dest_set_target_list().
+   * 
+   * Since: 2.6
+   * @param widget A Gtk::Widget that's a drag destination.
+   */
+  void drag_dest_add_image_targets();
+  
+  /** Add the URI targets supported by Gtk::Selection to
+   * the target list of the drag destination. The targets
+   * are added with @a info  = 0. If you need another value, 
+   * use gtk_target_list_add_uri_targets() and
+   * gtk_drag_dest_set_target_list().
+   * 
+   * Since: 2.6
+   * @param widget A Gtk::Widget that's a drag destination.
+   */
+  void drag_dest_add_uri_targets();
+ 
+  void drag_source_set(const ArrayHandle_TargetEntry& targets, Gdk::ModifierType start_button_mask = Gdk::MODIFIER_MASK, Gdk::DragAction actions = Gdk::ACTION_COPY);
+  
+
+  void drag_source_unset();
+
+  
+  /** Sets the icon that will be used for drags from a particular widget
+   * from a pixmap/mask. GTK+ retains references for the arguments, and 
+   * will release them when they are no longer needed.
+   * Use gtk_drag_source_set_icon_pixbuf() instead.
+   * @param colormap The colormap of the icon.
+   * @param pixmap The image data for the icon.
+   * @param mask The transparency mask for an image.
+   */
+  void drag_source_set_icon(const Glib::RefPtr<Gdk::Colormap>& colormap, const Glib::RefPtr<Gdk::Pixmap>& pixmap, const Glib::RefPtr<Gdk::Bitmap>& mask);
+  
+  /** Sets the icon that will be used for drags from a particular widget
+   * from a Gdk::Pixbuf. GTK+ retains a reference for @a pixbuf  and will 
+   * release it when it is no longer needed.
+   * @param pixbuf The Gdk::Pixbuf for the drag icon.
+   */
+  void drag_source_set_icon(const Glib::RefPtr<Gdk::Pixbuf>& pixbuf);
+  
+  /** Sets the icon that will be used for drags from a particular source
+   * to a stock icon.
+   * @param stock_id The ID of the stock icon to use.
+   */
+  void drag_source_set_icon(const StockID& stock_id);
+
+  
+  /** Add the text targets supported by Gtk::Selection to
+   * the target list of the drag source.  The targets
+   * are added with @a info  = 0. If you need another value, 
+   * use gtk_target_list_add_text_targets() and
+   * gtk_drag_source_set_target_list().
+   * 
+   * Since: 2.6
+   * @param widget A Gtk::Widget that's is a drag source.
+   */
+  void drag_source_add_text_targets();
+  
+  /** Add the URI targets supported by Gtk::Selection to
+   * the target list of the drag source.  The targets
+   * are added with @a info  = 0. If you need another value, 
+   * use gtk_target_list_add_uri_targets() and
+   * gtk_drag_source_set_target_list().
+   * 
+   * Since: 2.6
+   * @param widget A Gtk::Widget that's is a drag source.
+   */
+  void drag_source_add_uri_targets();
+  
+  /** Add the writable image targets supported by Gtk::Selection to
+   * the target list of the drag source. The targets
+   * are added with @a info  = 0. If you need another value, 
+   * use gtk_target_list_add_image_targets() and
+   * gtk_drag_source_set_target_list().
+   * 
+   * Since: 2.6
+   * @param widget A Gtk::Widget that's is a drag source.
+   */
+  void drag_source_add_image_targets();
+  
+  
+  /** Initiates a drag on the source side. The function
+   * only needs to be used when the application is
+   * starting drags itself, and is not needed when
+   * gtk_drag_source_set() is used.
+   * @param targets The targets (data formats) in which the
+   * source can provide the data.
+   * @param actions A bitmask of the allowed drag actions for this drag.
+   * @param button The button the user clicked to start the drag.
+   * @param event The event that triggered the start of the drag.
+   * @return The context for this drag.
+   */
+  Glib::RefPtr<Gdk::DragContext> drag_begin(const Glib::RefPtr<TargetList>& targets, Gdk::DragAction actions, int button, GdkEvent* event);
+  
+  /** Checks to see if a mouse drag starting at ( @a start_x , @a start_y ) and ending
+   * at ( @a current_x , @a current_y ) has passed the GTK+ drag threshold, and thus
+   * should trigger the beginning of a drag-and-drop operation.
+   * @param start_x X coordinate of start of drag.
+   * @param start_y Y coordinate of start of drag.
+   * @param current_x Current X coordinate.
+   * @param current_y Current Y coordinate.
+   * @return <tt>true</tt> if the drag threshold has been passed.
+   */
+  bool drag_check_threshold(int start_x, int start_y, int current_x, int current_y);
+  
+
+  //These should be a method of Gdk::DragContext, but gdkmm can't depend on gtkmm.
+  static Widget* drag_get_source_widget(const Glib::RefPtr<Gdk::DragContext>& context);
+  void drag_set_as_icon(const Glib::RefPtr<Gdk::DragContext>& context, int hot_x, int hot_y);
+  
+  
+  /** This function works like queue_resize(), except that the
+   * widget is not invalidated.
+   * 
+   * Since: 2.4
+   */
+  void queue_resize_no_redraw();
+  
+  /** Returns the current value of the "no_show_all" property, which determines
+   * whether calls to show_all() and hide_all() 
+   * will affect this widget.
+   * @return The current value of the "no_show_all" property.
+   * 
+   * Since: 2.4.
+   */
+  bool get_no_show_all() const;
+  
+  /** Sets the "no_show_all" property, which determines whether calls to 
+   * show_all() and hide_all() will affect this widget. 
+   * 
+   * This is mostly for use in constructing widget hierarchies with externally
+   * controlled visibility, see Gtk::UIManager.
+   * 
+   * Since: 2.4
+   * @param no_show_all The new value for the "no_show_all" property.
+   */
+  void set_no_show_all(bool no_show_all = true);
+
+  //Used when implementing containers:
+  
+  /** This function is useful only when implementing subclasses of Gtk::Container.
+   * Sets the container as the parent of @a widget , and takes care of
+   * some details such as updating the state and style of the child
+   * to reflect its new location. The opposite function is
+   * unparent().
+   * @param parent Parent container.
+   */
+  void set_parent(Widget& parent);
+  
+  /** This function is only for use in widget implementations.
+   * Should be called by implementations of the remove method
+   * on Gtk::Container, to dissociate a child from the container.
+   */
+  void unparent();
+
+  void draw_insertion_cursor(Glib::RefPtr<Gdk::Drawable> drawable, const Gdk::Rectangle& area, const Gdk::Rectangle& location, bool is_primary, TextDirection direction, bool draw_arrow = true);
+  
+         
+  /* FLAGS */
+
+  //: Returns property {flags.toplevel}.
+  bool is_toplevel() const;
+
+  //: Returns property {flags.nowindow}.
+  bool has_no_window() const;
+
+  //: Returns property {flags.realized}.
+  bool is_realized() const;
+
+  //: Returns property {flags.mapped}.
+  bool is_mapped() const;
+
+  //: Returns property {flags.visible}.
+  bool is_visible() const; 
+
+  //: Returns if the widget is ready to be drawn to.
+  // Checks to see if the widget is both visible and mapped which
+  // makes it possible to perform drawing commands on.
+  bool is_drawable() const;
+  
+  //: Returns property {flags.sensitive}. You might want to check
+  // is_sensitive instead.
+  bool sensitive() const;
+
+  bool parent_sensitive() const;
+  bool is_sensitive() const;
+  bool can_focus() const;
+  bool has_focus() const;
+  bool can_default() const;
+  bool has_default() const;
+  bool has_grab() const;
+  bool rc_style() const;
+  bool is_composite_child() const;
+  bool app_paintable() const;
+  bool receives_default() const;
+  bool double_buffered() const;
+
+  WidgetFlags get_flags() const;
+  void set_flags(WidgetFlags flags);
+  void unset_flags(WidgetFlags flags);
+
+  int get_width() const;
+  int get_height() const;
+
+  Gtk::StateType get_state() const;
+  Gtk::StateType get_saved_state() const;
+  Requisition get_requisition() const;
+  Allocation get_allocation() const;
+  Glib::RefPtr<Gdk::Window> get_window();
+  Glib::RefPtr<const Gdk::Window> get_window() const;
+
+
+  Glib::SignalProxy0< void > signal_show();
+
+  
+  Glib::SignalProxy0< void > signal_hide();
+
+
+  //: Emitted on mapping of a widget to the screen.
+  //- See {flags.mapped}.
+  
+
+  Glib::SignalProxy0< void > signal_map();
+
+
+  //- See {flags.mapped}.
+  
+
+  Glib::SignalProxy0< void > signal_unmap();
+
+
+  //: Emitted on realization of a widget.
+  //- See {flags.realized}.  This is also responsible for
+  //- setting {flags.realized} when it is done.  Therefore, 
+  //- when overriding the impl method, you should call the 
+  //- default realize method.
+  
+
+  Glib::SignalProxy0< void > signal_realize();
+
+
+  //- See {flags.realized}.  This should not be called by the user.
+  //__WRAP(meth|sig|impl,void unrealize_(),gtk_widget_unrealize,"unrealize")
+  
+
+  Glib::SignalProxy0< void > signal_unrealize();
+
+
+  Glib::SignalProxy1< void,Requisition* > signal_size_request();
+
+  
+  Glib::SignalProxy1< void,Allocation& > signal_size_allocate();
+
+
+// Changed signals -- inform widget of internal changes.
+// We rename parent_set => parent_changed 
+//  and      style_set  => style_changed 
+//  to avoid confusion with set_parent and set_style.
+
+  //: Informs objects that their state has changed.
+  //- The old state is passed as the argument.
+  
+
+  Glib::SignalProxy1< void,Gtk::StateType > signal_state_changed();
+
+
+  //: Informs objects that their parent changed.
+  //- The widget passed is the former parent, which may be 0 if 
+  //- there was no parent. (was parent_set in GTK+)
+  
+
+  Glib::SignalProxy1< void,Widget* > signal_parent_changed();
+
+
+  Glib::SignalProxy1< void,Widget* > signal_hierarchy_changed();
+
+
+  //: Informs objects that their style has been changed.
+  //- The former style is passed as the argument. (was style_set in gtk+)
+  
+
+  Glib::SignalProxy1< void,const Glib::RefPtr<Style>& > signal_style_changed();
+
+
+  Glib::SignalProxy1< void,TextDirection > signal_direction_changed();
+
+
+  Glib::SignalProxy1< void,bool > signal_grab_notify();
+
+
+  Glib::SignalProxy1< void,GParamSpec* > signal_child_notify();
+
+
+  //_WRAP_SIGNAL(void add_accelerator(guint, GtkAccelGroup*, guint accel_key, Gdk::ModifierType, AccelFlags), "add-accelerator")
+  //_WRAP_SIGNAL(void remove_accelerator(GtkAccelGroup* accel_group, guint, Gdk::ModifierType), "remove-accelerator")
+  
+
+  Glib::SignalProxy1< bool,bool > signal_mnemonic_activate();
+
+  
+  Glib::SignalProxy0< void > signal_grab_focus();
+
+  
+  Glib::SignalProxy1< bool,DirectionType > signal_focus();
+
+  
+  Glib::SignalProxy1< bool,GdkEvent* > signal_event();
+
+  
+  Glib::SignalProxy1< void,GdkEvent* > signal_event_after();
+
+
+  //: Event triggered by user pressing button.
+  
+
+  Glib::SignalProxy1< bool,GdkEventButton* > signal_button_press_event();
+
+
+  //: Event triggered by user releasing button.
+  
+
+  Glib::SignalProxy1< bool,GdkEventButton* > signal_button_release_event();
+
+
+  Glib::SignalProxy1< bool,GdkEventScroll* > signal_scroll_event();
+
+
+  //: Event triggered by user moving pointer.
+  
+
+  Glib::SignalProxy1< bool,GdkEventMotion* > signal_motion_notify_event();
+
+
+  //: Event triggered by window being closed.
+  
+
+  Glib::SignalProxy1< bool,GdkEventAny* > signal_delete_event();
+
+
+  //: Event triggered by window requiring a refresh.
+  //- Expose events cover a rectangular area that was covered
+  //- or obscured by another window.  That area is now exposed
+  //- and thus is needs to be redrawn.  
+  //-
+  //- If the application is not capable of redrawing sections
+  //- it should watch the count field and only draw on the last
+  //- even indicated.  This is important for things such as 
+  //- Gtk::DrawingArea. 
+  
+
+  Glib::SignalProxy1< bool,GdkEventExpose* > signal_expose_event();
+
+
+  //: Event triggered by a key press will widget has focus.
+  
+
+  Glib::SignalProxy1< bool,GdkEventKey* > signal_key_press_event();
+
+
+  //: Event triggered by a key release will widget has focus.
+  
+
+  Glib::SignalProxy1< bool,GdkEventKey* > signal_key_release_event();
+
+
+  //: Event triggered by pointer entering widget area.
+  
+
+  Glib::SignalProxy1< bool,GdkEventCrossing* > signal_enter_notify_event();
+
+
+  //: Event triggered by pointer leaving widget area.
+  
+
+  Glib::SignalProxy1< bool,GdkEventCrossing* > signal_leave_notify_event();
+
+ 
+  //: Event triggered by a window resizing.
+  
+
+  Glib::SignalProxy1< bool,GdkEventConfigure* > signal_configure_event();
+
+  
+  Glib::SignalProxy1< bool,GdkEventFocus* > signal_focus_in_event();
+
+  
+  Glib::SignalProxy1< bool,GdkEventFocus* > signal_focus_out_event();
+
+  
+  Glib::SignalProxy1< bool,GdkEventAny* > signal_map_event();
+
+  
+  Glib::SignalProxy1< bool,GdkEventAny* > signal_unmap_event();
+
+  
+  Glib::SignalProxy1< bool,GdkEventProperty* > signal_property_notify_event();
+
+  
+  Glib::SignalProxy1< bool,GdkEventSelection* > signal_selection_clear_event();
+
+  
+  Glib::SignalProxy1< bool,GdkEventSelection* > signal_selection_request_event();
+
+  
+  Glib::SignalProxy1< bool,GdkEventSelection* > signal_selection_notify_event();
+
+  
+  Glib::SignalProxy1< bool,GdkEventProximity* > signal_proximity_in_event();
+
+  
+  Glib::SignalProxy1< bool,GdkEventProximity* > signal_proximity_out_event();
+
+  
+  Glib::SignalProxy1< bool,GdkEventVisibility* > signal_visibility_notify_event();
+
+  
+  Glib::SignalProxy1< bool,GdkEventClient* > signal_client_event();
+
+  
+  Glib::SignalProxy1< bool,GdkEventAny* > signal_no_expose_event();
+
+  
+  Glib::SignalProxy1< bool,GdkEventWindowState* > signal_window_state_event();
+
+
+  //We use the optional custom_c_callback parameter with _WRAP_SIGNAL() for some of these,
+  //so that we can write special code to wrap the non-const SelectioData& output parameters:
+  
+
+  Glib::SignalProxy3< void,SelectionData&,guint,guint > signal_selection_get();
+
+  
+  Glib::SignalProxy2< void,const SelectionData&,guint > signal_selection_received();
+
+  
+  Glib::SignalProxy1< void,const Glib::RefPtr<Gdk::DragContext>& > signal_drag_begin();
+
+  
+  Glib::SignalProxy1< void,const Glib::RefPtr<Gdk::DragContext>& > signal_drag_end();
+
+
+  Glib::SignalProxy4< void,const Glib::RefPtr<Gdk::DragContext>&,SelectionData&,guint,guint > signal_drag_data_get();
+
+  
+  Glib::SignalProxy1< void,const Glib::RefPtr<Gdk::DragContext>& > signal_drag_data_delete();
+
+  
+  Glib::SignalProxy2< void,const Glib::RefPtr<Gdk::DragContext>&,guint > signal_drag_leave();
+
+  
+  Glib::SignalProxy4< bool,const Glib::RefPtr<Gdk::DragContext>&,int,int,guint > signal_drag_motion();
+
+  
+  Glib::SignalProxy4< bool,const Glib::RefPtr<Gdk::DragContext>&,int,int,guint > signal_drag_drop();
+
+  
+  Glib::SignalProxy6< void,const Glib::RefPtr<Gdk::DragContext>&,int,int,const SelectionData&,guint,guint > signal_drag_data_received();
+
+
+  //accessibility signals:
+  
+
+  Glib::SignalProxy0< Glib::RefPtr<Atk::Object> > signal_get_accessible();
+
+  
+  Glib::SignalProxy1< void,const Glib::RefPtr<Gdk::Screen>& > signal_screen_changed();
+
+
+//TODO: The signal_id is very C-like here:                                                                          
+  //_WRAP_SIGNAL(bool can_activate_accel(guint signal_id), "can_activate_accel")
+  
+  //Keybinding signals:
+  
+  
+  /** The name of the widget.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Glib::ustring> property_name() ;
+
+/** The name of the widget.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Glib::ustring> property_name() const;
+
+  /** The parent widget of this widget. Must be a Container widget.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Container*> property_parent() ;
+
+/** The parent widget of this widget. Must be a Container widget.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Container*> property_parent() const;
+
+  /** Override for width request of the widget
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<int> property_width_request() ;
+
+/** Override for width request of the widget
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<int> property_width_request() const;
+
+  /** Override for height request of the widget
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<int> property_height_request() ;
+
+/** Override for height request of the widget
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<int> property_height_request() const;
+
+  /** Whether the widget is visible.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_visible() ;
+
+/** Whether the widget is visible.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_visible() const;
+
+  /** Whether the widget responds to input.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_sensitive() ;
+
+/** Whether the widget responds to input.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_sensitive() const;
+
+  /** Whether the application will paint directly on the widget.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_app_paintable() ;
+
+/** Whether the application will paint directly on the widget.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_app_paintable() const;
+
+  /** Whether the widget can accept the input focus.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_can_focus() ;
+
+/** Whether the widget can accept the input focus.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_can_focus() const;
+
+  /** Whether the widget has the input focus.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_has_focus() ;
+
+/** Whether the widget has the input focus.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_has_focus() const;
+
+  /** Whether the widget can be the default widget.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_can_default() ;
+
+/** Whether the widget can be the default widget.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_can_default() const;
+
+  /** Whether the widget is the default widget.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_has_default() ;
+
+/** Whether the widget is the default widget.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_has_default() const;
+
+  /** If TRUE
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_receives_default() ;
+
+/** If TRUE
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_receives_default() const;
+
+  /** Whether the widget is part of a composite widget.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_composite_child() const;
+
+
+  /** The style of the widget
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy< Glib::RefPtr<Style> > property_style() ;
+
+/** The style of the widget
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Style> > property_style() const;
+
+  /** The event mask that decides what kind of GdkEvents this widget gets.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Gdk::EventMask> property_events() ;
+
+/** The event mask that decides what kind of GdkEvents this widget gets.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Gdk::EventMask> property_events() const;
+
+  /** The mask that decides what kind of extension events this widget gets.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Gdk::ExtensionMode> property_extension_events() ;
+
+/** The mask that decides what kind of extension events this widget gets.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Gdk::ExtensionMode> property_extension_events() const;
+
+
+protected:
+  //comment in GTK+ header: "seldomly overidden"
+    virtual void dispatch_child_properties_changed_vfunc(guint p1, GParamSpec** p2);
+
+    virtual void show_all_vfunc();
+    virtual void hide_all_vfunc();
+
+    virtual Glib::RefPtr<Atk::Object> get_accessible_vfunc();
+
+
+protected:
+  Widget();
+
+  
+  /** This function is only for use in widget implementations. Causes
+   * a widget to be mapped if it isn't already.
+   */
+  void map();
+  
+  /** This function is only for use in widget implementations. Causes
+   * a widget to be unmapped if it's currently mapped.
+   */
+  void unmap();
+  
+  /** Creates the GDK (windowing system) resources associated with a
+   * widget.  For example, @a widget -&gt;window will be created when a widget
+   * is realized.  Normally realization happens implicitly; if you show
+   * a widget and all its parent containers, then the widget will be
+   * realized and mapped automatically.
+   * 
+   * Realizing a widget requires all
+   * the widget's parent widgets to be realized; calling
+   * realize() realizes the widget's parents in addition to
+   *  @a widget  itself. If a widget is not yet inside a toplevel window
+   * when you realize it, bad things will happen.
+   * 
+   * This function is primarily used in widget implementations, and
+   * isn't very useful otherwise. Many times when you think you might
+   * need it, a better approach is to connect to a signal that will be
+   * called after the widget is realized automatically, such as
+   * "expose_event". Or simply Glib::signal_connect_after() to the
+   * "realize" signal.
+   */
+  void realize();
+  
+  /** This function is only useful in widget implementations.
+   * Causes a widget to be unrealized (frees all GDK resources
+   * associated with the widget, such as @a widget -&gt;window).
+   */
+  void unrealize();
+
+  
+  /** This function is only for use in widget implementations. Obtains
+   *  @a widget -&gt;requisition, unless someone has forced a particular
+   * geometry on the widget (e.g. with set_usize()), in which
+   * case it returns that geometry instead of the widget's requisition.
+   * 
+   * This function differs from size_request() in that
+   * it retrieves the last size request value from @a widget -&gt;requisition,
+   * while size_request() actually calls the "size_request" method
+   * on @a widget  to compute the size request and fill in @a widget -&gt;requisition,
+   * and only then returns @a widget -&gt;requisition.
+   * 
+   * Because this function does not call the "size_request" method, it
+   * can only be used when you know that @a widget -&gt;requisition is
+   * up-to-date, that is, size_request() has been called
+   * since the last time a resize was queued. In general, only container
+   * implementations have this information; applications should use
+   * size_request().
+   * @param requisition A Gtk::Requisition to be filled in.
+   */
+  void get_child_requisition(Requisition& requisition) const;
+
+  //The parameter name is "the_property_name" to avoid a warning because there is a method with the "property_name" name.
+  
+  /** Gets the value of a style property of @a widget .
+   * @param the_property_name The name of a style property.
+   * @param value Location to return the property value.
+   */
+  void get_style_property_value(
+                   const Glib::ustring& the_property_name, Glib::ValueBase& value) const;
+
+  void realize_if_needed();
+
+  void set_allocation(const Allocation& value);
+  void set_window(const Glib::RefPtr<Gdk::Window>& value);
+
+
+};
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+//The parameter name is "the_property_name" to avoid a warning because there is a method with the "property_name" name.
+template <class PropertyType>
+void Widget::get_style_property(const Glib::ustring& the_property_name, PropertyType& value) const
+{
+  Glib::Value<PropertyType> property_value;
+  property_value.init(Glib::Value<PropertyType>::value_type());
+
+  this->get_style_property_value(the_property_name, property_value);
+
+  value = property_value.get();
+}
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+} // namespace Gtk
+
+
+namespace Glib
+{
+  /** @relates Gtk::Widget
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gtk::Widget* wrap(GtkWidget* object, bool take_copy = false);
+}
+#endif /* _GTKMM_WIDGET_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/window.cc b/libs/gtkmm2/gtk/gtkmm/window.cc
new file mode 100644
index 0000000000..4be33fd86b
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/window.cc
@@ -0,0 +1,1242 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/window.h>
+#include <gtkmm/private/window_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* 
+ *
+ * Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/accelgroup.h>
+#include <gdkmm/cursor.h>
+#include <gtk/gtkwindow.h>
+
+
+namespace Gtk
+{
+
+Glib::RefPtr<AccelGroup> Window::get_accel_group()
+{
+  //There doesn't seem to be any gtk_window_get_accel_group().
+  //I think that you're supposed to remember what you added yourself.
+  //And that's what we do here.
+
+  if(!accel_group_)
+  {
+    accel_group_ = AccelGroup::create();
+    add_accel_group(accel_group_);
+  }
+
+  return accel_group_;
+}
+
+bool Window::is_toplevel() const
+{
+  return gobj()->type == GTK_WINDOW_TOPLEVEL;
+}
+
+bool Window::is_popup() const
+{
+  return gobj()->type == GTK_WINDOW_POPUP;
+}
+
+void Window::raise()
+{
+  get_window()->raise();
+}
+
+void Window::set_manage()
+{
+  g_warning("gtkmm: Attempt to call Gtk::manage() on a Gtk::Window, but a Gtk::Window has no parent container to manage its lifetime.\n");
+}
+
+void Window::destroy_()
+{
+  //Called from destructors.
+  //overridden so that the correct _destroy_c_instance() ends up being called by the destructor.
+
+  //GTKMM_LIFECYCLE
+
+  #ifdef GLIBMM_DEBUG_REFCOUNTING
+  g_warning("Gtk::Window::destroy_(): gobject_: %10X\n", gobject_);
+  if(gobject_)
+   g_warning("  gtypename: %s\n", G_OBJECT_TYPE_NAME(gobject_));
+  #endif
+
+  if ( !cpp_destruction_in_progress_ ) //see comment below.
+  {
+    //Prevent destroy_notify_() from running as a possible side-effect of gtk_object_destroy.
+    //We can't predict whether destroy_notify_() will really be run, so we'll disconnect the C++ instance here.
+    cpp_destruction_in_progress_ = true;
+
+    //destroy the C instance:
+    _destroy_c_instance();
+  }
+
+  //The C++ destructor will be reached later. This function was called by a destructor.
+}
+
+void Window::_destroy_c_instance()
+{
+  //We override this,
+  //because though top-level windows can only be destroyed with gtk_widget_destroy, according to Owen Taylor. murrayc.
+  #ifdef GLIBMM_DEBUG_REFCOUNTING
+  g_warning("Gtk::Window::_destroy_c_instance() gobject_=%10X\n", gobject_);
+  #endif
+
+  cpp_destruction_in_progress_ = true;
+
+  // remove our hook.
+  GtkObject* object = (GtkObject*)gobj();
+  if (object)
+  {
+    disconnect_cpp_wrapper();
+    //If we are killing the C++ instance before the C instance, then this might lead to strange behaviour.
+    //If this is a problem, then you'll have to use a managed() object, which will die only upon GTK+'s request.
+
+    //We can't do anything with the gobject_ if it's already been disposed.
+    //This prevents us from unref-ing it again, or destroying it again after GTK+ has told us that it has been disposed.
+    if (!gobject_disposed_)
+    {
+      //Windows can not be unrefed. They are "self-owning".
+      gtk_object_destroy(object);
+    }
+
+    //Glib::Object::~Object() will not g_object_unref() it too. because gobject_ is now 0.
+  }
+}
+ 
+void Window_Class::dispose_vfunc_callback(GObject* self)
+{
+  //Avoid disposal of Windows on delete_event (window close) signal.
+  
+  #ifdef GLIBMM_DEBUG_REFCOUNTING
+  g_warning("Window_Class::dispose_vfunc_callback(): gobject_: %p\n", (void*)self);
+  #endif
+
+  Widget *const obj = dynamic_cast<Widget*>(
+      Glib::ObjectBase::_get_current_wrapper(self));
+
+  // This function might be invoked recursively because we're triggering
+  // several signal emissions, particularly signal_hide().  Therefore we
+  // have to test for cpp_destruction_in_progress_ at this point.
+
+  if(obj && !obj->_cpp_destruction_is_in_progress()) //When it should really be destroyed, we zero gobj_.
+  {
+    GtkWidget* const pWidget = obj->gobj();
+    g_return_if_fail(pWidget == GTK_WIDGET(self));
+
+    // Abort dispose if the widget isn't managed, in order to prevent
+    // the nasty self-destroying behaviour of GTK+.  This applies to:
+    //
+    // - GtkWindow, if it received "delete_event"
+    // - GtkDialog, which destroys on "response" by default
+
+    #ifdef GLIBMM_DEBUG_REFCOUNTING
+    g_warning("Window_Class::dispose_vfunc_callback(): before gtk_widget_hide().");
+    #endif
+
+    // Now hide the widget.  The C++ object must _not_ be accessed anymore
+    // after this call, because a signal_hide() handler might delete it.
+    gtk_widget_hide(pWidget);
+
+    #ifdef GLIBMM_DEBUG_REFCOUNTING
+    g_warning("Window_Class::dispose_vfunc_callback(): after gtk_widget_hide().");
+    #endif
+
+    // GTKMM_LIFECYCLE
+    return; // Prevent calling of normal C dispose vfunc (see below)
+  }
+  else
+  {
+    #ifdef GLIBMM_DEBUG_REFCOUNTING
+    //g_warning("Window_Class::dispose_vfunc_callback(): unreferenced: before gtk_widget_hide().");
+    #endif
+
+    // Always hide widgets on gtk_object_destroy(), regardless of whether
+    // the widget is managed or not.  This is done for consistency so that
+    // connecting to signal_hide() is guaranteed to work.
+    //gtk_widget_hide(pWidget);
+
+    #ifdef GLIBMM_DEBUG_REFCOUNTING
+    //g_warning("Window_Class::dispose_vfunc_callback(): unreferenced:  after gtk_widget_hide().");
+    #endif
+  
+    GObjectClass *const base = static_cast<GObjectClass*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)));
+
+    #ifdef GLIBMM_DEBUG_REFCOUNTING
+    g_warning("Window_Class::dispose_vfunc_callback(): before calling base->dispose.");
+    #endif
+
+    if(base->dispose)
+      (*base->dispose)(self);
+
+    #ifdef GLIBMM_DEBUG_REFCOUNTING
+    g_warning("Window_Class::dispose_vfunc_callback(): after calling base->dispose.");
+    #endif
+  }
+}
+
+void Window::unset_focus()
+{
+  gtk_window_set_focus(gobj(), 0 /* See GTK+ docs */);
+}
+
+void Window::unset_default()
+{
+  gtk_window_set_default(gobj(), 0 /* See GTK+ docs */);
+}
+   
+} // namespace Gtk
+
+
+namespace
+{
+
+void Window_signal_set_focus_callback(GtkWindow* self, GtkWidget* p0,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,Widget* > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(Glib::wrap(p0)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+}
+
+const Glib::SignalProxyInfo Window_signal_set_focus_info =
+{
+  "set_focus",
+  (GCallback) &Window_signal_set_focus_callback,
+  (GCallback) &Window_signal_set_focus_callback
+};
+
+
+gboolean Window_signal_frame_event_callback(GtkWindow* self, GdkEvent* p0,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< bool,GdkEvent* > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        return static_cast<int>((*static_cast<SlotType*>(slot))(p0));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+gboolean Window_signal_frame_event_notify_callback(GtkWindow* self, GdkEvent* p0, void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,GdkEvent* > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(p0);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+const Glib::SignalProxyInfo Window_signal_frame_event_info =
+{
+  "frame_event",
+  (GCallback) &Window_signal_frame_event_callback,
+  (GCallback) &Window_signal_frame_event_notify_callback
+};
+
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Gtk::Window* wrap(GtkWindow* object, bool take_copy)
+{
+  return dynamic_cast<Gtk::Window *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& Window_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &Window_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_window_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void Window_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+    reinterpret_cast<GObjectClass*>(klass)->dispose = &dispose_vfunc_callback;
+    klass->set_focus = &set_focus_callback;
+  klass->frame_event = &frame_event_callback;
+}
+
+
+void Window_Class::set_focus_callback(GtkWindow* self, GtkWidget* p0)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      obj->on_set_focus(Glib::wrap(p0)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->set_focus)
+      (*base->set_focus)(self, p0);
+  }
+}
+
+gboolean Window_Class::frame_event_callback(GtkWindow* self, GdkEvent* p0)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+  // Non-gtkmmproc-generated custom classes implicitly call the default
+  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
+  // generated classes can use this optimisation, which avoids the unnecessary
+  // parameter conversions if there is no possibility of the virtual function
+  // being overridden:
+  if(obj && obj->is_derived_())
+  {
+    try // Trap C++ exceptions which would normally be lost because this is a C callback.
+    {
+      // Call the virtual member method, which derived classes might override.
+      return static_cast<int>(obj->on_frame_event(p0));
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+  else
+  {
+    BaseClassType *const base = static_cast<BaseClassType*>(
+        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
+    );
+
+    // Call the original underlying C function:
+    if(base && base->frame_event)
+      return (*base->frame_event)(self, p0);
+  }
+
+  typedef gboolean RType;
+  return RType();
+}
+
+
+Glib::ObjectBase* Window_Class::wrap_new(GObject* o)
+{
+  return new Window((GtkWindow*)(o)); //top-level windows can not be manage()ed.
+
+}
+
+
+/* The implementation: */
+
+Window::Window(const Glib::ConstructParams& construct_params)
+:
+  Gtk::Bin(construct_params)
+{
+  }
+
+Window::Window(GtkWindow* castitem)
+:
+  Gtk::Bin((GtkBin*)(castitem))
+{
+  }
+
+Window::~Window()
+{
+  destroy_();
+}
+
+Window::CppClassType Window::window_class_; // initialize static member
+
+GType Window::get_type()
+{
+  return window_class_.init().get_type();
+}
+
+GType Window::get_base_type()
+{
+  return gtk_window_get_type();
+}
+
+
+Window::Window(WindowType type)
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Gtk::Bin(Glib::ConstructParams(window_class_.init(), "type", ((GtkWindowType)(type)), (char*) 0))
+{
+  }
+
+WindowType Window::get_window_type() const
+{
+  return static_cast<WindowType>(gobj()->type);
+}
+
+Glib::RefPtr<Gdk::Window> Window::get_frame()
+{
+  Glib::RefPtr<Gdk::Window> ref_ptr(Glib::wrap((GdkWindowObject*)(gobj()->frame)));
+
+  if(ref_ptr)
+    ref_ptr->reference();
+
+  return ref_ptr;
+}
+
+Glib::RefPtr<const Gdk::Window> Window::get_frame() const
+{
+  Glib::RefPtr<const Gdk::Window> ref_ptr(Glib::wrap((GdkWindowObject*)(gobj()->frame)));
+
+  if(ref_ptr)
+    ref_ptr->reference();
+
+  return ref_ptr;
+}
+
+void Window::set_title(const Glib::ustring& title)
+{
+  gtk_window_set_title(gobj(), title.c_str());
+}
+
+Glib::ustring Window::get_title() const
+{
+  return Glib::convert_const_gchar_ptr_to_ustring(gtk_window_get_title(const_cast<GtkWindow*>(gobj())));
+}
+
+void Window::set_wmclass(const Glib::ustring& wmclass_name, const Glib::ustring& wmclass_class)
+{
+  gtk_window_set_wmclass(gobj(), wmclass_name.c_str(), wmclass_class.c_str());
+}
+
+void Window::set_role(const Glib::ustring& role)
+{
+  gtk_window_set_role(gobj(), role.c_str());
+}
+
+Glib::ustring Window::get_role() const
+{
+  return Glib::convert_const_gchar_ptr_to_ustring(gtk_window_get_role(const_cast<GtkWindow*>(gobj())));
+}
+
+void Window::add_accel_group(const Glib::RefPtr<AccelGroup>& accel_group)
+{
+  gtk_window_add_accel_group(gobj(), Glib::unwrap(accel_group));
+}
+
+void Window::remove_accel_group(const Glib::RefPtr<AccelGroup>& accel_group)
+{
+  gtk_window_remove_accel_group(gobj(), Glib::unwrap(accel_group));
+}
+
+void Window::set_position(WindowPosition position)
+{
+  gtk_window_set_position(gobj(), ((GtkWindowPosition)(position)));
+}
+
+bool Window::activate_focus()
+{
+  return gtk_window_activate_focus(gobj());
+}
+
+void Window::set_focus(Gtk::Widget& focus)
+{
+  gtk_window_set_focus(gobj(), (focus).gobj());
+}
+
+Widget* Window::get_focus()
+{
+  return Glib::wrap(gtk_window_get_focus(gobj()));
+}
+
+const Widget* Window::get_focus() const
+{
+  return Glib::wrap(gtk_window_get_focus(const_cast<GtkWindow*>(gobj())));
+}
+
+void Window::set_default(Gtk::Widget& default_widget)
+{
+  gtk_window_set_default(gobj(), (default_widget).gobj());
+}
+
+bool Window::activate_default()
+{
+  return gtk_window_activate_default(gobj());
+}
+
+void Window::set_transient_for(Window& parent)
+{
+  gtk_window_set_transient_for(gobj(), (parent).gobj());
+}
+
+Window* Window::get_transient_for()
+{
+  return Glib::wrap(gtk_window_get_transient_for(gobj()));
+}
+
+const Window* Window::get_transient_for() const
+{
+  return Glib::wrap(gtk_window_get_transient_for(const_cast<GtkWindow*>(gobj())));
+}
+
+void Window::set_type_hint(Gdk::WindowTypeHint hint)
+{
+  gtk_window_set_type_hint(gobj(), ((GdkWindowTypeHint)(hint)));
+}
+
+Gdk::WindowTypeHint Window::get_type_hint() const
+{
+  return ((Gdk::WindowTypeHint)(gtk_window_get_type_hint(const_cast<GtkWindow*>(gobj()))));
+}
+
+void Window::set_skip_taskbar_hint(bool setting)
+{
+  gtk_window_set_skip_taskbar_hint(gobj(), static_cast<int>(setting));
+}
+
+bool Window::get_skip_taskbar_hint() const
+{
+  return gtk_window_get_skip_taskbar_hint(const_cast<GtkWindow*>(gobj()));
+}
+
+void Window::set_skip_pager_hint(bool setting)
+{
+  gtk_window_set_skip_pager_hint(gobj(), static_cast<int>(setting));
+}
+
+bool Window::get_skip_pager_hint() const
+{
+  return gtk_window_get_skip_pager_hint(const_cast<GtkWindow*>(gobj()));
+}
+
+bool Window::get_destroy_with_parent() const
+{
+  return gtk_window_get_destroy_with_parent(const_cast<GtkWindow*>(gobj()));
+}
+
+void Window::set_resizable(bool resizable)
+{
+  gtk_window_set_resizable(gobj(), static_cast<int>(resizable));
+}
+
+bool Window::get_resizable() const
+{
+  return gtk_window_get_resizable(const_cast<GtkWindow*>(gobj()));
+}
+
+void Window::set_gravity(Gdk::Gravity gravity)
+{
+  gtk_window_set_gravity(gobj(), ((GdkGravity)(gravity)));
+}
+
+Gdk::Gravity Window::get_gravity() const
+{
+  return ((Gdk::Gravity)(gtk_window_get_gravity(const_cast<GtkWindow*>(gobj()))));
+}
+
+void Window::set_geometry_hints(Widget& geometry_widget, const Gdk::Geometry& geometry, Gdk::WindowHints geom_mask)
+{
+  gtk_window_set_geometry_hints(gobj(), (geometry_widget).gobj(), const_cast<GdkGeometry*>(&(geometry)), ((GdkWindowHints)(geom_mask)));
+}
+
+void Window::set_screen(const Glib::RefPtr<Gdk::Screen>& screen)
+{
+  gtk_window_set_screen(gobj(), Glib::unwrap(screen));
+}
+
+Glib::RefPtr<Gdk::Screen> Window::get_screen()
+{
+
+  Glib::RefPtr<Gdk::Screen> retvalue = Glib::wrap(gtk_window_get_screen(gobj()));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::RefPtr<const Gdk::Screen> Window::get_screen() const
+{
+
+  Glib::RefPtr<const Gdk::Screen> retvalue = Glib::wrap(gtk_window_get_screen(const_cast<GtkWindow*>(gobj())));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+void Window::set_has_frame(bool setting)
+{
+  gtk_window_set_has_frame(gobj(), static_cast<int>(setting));
+}
+
+bool Window::get_has_frame() const
+{
+  return gtk_window_get_has_frame(const_cast<GtkWindow*>(gobj()));
+}
+
+void Window::set_frame_dimensions(int left, int top, int right, int bottom)
+{
+  gtk_window_set_frame_dimensions(gobj(), left, top, right, bottom);
+}
+
+void Window::get_frame_dimensions(int& left, int& top, int& right, int& bottom) const
+{
+  gtk_window_get_frame_dimensions(const_cast<GtkWindow*>(gobj()), &left, &top, &right, &bottom);
+}
+
+void Window::set_decorated(bool setting)
+{
+  gtk_window_set_decorated(gobj(), static_cast<int>(setting));
+}
+
+bool Window::get_decorated() const
+{
+  return gtk_window_get_decorated(const_cast<GtkWindow*>(gobj()));
+}
+
+Glib::ListHandle< Glib::RefPtr<Gdk::Pixbuf> > Window::get_icon_list()
+{
+  return Glib::ListHandle< Glib::RefPtr<Gdk::Pixbuf> >(gtk_window_get_icon_list(gobj()), Glib::OWNERSHIP_SHALLOW);
+}
+
+Glib::ListHandle< Glib::RefPtr<const Gdk::Pixbuf> > Window::get_icon_list() const
+{
+  return Glib::ListHandle< Glib::RefPtr<const Gdk::Pixbuf> >(gtk_window_get_icon_list(const_cast<GtkWindow*>(gobj())), Glib::OWNERSHIP_SHALLOW);
+}
+
+void Window::set_icon_list(const Glib::ListHandle< Glib::RefPtr<Gdk::Pixbuf> >& list)
+{
+  gtk_window_set_icon_list(gobj(), list.data());
+}
+
+void Window::set_icon(const Glib::RefPtr<Gdk::Pixbuf>& icon)
+{
+  gtk_window_set_icon(gobj(), Glib::unwrap(icon));
+}
+
+bool Window::set_icon_from_file(const std::string& filename)
+{
+  GError *error = 0;
+  bool retvalue = gtk_window_set_icon_from_file(gobj(), filename.c_str(), &(error));
+  if(error) ::Glib::Error::throw_exception(error);
+  return retvalue;
+}
+
+Glib::RefPtr<Gdk::Pixbuf> Window::get_icon()
+{
+
+  Glib::RefPtr<Gdk::Pixbuf> retvalue = Glib::wrap(gtk_window_get_icon(gobj()));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::RefPtr<const Gdk::Pixbuf> Window::get_icon() const
+{
+
+  Glib::RefPtr<const Gdk::Pixbuf> retvalue = Glib::wrap(gtk_window_get_icon(const_cast<GtkWindow*>(gobj())));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+void Window::set_default_icon_list(const Glib::ListHandle< Glib::RefPtr<Gdk::Pixbuf> >& list)
+{
+  gtk_window_set_default_icon_list(list.data());
+}
+
+Glib::ListHandle< Glib::RefPtr<Gdk::Pixbuf> > Window::get_default_icon_list()
+{
+  return Glib::ListHandle< Glib::RefPtr<Gdk::Pixbuf> >(gtk_window_get_default_icon_list(), Glib::OWNERSHIP_SHALLOW);
+}
+
+bool Window::set_default_icon_from_file(const std::string& filename)
+{
+  GError *error = 0;
+  bool retvalue = gtk_window_set_default_icon_from_file(filename.c_str(), &(error));
+  if(error) ::Glib::Error::throw_exception(error);
+  return retvalue;
+}
+
+void Window::set_auto_startup_notification(bool setting)
+{
+  gtk_window_set_auto_startup_notification(static_cast<int>(setting));
+}
+
+void Window::set_modal(bool modal)
+{
+  gtk_window_set_modal(gobj(), static_cast<int>(modal));
+}
+
+bool Window::get_modal() const
+{
+  return gtk_window_get_modal(const_cast<GtkWindow*>(gobj()));
+}
+
+Glib::ListHandle<Window*> Window::list_toplevels()
+{
+  return Glib::ListHandle<Window*>(gtk_window_list_toplevels(), Glib::OWNERSHIP_SHALLOW);
+}
+
+void Window::add_mnemonic(guint keyval, Widget& target)
+{
+  gtk_window_add_mnemonic(gobj(), keyval, (target).gobj());
+}
+
+void Window::remove_mnemonic(guint keyval, Widget& target)
+{
+  gtk_window_remove_mnemonic(gobj(), keyval, (target).gobj());
+}
+
+bool Window::mnemonic_activate(guint keyval, Gdk::ModifierType modifier)
+{
+  return gtk_window_mnemonic_activate(gobj(), keyval, ((GdkModifierType)(modifier)));
+}
+
+void Window::set_mnemonic_modifier(Gdk::ModifierType modifier)
+{
+  gtk_window_set_mnemonic_modifier(gobj(), ((GdkModifierType)(modifier)));
+}
+
+Gdk::ModifierType Window::get_mnemonic_modifier()
+{
+  return ((Gdk::ModifierType)(gtk_window_get_mnemonic_modifier(gobj())));
+}
+
+void Window::present()
+{
+  gtk_window_present(gobj());
+}
+
+void Window::iconify()
+{
+  gtk_window_iconify(gobj());
+}
+
+void Window::deiconify()
+{
+  gtk_window_deiconify(gobj());
+}
+
+void Window::stick()
+{
+  gtk_window_stick(gobj());
+}
+
+void Window::unstick()
+{
+  gtk_window_unstick(gobj());
+}
+
+void Window::maximize()
+{
+  gtk_window_maximize(gobj());
+}
+
+void Window::unmaximize()
+{
+  gtk_window_unmaximize(gobj());
+}
+
+void Window::fullscreen()
+{
+  gtk_window_fullscreen(gobj());
+}
+
+void Window::unfullscreen()
+{
+  gtk_window_unfullscreen(gobj());
+}
+
+void Window::begin_resize_drag(Gdk::WindowEdge edge, int button, int root_x, int root_y, guint32 timestamp)
+{
+  gtk_window_begin_resize_drag(gobj(), ((GdkWindowEdge)(edge)), button, root_x, root_y, timestamp);
+}
+
+void Window::begin_move_drag(int button, int root_x, int root_y, guint32 timestamp)
+{
+  gtk_window_begin_move_drag(gobj(), button, root_x, root_y, timestamp);
+}
+
+void Window::set_default_size(int width, int height)
+{
+  gtk_window_set_default_size(gobj(), width, height);
+}
+
+void Window::get_default_size(int& width, int& height) const
+{
+  gtk_window_get_default_size(const_cast<GtkWindow*>(gobj()), &width, &height);
+}
+
+void Window::resize(int width, int height)
+{
+  gtk_window_resize(gobj(), width, height);
+}
+
+void Window::get_size(int& width, int& height) const
+{
+  gtk_window_get_size(const_cast<GtkWindow*>(gobj()), &width, &height);
+}
+
+void Window::move(int x, int y)
+{
+  gtk_window_move(gobj(), x, y);
+}
+
+void Window::get_position(int& root_x, int& root_y) const
+{
+  gtk_window_get_position(const_cast<GtkWindow*>(gobj()), &root_x, &root_y);
+}
+
+bool Window::parse_geometry(const Glib::ustring& geometry)
+{
+  return gtk_window_parse_geometry(gobj(), geometry.c_str());
+}
+
+void Window::reshow_with_initial_size()
+{
+  gtk_window_reshow_with_initial_size(gobj());
+}
+
+void Window::set_default_icon(const Glib::RefPtr<Gdk::Pixbuf>& icon)
+{
+  gtk_window_set_default_icon(Glib::unwrap(icon));
+}
+
+void Window::set_keep_above(bool setting)
+{
+  gtk_window_set_keep_above(gobj(), static_cast<int>(setting));
+}
+
+void Window::set_keep_below(bool setting)
+{
+  gtk_window_set_keep_below(gobj(), static_cast<int>(setting));
+}
+
+
+Glib::SignalProxy1< void,Widget* > Window::signal_set_focus()
+{
+  return Glib::SignalProxy1< void,Widget* >(this, &Window_signal_set_focus_info);
+}
+
+Glib::SignalProxy1< bool,GdkEvent* > Window::signal_frame_event()
+{
+  return Glib::SignalProxy1< bool,GdkEvent* >(this, &Window_signal_frame_event_info);
+}
+
+
+Glib::PropertyProxy<Glib::ustring> Window::property_title() 
+{
+  return Glib::PropertyProxy<Glib::ustring>(this, "title");
+}
+
+Glib::PropertyProxy_ReadOnly<Glib::ustring> Window::property_title() const
+{
+  return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "title");
+}
+
+Glib::PropertyProxy<bool> Window::property_allow_shrink() 
+{
+  return Glib::PropertyProxy<bool>(this, "allow-shrink");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> Window::property_allow_shrink() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "allow-shrink");
+}
+
+Glib::PropertyProxy<bool> Window::property_allow_grow() 
+{
+  return Glib::PropertyProxy<bool>(this, "allow-grow");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> Window::property_allow_grow() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "allow-grow");
+}
+
+Glib::PropertyProxy<bool> Window::property_resizable() 
+{
+  return Glib::PropertyProxy<bool>(this, "resizable");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> Window::property_resizable() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "resizable");
+}
+
+Glib::PropertyProxy<bool> Window::property_modal() 
+{
+  return Glib::PropertyProxy<bool>(this, "modal");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> Window::property_modal() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "modal");
+}
+
+Glib::PropertyProxy<WindowPosition> Window::property_window_position() 
+{
+  return Glib::PropertyProxy<WindowPosition>(this, "window-position");
+}
+
+Glib::PropertyProxy_ReadOnly<WindowPosition> Window::property_window_position() const
+{
+  return Glib::PropertyProxy_ReadOnly<WindowPosition>(this, "window-position");
+}
+
+Glib::PropertyProxy<int> Window::property_default_width() 
+{
+  return Glib::PropertyProxy<int>(this, "default-width");
+}
+
+Glib::PropertyProxy_ReadOnly<int> Window::property_default_width() const
+{
+  return Glib::PropertyProxy_ReadOnly<int>(this, "default-width");
+}
+
+Glib::PropertyProxy<int> Window::property_default_height() 
+{
+  return Glib::PropertyProxy<int>(this, "default-height");
+}
+
+Glib::PropertyProxy_ReadOnly<int> Window::property_default_height() const
+{
+  return Glib::PropertyProxy_ReadOnly<int>(this, "default-height");
+}
+
+Glib::PropertyProxy<bool> Window::property_destroy_with_parent() 
+{
+  return Glib::PropertyProxy<bool>(this, "destroy-with-parent");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> Window::property_destroy_with_parent() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "destroy-with-parent");
+}
+
+Glib::PropertyProxy< Glib::RefPtr<Gdk::Pixbuf> > Window::property_icon() 
+{
+  return Glib::PropertyProxy< Glib::RefPtr<Gdk::Pixbuf> >(this, "icon");
+}
+
+Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::Pixbuf> > Window::property_icon() const
+{
+  return Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::Pixbuf> >(this, "icon");
+}
+
+Glib::PropertyProxy< Glib::RefPtr<Gdk::Screen> > Window::property_screen() 
+{
+  return Glib::PropertyProxy< Glib::RefPtr<Gdk::Screen> >(this, "screen");
+}
+
+Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::Screen> > Window::property_screen() const
+{
+  return Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::Screen> >(this, "screen");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> Window::property_is_active() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "is-active");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> Window::property_has_toplevel_focus() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "has-toplevel-focus");
+}
+
+Glib::PropertyProxy<GdkWindowTypeHint> Window::property_type_hint() 
+{
+  return Glib::PropertyProxy<GdkWindowTypeHint>(this, "type-hint");
+}
+
+Glib::PropertyProxy_ReadOnly<GdkWindowTypeHint> Window::property_type_hint() const
+{
+  return Glib::PropertyProxy_ReadOnly<GdkWindowTypeHint>(this, "type-hint");
+}
+
+Glib::PropertyProxy<bool> Window::property_skip_taskbar_hint() 
+{
+  return Glib::PropertyProxy<bool>(this, "skip-taskbar-hint");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> Window::property_skip_taskbar_hint() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "skip-taskbar-hint");
+}
+
+Glib::PropertyProxy<bool> Window::property_skip_pager_hint() 
+{
+  return Glib::PropertyProxy<bool>(this, "skip-pager-hint");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> Window::property_skip_pager_hint() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "skip-pager-hint");
+}
+
+Glib::PropertyProxy<Glib::ustring> Window::property_role() 
+{
+  return Glib::PropertyProxy<Glib::ustring>(this, "role");
+}
+
+Glib::PropertyProxy_ReadOnly<Glib::ustring> Window::property_role() const
+{
+  return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "role");
+}
+
+Glib::PropertyProxy<bool> Window::property_decorated() 
+{
+  return Glib::PropertyProxy<bool>(this, "decorated");
+}
+
+Glib::PropertyProxy_ReadOnly<bool> Window::property_decorated() const
+{
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "decorated");
+}
+
+Glib::PropertyProxy<Gdk::Gravity> Window::property_gravity() 
+{
+  return Glib::PropertyProxy<Gdk::Gravity>(this, "gravity");
+}
+
+Glib::PropertyProxy_ReadOnly<Gdk::Gravity> Window::property_gravity() const
+{
+  return Glib::PropertyProxy_ReadOnly<Gdk::Gravity>(this, "gravity");
+}
+
+
+void Gtk::Window::on_set_focus(Widget* focus)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->set_focus)
+    (*base->set_focus)(gobj(),(GtkWidget*)Glib::unwrap(focus));
+}
+
+bool Gtk::Window::on_frame_event(GdkEvent* event)
+{
+  BaseClassType *const base = static_cast<BaseClassType*>(
+      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
+  );
+
+  if(base && base->frame_event)
+    return (*base->frame_event)(gobj(),event);
+
+  typedef bool RType;
+  return RType();
+}
+
+
+} // namespace Gtk
+
+
+namespace Glib
+{
+
+Glib::RefPtr<Gtk::WindowGroup> wrap(GtkWindowGroup* object, bool take_copy)
+{
+  return Glib::RefPtr<Gtk::WindowGroup>( dynamic_cast<Gtk::WindowGroup*> (Glib::wrap_auto ((GObject*)(object), take_copy)) );
+  //We use dynamic_cast<> in case of multiple inheritance.
+}
+
+} /* namespace Glib */
+
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& WindowGroup_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &WindowGroup_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_window_group_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void WindowGroup_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+}
+
+
+Glib::ObjectBase* WindowGroup_Class::wrap_new(GObject* object)
+{
+  return new WindowGroup((GtkWindowGroup*)object);
+}
+
+
+/* The implementation: */
+
+GtkWindowGroup* WindowGroup::gobj_copy()
+{
+  reference();
+  return gobj();
+}
+
+WindowGroup::WindowGroup(const Glib::ConstructParams& construct_params)
+:
+  Glib::Object(construct_params)
+{}
+
+WindowGroup::WindowGroup(GtkWindowGroup* castitem)
+:
+  Glib::Object((GObject*)(castitem))
+{}
+
+WindowGroup::~WindowGroup()
+{}
+
+
+WindowGroup::CppClassType WindowGroup::windowgroup_class_; // initialize static member
+
+GType WindowGroup::get_type()
+{
+  return windowgroup_class_.init().get_type();
+}
+
+GType WindowGroup::get_base_type()
+{
+  return gtk_window_group_get_type();
+}
+
+WindowGroup::WindowGroup()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Glib::Object(Glib::ConstructParams(windowgroup_class_.init()))
+{
+  }
+
+Glib::RefPtr<WindowGroup> WindowGroup::create()
+{
+  return Glib::RefPtr<WindowGroup>( new WindowGroup() );
+}
+void WindowGroup::add_window(Window& window)
+{
+  gtk_window_group_add_window(gobj(), (window).gobj());
+}
+
+void WindowGroup::remove_window(Window& window)
+{
+  gtk_window_group_remove_window(gobj(), (window).gobj());
+}
+
+
+} // namespace Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/window.h b/libs/gtkmm2/gtk/gtkmm/window.h
new file mode 100644
index 0000000000..442c68a011
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/window.h
@@ -0,0 +1,1637 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_WINDOW_H
+#define _GTKMM_WINDOW_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* window.h
+ * 
+ * Copyright (C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+ 
+#include <glibmm/object.h>
+#include <glibmm/listhandle.h>
+#include <gtkmm/bin.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkWindow GtkWindow;
+typedef struct _GtkWindowClass GtkWindowClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class Window_Class; } // namespace Gtk
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkWindowGroup GtkWindowGroup;
+typedef struct _GtkWindowGroupClass GtkWindowGroupClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class WindowGroup_Class; } // namespace Gtk
+namespace Gtk
+{
+
+class AccelGroup;
+class WindowGroup;
+
+
+/** Toplevel Window
+ * This represents all widgets which are physical windows controlled
+ * by the window manager.
+ *
+ * The window will be hidden when the window manager's close button is clicked. Override on_delete_event() to stop this.
+ *
+ * Gtk::manage() has no effect on Windows because they have no parent Containers.
+ * @ingroup Widgets
+ */
+
+class Window : public Bin
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Window CppObjectType;
+  typedef Window_Class CppClassType;
+  typedef GtkWindow BaseObjectType;
+  typedef GtkWindowClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~Window();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class Window_Class;
+  static CppClassType window_class_;
+
+  // noncopyable
+  Window(const Window&);
+  Window& operator=(const Window&);
+
+protected:
+  explicit Window(const Glib::ConstructParams& construct_params);
+  explicit Window(GtkWindow* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GtkObject.
+  GtkWindow*       gobj()       { return reinterpret_cast<GtkWindow*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GtkWindow* gobj() const { return reinterpret_cast<GtkWindow*>(gobject_); }
+
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+  virtual void on_set_focus(Widget* focus);
+  virtual bool on_frame_event(GdkEvent* event);
+
+
+private:
+
+  
+public:
+   explicit Window(WindowType type = WINDOW_TOPLEVEL);
+
+  /** The title of the window.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Glib::ustring> property_title() ;
+
+/** The title of the window.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Glib::ustring> property_title() const;
+
+  /** If TRUE
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_allow_shrink() ;
+
+/** If TRUE
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_allow_shrink() const;
+
+  /** If TRUE
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_allow_grow() ;
+
+/** If TRUE
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_allow_grow() const;
+
+  /** If TRUE
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_resizable() ;
+
+/** If TRUE
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_resizable() const;
+
+  /** If TRUE
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_modal() ;
+
+/** If TRUE
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_modal() const;
+
+  /** The initial position of the window.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<WindowPosition> property_window_position() ;
+
+/** The initial position of the window.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<WindowPosition> property_window_position() const;
+
+  /** The default width of the window
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<int> property_default_width() ;
+
+/** The default width of the window
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<int> property_default_width() const;
+
+  /** The default height of the window
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<int> property_default_height() ;
+
+/** The default height of the window
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<int> property_default_height() const;
+
+  /** If this window should be destroyed when the parent is destroyed.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_destroy_with_parent() ;
+
+/** If this window should be destroyed when the parent is destroyed.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_destroy_with_parent() const;
+
+  /** Icon for this window.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy< Glib::RefPtr<Gdk::Pixbuf> > property_icon() ;
+
+/** Icon for this window.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::Pixbuf> > property_icon() const;
+
+  
+  /** The screen where this window will be displayed.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy< Glib::RefPtr<Gdk::Screen> > property_screen() ;
+
+/** The screen where this window will be displayed.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::Screen> > property_screen() const;
+
+  /** Whether the toplevel is the current active window.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_is_active() const;
+
+
+  /** Whether the input focus is within this GtkWindow.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_has_toplevel_focus() const;
+
+
+  /** Hint to help the desktop environment understand what kind of window this is and how to treat it.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<GdkWindowTypeHint> property_type_hint() ;
+
+/** Hint to help the desktop environment understand what kind of window this is and how to treat it.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<GdkWindowTypeHint> property_type_hint() const;
+
+  /** TRUE if the window should not be in the task bar.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_skip_taskbar_hint() ;
+
+/** TRUE if the window should not be in the task bar.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_skip_taskbar_hint() const;
+
+  /** TRUE if the window should not be in the pager.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_skip_pager_hint() ;
+
+/** TRUE if the window should not be in the pager.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_skip_pager_hint() const;
+      
+  /** Unique identifier for the window to be used when restoring a session.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Glib::ustring> property_role() ;
+
+/** Unique identifier for the window to be used when restoring a session.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Glib::ustring> property_role() const;
+
+  /** Whether the window should be decorated by the window manager.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<bool> property_decorated() ;
+
+/** Whether the window should be decorated by the window manager.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<bool> property_decorated() const;
+
+  /** The window gravity of the window.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<Gdk::Gravity> property_gravity() ;
+
+/** The window gravity of the window.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<Gdk::Gravity> property_gravity() const;
+
+
+  bool is_toplevel() const;
+  bool is_dialog() const;
+  bool is_popup() const;
+
+  WindowType get_window_type() const;
+
+  //: This is special to the GTK+ linux-fb port.
+  Glib::RefPtr<Gdk::Window> get_frame();
+  Glib::RefPtr<const Gdk::Window> get_frame() const;
+
+
+  Glib::SignalProxy1< void,Widget* > signal_set_focus();
+
+  
+  Glib::SignalProxy1< bool,GdkEvent* > signal_frame_event();
+
+
+  //Keybinding signals:
+  
+  
+  /** Sets the title of the Gtk::Window. The title of a window will be
+   * displayed in its title bar; on the X&nbsp;%Window System, the title bar
+   * is rendered by the window
+   * manager, so exactly how the title appears to users may vary
+   * according to a user's exact configuration. The title should help a
+   * user distinguish this window from other windows they may have
+   * open. A good title might include the application name and current
+   * document filename, for example.
+   * @param title Title of the window.
+   */
+  void set_title(const Glib::ustring& title);
+
+  
+  /** Retrieves the title of the window. See set_title().
+   * @return The title of the window, or <tt>0</tt> if none has
+   * been set explicitely. The returned string is owned by the widget
+   * and must not be modified or freed.
+   */
+  Glib::ustring get_title() const;
+
+  
+  /** Don't use this function. It sets the X&nbsp;%Window System "class" and
+   * "name" hints for a window.  According to the ICCCM, you should
+   * always set these to the same value for all windows in an
+   * application, and GTK+ sets them to that value by default, so calling
+   * this function is sort of pointless. However, you may want to call
+   * set_role() on each window in your application, for the
+   * benefit of the session manager. Setting the role allows the window
+   * manager to restore window positions when loading a saved session.
+   * @param wmclass_name Window name hint.
+   * @param wmclass_class Window class hint.
+   */
+  void set_wmclass(const Glib::ustring& wmclass_name,
+                                const Glib::ustring& wmclass_class);
+
+  
+  /** This function is only useful on X11, not with other GTK+ targets.
+   * 
+   * In combination with the window title, the window role allows a
+   * window manager to identify "the
+   * same" window when an application is restarted. So for example you
+   * might set the "toolbox" role on your app's toolbox window, so that
+   * when the user restarts their session, the window manager can put
+   * the toolbox back in the same place.
+   * 
+   * If a window already has a unique title, you don't need to set the
+   * role, since the WM can use the title to identify the window when
+   * restoring the session.
+   * @param role Unique identifier for the window to be used when restoring a session.
+   */
+  void set_role(const Glib::ustring& role);
+
+  //: Returns the role of the window.
+  //- See {set_role()} for further explanation.
+  
+  /** Returns the role of the window. See set_role() for
+   * further explanation.
+   * @return The role of the window if set, or <tt>0</tt>. The
+   * returned is owned by the widget and must not be modified
+   * or freed.
+   */
+  Glib::ustring get_role() const;
+
+
+  /** Associate @a accel_group  with @a window , such that calling
+   * gtk_accel_groups_activate() on @a window  will activate accelerators
+   * in @a accel_group .
+   * @param accel_group A Gtk::AccelGroup.
+   */
+  void add_accel_group(const Glib::RefPtr<AccelGroup>& accel_group);
+
+  
+  /** Reverses the effects of add_accel_group().
+   * @param accel_group A Gtk::AccelGroup.
+   */
+  void remove_accel_group(const Glib::RefPtr<AccelGroup>& accel_group);
+
+  
+  /** Sets a position constraint for this window. If the old or new
+   * constraint is Gtk::WIN_POS_CENTER_ALWAYS, this will also cause
+   * the window to be repositioned to satisfy the new constraint.
+   * @param position A position constraint.
+   */
+  void set_position(WindowPosition position);
+
+  
+  /** Activates the current focused widget within the window.
+   * @return <tt>true</tt> if a widget got activated.
+   */
+  bool activate_focus();
+
+  
+  /** If @a focus  is not the current focus widget, and is focusable, sets
+   * it as the focus widget for the window. To set the focus to a particular
+   * widget in the toplevel, it is usually more convenient to use
+   * Gtk::Widget::grab_focus() instead of this function.
+   * @param focus Widget to be the new focus widget.
+   */
+  void set_focus(Gtk::Widget& focus);
+  void unset_focus();
+  
+  
+  /** Retrieves the current focused widget within the window.
+   * Note that this is the widget that would have the focus
+   * if the toplevel window focused; if the toplevel window
+   * is not focused then  <tt>GTK_WIDGET_HAS_FOCUS (widget)</tt> will
+   * not be <tt>true</tt> for the widget.
+   * @return The currently focused widget, or <tt>0</tt> if there is none.
+   */
+  Widget* get_focus();
+  
+  /** Retrieves the current focused widget within the window.
+   * Note that this is the widget that would have the focus
+   * if the toplevel window focused; if the toplevel window
+   * is not focused then  <tt>GTK_WIDGET_HAS_FOCUS (widget)</tt> will
+   * not be <tt>true</tt> for the widget.
+   * @return The currently focused widget, or <tt>0</tt> if there is none.
+   */
+  const Widget* get_focus() const;
+  
+  /** The default widget is the widget that's activated when the user
+   * presses Enter in a dialog (for example). This function sets the default widget for a Gtk::Window. When setting
+   * (rather than unsetting) the default widget it's generally easier to
+   * call Gtk::Widget::grab_focus() on the widget. Before making a widget
+   * the default widget, you must set the Gtk::CAN_DEFAULT flag on the
+   * widget you'd like to make the default using GTK_WIDGET_SET_FLAGS().
+   * @param default_widget Widget to be the default.
+   */
+  void set_default(Gtk::Widget& default_widget);
+  void unset_default();
+ 
+  
+  /** Activates the default widget for the window, unless the current 
+   * focused widget has been configured to receive the default action 
+   * (see Gtk::RECEIVES_DEFAULT in Gtk::WidgetFlags), in which case the
+   * focused widget is activated.
+   * @return <tt>true</tt> if a widget got activated.
+   */
+  bool activate_default();
+
+  
+  /** Dialog windows should be set transient for the main application
+   * window they were spawned from. This allows window managers to e.g. keep the
+   * dialog on top of the main window, or center the dialog over the
+   * main window. Gtk::Dialog::new_with_buttons() and other convenience
+   * functions in GTK+ will sometimes call
+   * set_transient_for() on your behalf.
+   * 
+   * On Windows, this function will and put the child window
+   * on top of the parent, much as the window manager would have
+   * done on X.
+   * @param parent Parent window.
+   */
+  void set_transient_for(Window& parent);
+
+  
+  /** Fetches the transient parent for this window. See
+   * set_transient_for().
+   * @return The transient parent for this window, or <tt>0</tt>
+   * if no transient parent has been set.
+   */
+  Window* get_transient_for();
+  
+  /** Fetches the transient parent for this window. See
+   * set_transient_for().
+   * @return The transient parent for this window, or <tt>0</tt>
+   * if no transient parent has been set.
+   */
+  const Window* get_transient_for() const;
+
+  
+  /** By setting the type hint for the window, you allow the window
+   * manager to decorate and handle the window in a way which is
+   * suitable to the function of the window in your application.
+   * 
+   * This function should be called before the window becomes visible.
+   * 
+   * Gtk::Dialog::new_with_buttons() and other convenience functions in GTK+
+   * will sometimes call set_type_hint() on your behalf.
+   * @param hint The window type.
+   */
+  void set_type_hint(Gdk::WindowTypeHint hint);
+
+  
+  /** Gets the type hint for this window. See set_type_hint().
+   * @return The type hint for @a window .
+   */
+  Gdk::WindowTypeHint get_type_hint() const;
+
+  
+  /** Windows may set a hint asking the desktop environment not to display
+   * the window in the task bar. This function sets this hint.
+   * 
+   * Since: 2.2
+   * @param setting <tt>true</tt> to keep this window from appearing in the task bar.
+   */
+  void set_skip_taskbar_hint(bool setting = true);
+  
+  /** Gets the value set by set_skip_taskbar_hint()
+   * @return <tt>true</tt> if window shouldn't be in taskbar
+   * 
+   * Since: 2.2.
+   */
+  bool get_skip_taskbar_hint() const;
+
+  
+  /** Windows may set a hint asking the desktop environment not to display
+   * the window in the pager. This function sets this hint.
+   * (A "pager" is any desktop navigation tool such as a workspace
+   * switcher that displays a thumbnail representation of the windows
+   * on the screen.)
+   * 
+   * Since: 2.2
+   * @param setting <tt>true</tt> to keep this window from appearing in the pager.
+   */
+  void set_skip_pager_hint(bool setting = true);
+  
+  /** Gets the value set by set_skip_pager_hint().
+   * @return <tt>true</tt> if window shouldn't be in pager
+   * 
+   * Since: 2.2.
+   */
+  bool get_skip_pager_hint() const;
+
+  //_WRAP_METHOD(void set_destroy_with_parent(bool setting = true), gtk_window_set_destroy_with_parent)
+  // I don't that that this is ever a good thing for C++.murrayc.
+
+  
+  /** Returns whether the window will be destroyed with its transient parent. See
+   * set_destroy_with_parent().
+   * @return <tt>true</tt> if the window will be destroyed with its transient parent.
+   */
+  bool get_destroy_with_parent() const;
+  // I don't that that this is ever a good thing for C++.murrayc.
+
+  
+  /** Sets whether the user can resize a window. Windows are user resizable
+   * by default.
+   * @param resizable <tt>true</tt> if the user can resize this window.
+   */
+  void set_resizable(bool resizable = true);
+
+  
+  /** Gets the value set by set_resizable().
+   * @return <tt>true</tt> if the user can resize the window.
+   */
+  bool get_resizable() const;
+
+  
+  /** Window gravity defines the meaning of coordinates passed to
+   * move(). See move() and Gdk::Gravity for
+   * more details.
+   * 
+   * The default window gravity is Gdk::GRAVITY_NORTH_WEST which will
+   * typically "do what you mean."
+   * @param gravity Window gravity.
+   */
+  void set_gravity(Gdk::Gravity gravity);
+
+  
+  /** Gets the value set by set_gravity().
+   * @return Window gravity.
+   */
+  Gdk::Gravity get_gravity() const;
+
+  
+  /** This function sets up hints about how a window can be resized by
+   * the user.  You can set a minimum and maximum size; allowed resize
+   * increments (e.g. for xterm, you can only resize by the size of a
+   * character); aspect ratios; and more. See the Gdk::Geometry struct.
+   * @param geometry_widget Widget the geometry hints will be applied to.
+   * @param geometry Struct containing geometry information.
+   * @param geom_mask Mask indicating which struct fields should be paid attention to.
+   */
+  void set_geometry_hints(Widget& geometry_widget,
+                                       const Gdk::Geometry& geometry,
+                                       Gdk::WindowHints geom_mask);
+
+  
+  /** Sets the Gdk::Screen where the @a window  is displayed; if
+   * the window is already mapped, it will be unmapped, and
+   * then remapped on the new screen.
+   * 
+   * Since: 2.2
+   * @param screen A Gdk::Screen.
+   */
+  void set_screen(const Glib::RefPtr<Gdk::Screen>& screen);
+
+  
+  /** Returns the Gdk::Screen associated with @a window .
+   * @return A Gdk::Screen.
+   * 
+   * Since: 2.2.
+   */
+  Glib::RefPtr<Gdk::Screen> get_screen();
+  
+  /** Returns the Gdk::Screen associated with @a window .
+   * @return A Gdk::Screen.
+   * 
+   * Since: 2.2.
+   */
+  Glib::RefPtr<const Gdk::Screen> get_screen() const;
+
+
+  /** (Note: this is a special-purpose function for the framebuffer port,
+   * that causes GTK+ to draw its own window border. For most applications,
+   * you want set_decorated() instead, which tells the window
+   * manager whether to draw the window border.)
+   * 
+   * If this function is called on a window with setting of <tt>true</tt>, before
+   * it is realized or showed, it will have a "frame" window around
+   *  @a window -&gt;window, accessible in @a window -&gt;frame. Using the signal 
+   * frame_event you can receive all events targeted at the frame.
+   * 
+   * This function is used by the linux-fb port to implement managed
+   * windows, but it could concievably be used by X-programs that
+   * want to do their own window decorations.
+   * @param setting A boolean.
+   */
+  void set_has_frame(bool setting = true);
+
+  
+  /** Accessor for whether the window has a frame window exterior to
+   *  @a window -&gt;window. Gets the value set by set_has_frame().
+   * @return <tt>true</tt> if a frame has been added to the window
+   * via set_has_frame().
+   */
+  bool get_has_frame() const;
+
+  
+  /** (Note: this is a special-purpose function intended for the framebuffer
+   * port; see set_has_frame(). It will have no effect on the
+   * window border drawn by the window manager, which is the normal
+   * case when using the X&nbsp;%Window system.)
+   * 
+   * For windows with frames (see set_has_frame()) this function
+   * can be used to change the size of the frame border.
+   * @param left The width of the left border.
+   * @param top The height of the top border.
+   * @param right The width of the right border.
+   * @param bottom The height of the bottom border.
+   */
+  void set_frame_dimensions(int left,  int top,
+                                         int right, int bottom);
+
+  
+  /** (Note: this is a special-purpose function intended for the
+   * framebuffer port; see set_has_frame(). It will not
+   * return the size of the window border drawn by the window manager, which is the normal
+   * case when using a windowing system.  See
+   * gdk_window_get_frame_extents() to get the standard window border
+   * extents.)
+   * 
+   * Retrieves the dimensions of the frame window for this toplevel.
+   * See set_has_frame(), set_frame_dimensions().
+   * @param left Location to store the width of the frame at the left.
+   * @param top Location to store the height of the frame at the top.
+   * @param right Location to store the width of the frame at the returns.
+   * @param bottom Location to store the height of the frame at the bottom.
+   */
+  void get_frame_dimensions(int& left,  int& top,
+                                         int& right, int& bottom) const;
+
+  
+  /** By default, windows are decorated with a title bar, resize
+   * controls, etc.  Some window
+   * managers allow GTK+ to disable these decorations, creating a
+   * borderless window. If you set the decorated property to <tt>false</tt>
+   * using this function, GTK+ will do its best to convince the window
+   * manager not to decorate the window. Depending on the system, this
+   * function may not have any effect when called on a window that is
+   * already visible, so you should call it before calling gtk_window_show().
+   * 
+   * On Windows, this function always works, since there's no window manager
+   * policy involved.
+   * @param setting <tt>true</tt> to decorate the window.
+   */
+  void set_decorated(bool setting = true);
+  
+  /** Returns whether the window has been set to have decorations
+   * such as a title bar via set_decorated().
+   * @return <tt>true</tt> if the window has been set to have decorations.
+   */
+  bool get_decorated() const;
+
+
+  /** Retrieves the list of icons set by set_icon_list().
+   * The list is copied, but the reference count on each
+   * member won't be incremented.
+   * @return Copy of window's icon list.
+   */
+  Glib::ListHandle< Glib::RefPtr<Gdk::Pixbuf> > get_icon_list();
+  
+  /** Retrieves the list of icons set by set_icon_list().
+   * The list is copied, but the reference count on each
+   * member won't be incremented.
+   * @return Copy of window's icon list.
+   */
+  Glib::ListHandle< Glib::RefPtr<const Gdk::Pixbuf> > get_icon_list() const;
+
+  
+  /** Sets up the icon representing a Gtk::Window. The icon is used when
+   * the window is minimized (also known as iconified).  Some window
+   * managers or desktop environments may also place it in the window
+   * frame, or display it in other contexts.
+   * 
+   * set_icon_list() allows you to pass in the same icon in
+   * several hand-drawn sizes. The list should contain the natural sizes
+   * your icon is available in; that is, don't scale the image before
+   * passing it to GTK+. Scaling is postponed until the last minute,
+   * when the desired final size is known, to allow best quality.
+   * 
+   * By passing several sizes, you may improve the final image quality
+   * of the icon, by reducing or eliminating automatic image scaling.
+   * 
+   * Recommended sizes to provide: 16x16, 32x32, 48x48 at minimum, and
+   * larger images (64x64, 128x128) if you have them.
+   * 
+   * See also set_default_icon_list() to set the icon
+   * for all windows in your application in one go.
+   * 
+   * Note that transient windows (those who have been set transient for another
+   * window using set_transient_for()) will inherit their
+   * icon from their transient parent. So there's no need to explicitly
+   * set the icon on transient windows.
+   * @param list List of Gdk::Pixbuf.
+   */
+  void set_icon_list(const Glib::ListHandle< Glib::RefPtr<Gdk::Pixbuf> >& list);
+
+  
+  /** Sets up the icon representing a Gtk::Window. This icon is used when
+   * the window is minimized (also known as iconified).  Some window
+   * managers or desktop environments may also place it in the window
+   * frame, or display it in other contexts.
+   * 
+   * The icon should be provided in whatever size it was naturally
+   * drawn; that is, don't scale the image before passing it to
+   * GTK+. Scaling is postponed until the last minute, when the desired
+   * final size is known, to allow best quality.
+   * 
+   * If you have your icon hand-drawn in multiple sizes, use
+   * set_icon_list(). Then the best size will be used.
+   * 
+   * This function is equivalent to calling set_icon_list()
+   * with a 1-element list.
+   * 
+   * See also set_default_icon_list() to set the icon
+   * for all windows in your application in one go.
+   * @param icon Icon image, or <tt>0</tt>.
+   */
+  void set_icon(const Glib::RefPtr<Gdk::Pixbuf>& icon);
+
+
+  /** Sets the icon for the window.
+   * 
+   * This function is equivalent to calling set_icon()
+   * with a pixbuf created by loading the image from @a filename .
+   * @param filename Location of icon file.
+   * @return <tt>true</tt> if setting the icon succeeded.
+   * 
+   * Since: 2.2.
+   */
+  bool set_icon_from_file(const std::string& filename);
+
+  
+  /** Gets the value set by set_icon() (or if you've
+   * called set_icon_list(), gets the first icon in
+   * the icon list).
+   * @return Icon for window.
+   */
+  Glib::RefPtr<Gdk::Pixbuf> get_icon();
+  
+  /** Gets the value set by set_icon() (or if you've
+   * called set_icon_list(), gets the first icon in
+   * the icon list).
+   * @return Icon for window.
+   */
+  Glib::RefPtr<const Gdk::Pixbuf> get_icon() const;
+
+  
+  /** Sets an icon list to be used as fallback for windows that haven't
+   * had set_icon_list() called on them to set up a
+   * window-specific icon list. This function allows you to set up the
+   * icon for all windows in your app at once.
+   * 
+   * See set_icon_list() for more details.
+   * @param list A list of Gdk::Pixbuf.
+   */
+  static void set_default_icon_list(
+                   const Glib::ListHandle< Glib::RefPtr<Gdk::Pixbuf> >& list);
+
+  
+  /** Gets the value set by Gtk::Window::set_default_icon_list().
+   * @return Copy of default icon list.
+   */
+  static Glib::ListHandle< Glib::RefPtr<Gdk::Pixbuf> > get_default_icon_list();
+  
+  
+  /** Sets an icon to be used as fallback for windows that haven't
+   * had set_icon_list() called on them from a file
+   * on disk. Warns on failure if @a err  is <tt>0</tt>.
+   * @param filename Location of icon file.
+   * @return <tt>true</tt> if setting the icon succeeded.
+   * 
+   * Since: 2.2.
+   */
+  static bool set_default_icon_from_file(const std::string& filename);
+  
+  /** By default, after showing the first Gtk::Window for each Gdk::Screen,
+   * GTK+ calls gdk_screen_notify_startup_complete().  Call this
+   * function to disable the automatic startup notification. You might
+   * do this if your first window is a splash screen, and you want to
+   * delay notification until after your real main window has been
+   * shown, for example.
+   * 
+   * In that example, you would disable startup notification
+   * temporarily, show your splash screen, then re-enable it so that
+   * showing the main window would automatically result in notification.
+   * 
+   * Since: 2.2
+   * @param setting <tt>true</tt> to automatically do startup notification.
+   */
+  static void set_auto_startup_notification(bool setting = true);
+
+  
+  /** Sets a window modal or non-modal. Modal windows prevent interaction
+   * with other windows in the same application. To keep modal dialogs
+   * on top of main application windows, use
+   * set_transient_for() to make the dialog transient for the
+   * parent; most window managers
+   * will then disallow lowering the dialog below the parent.
+   * @param modal Whether the window is modal.
+   */
+  void set_modal(bool modal = true);
+
+  
+  /** Returns whether the window is modal. See set_modal().
+   * @return <tt>true</tt> if the window is set to be modal and
+   * establishes a grab when shown.
+   */
+  bool get_modal() const;
+
+
+  /** Returns a list of all existing toplevel windows. The widgets
+   * in the list are not individually referenced. If you want
+   * to iterate through the list and perform actions involving
+   * callbacks that might destroy the widgets, you <em>must</em> call
+   * <tt>g_list_foreach (result, (GFunc)g_object_ref, <tt>0</tt>)</tt> first, and
+   * then unref all the widgets afterwards.
+   * @return List of toplevel widgets.
+   */
+  static Glib::ListHandle<Window*> list_toplevels();
+
+
+  /** Adds a mnemonic to this window.
+   * @param keyval The mnemonic.
+   * @param target The widget that gets activated by the mnemonic.
+   */
+  void add_mnemonic(guint keyval, Widget& target);
+
+  
+  /** Removes a mnemonic from this window.
+   * @param keyval The mnemonic.
+   * @param target The widget that gets activated by the mnemonic.
+   */
+  void remove_mnemonic(guint keyval, Widget& target);
+
+  
+  /** Activates the targets associated with the mnemonic.
+   * @param keyval The mnemonic.
+   * @param modifier The modifiers.
+   * @return <tt>true</tt> if the activation is done.
+   */
+  bool mnemonic_activate(guint keyval, Gdk::ModifierType modifier);
+
+  
+  /** Sets the mnemonic modifier for this window.
+   * @param modifier The modifier mask used to activate
+   * mnemonics on this window.
+   */
+  void set_mnemonic_modifier(Gdk::ModifierType modifier);
+
+  
+  /** Returns the mnemonic modifier for this window. See
+   * set_mnemonic_modifier().
+   * @return The modifier mask used to activate
+   * mnemonics on this window.
+   */
+  Gdk::ModifierType get_mnemonic_modifier();
+
+
+  /** Presents a window to the user. This may mean raising the window
+   * in the stacking order, deiconifying it, moving it to the current
+   * desktop, and/or giving it the keyboard focus, possibly dependent
+   * on the user's platform, window manager, and preferences.
+   * 
+   * If @a window  is hidden, this function calls Gtk::Widget::show()
+   * as well.
+   * 
+   * This function should be used when the user tries to open a window
+   * that's already open. Say for example the preferences dialog is
+   * currently open, and the user chooses Preferences from the menu
+   * a second time; use present() to move the already-open dialog
+   * where the user can see it.
+   */
+  void present();
+
+  
+  /** Asks to iconify (i.e.\ minimize) the specified @a window . Note that
+   * you shouldn't assume the window is definitely iconified afterward,
+   * because other entities (e.g. the user or window manager) could deiconify it
+   * again, or there may not be a window manager in which case
+   * iconification isn't possible, etc. But normally the window will end
+   * up iconified. Just don't write code that crashes if not.
+   * 
+   * It's permitted to call this function before showing a window,
+   * in which case the window will be iconified before it ever appears
+   * onscreen.
+   * 
+   * You can track iconification via the "window_state_event" signal
+   * on Gtk::Widget.
+   */
+  void iconify();
+  
+  /** Asks to deiconify (i.e.\ unminimize) the specified @a window . Note
+   * that you shouldn't assume the window is definitely deiconified
+   * afterward, because other entities (e.g. the user or window manager) could iconify it
+   * again before your code which assumes deiconification gets to run.
+   * 
+   * You can track iconification via the "window_state_event" signal
+   * on Gtk::Widget.
+   */
+  void deiconify();
+
+  
+  /** Asks to stick @a window , which means that it will appear on all user
+   * desktops. Note that you shouldn't assume the window is definitely
+   * stuck afterward, because other entities (e.g. the user or window manager) could unstick it
+   * again, and some window managers do not support sticking
+   * windows. But normally the window will end up stuck. Just don't
+   * write code that crashes if not.
+   * 
+   * It's permitted to call this function before showing a window.
+   * 
+   * You can track stickiness via the "window_state_event" signal
+   * on Gtk::Widget.
+   */
+  void stick();
+  
+  /** Asks to unstick @a window , which means that it will appear on only
+   * one of the user's desktops. Note that you shouldn't assume the
+   * window is definitely unstuck afterward, because other entities
+   * (e.g. the user or window
+   * manager) could stick it again. But normally the window will
+   * end up stuck. Just don't write code that crashes if not.
+   * 
+   * You can track stickiness via the "window_state_event" signal
+   * on Gtk::Widget.
+   */
+  void unstick();
+
+  
+  /** Asks to maximize @a window , so that it becomes full-screen. Note that
+   * you shouldn't assume the window is definitely maximized afterward,
+   * because other entities (e.g. the user or window manager) could unmaximize it
+   * again, and not all window managers support maximization. But
+   * normally the window will end up maximized. Just don't write code
+   * that crashes if not.
+   * 
+   * It's permitted to call this function before showing a window,
+   * in which case the window will be maximized when it appears onscreen
+   * initially.
+   * 
+   * You can track maximization via the "window_state_event" signal
+   * on Gtk::Widget.
+   */
+  void maximize();
+  
+  /** Asks to unmaximize @a window . Note that you shouldn't assume the
+   * window is definitely unmaximized afterward, because other entities
+   * (e.g. the user or window
+   * manager) could maximize it again, and not all window
+   * managers honor requests to unmaximize. But normally the window will
+   * end up unmaximized. Just don't write code that crashes if not.
+   * 
+   * You can track maximization via the "window_state_event" signal
+   * on Gtk::Widget.
+   */
+  void unmaximize();
+
+  
+  /** Asks to place @a window  in the fullscreen state. Note that you
+   * shouldn't assume the window is definitely full screen afterward,
+   * because other entities (e.g. the user or window manager) could unfullscreen it
+   * again, and not all window managers honor requests to fullscreen
+   * windows. But normally the window will end up fullscreen. Just
+   * don't write code that crashes if not.
+   * 
+   * You can track the fullscreen state via the "window_state_event" signal
+   * on Gtk::Widget.
+   * 
+   * Since: 2.2
+   */
+  void fullscreen();
+  
+  /** Asks to toggle off the fullscreen state for @a window . Note that you
+   * shouldn't assume the window is definitely not full screen
+   * afterward, because other entities (e.g. the user or window manager) could fullscreen it
+   * again, and not all window managers honor requests to unfullscreen
+   * windows. But normally the window will end up restored to its normal
+   * state. Just don't write code that crashes if not.
+   * 
+   * You can track the fullscreen state via the "window_state_event" signal
+   * on Gtk::Widget.
+   * 
+   * Since: 2.2
+   */
+  void unfullscreen();
+        
+  
+  /** Starts resizing a window. This function is used if an application
+   * has window resizing controls. When GDK can support it, the resize
+   * will be done using the standard mechanism for the window manager or windowing
+   * system. Otherwise, GDK will try to emulate window resizing,
+   * potentially not all that well, depending on the windowing system.
+   * @param button Mouse button that initiated the drag.
+   * @param edge Position of the resize control.
+   * @param root_x X position where the user clicked to initiate the drag, in root window coordinates.
+   * @param root_y Y position where the user clicked to initiate the drag.
+   * @param timestamp Timestamp from the click event that initiated the drag.
+   */
+  void begin_resize_drag(Gdk::WindowEdge edge,
+                   int button, int root_x, int root_y, guint32 timestamp);
+
+  
+  /** Starts moving a window. This function is used if an application has
+   * window movement grips. When GDK can support it, the window movement
+   * will be done using the standard mechanism for the window manager or windowing
+   * system. Otherwise, GDK will try to emulate window movement,
+   * potentially not all that well, depending on the windowing system.
+   * @param button Mouse button that initiated the drag.
+   * @param root_x X position where the user clicked to initiate the drag, in root window coordinates.
+   * @param root_y Y position where the user clicked to initiate the drag.
+   * @param timestamp Timestamp from the click event that initiated the drag.
+   */
+  void begin_move_drag(
+                   int button, int root_x, int root_y, guint32 timestamp);
+
+  
+  /** Sets the default size of a window. If the window's "natural" size
+   * (its size request) is larger than the default, the default will be
+   * ignored. More generally, if the default size does not obey the
+   * geometry hints for the window (set_geometry_hints() can
+   * be used to set these explicitly), the default size will be clamped
+   * to the nearest permitted size.
+   * 
+   * Unlike Gtk::Widget::set_size_request(), which sets a size request for
+   * a widget and thus would keep users from shrinking the window, this
+   * function only sets the initial size, just as if the user had
+   * resized the window themselves. Users can still shrink the window
+   * again as they normally would. Setting a default size of -1 means to
+   * use the "natural" default size (the size request of the window).
+   * 
+   * For more control over a window's initial size and how resizing works,
+   * investigate set_geometry_hints().
+   * 
+   * For some uses, resize() is a more appropriate function.
+   * resize() changes the current size of the window, rather
+   * than the size to be used on initial display. resize() always
+   * affects the window itself, not the geometry widget.
+   * 
+   * The default size of a window only affects the first time a window is
+   * shown; if a window is hidden and re-shown, it will remember the size
+   * it had prior to hiding, rather than using the default size.
+   * 
+   * Windows can't actually be 0x0 in size, they must be at least 1x1, but
+   * passing 0 for @a width  and @a height  is OK, resulting in a 1x1 default size.
+   * @param width Width in pixels, or -1 to unset the default width.
+   * @param height Height in pixels, or -1 to unset the default height.
+   */
+  void set_default_size(int width, int height);
+
+  
+  /** Gets the default size of the window. A value of -1 for the width or
+   * height indicates that a default size has not been explicitly set
+   * for that dimension, so the "natural" size of the window will be
+   * used.
+   * @param width Location to store the default width.
+   * @param height Location to store the default height.
+   */
+  void get_default_size(int& width, int& height) const;
+
+  
+  /** Resizes the window as if the user had done so, obeying geometry
+   * constraints. The default geometry constraint is that windows may
+   * not be smaller than their size request; to override this
+   * constraint, call Gtk::Widget::set_size_request() to set the window's
+   * request to a smaller value.
+   * 
+   * If resize() is called before showing a window for the
+   * first time, it overrides any default size set with
+   * set_default_size().
+   * 
+   * Windows may not be resized smaller than 1 by 1 pixels.
+   * @param width Width in pixels to resize the window to.
+   * @param height Height in pixels to resize the window to.
+   */
+  void resize(int width, int height);
+
+  
+  /** Obtains the current size of @a window . If @a window  is not onscreen,
+   * it returns the size GTK+ will suggest to the window manager for the initial window
+   * size (but this is not reliably the same as the size the window
+   * manager will actually select). The size obtained by
+   * get_size() is the last size received in a
+   * Gdk::EventConfigure, that is, GTK+ uses its locally-stored size,
+   * rather than querying the X server for the size. As a result, if you
+   * call resize() then immediately call
+   * get_size(), the size won't have taken effect yet. After
+   * the window manager processes the resize request, GTK+ receives
+   * notification that the size has changed via a configure event, and
+   * the size of the window gets updated.
+   * 
+   * @note Nearly any use of this function creates a race condition,
+   * because the size of the window may change between the time that you
+   * get the size and the time that you perform some action assuming
+   * that size is the current size. To avoid race conditions, connect to
+   * "configure_event" on the window and adjust your size-dependent
+   * state to match the size delivered in the Gdk::EventConfigure.
+   * 
+   * @note The returned size does <em>not</em> include the
+   * size of the window manager decorations (aka the window frame or
+   * border). Those are not drawn by GTK+ and GTK+ has no reliable
+   * method of determining their size.
+   * 
+   * @note If you are getting a window size in order to position
+   * the window onscreen, there may be a better way. The preferred
+   * way is to simply set the window's semantic type with
+   * set_type_hint(), which allows the window manager to
+   * e.g. center dialogs. Also, if you set the transient parent of
+   * dialogs with set_transient_for() window managers
+   * will often center the dialog over its parent window. It's
+   * much preferred to let the window manager handle these
+   * things rather than doing it yourself, because all apps will
+   * behave consistently and according to user prefs if the window
+   * manager handles it. Also, the window manager can take the size
+   * of the window decorations/border into account, while your
+   * application cannot.
+   * 
+   * In any case, if you insist on application-specified window
+   * positioning, there's <em>still</em> a better way than
+   * doing it yourself - set_position() will frequently
+   * handle the details for you.
+   * @param width Return location for width.
+   * @param height Return location for height.
+   */
+  void get_size(int& width, int& height) const;
+
+
+  /** Asks the window manager to move
+   *  @a window  to the given position.  %Window managers are free to ignore
+   * this; most window managers ignore requests for initial window
+   * positions (instead using a user-defined placement algorithm) and
+   * honor requests after the window has already been shown.
+   * 
+   * @note the position is the position of the gravity-determined
+   * reference point for the window. The gravity determines two things:
+   * first, the location of the reference point in root window
+   * coordinates; and second, which point on the window is positioned at
+   * the reference point.
+   * 
+   * By default the gravity is Gdk::GRAVITY_NORTH_WEST, so the reference
+   * point is simply the @a x , @a y  supplied to move(). The
+   * top-left corner of the window decorations (aka window frame or
+   * border) will be placed at @a x , @a y .  Therefore, to position a window
+   * at the top left of the screen, you want to use the default gravity
+   * (which is Gdk::GRAVITY_NORTH_WEST) and move the window to 0,0.
+   * 
+   * To position a window at the bottom right corner of the screen, you
+   * would set Gdk::GRAVITY_SOUTH_EAST, which means that the reference
+   * point is at @a x  + the window width and @a y  + the window height, and
+   * the bottom-right corner of the window border will be placed at that
+   * reference point. So, to place a window in the bottom right corner
+   * you would first set gravity to south east, then write:
+   * <tt>gtk_window_move (window, gdk_screen_width() - window_width,
+   * gdk_screen_height() - window_height)</tt>.
+   * 
+   * The Extended Window Manager Hints specification at 
+   * http://www.freedesktop.org/standards/wm-spec has a 
+   * nice table of gravities in the "implementation notes" section.
+   * 
+   * The get_position() documentation may also be relevant.
+   * @param x X coordinate to move window to.
+   * @param y Y coordinate to move window to.
+   */
+  void move(int x, int y);
+
+  
+  /** This function returns the position you need to pass to
+   * move() to keep @a window  in its current position.  This
+   * means that the meaning of the returned value varies with window
+   * gravity. See move() for more details.
+   * 
+   * If you haven't changed the window gravity, its gravity will be
+   * Gdk::GRAVITY_NORTH_WEST. This means that get_position()
+   * gets the position of the top-left corner of the window manager
+   * frame for the window. move() sets the position of this
+   * same top-left corner.
+   * 
+   * get_position() is not 100% reliable because the X&nbsp;%Window System
+   * does not specify a way to obtain the geometry of the
+   * decorations placed on a window by the window manager.
+   * Thus GTK+ is using a "best guess" that works with most
+   * window managers.
+   * 
+   * Moreover, nearly all window managers are historically broken with
+   * respect to their handling of window gravity. So moving a window to
+   * its current position as returned by get_position() tends
+   * to result in moving the window slightly. %Window managers are
+   * slowly getting better over time.
+   * 
+   * If a window has gravity Gdk::GRAVITY_STATIC the window manager
+   * frame is not relevant, and thus get_position() will
+   * always produce accurate results. However you can't use static
+   * gravity to do things like place a window in a corner of the screen,
+   * because static gravity ignores the window manager decorations.
+   * 
+   * If you are saving and restoring your application's window
+   * positions, you should know that it's impossible for applications to
+   * do this without getting it somewhat wrong because applications do
+   * not have sufficient knowledge of window manager state. The Correct
+   * Mechanism is to support the session management protocol (see the
+   * "GnomeClient" object in the GNOME libraries for example) and allow
+   * the window manager to save your window sizes and positions.
+   * @param root_x Return location for X coordinate of gravity-determined reference point.
+   * @param root_y Return location for Y coordinate of gravity-determined reference point.
+   */
+  void get_position(int& root_x, int& root_y) const;
+
+  
+  /** Parses a standard X&nbsp;%Window System geometry string - see the
+   * manual page for X (type 'man X') for details on this.
+   * parse_geometry() does work on all GTK+ ports
+   * including Win32 but is primarily intended for an X environment.
+   * 
+   * If either a size or a position can be extracted from the
+   * geometry string, parse_geometry() returns <tt>true</tt>
+   * and calls set_default_size() and/or move()
+   * to resize/move the window.
+   * 
+   * If parse_geometry() returns <tt>true</tt>, it will also
+   * set the Gdk::HINT_USER_POS and/or Gdk::HINT_USER_SIZE hints
+   * indicating to the window manager that the size/position of
+   * the window was user-specified. This causes most window
+   * managers to honor the geometry.
+   * 
+   * Note that for parse_geometry() to work as expected, it has
+   * to be called when the window has its "final" size, i.e. after calling
+   * Gtk::Widget::show_all() on the contents and set_geometry_hints()
+   * on the window.
+   * 
+   * @code
+   * int
+   * main (int argc, char *argv[])
+   * {
+   * GtkWidget *window, vbox;
+   * GdkGeometry size_hints;
+   * 
+   * gtk_init (&amp;argc, &amp;argv);
+   * 
+   * window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+   * vbox = gtk_vbox_new (<tt>false</tt>, 0);
+   * 
+   * gtk_container_add (GTK_CONTAINER (window), vbox);
+   * fill_with_content (vbox);
+   * gtk_widget_show_all (vbox);
+   * 
+   * size_hints = {
+   * 100, 50, 0, 0, 100, 50, 10, 10, 0.0, 0.0, GDK_GRAVITY_NORTH_WEST  
+   * };
+   * 
+   * gtk_window_set_geometry_hints (GTK_WINDOW (window),
+   * window,
+   * &amp;size_hints,
+   * GDK_HINT_MIN_SIZE | 
+   * GDK_HINT_BASE_SIZE | 
+   * GDK_HINT_RESIZE_INC);
+   * 
+   * if (argc &gt; 1)
+   * {
+   * if (!gtk_window_parse_geometry (GTK_WINDOW (window), argv[1]))
+   * fprintf (stderr, "Failed to parse '&percnt;s'<tt>\\n</tt>", argv[1]);
+   * }
+   * 
+   * gtk_widget_show_all (window);
+   * gtk_main();
+   * 
+   * return 0;
+   * }
+   * @endcode
+   * @param geometry Geometry string.
+   * @return <tt>true</tt> if string was parsed successfully.
+   */
+  bool parse_geometry(const Glib::ustring& geometry);
+
+  
+  /** Hides @a window , then reshows it, resetting the
+   * default size and position of the window. Used
+   * by GUI builders only.
+   */
+  void reshow_with_initial_size();
+
+
+  /** Sets an icon to be used as fallback for windows that haven't
+   * had set_icon() called on them from a pixbuf.
+   * 
+   * Since: 2.4
+   * @param icon The icon.
+   */
+  static void set_default_icon(const Glib::RefPtr<Gdk::Pixbuf>& icon);
+  
+  /** Asks to keep @a window  above, so that it stays on top. Note that
+   * you shouldn't assume the window is definitely above afterward,
+   * because other entities (e.g. the user or window manager) could not keep it above,
+   * and not all window managers support keeping windows above. But
+   * normally the window will end kept above. Just don't write code
+   * that crashes if not.
+   * 
+   * It's permitted to call this function before showing a window,
+   * in which case the window will be kept above when it appears onscreen
+   * initially.
+   * 
+   * You can track the above state via the "window_state_event" signal
+   * on Gtk::Widget.
+   * 
+   * Note that, according to the Extended Window Manager Hints
+   * specification, the above state is mainly meant for user preferences and should not be used 
+   * by applications e.g. for drawing attention to their dialogs.
+   * 
+   * Since: 2.4
+   * @param setting Whether to keep @a window  above other windows.
+   */
+  void set_keep_above(bool setting = true);
+  
+  /** Asks to keep @a window  below, so that it stays in bottom. Note that
+   * you shouldn't assume the window is definitely below afterward,
+   * because other entities (e.g. the user or window manager) could not keep it below,
+   * and not all window managers support putting windows below. But
+   * normally the window will be kept below. Just don't write code
+   * that crashes if not.
+   * 
+   * It's permitted to call this function before showing a window,
+   * in which case the window will be kept below when it appears onscreen
+   * initially.
+   * 
+   * You can track the below state via the "window_state_event" signal
+   * on Gtk::Widget.
+   * 
+   * Note that, according to the Extended Window Manager Hints
+   * specification, the above state is mainly meant for user preferences and should not be used 
+   * by applications e.g. for drawing attention to their dialogs.
+   * 
+   * Since: 2.4
+   * @param setting Whether to keep @a window  below other windows.
+   */
+  void set_keep_below(bool setting = true);
+
+  
+  /** Returns a default accel group for this window
+   * This is a gtkmm-specific function.  This accel group can not
+   * be removed.
+   */
+  Glib::RefPtr<AccelGroup> get_accel_group();
+
+  /** Brings the window to the front.
+   * This is just a more obvious convenience wrapper for get_window()->raise().
+   */
+  virtual void raise();
+
+  ///Overriden to warn that it doesn't make sense to use Gtk::manage() on this class because it has no parent container.
+  virtual void set_manage();
+
+protected:
+
+  //See comments in the implementations:
+  void destroy_();
+  void _destroy_c_instance();
+
+private:
+
+  //We'll create an accel_group if it's requested, and remember it.
+  //Otherwise, you'd have to create it, add it to the window, then remember it somewhere else while you add it to other widgets.
+  Glib::RefPtr<AccelGroup> accel_group_;
+
+
+};
+
+
+class WindowGroup : public Glib::Object
+{
+  
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+public:
+  typedef WindowGroup CppObjectType;
+  typedef WindowGroup_Class CppClassType;
+  typedef GtkWindowGroup BaseObjectType;
+  typedef GtkWindowGroupClass BaseClassType;
+
+private:  friend class WindowGroup_Class;
+  static CppClassType windowgroup_class_;
+
+private:
+  // noncopyable
+  WindowGroup(const WindowGroup&);
+  WindowGroup& operator=(const WindowGroup&);
+
+protected:
+  explicit WindowGroup(const Glib::ConstructParams& construct_params);
+  explicit WindowGroup(GtkWindowGroup* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+  virtual ~WindowGroup();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GObject.
+  GtkWindowGroup*       gobj()       { return reinterpret_cast<GtkWindowGroup*>(gobject_); }
+
+  ///Provides access to the underlying C GObject.
+  const GtkWindowGroup* gobj() const { return reinterpret_cast<GtkWindowGroup*>(gobject_); }
+
+  ///Provides access to the underlying C instance. The caller is responsible for unrefing it. Use when directly setting fields in structs.
+  GtkWindowGroup* gobj_copy();
+
+private:
+
+
+protected:
+  WindowGroup();
+
+public:
+  
+  static Glib::RefPtr<WindowGroup> create();
+
+
+  /** Adds a window to a Gtk::WindowGroup.
+   * @param window The Gtk::Window to add.
+   */
+  void add_window(Window& window);
+  
+  /** Removes a window from a Gtk::WindowGroup.
+   * @param window The Gtk::Window to remove.
+   */
+  void remove_window(Window& window);
+
+
+public:
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+};
+
+} // namespace Gtk
+
+
+namespace Glib
+{
+  /** @relates Gtk::Window
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Gtk::Window* wrap(GtkWindow* object, bool take_copy = false);
+}
+
+namespace Glib
+{
+  /** @relates Gtk::WindowGroup
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Glib::RefPtr<Gtk::WindowGroup> wrap(GtkWindowGroup* object, bool take_copy = false);
+}
+
+
+#endif /* _GTKMM_WINDOW_H */
+
diff --git a/libs/gtkmm2/gtk/gtkmm/wrap_init.cc b/libs/gtkmm2/gtk/gtkmm/wrap_init.cc
new file mode 100644
index 0000000000..9c1713c033
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/wrap_init.cc
@@ -0,0 +1,740 @@
+
+#include <glib.h>
+
+// Disable the 'const' function attribute of the get_type() functions.
+// GCC would optimize them out because we don't use the return value.
+#undef  G_GNUC_CONST
+#define G_GNUC_CONST /* empty */
+
+#include <gtkmm/wrap_init.h>
+#include <glibmm/error.h>
+#include <glibmm/object.h>
+
+// #include the widget headers so that we can call the get_type() static methods:
+
+#include "plug.h"
+#include "socket.h"
+#include "aboutdialog.h"
+#include "accelgroup.h"
+#include "accellabel.h"
+#include "action.h"
+#include "actiongroup.h"
+#include "adjustment.h"
+#include "alignment.h"
+#include "arrow.h"
+#include "aspectframe.h"
+#include "bin.h"
+#include "box.h"
+#include "button.h"
+#include "buttonbox.h"
+#include "calendar.h"
+#include "celleditable.h"
+#include "celllayout.h"
+#include "cellview.h"
+#include "cellrenderer.h"
+#include "cellrenderercombo.h"
+#include "cellrendererpixbuf.h"
+#include "cellrendererprogress.h"
+#include "cellrenderertext.h"
+#include "cellrenderertoggle.h"
+#include "checkbutton.h"
+#include "checkmenuitem.h"
+#include "clipboard.h"
+#include "colorselection.h"
+#include "colorbutton.h"
+#include "combobox.h"
+#include "comboboxentry.h"
+#include "container.h"
+#include "curve.h"
+#include "dialog.h"
+#include "drawingarea.h"
+#include "editable.h"
+#include "entry.h"
+#include "entrycompletion.h"
+#include "enums.h"
+#include "eventbox.h"
+#include "expander.h"
+#include "filechooser.h"
+#include "filechooserbutton.h"
+#include "filechooserwidget.h"
+#include "filechooserdialog.h"
+#include "filefilter.h"
+#include "fileselection.h"
+#include "fixed.h"
+#include "fontbutton.h"
+#include "fontselection.h"
+#include "frame.h"
+#include "handlebox.h"
+#include "iconfactory.h"
+#include "iconset.h"
+#include "iconsource.h"
+#include "iconinfo.h"
+#include "icontheme.h"
+#include "iconview.h"
+#include "image.h"
+#include "imagemenuitem.h"
+#include "inputdialog.h"
+#include "invisible.h"
+#include "item.h"
+#include "label.h"
+#include "layout.h"
+#include "liststore.h"
+#include "main.h"
+#include "menu.h"
+#include "menubar.h"
+#include "menuitem.h"
+#include "menushell.h"
+#include "menutoolbutton.h"
+#include "messagedialog.h"
+#include "misc.h"
+#include "notebook.h"
+#include "object.h"
+#include "optionmenu.h"
+#include "paned.h"
+#include "progressbar.h"
+#include "radioaction.h"
+#include "radiobutton.h"
+#include "radiomenuitem.h"
+#include "radiotoolbutton.h"
+#include "range.h"
+#include "rc.h"
+#include "ruler.h"
+#include "scale.h"
+#include "scrollbar.h"
+#include "scrolledwindow.h"
+#include "selectiondata.h"
+#include "separator.h"
+#include "separatormenuitem.h"
+#include "separatortoolitem.h"
+#include "settings.h"
+#include "sizegroup.h"
+#include "spinbutton.h"
+#include "statusbar.h"
+#include "stockitem.h"
+#include "style.h"
+#include "table.h"
+#include "targetlist.h"
+#include "tearoffmenuitem.h"
+#include "textattributes.h"
+#include "textbuffer.h"
+#include "textchildanchor.h"
+#include "textiter.h"
+#include "textmark.h"
+#include "texttag.h"
+#include "texttagtable.h"
+#include "textview.h"
+#include "toggleaction.h"
+#include "togglebutton.h"
+#include "toggletoolbutton.h"
+#include "toolbar.h"
+#include "toolitem.h"
+#include "toolbutton.h"
+#include "tooltips.h"
+#include "treedragdest.h"
+#include "treedragsource.h"
+#include "treepath.h"
+#include "treerowreference.h"
+#include "treeselection.h"
+#include "treesortable.h"
+#include "treeiter.h"
+#include "treemodel.h"
+#include "treemodelfilter.h"
+#include "treemodelsort.h"
+#include "treestore.h"
+#include "treeview.h"
+#include "treeviewcolumn.h"
+#include "viewport.h"
+#include "uimanager.h"
+#include "widget.h"
+#include "window.h"
+#include "combo.h"
+
+extern "C"
+{
+
+//Declarations of the *_get_type() functions:
+
+GType gtk_about_dialog_get_type(void);
+GType gtk_accel_group_get_type(void);
+GType gtk_accel_label_get_type(void);
+GType gtk_action_get_type(void);
+GType gtk_action_group_get_type(void);
+GType gtk_adjustment_get_type(void);
+GType gtk_alignment_get_type(void);
+GType gtk_arrow_get_type(void);
+GType gtk_aspect_frame_get_type(void);
+GType gtk_bin_get_type(void);
+GType gtk_box_get_type(void);
+GType gtk_button_get_type(void);
+GType gtk_button_box_get_type(void);
+GType gtk_calendar_get_type(void);
+GType gtk_cell_renderer_get_type(void);
+GType gtk_cell_renderer_combo_get_type(void);
+GType gtk_cell_renderer_pixbuf_get_type(void);
+GType gtk_cell_renderer_progress_get_type(void);
+GType gtk_cell_renderer_text_get_type(void);
+GType gtk_cell_renderer_toggle_get_type(void);
+GType gtk_cell_view_get_type(void);
+GType gtk_check_button_get_type(void);
+GType gtk_check_menu_item_get_type(void);
+GType gtk_clipboard_get_type(void);
+GType gtk_color_button_get_type(void);
+GType gtk_color_selection_get_type(void);
+GType gtk_color_selection_dialog_get_type(void);
+GType gtk_combo_get_type(void);
+GType gtk_combo_box_get_type(void);
+GType gtk_combo_box_entry_get_type(void);
+GType gtk_list_get_type(void);
+GType gtk_list_item_get_type(void);
+GType gtk_container_get_type(void);
+GType gtk_curve_get_type(void);
+GType gtk_dialog_get_type(void);
+GType gtk_drawing_area_get_type(void);
+GType gtk_entry_get_type(void);
+GType gtk_entry_completion_get_type(void);
+GType gtk_event_box_get_type(void);
+GType gtk_expander_get_type(void);
+GType gtk_file_chooser_button_get_type(void);
+GType gtk_file_chooser_dialog_get_type(void);
+GType gtk_file_chooser_widget_get_type(void);
+GType gtk_file_filter_get_type(void);
+GType gtk_file_selection_get_type(void);
+GType gtk_fixed_get_type(void);
+GType gtk_font_button_get_type(void);
+GType gtk_font_selection_get_type(void);
+GType gtk_font_selection_dialog_get_type(void);
+GType gtk_frame_get_type(void);
+GType gtk_gamma_curve_get_type(void);
+GType gtk_hbox_get_type(void);
+GType gtk_hbutton_box_get_type(void);
+GType gtk_hpaned_get_type(void);
+GType gtk_hruler_get_type(void);
+GType gtk_hscale_get_type(void);
+GType gtk_hscrollbar_get_type(void);
+GType gtk_hseparator_get_type(void);
+GType gtk_handle_box_get_type(void);
+GType gtk_icon_factory_get_type(void);
+GType gtk_icon_theme_get_type(void);
+GType gtk_icon_view_get_type(void);
+GType gtk_image_get_type(void);
+GType gtk_image_menu_item_get_type(void);
+GType gtk_input_dialog_get_type(void);
+GType gtk_invisible_get_type(void);
+GType gtk_item_get_type(void);
+GType gtk_label_get_type(void);
+GType gtk_layout_get_type(void);
+GType gtk_list_store_get_type(void);
+GType gtk_menu_get_type(void);
+GType gtk_menu_bar_get_type(void);
+GType gtk_menu_item_get_type(void);
+GType gtk_menu_shell_get_type(void);
+GType gtk_menu_tool_button_get_type(void);
+GType gtk_message_dialog_get_type(void);
+GType gtk_misc_get_type(void);
+GType gtk_notebook_get_type(void);
+GType gtk_object_get_type(void);
+GType gtk_option_menu_get_type(void);
+GType gtk_paned_get_type(void);
+#ifndef G_OS_WIN32
+GType gtk_plug_get_type(void);
+#endif //G_OS_WIN32
+GType gtk_progress_bar_get_type(void);
+GType gtk_radio_action_get_type(void);
+GType gtk_radio_button_get_type(void);
+GType gtk_radio_menu_item_get_type(void);
+GType gtk_radio_tool_button_get_type(void);
+GType gtk_range_get_type(void);
+GType gtk_rc_style_get_type(void);
+GType gtk_ruler_get_type(void);
+GType gtk_scale_get_type(void);
+GType gtk_scrollbar_get_type(void);
+GType gtk_scrolled_window_get_type(void);
+GType gtk_separator_get_type(void);
+GType gtk_separator_menu_item_get_type(void);
+GType gtk_separator_tool_item_get_type(void);
+GType gtk_settings_get_type(void);
+GType gtk_size_group_get_type(void);
+#ifndef G_OS_WIN32
+GType gtk_socket_get_type(void);
+#endif //G_OS_WIN32
+GType gtk_spin_button_get_type(void);
+GType gtk_statusbar_get_type(void);
+GType gtk_style_get_type(void);
+GType gtk_table_get_type(void);
+GType gtk_tearoff_menu_item_get_type(void);
+GType gtk_text_buffer_get_type(void);
+GType gtk_text_child_anchor_get_type(void);
+GType gtk_text_mark_get_type(void);
+GType gtk_text_tag_get_type(void);
+GType gtk_text_tag_table_get_type(void);
+GType gtk_text_view_get_type(void);
+GType gtk_toggle_action_get_type(void);
+GType gtk_toggle_button_get_type(void);
+GType gtk_toggle_tool_button_get_type(void);
+GType gtk_tool_button_get_type(void);
+GType gtk_tool_item_get_type(void);
+GType gtk_toolbar_get_type(void);
+GType gtk_tooltips_get_type(void);
+GType gtk_tree_model_filter_get_type(void);
+GType gtk_tree_model_sort_get_type(void);
+GType gtk_tree_selection_get_type(void);
+GType gtk_tree_store_get_type(void);
+GType gtk_tree_view_get_type(void);
+GType gtk_tree_view_column_get_type(void);
+GType gtk_ui_manager_get_type(void);
+GType gtk_vbox_get_type(void);
+GType gtk_vbutton_box_get_type(void);
+GType gtk_vpaned_get_type(void);
+GType gtk_vruler_get_type(void);
+GType gtk_vscale_get_type(void);
+GType gtk_vscrollbar_get_type(void);
+GType gtk_vseparator_get_type(void);
+GType gtk_viewport_get_type(void);
+GType gtk_widget_get_type(void);
+GType gtk_window_get_type(void);
+GType gtk_window_group_get_type(void);
+
+//Declarations of the *_error_quark() functions:
+
+GQuark gtk_file_chooser_error_quark(void);
+GQuark gtk_icon_theme_error_quark(void);
+} // extern "C"
+
+
+//Declarations of the *_Class::wrap_new() methods, instead of including all the private headers:
+
+namespace Gtk {  class AboutDialog_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class AccelGroup_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class AccelLabel_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class Action_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class ActionGroup_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class Adjustment_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class Alignment_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class Arrow_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class AspectFrame_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class Bin_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class Box_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class Button_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class ButtonBox_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class Calendar_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class CellRenderer_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class CellRendererCombo_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class CellRendererPixbuf_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class CellRendererProgress_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class CellRendererText_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class CellRendererToggle_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class CellView_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class CheckButton_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class CheckMenuItem_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class Clipboard_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class ColorButton_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class ColorSelection_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class ColorSelectionDialog_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class Combo_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class ComboBox_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class ComboBoxEntry_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class ComboDropDown_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class ComboDropDownItem_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class Container_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class Curve_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class Dialog_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class DrawingArea_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class Entry_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class EntryCompletion_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class EventBox_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class Expander_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class FileChooserButton_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class FileChooserDialog_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class FileChooserWidget_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class FileFilter_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class FileSelection_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class Fixed_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class FontButton_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class FontSelection_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class FontSelectionDialog_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class Frame_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class GammaCurve_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class HBox_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class HButtonBox_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class HPaned_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class HRuler_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class HScale_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class HScrollbar_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class HSeparator_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class HandleBox_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class IconFactory_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class IconTheme_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class IconView_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class Image_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class ImageMenuItem_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class InputDialog_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class Invisible_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class Item_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class Label_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class Layout_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class ListStore_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class Menu_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class MenuBar_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class MenuItem_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class MenuShell_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class MenuToolButton_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class MessageDialog_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class Misc_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class Notebook_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class Object_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class OptionMenu_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class Paned_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+#ifndef G_OS_WIN32
+namespace Gtk {  class Plug_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+#endif //G_OS_WIN32
+namespace Gtk {  class ProgressBar_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class RadioAction_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class RadioButton_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class RadioMenuItem_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class RadioToolButton_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class Range_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class RcStyle_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class Ruler_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class Scale_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class Scrollbar_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class ScrolledWindow_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class Separator_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class SeparatorMenuItem_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class SeparatorToolItem_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class Settings_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class SizeGroup_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+#ifndef G_OS_WIN32
+namespace Gtk {  class Socket_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+#endif //G_OS_WIN32
+namespace Gtk {  class SpinButton_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class Statusbar_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class Style_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class Table_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class TearoffMenuItem_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class TextBuffer_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class TextChildAnchor_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class TextMark_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class TextTag_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class TextTagTable_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class TextView_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class ToggleAction_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class ToggleButton_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class ToggleToolButton_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class ToolButton_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class ToolItem_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class Toolbar_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class Tooltips_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class TreeModelFilter_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class TreeModelSort_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class TreeSelection_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class TreeStore_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class TreeView_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class TreeViewColumn_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class UIManager_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class VBox_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class VButtonBox_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class VPaned_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class VRuler_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class VScale_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class VScrollbar_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class VSeparator_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class Viewport_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class Widget_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class Window_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Gtk {  class WindowGroup_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+
+namespace Gtk { 
+
+void wrap_init()
+{
+  // Register Error domains:
+  Glib::Error::register_domain(gtk_file_chooser_error_quark(), &Gtk::FileChooserError::throw_func);
+  Glib::Error::register_domain(gtk_icon_theme_error_quark(), &Gtk::IconThemeError::throw_func);
+
+// Map gtypes to gtkmm wrapper-creation functions:
+  Glib::wrap_register(gtk_about_dialog_get_type(), &Gtk::AboutDialog_Class::wrap_new);
+  Glib::wrap_register(gtk_accel_group_get_type(), &Gtk::AccelGroup_Class::wrap_new);
+  Glib::wrap_register(gtk_accel_label_get_type(), &Gtk::AccelLabel_Class::wrap_new);
+  Glib::wrap_register(gtk_action_get_type(), &Gtk::Action_Class::wrap_new);
+  Glib::wrap_register(gtk_action_group_get_type(), &Gtk::ActionGroup_Class::wrap_new);
+  Glib::wrap_register(gtk_adjustment_get_type(), &Gtk::Adjustment_Class::wrap_new);
+  Glib::wrap_register(gtk_alignment_get_type(), &Gtk::Alignment_Class::wrap_new);
+  Glib::wrap_register(gtk_arrow_get_type(), &Gtk::Arrow_Class::wrap_new);
+  Glib::wrap_register(gtk_aspect_frame_get_type(), &Gtk::AspectFrame_Class::wrap_new);
+  Glib::wrap_register(gtk_bin_get_type(), &Gtk::Bin_Class::wrap_new);
+  Glib::wrap_register(gtk_box_get_type(), &Gtk::Box_Class::wrap_new);
+  Glib::wrap_register(gtk_button_get_type(), &Gtk::Button_Class::wrap_new);
+  Glib::wrap_register(gtk_button_box_get_type(), &Gtk::ButtonBox_Class::wrap_new);
+  Glib::wrap_register(gtk_calendar_get_type(), &Gtk::Calendar_Class::wrap_new);
+  Glib::wrap_register(gtk_cell_renderer_get_type(), &Gtk::CellRenderer_Class::wrap_new);
+  Glib::wrap_register(gtk_cell_renderer_combo_get_type(), &Gtk::CellRendererCombo_Class::wrap_new);
+  Glib::wrap_register(gtk_cell_renderer_pixbuf_get_type(), &Gtk::CellRendererPixbuf_Class::wrap_new);
+  Glib::wrap_register(gtk_cell_renderer_progress_get_type(), &Gtk::CellRendererProgress_Class::wrap_new);
+  Glib::wrap_register(gtk_cell_renderer_text_get_type(), &Gtk::CellRendererText_Class::wrap_new);
+  Glib::wrap_register(gtk_cell_renderer_toggle_get_type(), &Gtk::CellRendererToggle_Class::wrap_new);
+  Glib::wrap_register(gtk_cell_view_get_type(), &Gtk::CellView_Class::wrap_new);
+  Glib::wrap_register(gtk_check_button_get_type(), &Gtk::CheckButton_Class::wrap_new);
+  Glib::wrap_register(gtk_check_menu_item_get_type(), &Gtk::CheckMenuItem_Class::wrap_new);
+  Glib::wrap_register(gtk_clipboard_get_type(), &Gtk::Clipboard_Class::wrap_new);
+  Glib::wrap_register(gtk_color_button_get_type(), &Gtk::ColorButton_Class::wrap_new);
+  Glib::wrap_register(gtk_color_selection_get_type(), &Gtk::ColorSelection_Class::wrap_new);
+  Glib::wrap_register(gtk_color_selection_dialog_get_type(), &Gtk::ColorSelectionDialog_Class::wrap_new);
+  Glib::wrap_register(gtk_combo_get_type(), &Gtk::Combo_Class::wrap_new);
+  Glib::wrap_register(gtk_combo_box_get_type(), &Gtk::ComboBox_Class::wrap_new);
+  Glib::wrap_register(gtk_combo_box_entry_get_type(), &Gtk::ComboBoxEntry_Class::wrap_new);
+  Glib::wrap_register(gtk_list_get_type(), &Gtk::ComboDropDown_Class::wrap_new);
+  Glib::wrap_register(gtk_list_item_get_type(), &Gtk::ComboDropDownItem_Class::wrap_new);
+  Glib::wrap_register(gtk_container_get_type(), &Gtk::Container_Class::wrap_new);
+  Glib::wrap_register(gtk_curve_get_type(), &Gtk::Curve_Class::wrap_new);
+  Glib::wrap_register(gtk_dialog_get_type(), &Gtk::Dialog_Class::wrap_new);
+  Glib::wrap_register(gtk_drawing_area_get_type(), &Gtk::DrawingArea_Class::wrap_new);
+  Glib::wrap_register(gtk_entry_get_type(), &Gtk::Entry_Class::wrap_new);
+  Glib::wrap_register(gtk_entry_completion_get_type(), &Gtk::EntryCompletion_Class::wrap_new);
+  Glib::wrap_register(gtk_event_box_get_type(), &Gtk::EventBox_Class::wrap_new);
+  Glib::wrap_register(gtk_expander_get_type(), &Gtk::Expander_Class::wrap_new);
+  Glib::wrap_register(gtk_file_chooser_button_get_type(), &Gtk::FileChooserButton_Class::wrap_new);
+  Glib::wrap_register(gtk_file_chooser_dialog_get_type(), &Gtk::FileChooserDialog_Class::wrap_new);
+  Glib::wrap_register(gtk_file_chooser_widget_get_type(), &Gtk::FileChooserWidget_Class::wrap_new);
+  Glib::wrap_register(gtk_file_filter_get_type(), &Gtk::FileFilter_Class::wrap_new);
+  Glib::wrap_register(gtk_file_selection_get_type(), &Gtk::FileSelection_Class::wrap_new);
+  Glib::wrap_register(gtk_fixed_get_type(), &Gtk::Fixed_Class::wrap_new);
+  Glib::wrap_register(gtk_font_button_get_type(), &Gtk::FontButton_Class::wrap_new);
+  Glib::wrap_register(gtk_font_selection_get_type(), &Gtk::FontSelection_Class::wrap_new);
+  Glib::wrap_register(gtk_font_selection_dialog_get_type(), &Gtk::FontSelectionDialog_Class::wrap_new);
+  Glib::wrap_register(gtk_frame_get_type(), &Gtk::Frame_Class::wrap_new);
+  Glib::wrap_register(gtk_gamma_curve_get_type(), &Gtk::GammaCurve_Class::wrap_new);
+  Glib::wrap_register(gtk_hbox_get_type(), &Gtk::HBox_Class::wrap_new);
+  Glib::wrap_register(gtk_hbutton_box_get_type(), &Gtk::HButtonBox_Class::wrap_new);
+  Glib::wrap_register(gtk_hpaned_get_type(), &Gtk::HPaned_Class::wrap_new);
+  Glib::wrap_register(gtk_hruler_get_type(), &Gtk::HRuler_Class::wrap_new);
+  Glib::wrap_register(gtk_hscale_get_type(), &Gtk::HScale_Class::wrap_new);
+  Glib::wrap_register(gtk_hscrollbar_get_type(), &Gtk::HScrollbar_Class::wrap_new);
+  Glib::wrap_register(gtk_hseparator_get_type(), &Gtk::HSeparator_Class::wrap_new);
+  Glib::wrap_register(gtk_handle_box_get_type(), &Gtk::HandleBox_Class::wrap_new);
+  Glib::wrap_register(gtk_icon_factory_get_type(), &Gtk::IconFactory_Class::wrap_new);
+  Glib::wrap_register(gtk_icon_theme_get_type(), &Gtk::IconTheme_Class::wrap_new);
+  Glib::wrap_register(gtk_icon_view_get_type(), &Gtk::IconView_Class::wrap_new);
+  Glib::wrap_register(gtk_image_get_type(), &Gtk::Image_Class::wrap_new);
+  Glib::wrap_register(gtk_image_menu_item_get_type(), &Gtk::ImageMenuItem_Class::wrap_new);
+  Glib::wrap_register(gtk_input_dialog_get_type(), &Gtk::InputDialog_Class::wrap_new);
+  Glib::wrap_register(gtk_invisible_get_type(), &Gtk::Invisible_Class::wrap_new);
+  Glib::wrap_register(gtk_item_get_type(), &Gtk::Item_Class::wrap_new);
+  Glib::wrap_register(gtk_label_get_type(), &Gtk::Label_Class::wrap_new);
+  Glib::wrap_register(gtk_layout_get_type(), &Gtk::Layout_Class::wrap_new);
+  Glib::wrap_register(gtk_list_store_get_type(), &Gtk::ListStore_Class::wrap_new);
+  Glib::wrap_register(gtk_menu_get_type(), &Gtk::Menu_Class::wrap_new);
+  Glib::wrap_register(gtk_menu_bar_get_type(), &Gtk::MenuBar_Class::wrap_new);
+  Glib::wrap_register(gtk_menu_item_get_type(), &Gtk::MenuItem_Class::wrap_new);
+  Glib::wrap_register(gtk_menu_shell_get_type(), &Gtk::MenuShell_Class::wrap_new);
+  Glib::wrap_register(gtk_menu_tool_button_get_type(), &Gtk::MenuToolButton_Class::wrap_new);
+  Glib::wrap_register(gtk_message_dialog_get_type(), &Gtk::MessageDialog_Class::wrap_new);
+  Glib::wrap_register(gtk_misc_get_type(), &Gtk::Misc_Class::wrap_new);
+  Glib::wrap_register(gtk_notebook_get_type(), &Gtk::Notebook_Class::wrap_new);
+  Glib::wrap_register(gtk_object_get_type(), &Gtk::Object_Class::wrap_new);
+  Glib::wrap_register(gtk_option_menu_get_type(), &Gtk::OptionMenu_Class::wrap_new);
+  Glib::wrap_register(gtk_paned_get_type(), &Gtk::Paned_Class::wrap_new);
+#ifndef G_OS_WIN32
+  Glib::wrap_register(gtk_plug_get_type(), &Gtk::Plug_Class::wrap_new);
+#endif //G_OS_WIN32
+  Glib::wrap_register(gtk_progress_bar_get_type(), &Gtk::ProgressBar_Class::wrap_new);
+  Glib::wrap_register(gtk_radio_action_get_type(), &Gtk::RadioAction_Class::wrap_new);
+  Glib::wrap_register(gtk_radio_button_get_type(), &Gtk::RadioButton_Class::wrap_new);
+  Glib::wrap_register(gtk_radio_menu_item_get_type(), &Gtk::RadioMenuItem_Class::wrap_new);
+  Glib::wrap_register(gtk_radio_tool_button_get_type(), &Gtk::RadioToolButton_Class::wrap_new);
+  Glib::wrap_register(gtk_range_get_type(), &Gtk::Range_Class::wrap_new);
+  Glib::wrap_register(gtk_rc_style_get_type(), &Gtk::RcStyle_Class::wrap_new);
+  Glib::wrap_register(gtk_ruler_get_type(), &Gtk::Ruler_Class::wrap_new);
+  Glib::wrap_register(gtk_scale_get_type(), &Gtk::Scale_Class::wrap_new);
+  Glib::wrap_register(gtk_scrollbar_get_type(), &Gtk::Scrollbar_Class::wrap_new);
+  Glib::wrap_register(gtk_scrolled_window_get_type(), &Gtk::ScrolledWindow_Class::wrap_new);
+  Glib::wrap_register(gtk_separator_get_type(), &Gtk::Separator_Class::wrap_new);
+  Glib::wrap_register(gtk_separator_menu_item_get_type(), &Gtk::SeparatorMenuItem_Class::wrap_new);
+  Glib::wrap_register(gtk_separator_tool_item_get_type(), &Gtk::SeparatorToolItem_Class::wrap_new);
+  Glib::wrap_register(gtk_settings_get_type(), &Gtk::Settings_Class::wrap_new);
+  Glib::wrap_register(gtk_size_group_get_type(), &Gtk::SizeGroup_Class::wrap_new);
+#ifndef G_OS_WIN32
+  Glib::wrap_register(gtk_socket_get_type(), &Gtk::Socket_Class::wrap_new);
+#endif //G_OS_WIN32
+  Glib::wrap_register(gtk_spin_button_get_type(), &Gtk::SpinButton_Class::wrap_new);
+  Glib::wrap_register(gtk_statusbar_get_type(), &Gtk::Statusbar_Class::wrap_new);
+  Glib::wrap_register(gtk_style_get_type(), &Gtk::Style_Class::wrap_new);
+  Glib::wrap_register(gtk_table_get_type(), &Gtk::Table_Class::wrap_new);
+  Glib::wrap_register(gtk_tearoff_menu_item_get_type(), &Gtk::TearoffMenuItem_Class::wrap_new);
+  Glib::wrap_register(gtk_text_buffer_get_type(), &Gtk::TextBuffer_Class::wrap_new);
+  Glib::wrap_register(gtk_text_child_anchor_get_type(), &Gtk::TextChildAnchor_Class::wrap_new);
+  Glib::wrap_register(gtk_text_mark_get_type(), &Gtk::TextMark_Class::wrap_new);
+  Glib::wrap_register(gtk_text_tag_get_type(), &Gtk::TextTag_Class::wrap_new);
+  Glib::wrap_register(gtk_text_tag_table_get_type(), &Gtk::TextTagTable_Class::wrap_new);
+  Glib::wrap_register(gtk_text_view_get_type(), &Gtk::TextView_Class::wrap_new);
+  Glib::wrap_register(gtk_toggle_action_get_type(), &Gtk::ToggleAction_Class::wrap_new);
+  Glib::wrap_register(gtk_toggle_button_get_type(), &Gtk::ToggleButton_Class::wrap_new);
+  Glib::wrap_register(gtk_toggle_tool_button_get_type(), &Gtk::ToggleToolButton_Class::wrap_new);
+  Glib::wrap_register(gtk_tool_button_get_type(), &Gtk::ToolButton_Class::wrap_new);
+  Glib::wrap_register(gtk_tool_item_get_type(), &Gtk::ToolItem_Class::wrap_new);
+  Glib::wrap_register(gtk_toolbar_get_type(), &Gtk::Toolbar_Class::wrap_new);
+  Glib::wrap_register(gtk_tooltips_get_type(), &Gtk::Tooltips_Class::wrap_new);
+  Glib::wrap_register(gtk_tree_model_filter_get_type(), &Gtk::TreeModelFilter_Class::wrap_new);
+  Glib::wrap_register(gtk_tree_model_sort_get_type(), &Gtk::TreeModelSort_Class::wrap_new);
+  Glib::wrap_register(gtk_tree_selection_get_type(), &Gtk::TreeSelection_Class::wrap_new);
+  Glib::wrap_register(gtk_tree_store_get_type(), &Gtk::TreeStore_Class::wrap_new);
+  Glib::wrap_register(gtk_tree_view_get_type(), &Gtk::TreeView_Class::wrap_new);
+  Glib::wrap_register(gtk_tree_view_column_get_type(), &Gtk::TreeViewColumn_Class::wrap_new);
+  Glib::wrap_register(gtk_ui_manager_get_type(), &Gtk::UIManager_Class::wrap_new);
+  Glib::wrap_register(gtk_vbox_get_type(), &Gtk::VBox_Class::wrap_new);
+  Glib::wrap_register(gtk_vbutton_box_get_type(), &Gtk::VButtonBox_Class::wrap_new);
+  Glib::wrap_register(gtk_vpaned_get_type(), &Gtk::VPaned_Class::wrap_new);
+  Glib::wrap_register(gtk_vruler_get_type(), &Gtk::VRuler_Class::wrap_new);
+  Glib::wrap_register(gtk_vscale_get_type(), &Gtk::VScale_Class::wrap_new);
+  Glib::wrap_register(gtk_vscrollbar_get_type(), &Gtk::VScrollbar_Class::wrap_new);
+  Glib::wrap_register(gtk_vseparator_get_type(), &Gtk::VSeparator_Class::wrap_new);
+  Glib::wrap_register(gtk_viewport_get_type(), &Gtk::Viewport_Class::wrap_new);
+  Glib::wrap_register(gtk_widget_get_type(), &Gtk::Widget_Class::wrap_new);
+  Glib::wrap_register(gtk_window_get_type(), &Gtk::Window_Class::wrap_new);
+  Glib::wrap_register(gtk_window_group_get_type(), &Gtk::WindowGroup_Class::wrap_new);
+
+  // Register the gtkmm gtypes:
+  Gtk::AboutDialog::get_type();
+  Gtk::AccelGroup::get_type();
+  Gtk::AccelLabel::get_type();
+  Gtk::Action::get_type();
+  Gtk::ActionGroup::get_type();
+  Gtk::Adjustment::get_type();
+  Gtk::Alignment::get_type();
+  Gtk::Arrow::get_type();
+  Gtk::AspectFrame::get_type();
+  Gtk::Bin::get_type();
+  Gtk::Box::get_type();
+  Gtk::Button::get_type();
+  Gtk::ButtonBox::get_type();
+  Gtk::Calendar::get_type();
+  Gtk::CellRenderer::get_type();
+  Gtk::CellRendererCombo::get_type();
+  Gtk::CellRendererPixbuf::get_type();
+  Gtk::CellRendererProgress::get_type();
+  Gtk::CellRendererText::get_type();
+  Gtk::CellRendererToggle::get_type();
+  Gtk::CellView::get_type();
+  Gtk::CheckButton::get_type();
+  Gtk::CheckMenuItem::get_type();
+  Gtk::Clipboard::get_type();
+  Gtk::ColorButton::get_type();
+  Gtk::ColorSelection::get_type();
+  Gtk::ColorSelectionDialog::get_type();
+  Gtk::Combo::get_type();
+  Gtk::ComboBox::get_type();
+  Gtk::ComboBoxEntry::get_type();
+  Gtk::ComboDropDown::get_type();
+  Gtk::ComboDropDownItem::get_type();
+  Gtk::Container::get_type();
+  Gtk::Curve::get_type();
+  Gtk::Dialog::get_type();
+  Gtk::DrawingArea::get_type();
+  Gtk::Entry::get_type();
+  Gtk::EntryCompletion::get_type();
+  Gtk::EventBox::get_type();
+  Gtk::Expander::get_type();
+  Gtk::FileChooserButton::get_type();
+  Gtk::FileChooserDialog::get_type();
+  Gtk::FileChooserWidget::get_type();
+  Gtk::FileFilter::get_type();
+  Gtk::FileSelection::get_type();
+  Gtk::Fixed::get_type();
+  Gtk::FontButton::get_type();
+  Gtk::FontSelection::get_type();
+  Gtk::FontSelectionDialog::get_type();
+  Gtk::Frame::get_type();
+  Gtk::GammaCurve::get_type();
+  Gtk::HBox::get_type();
+  Gtk::HButtonBox::get_type();
+  Gtk::HPaned::get_type();
+  Gtk::HRuler::get_type();
+  Gtk::HScale::get_type();
+  Gtk::HScrollbar::get_type();
+  Gtk::HSeparator::get_type();
+  Gtk::HandleBox::get_type();
+  Gtk::IconFactory::get_type();
+  Gtk::IconTheme::get_type();
+  Gtk::IconView::get_type();
+  Gtk::Image::get_type();
+  Gtk::ImageMenuItem::get_type();
+  Gtk::InputDialog::get_type();
+  Gtk::Invisible::get_type();
+  Gtk::Item::get_type();
+  Gtk::Label::get_type();
+  Gtk::Layout::get_type();
+  Gtk::ListStore::get_type();
+  Gtk::Menu::get_type();
+  Gtk::MenuBar::get_type();
+  Gtk::MenuItem::get_type();
+  Gtk::MenuShell::get_type();
+  Gtk::MenuToolButton::get_type();
+  Gtk::MessageDialog::get_type();
+  Gtk::Misc::get_type();
+  Gtk::Notebook::get_type();
+  Gtk::Object::get_type();
+  Gtk::OptionMenu::get_type();
+  Gtk::Paned::get_type();
+#ifndef G_OS_WIN32
+  Gtk::Plug::get_type();
+#endif //G_OS_WIN32
+  Gtk::ProgressBar::get_type();
+  Gtk::RadioAction::get_type();
+  Gtk::RadioButton::get_type();
+  Gtk::RadioMenuItem::get_type();
+  Gtk::RadioToolButton::get_type();
+  Gtk::Range::get_type();
+  Gtk::RcStyle::get_type();
+  Gtk::Ruler::get_type();
+  Gtk::Scale::get_type();
+  Gtk::Scrollbar::get_type();
+  Gtk::ScrolledWindow::get_type();
+  Gtk::Separator::get_type();
+  Gtk::SeparatorMenuItem::get_type();
+  Gtk::SeparatorToolItem::get_type();
+  Gtk::Settings::get_type();
+  Gtk::SizeGroup::get_type();
+#ifndef G_OS_WIN32
+  Gtk::Socket::get_type();
+#endif //G_OS_WIN32
+  Gtk::SpinButton::get_type();
+  Gtk::Statusbar::get_type();
+  Gtk::Style::get_type();
+  Gtk::Table::get_type();
+  Gtk::TearoffMenuItem::get_type();
+  Gtk::TextBuffer::get_type();
+  Gtk::TextChildAnchor::get_type();
+  Gtk::TextMark::get_type();
+  Gtk::TextTag::get_type();
+  Gtk::TextTagTable::get_type();
+  Gtk::TextView::get_type();
+  Gtk::ToggleAction::get_type();
+  Gtk::ToggleButton::get_type();
+  Gtk::ToggleToolButton::get_type();
+  Gtk::ToolButton::get_type();
+  Gtk::ToolItem::get_type();
+  Gtk::Toolbar::get_type();
+  Gtk::Tooltips::get_type();
+  Gtk::TreeModelFilter::get_type();
+  Gtk::TreeModelSort::get_type();
+  Gtk::TreeSelection::get_type();
+  Gtk::TreeStore::get_type();
+  Gtk::TreeView::get_type();
+  Gtk::TreeViewColumn::get_type();
+  Gtk::UIManager::get_type();
+  Gtk::VBox::get_type();
+  Gtk::VButtonBox::get_type();
+  Gtk::VPaned::get_type();
+  Gtk::VRuler::get_type();
+  Gtk::VScale::get_type();
+  Gtk::VScrollbar::get_type();
+  Gtk::VSeparator::get_type();
+  Gtk::Viewport::get_type();
+  Gtk::Widget::get_type();
+  Gtk::Window::get_type();
+  Gtk::WindowGroup::get_type();
+
+} // wrap_init()
+
+} //Gtk
+
+
diff --git a/libs/gtkmm2/gtk/gtkmm/wrap_init.h b/libs/gtkmm2/gtk/gtkmm/wrap_init.h
new file mode 100644
index 0000000000..9f7574c5a2
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/wrap_init.h
@@ -0,0 +1,32 @@
+#ifndef _GTKMM_WRAP_INIT_H
+#define _GTKMM_WRAP_INIT_H
+
+/* wrap_init.h
+ *
+ * Copyright (C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+// wrap_init.cc is generated by tools/generate_wrap_init.pl
+
+namespace Gtk
+{
+
+void wrap_init();
+
+} /* namespace Gtk */
+
+#endif // _GTKMM_WRAP_INIT_H
diff --git a/libs/gtkmm2/gtk/gtkmmconfig.h b/libs/gtkmm2/gtk/gtkmmconfig.h
new file mode 100644
index 0000000000..b28315ec71
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmmconfig.h
@@ -0,0 +1,42 @@
+/* gtk/gtkmmconfig.h.  Generated by configure.  */
+#ifndef _GTKMM_CONFIG_H
+#define _GTKMM_CONFIG_H 1
+
+#include <gdkmmconfig.h>
+
+/* version numbers */
+#define GTKMM_MAJOR_VERSION 2
+#define GTKMM_MINOR_VERSION 6
+#define GTKMM_MICRO_VERSION 1
+
+#ifdef GLIBMM_CONFIGURE
+/* compiler feature tests that are used during compile time and run-time
+   by gtkmm only. */
+
+/* SUN Forte, AIX, and Tru64 have the problem with flockfile and
+   funlockfile - configure finds it but the compiler can not find it
+   while compiling demowindow.cc. undef HAVE_FLOCKFILE and
+   HAVE_FUNLOCKFILE for now, so that it builds on those platforms. */
+
+/* #undef HAVE_FLOCKFILE */
+/* #undef HAVE_FUNLOCKFILE */
+/* #undef GETC_UNLOCKED */
+
+#endif /* GLIBMM_CONFIGURE */
+
+#ifdef GLIBMM_DLL
+  #if defined(GTKMM_BUILD) && defined(_WINDLL)
+    // Do not dllexport as it is handled by gendef on MSVC
+    #define GTKMM_API
+  #elif !defined(GTKMM_BUILD)
+    #define GTKMM_API __declspec(dllimport)
+  #else
+    /* Build a static library */
+    #define GTKMM_API
+  #endif /* GTKMM_BUILD - _WINDLL */
+#else
+  #define GTKMM_API
+#endif /* GLIBMM_DLL */
+
+#endif /* _GTKMM_CONFIG_H */
+
diff --git a/libs/gtkmm2/pango/SConscript b/libs/gtkmm2/pango/SConscript
new file mode 100644
index 0000000000..f869598895
--- /dev/null
+++ b/libs/gtkmm2/pango/SConscript
@@ -0,0 +1,11 @@
+import glob
+import os
+
+pangomm_files = glob.glob('pangomm/*.cc')
+
+Import('env libraries')
+pangomm = env.Copy()
+pangomm.Merge([libraries['glibmm2'], libraries['pango'], libraries['sigc2']])
+
+libpangomm = pangomm.StaticLibrary('pangomm', pangomm_files)
+Default(libpangomm)
diff --git a/libs/gtkmm2/pango/pangomm.h b/libs/gtkmm2/pango/pangomm.h
new file mode 100644
index 0000000000..f319c23f06
--- /dev/null
+++ b/libs/gtkmm2/pango/pangomm.h
@@ -0,0 +1,41 @@
+/* $Id$ */
+
+/* pangomm - a C++ wrapper for the GLib toolkit
+ *
+ * Copyright 2002 Free Software Foundation
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#ifndef _PANGOMM_H
+#define _PANGOMM_H
+
+#include <pangomm/attrlist.h>
+#include <pangomm/context.h>
+#include <pangomm/coverage.h>
+#include <pangomm/fontdescription.h>
+#include <pangomm/fontface.h>
+#include <pangomm/fontfamily.h>
+#include <pangomm/font.h>
+#include <pangomm/fontmap.h>
+#include <pangomm/fontmetrics.h>
+#include <pangomm/fontset.h>
+#include <pangomm/layout.h>
+#include <pangomm/layoutiter.h>
+#include <pangomm/layoutline.h>
+#include <pangomm/tabarray.h>
+
+#endif /* _PANGOMM_H */
+
diff --git a/libs/gtkmm2/pango/pangomm/attributes.cc b/libs/gtkmm2/pango/pangomm/attributes.cc
new file mode 100644
index 0000000000..2d23e5d77b
--- /dev/null
+++ b/libs/gtkmm2/pango/pangomm/attributes.cc
@@ -0,0 +1,534 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <pangomm/attributes.h>
+#include <pangomm/private/attributes_p.h>
+
+#include <pango/pango-enum-types.h>
+/*
+ *
+ * Copyright 2002 Free Software Foundation
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+namespace Pango
+{
+
+Attribute::Attribute()
+:
+  gobject_(0)
+{}
+
+Attribute::Attribute(const Attribute& src)
+:
+  gobject_(src.gobject_ ? pango_attribute_copy(src.gobject_) : 0)
+{}
+
+Attribute::Attribute(PangoAttribute* castitem, bool take_copy)
+{
+  if(take_copy)
+  {
+    if(castitem)
+      gobject_ = pango_attribute_copy(castitem);
+    else
+      gobject_ = 0;
+  }
+  else
+  {
+    // It was given to us by a function which has already made a copy for us to keep.
+    gobject_ = castitem;
+  }
+}
+
+Attribute::~Attribute()
+{
+  if(gobject_)
+    pango_attribute_destroy(gobject_);
+  gobject_ = 0;
+}
+
+Attribute& Attribute::operator=(const Attribute& src)
+{
+  PangoAttribute *const new_gobject = (src.gobject_ ? pango_attribute_copy(src.gobject_) : 0);
+
+  if(gobject_)
+    pango_attribute_destroy(gobject_);
+  gobject_ = new_gobject;
+
+  return *this;
+}
+
+AttrType Attribute::get_type() const
+{
+  return (AttrType) ((gobject_) ? gobj()->klass->type : PANGO_ATTR_INVALID);
+}
+
+AttrType Attribute::register_type(const Glib::ustring& name)
+{
+  return (AttrType)pango_attr_type_register(name.c_str());
+}
+
+AttrString Attribute::create_attr_family(const Glib::ustring& family)
+{
+  return Glib::wrap((PangoAttrString*)pango_attr_family_new(family.c_str()));
+}
+
+AttrLanguage Attribute::create_attr_language(const Language& language)
+{
+  return Glib::wrap((PangoAttrLanguage*)pango_attr_language_new(const_cast<PangoLanguage*>(language.gobj())));
+}
+
+AttrColor Attribute::create_attr_foreground(guint16 red, guint16 green, guint16 blue)
+{
+  return Glib::wrap((PangoAttrColor*)pango_attr_foreground_new(red, green, blue));
+}
+
+AttrColor Attribute::create_attr_background(guint16 red, guint16 green, guint16 blue)
+{
+  return Glib::wrap((PangoAttrColor*)pango_attr_background_new(red, green, blue));
+}
+
+AttrInt Attribute::create_attr_size(int size)
+{
+  return Glib::wrap((PangoAttrInt*)pango_attr_size_new(size));
+}
+
+AttrInt Attribute::create_attr_style(Style style)
+{
+  return Glib::wrap((PangoAttrInt*)pango_attr_style_new((PangoStyle)style));
+}
+
+AttrInt Attribute::create_attr_weight(Weight weight)
+{
+  return Glib::wrap((PangoAttrInt*)pango_attr_weight_new((PangoWeight)weight));
+}
+
+AttrInt Attribute::create_attr_variant(Variant variant)
+{
+  return Glib::wrap((PangoAttrInt*)pango_attr_variant_new((PangoVariant)variant));
+}
+
+AttrInt Attribute::create_attr_stretch(Stretch stretch)
+{
+  return Glib::wrap((PangoAttrInt*)pango_attr_stretch_new((PangoStretch)stretch));
+}
+
+AttrFontDesc Attribute::create_attr_font_desc(const FontDescription& desc)
+{
+  return Glib::wrap((PangoAttrFontDesc*)pango_attr_font_desc_new(desc.gobj()));
+}
+
+AttrInt Attribute::create_attr_underline(Underline underline)
+{
+  return Glib::wrap((PangoAttrInt*)pango_attr_underline_new((PangoUnderline)underline));
+}
+
+AttrInt Attribute::create_attr_strikethrough(bool strikethrough)
+{
+  return Glib::wrap((PangoAttrInt*)pango_attr_strikethrough_new(strikethrough));
+}
+
+AttrInt Attribute::create_attr_rise(int rise)
+{
+  return Glib::wrap((PangoAttrInt*)pango_attr_rise_new(rise));
+}
+
+AttrFloat Attribute::create_attr_scale(double scale_factor)
+{
+  return Glib::wrap((PangoAttrFloat*)pango_attr_scale_new(scale_factor));
+}
+
+AttrShape Attribute::create_attr_shape(const Rectangle& ink_rect, const Rectangle& logical_rect)
+{
+  return Glib::wrap((PangoAttrShape*)pango_attr_shape_new(ink_rect.gobj(), logical_rect.gobj()));
+}
+
+
+AttrString::AttrString()
+{}
+
+AttrString::AttrString(const AttrString& src)
+:
+  Attribute(src)
+{}
+
+AttrString::AttrString(PangoAttrString* castitem, bool take_copy)
+:
+  Attribute((PangoAttribute*)castitem, take_copy)
+{}
+
+AttrString& AttrString::operator=(const AttrString& src)
+{
+  Attribute::operator=(src);
+  return *this;
+}
+
+void AttrString::set_string(const Glib::ustring& str)
+{
+  g_free(gobj()->value);
+  gobj()->value = g_strdup(str.c_str());
+}
+
+
+AttrLanguage::AttrLanguage()
+{}
+
+AttrLanguage::AttrLanguage(const AttrLanguage& src)
+:
+  Attribute(src)
+{}
+
+AttrLanguage::AttrLanguage(PangoAttrLanguage* castitem, bool take_copy)
+:
+  Attribute((PangoAttribute*)castitem, take_copy)
+{}
+
+AttrLanguage& AttrLanguage::operator=(const AttrLanguage& src)
+{
+  Attribute::operator=(src);
+  return *this;
+}
+
+
+AttrColor::AttrColor()
+{}
+
+AttrColor::AttrColor(const AttrColor& src)
+:
+  Attribute(src)
+{}
+
+AttrColor::AttrColor(PangoAttrColor* castitem, bool take_copy)
+:
+  Attribute((PangoAttribute*)castitem, take_copy)
+{}
+
+AttrColor& AttrColor::operator=(const AttrColor& src)
+{
+  Attribute::operator=(src);
+  return *this;
+}
+
+
+AttrInt::AttrInt()
+{}
+
+AttrInt::AttrInt(const AttrInt& src)
+:
+  Attribute(src)
+{}
+
+AttrInt::AttrInt(PangoAttrInt* castitem, bool take_copy)
+:
+  Attribute((PangoAttribute*)castitem, take_copy)
+{}
+
+AttrInt& AttrInt::operator=(const AttrInt& src)
+{
+  Attribute::operator=(src);
+  return *this;
+}
+
+
+AttrFloat::AttrFloat()
+{}
+
+AttrFloat::AttrFloat(const AttrFloat& src)
+:
+  Attribute(src)
+{}
+
+AttrFloat::AttrFloat(PangoAttrFloat* castitem, bool take_copy)
+:
+  Attribute((PangoAttribute*)castitem, take_copy)
+{}
+
+AttrFloat& AttrFloat::operator=(const AttrFloat& src)
+{
+  Attribute::operator=(src);
+  return *this;
+}
+
+
+AttrFontDesc::AttrFontDesc()
+{}
+
+AttrFontDesc::AttrFontDesc(const AttrFontDesc& src)
+:
+  Attribute(src)
+{}
+
+AttrFontDesc::AttrFontDesc(PangoAttrFontDesc* castitem, bool take_copy)
+:
+  Attribute((PangoAttribute*)castitem, take_copy)
+{}
+
+AttrFontDesc& AttrFontDesc::operator=(const AttrFontDesc& src)
+{
+  Attribute::operator=(src);
+  return *this;
+}
+
+void AttrFontDesc::set_desc(const FontDescription& desc)
+{
+  pango_font_description_free(gobj()->desc);
+  gobj()->desc = pango_font_description_copy(desc.gobj());
+}
+
+
+AttrShape::AttrShape()
+{}
+
+AttrShape::AttrShape(const AttrShape& src)
+:
+  Attribute(src)
+{}
+
+AttrShape::AttrShape(PangoAttrShape* castitem, bool take_copy)
+:
+  Attribute((PangoAttribute*)castitem, take_copy)
+{}
+
+AttrShape& AttrShape::operator=(const AttrShape& src)
+{
+  Attribute::operator=(src);
+  return *this;
+}
+
+} //namespace Pango
+
+
+namespace Glib
+{
+
+Pango::Attribute wrap(PangoAttribute* object, bool take_copy)
+{
+  return Pango::Attribute(object, take_copy);
+}
+
+Pango::AttrString wrap(PangoAttrString* object, bool take_copy)
+{
+  return Pango::AttrString(object, take_copy);
+}
+
+Pango::AttrLanguage wrap(PangoAttrLanguage* object, bool take_copy)
+{
+  return Pango::AttrLanguage(object, take_copy);
+}
+
+Pango::AttrColor wrap(PangoAttrColor* object, bool take_copy)
+{
+  return Pango::AttrColor(object, take_copy);
+}
+
+Pango::AttrInt wrap(PangoAttrInt* object, bool take_copy)
+{
+  return Pango::AttrInt(object, take_copy);
+}
+
+Pango::AttrFloat wrap(PangoAttrFloat* object, bool take_copy)
+{
+  return Pango::AttrFloat(object, take_copy);
+}
+
+Pango::AttrFontDesc wrap(PangoAttrFontDesc* object, bool take_copy)
+{
+  return Pango::AttrFontDesc(object, take_copy);
+}
+
+Pango::AttrShape wrap(PangoAttrShape* object, bool take_copy)
+{
+  return Pango::AttrShape(object, take_copy);
+}
+
+} //namespace Glib
+
+
+namespace
+{
+} // anonymous namespace
+
+// static
+GType Glib::Value<Pango::AttrType>::value_type()
+{
+  return pango_attr_type_get_type();
+}
+
+// static
+GType Glib::Value<Pango::Underline>::value_type()
+{
+  return pango_underline_get_type();
+}
+
+
+namespace Pango
+{
+
+
+unsigned int Attribute::get_start_index() const
+{
+  return gobj()->start_index;
+}
+
+unsigned int Attribute::get_end_index() const
+{
+  return gobj()->end_index;
+}
+
+void Attribute::set_start_index(const unsigned int& value)
+{
+  gobj()->start_index = value;
+}
+
+void Attribute::set_end_index(const unsigned int& value)
+{
+  gobj()->end_index = value;
+}
+
+bool Attribute::equal(const Attribute& attr2) const
+{
+  return pango_attribute_equal(const_cast<PangoAttribute*>(gobj()), (attr2).gobj());
+}
+
+
+} // namespace Pango
+
+
+namespace Pango
+{
+
+
+Glib::ustring AttrString::get_string() const
+{
+  return Glib::convert_const_gchar_ptr_to_ustring(gobj()->value);
+}
+
+
+} // namespace Pango
+
+
+namespace Pango
+{
+
+
+Language AttrLanguage::get_language() const
+{
+  return Language(gobj()->value);
+}
+
+void AttrLanguage::set_language(const Language& value)
+{
+  gobj()->value = const_cast<PangoLanguage*>((value).gobj());
+}
+
+
+} // namespace Pango
+
+
+namespace Pango
+{
+
+
+Color AttrColor::get_color() const
+{
+  return Color(&(gobj()->color));
+}
+
+void AttrColor::set_color(const Color& value)
+{
+  gobj()->color = *(value).gobj();
+}
+
+
+} // namespace Pango
+
+
+namespace Pango
+{
+
+
+int AttrInt::get_value() const
+{
+  return gobj()->value;
+}
+
+void AttrInt::set_value(const int& value)
+{
+  gobj()->value = value;
+}
+
+
+} // namespace Pango
+
+
+namespace Pango
+{
+
+
+double AttrFloat::get_value() const
+{
+  return gobj()->value;
+}
+
+void AttrFloat::set_value(const double& value)
+{
+  gobj()->value = value;
+}
+
+
+} // namespace Pango
+
+
+namespace Pango
+{
+
+
+FontDescription AttrFontDesc::get_desc() const
+{
+  return FontDescription((gobj()->desc));
+}
+
+
+} // namespace Pango
+
+
+namespace Pango
+{
+
+
+Rectangle AttrShape::get_ink_rect() const
+{
+  return Rectangle(&(gobj()->ink_rect));
+}
+
+Rectangle AttrShape::get_logical_rect() const
+{
+  return Rectangle(&(gobj()->logical_rect));
+}
+
+void AttrShape::set_ink_rect(const Rectangle& value)
+{
+  gobj()->ink_rect = *(value).gobj();
+}
+
+void AttrShape::set_logical_rect(const Rectangle& value)
+{
+  gobj()->logical_rect = *(value).gobj();
+}
+
+
+} // namespace Pango
+
+
diff --git a/libs/gtkmm2/pango/pangomm/attributes.h b/libs/gtkmm2/pango/pangomm/attributes.h
new file mode 100644
index 0000000000..25baa96475
--- /dev/null
+++ b/libs/gtkmm2/pango/pangomm/attributes.h
@@ -0,0 +1,669 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _PANGOMM_ATTRIBUTES_H
+#define _PANGOMM_ATTRIBUTES_H
+
+#include <glibmm.h>
+
+/* attributes.h
+ *
+ * Copyright (C) 2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <pangomm/language.h>
+#include <pangomm/rectangle.h>
+#include <pangomm/color.h>
+#include <pangomm/fontdescription.h>
+#include <pango/pango-attributes.h>
+
+
+namespace Pango
+{
+
+
+/** @addtogroup pangommEnums Enums and Flags */
+
+/** Pango::AttrType distinguishes between different types of attributes.
+ * Along with the predefined values, it is possible to allocate additional values for
+ * custom attributes using Pango::Attribute::register_type(). The predefined values
+ * are given below.
+ * @ingroup pangommEnums
+ */
+enum AttrType
+{
+  ATTR_INVALID,
+  ATTR_LANGUAGE,
+  ATTR_FAMILY,
+  ATTR_STYLE,
+  ATTR_WEIGHT,
+  ATTR_VARIANT,
+  ATTR_STRETCH,
+  ATTR_SIZE,
+  ATTR_FONT_DESC,
+  ATTR_FOREGROUND,
+  ATTR_BACKGROUND,
+  ATTR_UNDERLINE,
+  ATTR_STRIKETHROUGH,
+  ATTR_RISE,
+  ATTR_SHAPE,
+  ATTR_SCALE,
+  ATTR_FALLBACK,
+  ATTR_LETTER_SPACING,
+  ATTR_UNDERLINE_COLOR,
+  ATTR_STRIKETHROUGH_COLOR
+};
+
+} // namespace Pango
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Pango::AttrType> : public Glib::Value_Enum<Pango::AttrType>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Pango
+{
+
+
+/** A Pango::Underline is used to specify whether text should be underlined, and if so, the type of underlining.
+ * @ingroup pangommEnums
+ */
+enum Underline
+{
+  UNDERLINE_NONE,
+  UNDERLINE_SINGLE,
+  UNDERLINE_DOUBLE,
+  UNDERLINE_LOW,
+  UNDERLINE_ERROR
+};
+
+} // namespace Pango
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Pango::Underline> : public Glib::Value_Enum<Pango::Underline>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Pango
+{
+
+
+/** A Pango::LogAttr stores information about the attributes of a single character.
+ */
+typedef PangoLogAttr LogAttr;
+
+
+class AttrString;
+class AttrLanguage;
+class AttrColor;
+class AttrInt;
+class AttrFloat;
+class AttrFontDesc;
+class AttrShape;
+
+/** The Pango::Attribute structure represents the common portions of all attributes.
+ * Particular types of attributes derive this class. It holds the range in which the
+ * value in the type-specific part of the attribute applies.
+ *
+ * Attributed text is used in a number of places in pango. It is used as the input to
+ * the itemization process and also when creating a Pango::Layout.
+ */
+class Attribute
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Attribute CppObjectType;
+  typedef PangoAttribute BaseObjectType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+private:
+
+  
+public:
+  /** Constructs an invalid attribute.
+   */
+  Attribute();
+
+  Attribute(const Attribute& src);
+  explicit Attribute(PangoAttribute* castitem, bool take_copy=true);
+  ~Attribute();
+
+  Attribute& operator=(const Attribute& src);
+
+  /** Gets the type ID for this attribute.
+   * @return The type ID for this attribute or ATTR_INVALID if the attribute is invalid.
+   */
+  AttrType get_type() const;
+
+  /** Allocate a new attribute type ID.
+   * @param name An identifier for the type (currently unused).
+   * @return The new type ID.
+   */
+  static AttrType register_type(const Glib::ustring& name);
+
+  /** Gets the start index of the range.
+   * @return The start index of the range.
+   */
+  unsigned int get_start_index() const;
+
+  /** Gets the end index of the range. The character at this index is not included in the range.
+   * @return The end index of the range.
+   */
+  unsigned int get_end_index() const;
+
+  /** Sets the start index of the range.
+   * @param value The new start index.
+   */
+  void set_start_index(const unsigned int& value);
+
+  /** Sets the end index of the range. The character at this index is not included in the range.
+   * @param value The new end index.
+   */
+  void set_end_index(const unsigned int& value);
+
+  
+  /** Compare two attributes for equality. This compares only the
+   * actual value of the two attributes and not the ranges that the
+   * attributes apply to.
+   * @param attr2 Another Pango::Attribute.
+   * @return <tt>true</tt> if the two attributes have the same value.
+   */
+  bool equal(const Attribute& attr2) const;
+
+  /// Provides access to the underlying C GObject.  
+  PangoAttribute*       gobj()       { return gobject_; }
+  /// Provides access to the underlying C GObject.
+  PangoAttribute* const gobj() const { return gobject_; }
+
+  /** Create a new font family attribute.
+   * @param family The family or comma separated list of families.
+   * @return An attribute of type AttrString.
+   */
+  static AttrString create_attr_family(const Glib::ustring& family);
+
+  /** Create a new language tag attribute
+   * @param language The language tag.
+   * @return An attribute of type AttrLanguage.
+   */
+  static AttrLanguage create_attr_language(const Language& language);
+
+  /** Create a new foreground color attribute.
+   * @param red The red value (ranging from 0 to 65535).
+   * @param green The green value (ranging from 0 to 65535).
+   * @param blue The blue value (ranging from 0 to 65535).
+   * @return An attribute of type AttrColor.
+   */
+  static AttrColor create_attr_foreground(guint16 red, guint16 green, guint16 blue);
+
+  /** Create a new background color attribute.
+   * @param red The red value (ranging from 0 to 65535).
+   * @param green The green value (ranging from 0 to 65535).
+   * @param blue The blue value (ranging from 0 to 65535).
+   * @return An attribute of type AttrColor.
+   */
+  static AttrColor create_attr_background(guint16 red, guint16 green, guint16 blue);
+
+  /** Create a new font-size attribute.
+   * @param size The font size, in 1000ths of a point.
+   * @return An attribute of type AttrInt.
+   */
+  static AttrInt create_attr_size(int size);
+
+  /** Create a new font slant style attribute.
+   * @param style The slant style.
+   * @return An attribute of type AttrInt.
+   */
+  static AttrInt create_attr_style(Style style);
+
+  /** Create a new font weight attribute.
+   * @param weight The weight.
+   * @return An attribute of type AttrInt.
+   */
+  static AttrInt create_attr_weight(Weight weight);
+
+  /** Create a new font variant attribute (normal or small caps).
+   * @param variant The variant.
+   * @return An attribute of type AttrInt.
+   */
+  static AttrInt create_attr_variant(Variant variant);
+
+  /** Create a new font stretch attribute.
+   * @param stretch The stretch.
+   * @return An attribute of type AttrInt.
+   */
+  static AttrInt create_attr_stretch(Stretch stretch);
+
+  /** Create a new font description attribute.
+   * This attribute allows setting family, style, weight, variant, stretch, and size simultaneously.
+   * @param desc The font description.
+   * @return An attribute of type AttrFontDesc.
+   */
+  static AttrFontDesc create_attr_font_desc(const FontDescription& desc);
+
+  /** Create a new underline-style object.
+   * @param underline The underline style.
+   * @return An attribute of type AttrInt.
+   */
+  static AttrInt create_attr_underline(Underline underline);
+
+  /** Create a new font strike-through attribute.
+   * @param strikethrough True indicates the text should be struck-through.
+   * @return An attribute of type AttrInt.
+   */
+  static AttrInt create_attr_strikethrough(bool strikethrough);
+
+  /** Create a new baseline displacement attribute.
+   * @param rise The amount that the text should be displaced vertically, in 10'000ths of an em. Positive values displace the text upwards.
+   * @return An attribute of type AttrInt.
+   */
+  static AttrInt create_attr_rise(int rise);
+
+  /** Create a new font size scale attribute.
+   * The base font for the affected text will have its size multiplied by scale_factor.
+   * @param scale_factor Factor to scale the font.
+   * @return An attribute of type AttrFloat.
+   */
+  static AttrFloat create_attr_scale(double scale_factor);
+
+  /** Create a new shape attribute.
+   * A shape is used to impose a particular ink and logical rect on the result of shaping a particular glyph.
+   * This might be used, for instance, for embedding a picture or a widget inside a PangoLayout.
+   * @param ink_rect Ink rectangle to assign to each character.
+   * @param logical_rect Logical rectangle assign to each character.
+   * @return An attribute of type AttrShape.
+   */
+  static AttrShape create_attr_shape(const Rectangle& ink_rect, const Rectangle& logical_rect);
+
+protected:
+  PangoAttribute* gobject_;
+
+
+};
+
+/** @relates Pango::Attribute */
+inline bool operator==(const Attribute& lhs, const Attribute& rhs)
+{
+  return lhs.equal(rhs);
+}
+
+/** @relates Pango::Attribute */
+inline bool operator!=(const Attribute& lhs, const Attribute& rhs)
+{
+  return lhs.equal(rhs);
+}
+
+
+/** A Pango::AttrString is used to represent an attribute with a string value.
+ */
+class AttrString : public Attribute
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef AttrString CppObjectType;
+  typedef PangoAttrString BaseObjectType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+private:
+
+
+protected:
+  AttrString();
+public:
+  AttrString(const AttrString& src);
+  explicit AttrString(PangoAttrString* castitem, bool take_copy=true);
+
+  AttrString& operator=(const AttrString& src);
+
+  /** Gets the string which is the value of the attribute.
+   * @return The string value of the attribute.
+   */
+  Glib::ustring get_string() const;
+
+  /** Sets the string which is the value of the attribute.
+   * @param string The new string value for the attribute.
+   */
+  void set_string(const Glib::ustring& string);
+
+  /// Provides access to the underlying C GObject.  
+  PangoAttrString*       gobj()       { return reinterpret_cast<PangoAttrString*>(gobject_); }
+  /// Provides access to the underlying C GObject.
+  const PangoAttrString* gobj() const { return reinterpret_cast<const PangoAttrString*>(gobject_); }
+
+
+};
+
+
+/** A Pango::AttrLanguage is used to represent an attribute that is a language.
+ */
+class AttrLanguage : public Attribute
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef AttrLanguage CppObjectType;
+  typedef PangoAttrLanguage BaseObjectType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+private:
+
+
+protected:
+  AttrLanguage();
+public:
+  AttrLanguage(const AttrLanguage& src);
+  explicit AttrLanguage(PangoAttrLanguage* castitem, bool take_copy=true);
+
+  AttrLanguage& operator=(const AttrLanguage& src);
+
+  /** Gets the language which is the value of the attribute.
+   * @return The language tag of the attribute.
+   */
+  Language get_language() const;
+
+  /** Sets the language which is the value of the attribute.
+   * @param value The new language tag for the attribute.
+   */
+  void set_language(const Language& value);
+
+  /// Provides access to the underlying C GObject.  
+  PangoAttrLanguage*       gobj()       { return reinterpret_cast<PangoAttrLanguage*>(gobject_); }
+  /// Provides access to the underlying C GObject.
+  const PangoAttrLanguage* gobj() const { return reinterpret_cast<const PangoAttrLanguage*>(gobject_); }
+
+
+};
+
+
+/** A Pango::AttrColor is used to represent an attribute which is a color.
+ */
+class AttrColor : public Attribute
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef AttrColor CppObjectType;
+  typedef PangoAttrColor BaseObjectType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+private:
+
+
+protected:
+  AttrColor();
+public:
+  AttrColor(const AttrColor& src);
+  explicit AttrColor(PangoAttrColor* castitem, bool take_copy=true);
+
+  AttrColor& operator=(const AttrColor& src);
+
+  /** Gets the color which is the value of the attribute.
+   * @return The color value of the attribute.
+   */
+  Color get_color() const;
+
+  /** Sets the color which is the value of the attribute.
+   * @param value The new color value for the attribute.
+   */
+  void set_color(const Color& value);
+
+  /// Provides access to the underlying C GObject.  
+  PangoAttrColor*       gobj()       { return reinterpret_cast<PangoAttrColor*>(gobject_); }
+  /// Provides access to the underlying C GObject.
+  const PangoAttrColor* gobj() const { return reinterpret_cast<const PangoAttrColor*>(gobject_); }
+
+
+};
+
+
+/** A Pango::AttrInt is used to represent an attribute with an integer or enumeration value.
+ */
+class AttrInt : public Attribute
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef AttrInt CppObjectType;
+  typedef PangoAttrInt BaseObjectType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+private:
+
+
+protected:
+  AttrInt();
+public:
+  AttrInt(const AttrInt& src);
+  explicit AttrInt(PangoAttrInt* castitem, bool take_copy=true);
+
+  AttrInt& operator=(const AttrInt& src);
+
+  /** Gets the integer value of the attribute.
+   * @return The integer value of the attribute.
+   */
+  int get_value() const;
+
+  /** Sets the integer value of the attribute.
+   * @param value The new integer value for the attribute.
+   */
+  void set_value(const int& value);
+
+  /// Provides access to the underlying C GObject.  
+  PangoAttrInt*       gobj()       { return reinterpret_cast<PangoAttrInt*>(gobject_); }
+  /// Provides access to the underlying C GObject.
+  const PangoAttrInt* gobj() const { return reinterpret_cast<const PangoAttrInt*>(gobject_); }
+
+
+};
+
+
+/** A Pango::AttrFloat is used to represent an attribute with a float or double value.
+ */
+class AttrFloat : public Attribute
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef AttrFloat CppObjectType;
+  typedef PangoAttrFloat BaseObjectType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+private:
+
+
+protected:
+  AttrFloat();
+public:
+  AttrFloat(const AttrFloat& src);
+  explicit AttrFloat(PangoAttrFloat* castitem, bool take_copy=true);
+
+  AttrFloat& operator=(const AttrFloat& src);
+
+  /** Gets the floating point value of the attribute.
+   * @return The floating point value of the attribute.
+   */
+  double get_value() const;
+
+  /** Sets the floating point value of the attribute.
+   * @param value The new floating point value for the attribute.
+   */
+  void set_value(const double& value);
+
+  /// Provides access to the underlying C GObject.
+  PangoAttrFloat*       gobj()       { return reinterpret_cast<PangoAttrFloat*>(gobject_); }
+  /// Provides access to the underlying C GObject.
+  const PangoAttrFloat* gobj() const { return reinterpret_cast<const PangoAttrFloat*>(gobject_); }
+
+
+};
+
+
+/** A Pango::AttrFontDesc is used to represent an attribute that sets all aspects of the font description at once.
+ */
+class AttrFontDesc : public Attribute
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef AttrFontDesc CppObjectType;
+  typedef PangoAttrFontDesc BaseObjectType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+private:
+
+
+protected:
+  AttrFontDesc();
+public:
+  AttrFontDesc(const AttrFontDesc& src);
+  explicit AttrFontDesc(PangoAttrFontDesc* castitem, bool take_copy=true);
+
+  AttrFontDesc& operator=(const AttrFontDesc& src);
+
+  /** Gets the font description which is the value of the attribute.
+   * @return The font description of the attribute.
+   */
+  FontDescription get_desc() const;
+
+  /** Sets the font description which is the value of the attribute.
+   * @param desc The new font description for the attribute.
+   */
+  void set_desc(const FontDescription& desc);
+  
+  /// Provides access to the underlying C GObject.
+  PangoAttrFontDesc*       gobj()       { return reinterpret_cast<PangoAttrFontDesc*>(gobject_); }
+  /// Provides access to the underlying C GObject.
+  const PangoAttrFontDesc* gobj() const { return reinterpret_cast<const PangoAttrFontDesc*>(gobject_); }
+
+
+};
+
+
+/** A Pango::AttrShape structure is used to represent an attribute which imposes shape restrictions.
+ */
+class AttrShape : public Attribute
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef AttrShape CppObjectType;
+  typedef PangoAttrShape BaseObjectType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+private:
+
+
+protected:
+  AttrShape();
+public:
+  AttrShape(const AttrShape& src);
+  explicit AttrShape(PangoAttrShape* castitem, bool take_copy=true);
+
+  AttrShape& operator=(const AttrShape& src);
+
+  /** Gets the ink rectangle to restrict to.
+   * @return The ink rectangle of the attribute.
+   */
+  Rectangle get_ink_rect() const;
+
+  /** Gets the logical rectangle to restrict to.
+   * @return The logical rectangle of the attribute.
+   */
+  Rectangle get_logical_rect() const;
+
+  /** Sets the ink rectangle to restrict to.
+   * @param value The new ink rectangle for the attribute.
+   */
+  void set_ink_rect(const Rectangle& value);
+
+  /** Sets the logical rectangle to restrict to.
+   * @param value The new logical rectangle for the attribute.
+   */
+  void set_logical_rect(const Rectangle& value);
+
+  /// Provides access to the underlying C GObject.  
+  PangoAttrShape*       gobj()       { return reinterpret_cast<PangoAttrShape*>(gobject_); }
+  /// Provides access to the underlying C GObject.
+  const PangoAttrShape* gobj() const { return reinterpret_cast<const PangoAttrShape*>(gobject_); }
+
+
+};
+
+
+struct AttributeTraits
+{
+  typedef Pango::Attribute      CppType;
+  typedef const PangoAttribute* CType;
+  typedef PangoAttribute*       CTypeNonConst;
+
+  static CType   to_c_type      (const CppType& obj) { return obj.gobj(); }
+  static CType   to_c_type      (CType ptr) { return ptr; }
+  static CppType to_cpp_type    (CType ptr) { return CppType(const_cast<CTypeNonConst>(ptr), true); }
+  static void    release_c_type (CType ptr) { pango_attribute_destroy(const_cast<CTypeNonConst>(ptr)); }
+};
+
+typedef Glib::SListHandle<Attribute, AttributeTraits> SListHandle_Attribute;
+
+} // namespace Pango
+
+
+namespace Glib
+{
+
+/** @relates Pango::Attribute */
+Pango::Attribute wrap(PangoAttribute* object, bool take_copy = false);
+
+/** @relates Pango::AttrString */
+Pango::AttrString wrap(PangoAttrString* object, bool take_copy = false);
+
+/** @relates Pango::AttrLanguage */
+Pango::AttrLanguage wrap(PangoAttrLanguage* object, bool take_copy = false);
+
+/** @relates Pango::AttrColor */
+Pango::AttrColor wrap(PangoAttrColor* object, bool take_copy = false);
+
+/** @relates Pango::AttrInt */
+Pango::AttrInt wrap(PangoAttrInt* object, bool take_copy = false);
+
+/** @relates Pango::AttrFloat */
+Pango::AttrFloat wrap(PangoAttrFloat* object, bool take_copy = false);
+
+/** @relates Pango::AttrFontDesc */
+Pango::AttrFontDesc wrap(PangoAttrFontDesc* object, bool take_copy = false);
+
+/** @relates Pango::AttrShape */
+Pango::AttrShape wrap(PangoAttrShape* object, bool take_copy = false);
+
+} //namespace Glib
+
+
+#endif /* _PANGOMM_ATTRIBUTES_H */
+
diff --git a/libs/gtkmm2/pango/pangomm/attriter.cc b/libs/gtkmm2/pango/pangomm/attriter.cc
new file mode 100644
index 0000000000..71fa57052a
--- /dev/null
+++ b/libs/gtkmm2/pango/pangomm/attriter.cc
@@ -0,0 +1,180 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <pangomm/attriter.h>
+#include <pangomm/private/attriter_p.h>
+
+/*
+ *
+ * Copyright 1998-1999 The Gtk-- Development Team
+ * Copyright 2001      Free Software Foundation
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+namespace Pango
+{
+
+AttrIter::AttrIter()
+:
+  gobject_(0)
+{}
+
+AttrIter::AttrIter(const AttrIter& src)
+:
+  gobject_(src.gobject_ ? pango_attr_iterator_copy(src.gobject_) : 0)
+{}
+
+AttrIter::AttrIter(PangoAttrIterator* castitem, bool take_copy)
+{
+  if(take_copy)
+  {
+    if(castitem)
+      gobject_ = pango_attr_iterator_copy(castitem);
+    else
+      gobject_ = 0;
+  }
+  else
+  {
+    gobject_ = castitem;
+  }
+}
+
+AttrIter::~AttrIter()
+{
+  if(gobject_)
+     pango_attr_iterator_destroy(gobject_);
+}
+
+AttrIter& AttrIter::operator=(const AttrIter& src)
+{
+  PangoAttrIterator *const new_gobject = (src.gobject_ ? pango_attr_iterator_copy(src.gobject_) : 0);
+
+  if(gobject_)
+     pango_attr_iterator_destroy(gobject_);
+  gobject_ = new_gobject;
+
+  return *this;
+}
+
+AttrIter& AttrIter::operator++()
+{
+  next();
+  return *this;
+}
+
+const AttrIter AttrIter::operator++(int)
+{
+  AttrIter previous(*this);
+  next();
+  return previous;
+}
+
+/* operator bool() cannot be implemented to work properly if a Pango::AttrIter is created
+ * from an already invalid PangoAttrIterator* because there is no way to validate it.
+ * Otherwise the iterator can only become invalid after some call to Pango::AttrIter::next()
+ * in which case gobject_ is destroyed thus marking the iterator as invalid.
+ */
+AttrIter::operator bool() const
+{
+  return (gobject_ != 0);
+}
+
+bool AttrIter::next()
+{
+  if(!pango_attr_iterator_next(gobj()))
+  {
+    pango_attr_iterator_destroy(gobject_);
+    gobject_ = 0; // Mark as invalid. There is no other way to determine whether the iterator is valid later.
+    return false;
+  }
+  else
+    return true;
+}
+
+FontDescription AttrIter::get_font_desc() const
+{
+  FontDescription desc;
+  pango_attr_iterator_get_font(const_cast<PangoAttrIterator*>(gobj()), desc.gobj(), 0, 0);
+
+  // See pango ref docs for pango_attr_iterator_get_font.
+  pango_font_description_set_family(desc.gobj(), pango_font_description_get_family(desc.gobj()));
+
+  return desc;
+}
+
+Language AttrIter::get_language() const
+{
+  FontDescription desc;
+  PangoLanguage* language = 0;
+
+  pango_attr_iterator_get_font(const_cast<PangoAttrIterator*>(gobj()), desc.gobj(), &language, 0);
+
+  return Language(language, true);
+}
+
+SListHandle_Attribute AttrIter::get_extra_attrs() const
+{
+  FontDescription desc;
+  GSList* extra_attrs = 0;
+
+  pango_attr_iterator_get_font(const_cast<PangoAttrIterator*>(gobj()), desc.gobj(), 0, &extra_attrs);
+
+  return SListHandle_Attribute(extra_attrs, Glib::OWNERSHIP_DEEP);
+}
+
+SListHandle_Attribute AttrIter::get_attrs() const
+{
+  GSList* attrs = pango_attr_iterator_get_attrs( const_cast<PangoAttrIterator*>(gobj()) );
+  return SListHandle_Attribute(attrs, Glib::OWNERSHIP_DEEP);
+}
+   
+
+} /* namespace Pango */
+
+
+namespace Glib
+{
+
+Pango::AttrIter wrap(PangoAttrIterator* object, bool take_copy)
+{
+  return Pango::AttrIter(object, take_copy);
+}
+
+} /* namespace Glib */
+
+
+namespace
+{
+} // anonymous namespace
+
+
+namespace Pango
+{
+
+
+void AttrIter::get_range(int& start, int& end) const
+{
+  pango_attr_iterator_range(const_cast<PangoAttrIterator*>(gobj()), &start, &end);
+}
+
+Attribute AttrIter::get_attribute(AttrType type) const
+{
+  return Attribute((pango_attr_iterator_get(const_cast<PangoAttrIterator*>(gobj()), ((PangoAttrType)(type)))));
+}
+
+
+} // namespace Pango
+
+
diff --git a/libs/gtkmm2/pango/pangomm/attriter.h b/libs/gtkmm2/pango/pangomm/attriter.h
new file mode 100644
index 0000000000..ce654e92dd
--- /dev/null
+++ b/libs/gtkmm2/pango/pangomm/attriter.h
@@ -0,0 +1,147 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _PANGOMM_ATTRITER_H
+#define _PANGOMM_ATTRITER_H
+
+#include <glibmm.h>
+
+/* attriter.h
+ *
+ * Copyright (C) 1998-1999 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <glibmm/slisthandle.h>
+#include <pangomm/attributes.h>
+
+
+namespace Pango
+{
+
+/** A Pango::AttrIter is used to represent an iterator through a Pango::AttrList.
+ * A new iterator is created with Pango::AttrList::get_iter(). Once the iterator is created,
+ * it can be advanced through the style changes in the text using Pango::AttrIter::next().
+ * At each style change, the range of the current style segment and the attributes currently in effect can be queried.
+ */
+class AttrIter
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef AttrIter CppObjectType;
+  typedef PangoAttrIterator BaseObjectType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+private:
+
+  
+public:
+  typedef std::forward_iterator_tag iterator_category;
+  typedef int                       difference_type;
+
+protected:
+  AttrIter();
+
+public:
+  explicit AttrIter(PangoAttrIterator* castitem, bool take_copy=true);
+  AttrIter(const AttrIter& src);
+
+  ~AttrIter();
+
+  AttrIter& operator=(const AttrIter& src);
+
+  /** Advance the iterator until the next change of style.
+   * The iterator becomes invalid if the end of the list is reached.
+   * @return The iterator itself.
+   */
+  AttrIter&      operator++();
+
+  const AttrIter operator++(int);
+
+  /** Check whether the iterator is valid.
+   * @return <tt>true</tt> if the iterator is valid.
+   */
+  operator bool() const;
+
+  /** The same as operator++().
+   * @return <tt>false</tt> if the end of the list is reached.
+   */
+  bool next();
+
+  
+  /** Get the range of the current segment.
+   * @param start Location to store the start of the range.
+   * @param end Location to store the end of the range.
+   */
+  void get_range(int& start, int& end) const;
+  
+  /** Find the current attribute of a particular type at the iterator
+   * location. When multiple attributes of the same type overlap,
+   * the attribute whose range starts closest to the current location
+   * is used.
+   * @param type The type of attribute to find.
+   * @return The current attribute of the given type, or <tt>0</tt>
+   * if no attribute of that type applies to the current
+   * location.
+   */
+  Attribute get_attribute(AttrType type) const;
+
+  /** Get the font description used at the current iterator position.
+   * @return The font description used at the current iterator position.
+   */
+  FontDescription get_font_desc() const;
+
+  /** Gets the language tag used at current iterator position.
+   * @return The language tag or an empty Pango::Language object if non is found.
+   */
+  Language get_language() const;
+
+  /** Gets a list of non-font attributes at the the current iterator position.
+   * Only the highest priority value of each attribute will be added to this list.
+   * @return The list of non-font attributes at the current iterator position.
+   */
+  SListHandle_Attribute get_extra_attrs() const;
+
+  /** Gets a list all attributes a the current position of the
+   * iterator.
+   *
+   * @result A list of all attributes for the current range.
+   */
+  SListHandle_Attribute get_attrs() const;
+  
+
+  PangoAttrIterator*       gobj()       { return gobject_; }
+  const PangoAttrIterator* gobj() const { return gobject_; }
+
+protected:
+  PangoAttrIterator* gobject_;
+
+
+};
+
+} // namespace Pango
+
+
+namespace Glib
+{
+
+/** @relates Pango::AttrIter */
+Pango::AttrIter wrap(PangoAttrIterator* object, bool take_copy=false);
+
+} // namespace Glib
+
+
+#endif /* _PANGOMM_ATTRITER_H */
+
diff --git a/libs/gtkmm2/pango/pangomm/attrlist.cc b/libs/gtkmm2/pango/pangomm/attrlist.cc
new file mode 100644
index 0000000000..deba57a453
--- /dev/null
+++ b/libs/gtkmm2/pango/pangomm/attrlist.cc
@@ -0,0 +1,161 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <pangomm/attrlist.h>
+#include <pangomm/private/attrlist_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/*
+ *
+ * Copyright 1998-1999 The Gtk-- Development Team
+ * Copyright 2001      Free Software Foundation
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+namespace Pango
+{
+
+AttrList::AttrList(const Glib::ustring& markup_text, gunichar accel_marker)
+{
+  gboolean bTest = pango_parse_markup(markup_text.c_str(), -1 /* means null-terminated */, accel_marker,
+                   	                  &gobject_, 0, 0, 0);
+  if(bTest == FALSE)
+    gobject_ = 0;
+}
+
+AttrList::AttrList(const Glib::ustring& markup_text, gunichar accel_marker, Glib::ustring& text, gunichar& accel_char)
+{
+  //initialize output parameters:
+  text.erase();
+  accel_char = 0;
+
+  gchar* pchText = 0;
+  gboolean bTest = pango_parse_markup(markup_text.c_str(), -1 /* means null-terminated */, accel_marker,
+                   	                  &gobject_, &pchText, &accel_char, 0);
+  if(bTest == FALSE)
+  {
+    gobject_ = 0;
+  }
+  else
+  {
+    text = pchText;
+    g_free(pchText);
+  }
+}
+
+void AttrList::insert(Attribute& attr)
+{
+  pango_attr_list_insert(gobj(), pango_attribute_copy(attr.gobj()));
+}
+ 
+void AttrList::insert_before(Attribute& attr)
+{
+  pango_attr_list_insert_before(gobj(), pango_attribute_copy(attr.gobj()));
+}
+
+void AttrList::change(Attribute& attr)
+{
+  pango_attr_list_change(gobj(), pango_attribute_copy(attr.gobj()));
+}
+ 
+} /* namespace Pango */
+
+
+namespace
+{
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Pango::AttrList wrap(PangoAttrList* object, bool take_copy)
+{
+  return Pango::AttrList(object, take_copy);
+}
+
+} // namespace Glib
+
+
+namespace Pango
+{
+
+
+// static
+GType AttrList::get_type()
+{
+  return pango_attr_list_get_type();
+}
+
+AttrList::AttrList()
+:
+  gobject_ (pango_attr_list_new())
+{}
+
+AttrList::AttrList(const AttrList& other)
+:
+  gobject_ ((other.gobject_) ? pango_attr_list_copy(other.gobject_) : 0)
+{}
+
+AttrList::AttrList(PangoAttrList* gobject, bool make_a_copy)
+:
+  // For BoxedType wrappers, make_a_copy is true by default.  The static
+  // BoxedType wrappers must always take a copy, thus make_a_copy = true
+  // ensures identical behaviour if the default argument is used.
+  gobject_ ((make_a_copy && gobject) ? pango_attr_list_copy(gobject) : gobject)
+{}
+
+AttrList& AttrList::operator=(const AttrList& other)
+{
+  AttrList temp (other);
+  swap(temp);
+  return *this;
+}
+
+AttrList::~AttrList()
+{
+  if(gobject_)
+    pango_attr_list_unref(gobject_);
+}
+
+void AttrList::swap(AttrList& other)
+{
+  PangoAttrList *const temp = gobject_;
+  gobject_ = other.gobject_;
+  other.gobject_ = temp;
+}
+
+PangoAttrList* AttrList::gobj_copy() const
+{
+  return pango_attr_list_copy(gobject_);
+}
+
+
+void AttrList::splice(AttrList& other, int pos, int len)
+{
+  pango_attr_list_splice(gobj(), (other).gobj(), pos, len);
+}
+
+AttrIter AttrList::get_iter()
+{
+  return Glib::wrap((pango_attr_list_get_iterator(gobj())));
+}
+
+
+} // namespace Pango
+
+
diff --git a/libs/gtkmm2/pango/pangomm/attrlist.h b/libs/gtkmm2/pango/pangomm/attrlist.h
new file mode 100644
index 0000000000..78d435e729
--- /dev/null
+++ b/libs/gtkmm2/pango/pangomm/attrlist.h
@@ -0,0 +1,182 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _PANGOMM_ATTRLIST_H
+#define _PANGOMM_ATTRLIST_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* attrlist.h
+ *
+ * Copyright (C) 1998-1999 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <pangomm/attributes.h>
+#include <pangomm/attriter.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+extern "C" { typedef struct _PangoAttrList PangoAttrList; }
+#endif
+
+namespace Pango
+{
+
+/** A Pango::AttrList represents a list of attributes that apply to a section of text.
+ * The attributes are, in general, allowed to overlap in an arbitrary fashion, however,
+ * if the attributes are manipulated only through Pango::AttrList::change(), the overlap between properties will meet stricter criteria.
+ *
+ * Since the Pango::AttrList structure is stored as a linear list, it is not suitable for storing attributes for large amounts of text.
+ * In general, you should not use a single Pango::AttrList for more than one paragraph of text.
+ */
+class AttrList
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef AttrList CppObjectType;
+  typedef PangoAttrList BaseObjectType;
+
+  static GType get_type() G_GNUC_CONST;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  AttrList();
+
+  explicit AttrList(PangoAttrList* gobject, bool make_a_copy = true);
+
+  AttrList(const AttrList& other);
+  AttrList& operator=(const AttrList& other);
+
+  ~AttrList();
+
+  void swap(AttrList& other);
+
+  ///Provides access to the underlying C instance.
+  PangoAttrList*       gobj()       { return gobject_; }
+
+  ///Provides access to the underlying C instance.
+  const PangoAttrList* gobj() const { return gobject_; }
+
+  ///Provides access to the underlying C instance. The caller is responsible for freeing it. Use when directly setting fields in structs.
+  PangoAttrList* gobj_copy() const;
+
+protected:
+  PangoAttrList* gobject_;
+
+private:
+
+  
+public:
+  /** Constructs an attribute list by parsing a marked-up text (see markup format).
+   * If @a accel_marker is nonzero, the given character will mark the character
+   * following it as an accelerator. For example, the accel marker might be an
+   * ampersand or underscore. All characters marked as an accelerator will receive
+   * a Pango::UNDERLINE_LOW attribute.
+   * Two @a accel_marker characters following each other
+   * produce a single literal @a accel_marker character.
+   *
+   * @param markup_text Markup to parse (see markup format).
+   * @param accel_marker Character that precedes an accelerator, or <tt>0</tt> for none.
+   */
+  explicit AttrList(const Glib::ustring& markup_text, gunichar accel_marker=0);
+
+  /** Constructs an attribute list by parsing a marked-up text (see markup format).
+   * @a text is set to the plaintext string.
+   * If @a accel_marker is nonzero, the given character will mark the character 
+   * following it as an accelerator. For example, the accel marker might be an 
+   * ampersand or underscore. All characters marked as an accelerator will receive
+   * a Pango::UNDERLINE_LOW attribute. The first character so marked will be 
+   * returned in @a accel_char. Two @a accel_marker characters following each other 
+   * produce a single literal @a accel_marker character.
+   *
+   * @param markup_text Markup to parse (see markup format).
+   * @param accel_marker Character that precedes an accelerator, or <tt>0</tt> for none.
+   * @param text Return location for text with tags stripped.
+   * @param accel_char Return location for accelerator char.
+   */
+  AttrList(const Glib::ustring& markup_text, gunichar accel_marker, Glib::ustring& text, gunichar& accel_char);
+
+  void insert(Attribute& attr);
+   // hand code because we need to pass a copy of the attribute
+  void insert_before(Attribute& attr);
+   // hand code because we need to pass a copy of the attribute
+  void change(Attribute& attr);
+   // hand code because we need to pass a copy of the attribute
+  
+  /** This function splices attribute list @a other  into @a list .
+   * This operation is equivalent to stretching every attribute
+   * applies at position @a pos  in @a list  by an amount @a len ,
+   * and then calling pango_attr_list_change() with a copy
+   * of each attributes in @a other  in sequence (offset in position by @a pos ).
+   * 
+   * This operation proves useful for, for instance, inserting
+   * a preedit string in the middle of an edit buffer.
+   * @param other Another Pango::AttrList.
+   * @param pos The position in @a list  at which to insert @a other .
+   * @param len The length of the spliced segment. (Note that this
+   * must be specified since the attributes in @a other 
+   * may only be present at some subsection of this range).
+   */
+  void splice(AttrList& other, int pos, int len);
+  
+  /** Create a iterator initialized to the beginning of the list.
+   * @return A new Pango::Iterator. @a list  must not be modified
+   * until this iterator is freed with pango_attr_iterator_destroy().
+   */
+  AttrIter get_iter();
+
+  //TODO: Though it doesn't seem important:
+  //PangoAttrList* pango_attr_list_filter (PangoAttrList* list, PangoAttrFilterFunc  func, gpointer             data)
+
+
+};
+
+} //namespace Pango
+
+
+namespace Pango
+{
+
+/** @relates Pango::AttrList
+ * @param lhs The left-hand side
+ * @param rhs The right-hand side
+ */
+inline void swap(AttrList& lhs, AttrList& rhs)
+  { lhs.swap(rhs); }
+
+} // namespace Pango
+
+namespace Glib
+{
+
+/** @relates Pango::AttrList
+ * @param object The C instance
+ * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+ * @result A C++ instance that wraps this C instance.
+ */
+Pango::AttrList wrap(PangoAttrList* object, bool take_copy = false);
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+template <>
+class Value<Pango::AttrList> : public Glib::Value_Boxed<Pango::AttrList>
+{};
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+} // namespace Glib
+
+#endif /* _PANGOMM_ATTRLIST_H */
+
diff --git a/libs/gtkmm2/pango/pangomm/color.cc b/libs/gtkmm2/pango/pangomm/color.cc
new file mode 100644
index 0000000000..946d7fcc37
--- /dev/null
+++ b/libs/gtkmm2/pango/pangomm/color.cc
@@ -0,0 +1,124 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <pangomm/color.h>
+#include <pangomm/private/color_p.h>
+
+/* Copyright (C) 2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+namespace Pango
+{
+
+/* For some unknown reason pango doesn't provide pango_color_new(). Let's define an
+ * equivalent function ourself! */
+PangoColor* _pango_color_new()
+{
+  return g_new(PangoColor, 1);
+}
+
+Color::operator bool()
+{
+  return gobj() != 0;
+}
+
+} /* namespace Pango */
+
+
+namespace
+{
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Pango::Color& wrap(PangoColor* object)
+{
+  return *reinterpret_cast<Pango::Color*>(object);
+}
+
+const Pango::Color& wrap(const PangoColor* object)
+{
+  return *reinterpret_cast<const Pango::Color*>(object);
+}
+
+} // namespace Glib
+
+
+namespace Pango
+{
+
+
+// static
+GType Color::get_type()
+{
+  return pango_color_get_type();
+}
+
+Color::Color()
+{
+  GLIBMM_INITIALIZE_STRUCT(gobject_, PangoColor);
+}
+
+Color::Color(const PangoColor* gobject)
+{
+  if(gobject)
+    gobject_ = *gobject;
+  else
+    GLIBMM_INITIALIZE_STRUCT(gobject_, PangoColor);
+}
+
+
+guint16 Color::get_red() const
+{
+  return gobj()->red;
+}
+
+guint16 Color::get_green() const
+{
+  return gobj()->green;
+}
+
+guint16 Color::get_blue() const
+{
+  return gobj()->blue;
+}
+
+void Color::set_red(const guint16& value)
+{
+  gobj()->red = value;
+}
+
+void Color::set_green(const guint16& value)
+{
+  gobj()->green = value;
+}
+
+void Color::set_blue(const guint16& value)
+{
+  gobj()->blue = value;
+}
+
+bool Color::parse(const Glib::ustring& spec)
+{
+  return pango_color_parse(gobj(), spec.c_str());
+}
+
+
+} // namespace Pango
+
+
diff --git a/libs/gtkmm2/pango/pangomm/color.h b/libs/gtkmm2/pango/pangomm/color.h
new file mode 100644
index 0000000000..07ce119896
--- /dev/null
+++ b/libs/gtkmm2/pango/pangomm/color.h
@@ -0,0 +1,138 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _PANGOMM_COLOR_H
+#define _PANGOMM_COLOR_H
+
+#include <glibmm.h>
+
+/* Copyright (C) 2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <pango/pango-attributes.h>
+
+
+namespace Pango
+{
+
+/** A Pango::Color is used to represent a color in an uncalibrated RGB colorspace.
+ */
+class Color
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Color CppObjectType;
+  typedef PangoColor BaseObjectType;
+
+  static GType get_type() G_GNUC_CONST;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  Color();
+
+  explicit Color(const PangoColor* gobject); // always takes a copy
+
+  ///Provides access to the underlying C instance.
+  PangoColor*       gobj()       { return &gobject_; }
+
+  ///Provides access to the underlying C instance.
+  const PangoColor* gobj() const { return &gobject_; }
+
+protected:
+  PangoColor gobject_;
+
+private:
+  
+  
+public:
+
+  /// Tests whether the Color is valid.
+  operator bool();
+  
+  /** Gets the red component of the color.
+   * @return The red component of the color. This is a value between 0 and 65535, with 65535 indicating full intensity.
+   */
+  guint16 get_red() const;
+
+  /** Gets the green component of the color.
+   * @return The green component of the color. This is a value between 0 and 65535, with 65535 indicating full intensity.
+   */
+  guint16 get_green() const;
+
+  /** Gets the blue component of the color.
+   * @return The blue component of the color. This is a value between 0 and 65535, with 65535 indicating full intensity.
+   */
+  guint16 get_blue() const;
+
+  /** Sets the red component of the color.
+   * @param value The red component of the color. This is a value between 0 and 65535, with 65535 indicating full intensity.
+   */
+  void set_red(const guint16& value);
+
+  /** Sets the green component of the color.
+   * @param value The green component of the color. This is a value between 0 and 65535, with 65535 indicating full intensity.
+   */
+  void set_green(const guint16& value);
+
+  /** Sets the blue component of the color.
+   * @param value The blue component of the color. This is a value between 0 and 65535, with 65535 indicating full intensity.
+   */
+  void set_blue(const guint16& value);
+
+  
+  /** Fill in the fields of a color from a string specification. The
+   * string can either one of a large set of standard names. (Taken
+   * from the X11 &lt;filename&gt;rgb.txt&lt;/filename&gt; file), or it can be a hex value in the
+   * form '#rgb' '#rrggbb' '#rrrgggbbb' or '#rrrrggggbbbb' where
+   * 'r', 'g' and 'b' are hex digits of the red, green, and blue
+   * components of the color, respectively. (White in the four
+   * forms is '#fff' '#ffffff' '#fffffffff' and '#ffffffffffff')
+   * @param spec A string specifying the new color.
+   * @return <tt>true</tt> if parsing of the specifier succeeded,
+   * otherwise false.
+   */
+  bool parse(const Glib::ustring& spec);
+
+
+};
+
+} /* namespace Pango */
+
+
+namespace Glib
+{
+
+/** @relates Pango::Color
+ * @param object The C instance
+ * @result A C++ instance that wraps this C instance.
+ */
+Pango::Color& wrap(PangoColor* object);
+
+/** @relates Pango::Color
+ * @param object The C instance
+ * @result A C++ instance that wraps this C instance.
+ */
+const Pango::Color& wrap(const PangoColor* object);
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+template <>
+class Value<Pango::Color> : public Glib::Value_Boxed<Pango::Color>
+{};
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+} // namespace Glib
+
+#endif /* _PANGOMM_COLOR_H */
+
diff --git a/libs/gtkmm2/pango/pangomm/context.cc b/libs/gtkmm2/pango/pangomm/context.cc
new file mode 100644
index 0000000000..5acd2cc9cf
--- /dev/null
+++ b/libs/gtkmm2/pango/pangomm/context.cc
@@ -0,0 +1,239 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <pangomm/context.h>
+#include <pangomm/private/context_p.h>
+
+#include <pango/pango-enum-types.h>
+// -*- c++ -*-
+/* $Id$ */
+
+/* 
+ *
+ * Copyright 1998-1999 The Gtk-- Development Team
+ * Copyright 2001      Free Software Foundation
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+namespace Pango
+{
+
+Glib::ArrayHandle< Glib::RefPtr<FontFamily> > Context::list_families() const
+{
+  //Get array:
+  PangoFontFamily** pFamilies = 0;
+  int n_families = 0;
+  pango_context_list_families(const_cast<PangoContext*>(gobj()), &pFamilies, &n_families);
+  
+  return Glib::ArrayHandle< Glib::RefPtr<FontFamily> >
+      (pFamilies, n_families, Glib::OWNERSHIP_SHALLOW);
+}
+
+Pango::FontMetrics Context::get_metrics(const FontDescription& desc) const
+{
+  return FontMetrics(pango_context_get_metrics(const_cast<PangoContext*>(gobj()), desc.gobj(), 0));
+}
+
+ListHandle_Item Context::itemize(const Glib::ustring& text, const AttrList& attrs) const
+{
+  return ListHandle_Item(
+      pango_itemize(const_cast<PangoContext*>(gobj()),
+                    text.c_str(), 0, text.bytes(),
+                    const_cast<PangoAttrList*>(attrs.gobj()), 0),
+      Glib::OWNERSHIP_DEEP);
+}
+
+ListHandle_Item Context::itemize(const Glib::ustring& text, int start_index, int length,
+                                 const AttrList& attrs, AttrIter& cached_iter) const
+{
+  return ListHandle_Item(
+      pango_itemize(const_cast<PangoContext*>(gobj()),
+                    text.c_str(), start_index, length,
+                    const_cast<PangoAttrList*>(attrs.gobj()), cached_iter.gobj()),
+      Glib::OWNERSHIP_DEEP);
+}
+
+} /* namespace Pango */
+
+
+namespace
+{
+} // anonymous namespace
+
+// static
+GType Glib::Value<Pango::Direction>::value_type()
+{
+  return pango_direction_get_type();
+}
+
+
+namespace Glib
+{
+
+Glib::RefPtr<Pango::Context> wrap(PangoContext* object, bool take_copy)
+{
+  return Glib::RefPtr<Pango::Context>( dynamic_cast<Pango::Context*> (Glib::wrap_auto ((GObject*)(object), take_copy)) );
+  //We use dynamic_cast<> in case of multiple inheritance.
+}
+
+} /* namespace Glib */
+
+
+namespace Pango
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& Context_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &Context_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(pango_context_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void Context_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+}
+
+
+Glib::ObjectBase* Context_Class::wrap_new(GObject* object)
+{
+  return new Context((PangoContext*)object);
+}
+
+
+/* The implementation: */
+
+PangoContext* Context::gobj_copy()
+{
+  reference();
+  return gobj();
+}
+
+Context::Context(const Glib::ConstructParams& construct_params)
+:
+  Glib::Object(construct_params)
+{}
+
+Context::Context(PangoContext* castitem)
+:
+  Glib::Object((GObject*)(castitem))
+{}
+
+Context::~Context()
+{}
+
+
+Context::CppClassType Context::context_class_; // initialize static member
+
+GType Context::get_type()
+{
+  return context_class_.init().get_type();
+}
+
+GType Context::get_base_type()
+{
+  return pango_context_get_type();
+}
+
+
+Context::Context()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Glib::Object(Glib::ConstructParams(context_class_.init()))
+{
+  }
+
+Glib::RefPtr<FontMap> Context::get_font_map()
+{
+  return Glib::wrap(pango_context_get_font_map(gobj()));
+}
+
+Glib::RefPtr<const FontMap> Context::get_font_map() const
+{
+  return Glib::wrap(pango_context_get_font_map(const_cast<PangoContext*>(gobj())));
+}
+
+Glib::RefPtr<Font> Context::load_font(const FontDescription& desc) const
+{
+  return Glib::wrap(pango_context_load_font(const_cast<PangoContext*>(gobj()), (desc).gobj()));
+}
+
+Glib::RefPtr<Fontset> Context::load_fontset(const FontDescription& desc, const Language& language) const
+{
+  return Glib::wrap(pango_context_load_fontset(const_cast<PangoContext*>(gobj()), (desc).gobj(), const_cast<PangoLanguage*>((language).gobj())));
+}
+
+FontMetrics Context::get_metrics(const FontDescription& desc, const Language& language) const
+{
+  return FontMetrics((pango_context_get_metrics(const_cast<PangoContext*>(gobj()), (desc).gobj(), const_cast<PangoLanguage*>((language).gobj()))));
+}
+
+void Context::set_font_description(const FontDescription& desc)
+{
+  pango_context_set_font_description(gobj(), (desc).gobj());
+}
+
+FontDescription Context::get_font_description() const
+{
+  return FontDescription((pango_context_get_font_description(const_cast<PangoContext*>(gobj()))));
+}
+
+Language Context::get_language() const
+{
+  return Language(pango_context_get_language(const_cast<PangoContext*>(gobj())));
+}
+
+void Context::set_language(const Language& language)
+{
+  pango_context_set_language(gobj(), const_cast<PangoLanguage*>((language).gobj()));
+}
+
+void Context::set_base_dir(Direction direction)
+{
+  pango_context_set_base_dir(gobj(), ((PangoDirection)(direction)));
+}
+
+Direction Context::get_base_dir() const
+{
+  return ((Direction)(pango_context_get_base_dir(const_cast<PangoContext*>(gobj()))));
+}
+
+void Context::set_matrix(const Matrix& matrix)
+{
+  pango_context_set_matrix(gobj(), &(matrix));
+}
+
+
+} // namespace Pango
+
+
diff --git a/libs/gtkmm2/pango/pangomm/context.h b/libs/gtkmm2/pango/pangomm/context.h
new file mode 100644
index 0000000000..6ce379ff89
--- /dev/null
+++ b/libs/gtkmm2/pango/pangomm/context.h
@@ -0,0 +1,349 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _PANGOMM_CONTEXT_H
+#define _PANGOMM_CONTEXT_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* context.h
+ * 
+ * Copyright (C) 1998-1999 The gtkmm Development Team 
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+
+#include <glibmm/object.h>
+#include <glibmm/arrayhandle.h>
+#include <glibmm/listhandle.h>
+#include <pangomm/fontdescription.h>
+#include <pangomm/fontmetrics.h>
+#include <pangomm/fontset.h>
+#include <pangomm/fontmap.h>
+#include <pangomm/item.h>
+#include <pangomm/attrlist.h>
+#include <pangomm/types.h> //For Matrix
+#include <pango/pango-context.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _PangoContext PangoContext;
+typedef struct _PangoContextClass PangoContextClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Pango
+{ class Context_Class; } // namespace Pango
+namespace Pango
+{
+
+
+/** @addtogroup pangommEnums Enums and Flags */
+
+/**
+ * @ingroup pangommEnums
+ */
+enum Direction
+{
+  DIRECTION_LTR,
+  DIRECTION_RTL,
+  DIRECTION_TTB_LTR,
+  DIRECTION_TTB_RTL,
+  DIRECTION_WEAK_LTR,
+  DIRECTION_WEAK_RTL,
+  DIRECTION_NEUTRAL
+};
+
+} // namespace Pango
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Pango::Direction> : public Glib::Value_Enum<Pango::Direction>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Pango
+{
+
+
+/** A Pango::Context stores global information used to control the itemization process.
+ * You can retrieve a Pango::Context object with Gtk::Widget::create_pango_context() or
+ * Gtk::Widget::get_pango_context(). If you don't use gtkmm call some c function of the
+ * pango backend you intend to use and create a wrapper for the returned context,
+ * e.g. Glib::wrap(pango_x_get_context()).
+ *
+ * Creating a Pango::Context object is the starting point of every rendering process.
+ * You can either use it to create a high level Pango::Layout object which does all
+ * the hard work for you by passing it into
+ * Pango::Layout::create() or to generate glyph strings from character strings with
+ * the help of itemize() and Pango::Item::shape() subsequently.
+ *
+ * Which fonts are used for rendering can be influenced by setting the default
+ * font description, language and base direction of the context.
+ *
+ * If you want to calculate the space some text will need to be displayed you
+ * might find the functions of Pango::FontMetrics useful. Use get_metrics() to
+ * obtain the Pango::FontMetrics object for a specific Pango::FontDescription.
+ * For more detailed calculations in a rendering-system-independant manner
+ * and to determine whether specific characters can be represented by the
+ * font that would be used for a specific Pango::FontDescription load a
+ * Pango::Fontset with load_fontset() (load_font() returns the Pango::Font
+ * that is the closest match for a Pango::FontDescription; however that's not
+ * necessarily the font that will be used for rendering).
+ */
+
+class Context : public Glib::Object
+{
+   
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+public:
+  typedef Context CppObjectType;
+  typedef Context_Class CppClassType;
+  typedef PangoContext BaseObjectType;
+  typedef PangoContextClass BaseClassType;
+
+private:  friend class Context_Class;
+  static CppClassType context_class_;
+
+private:
+  // noncopyable
+  Context(const Context&);
+  Context& operator=(const Context&);
+
+protected:
+  explicit Context(const Glib::ConstructParams& construct_params);
+  explicit Context(PangoContext* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+  virtual ~Context();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GObject.
+  PangoContext*       gobj()       { return reinterpret_cast<PangoContext*>(gobject_); }
+
+  ///Provides access to the underlying C GObject.
+  const PangoContext* gobj() const { return reinterpret_cast<PangoContext*>(gobject_); }
+
+  ///Provides access to the underlying C instance. The caller is responsible for unrefing it. Use when directly setting fields in structs.
+  PangoContext* gobj_copy();
+
+private:
+
+    //PANGO_ENABLE_BACKEND
+   
+protected:
+  Context();
+  
+public:
+  /** List all available font families for a context.
+   * You can specify one of these as your desired font family in the Pango::FontDesciption
+   * objects you use, e.g. in the default font description of the context.
+   * @return An array of Pango::FontFamily objects.
+   */
+  Glib::ArrayHandle< Glib::RefPtr<FontFamily> > list_families() const;
+  
+  
+  /** Gets the Pango::Fontmap used to look up fonts for this context.
+   * @return The font map for the Pango::Context. This value
+   * is owned by Pango and should not be unreferenced.
+   * 
+   * Since: 1.6.
+   */
+  Glib::RefPtr<FontMap> get_font_map();
+  
+  /** Gets the Pango::Fontmap used to look up fonts for this context.
+   * @return The font map for the Pango::Context. This value
+   * is owned by Pango and should not be unreferenced.
+   * 
+   * Since: 1.6.
+   */
+  Glib::RefPtr<const FontMap> get_font_map() const;  
+
+  
+  /** Loads the font in one of the fontmaps in the context
+   * that is the closest match for @a desc .
+   * @param desc A Pango::FontDescription describing the font to load.
+   * @return The font loaded, or <tt>0</tt> if no font matched.
+   */
+  Glib::RefPtr<Font> load_font(const FontDescription& desc) const;
+  
+  /** Load a set of fonts in the context that can be used to render
+   * a font matching @a desc .
+   * @param desc A Pango::FontDescription describing the fonts to load.
+   * @param language A Pango::Language the fonts will be used for.
+   * @return The fontset, or <tt>0</tt> if no font matched.
+   */
+  Glib::RefPtr<Fontset> load_fontset(const FontDescription& desc, const Language& language) const;
+
+  /** Get overall metric information for a particular font description.
+   * The metrics may be substantially different for different scripts. However this
+   * function overload returns the metrics of the entire font.
+   * @param desc A Pango::FontDescription object.
+   * @return A Pango::FontMetrics object.
+   */
+  FontMetrics get_metrics(const FontDescription& desc) const;
+  
+  /** Get overall metric information for a font particular font
+   * description.  Since the metrics may be substantially different for
+   * different scripts, a language tag can be provided to indicate that
+   * the metrics should be retrieved that correspond to the script(s)
+   * used by that language.
+   * 
+   * The Pango::FontDescription is interpreted in the same way as
+   * by pango_itemize(), and the family name may be a comma separated
+   * list of figures. If characters from multiple of these families
+   * would be used to render the string, then the returned fonts would
+   * be a composite of the metrics for the fonts loaded for the
+   * individual families.
+   * @param desc A Pango::FontDescription structure.
+   * @param language Language tag used to determine which script to get the metrics
+   * for.
+   * @return A Pango::Metrics object.
+   */
+  FontMetrics get_metrics(const FontDescription& desc, const Language& language) const;
+  
+  /** Set the default font description for the context
+   * @param desc The new pango font description.
+   */
+  void set_font_description(const FontDescription& desc);
+  
+  /** Retrieve the default font description for the context.
+   * @return A pointer to the context's default font description.
+   * This value must not be modified or freed.
+   */
+  FontDescription get_font_description() const;
+  
+  /** Retrieves the global language tag for the context.
+   * @return The global language tag.
+   */
+  Language get_language() const;
+  
+  /** Sets the global language tag for the context.
+   * @param language The new language tag.
+   */
+  void set_language(const Language& language);
+  
+  /** Sets the base direction for the context.
+   * 
+   * The base direction is used in applying the Unicode bidirectional
+   * algorithm; if the @a direction  is Pango::DIRECTION_LTR or
+   * Pango::DIRECTION_RTL, then the value will be used as the paragraph
+   * direction in the Unicode bidirectional algorithm.  A value of
+   * Pango::DIRECTION_WEAK_LTR or Pango::DIRECTION_WEAK_RTL is used only
+   * for paragraphs that do not contain any strong characters themselves.
+   * @param direction The new base direction.
+   */
+  void set_base_dir(Direction direction);
+  
+  /** Retrieves the base direction for the context. See
+   * pango_context_set_base_dir().
+   * @return The base direction for the context.
+   */
+  Direction get_base_dir() const;
+
+  
+  /** Sets the transformation matrix that will be applied when rendering
+   * with this context. Note that reported metrics are in the user space
+   * coordinates before the application of the matrix, not device-space
+   * coordiantes after the application of the matrix. So, they don't scale
+   * with the matrix, though they may change slightly for different
+   * matrices, depending on how the text is fit to the pixel grid.
+   * 
+   * Since: 1.6
+   * @param matrix A Pango::Matrix, or <tt>0</tt> to unset any existing matrix.
+   * (No matrix set is the same as setting the identity matrix.).
+   */
+  void set_matrix(const Matrix& matrix);
+  //TODO: _WRAP_METHOD(Matrix get_matrix() const, pango_context_get_matrix)
+
+  /** Breaks a piece of text into segments with consistent directional level and shaping engine.
+   * Each byte of @a text will be contained in exactly one of the items in the returned list.
+   * The generated list of items will be in logical order (the start offsets of the items
+   * are ascending).
+   * @param text The text to itemize.
+   * @param attrs The set of attributes that apply.
+   * @return A list of Pango::Item objects.
+   */
+  ListHandle_Item itemize(const Glib::ustring& text, const AttrList& attrs) const;
+
+  /** Breaks a piece of text into segments with consistent directional level and shaping engine.
+   * Each byte of @a text will be contained in exactly one of the items in the returned list. 
+   * The generated list of items will be in logical order (the start offsets of the items
+   * are ascending).
+   *
+   * @a cached_iter should be an iterator over @a attrs currently positioned at a range before
+   * or containing @a start_index. @a cached_iter will be advanced to the range covering the
+   * position just after @a start_index + @a length. (i.e. if itemizing in a loop, just keep
+   * passing in the same @a cached_iter).
+   *
+   * @param text The text to itemize.
+   * @param start_index First byte in @a text to process.
+   * @param length The number of bytes (not characters) to process after @a start_index. This must be >= <tt>0</tt>.
+   * @param attrs The set of attributes that apply to @a text.
+   * @param cached_iter Cached attribute iterator.
+   * @return A list of Pango::Item structures.
+   */
+  ListHandle_Item itemize(const Glib::ustring& text, int start_index, int length,
+                          const AttrList& attrs, AttrIter& cached_iter) const;
+
+
+public:
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+};
+
+} /* namespace Pango */
+
+
+namespace Glib
+{
+  /** @relates Pango::Context
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Glib::RefPtr<Pango::Context> wrap(PangoContext* object, bool take_copy = false);
+}
+
+
+#endif /* _PANGOMM_CONTEXT_H */
+
diff --git a/libs/gtkmm2/pango/pangomm/coverage.cc b/libs/gtkmm2/pango/pangomm/coverage.cc
new file mode 100644
index 0000000000..e755994012
--- /dev/null
+++ b/libs/gtkmm2/pango/pangomm/coverage.cc
@@ -0,0 +1,151 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <pangomm/coverage.h>
+#include <pangomm/private/coverage_p.h>
+
+#include <pango/pango-enum-types.h>
+// -*- c++ -*-
+/* $Id$ */
+
+/*
+ *
+ * Copyright 1998-1999 The Gtk-- Development Team
+ * Copyright 2001      Free Software Foundation
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+namespace Pango
+{
+
+Glib::ArrayHandle<unsigned char> Coverage::to_bytes() const
+{
+  guchar* bytes = 0;
+  int n_bytes = 0;
+  pango_coverage_to_bytes(const_cast<PangoCoverage*>(gobj()), &bytes, &n_bytes);
+  return Glib::ArrayHandle<unsigned char>(bytes, n_bytes, Glib::OWNERSHIP_SHALLOW);
+}
+
+} /* namespace Pango */
+
+
+namespace
+{
+} // anonymous namespace
+
+// static
+GType Glib::Value<Pango::CoverageLevel>::value_type()
+{
+  return pango_coverage_level_get_type();
+}
+
+
+/* Why reinterpret_cast<Coverage*>(gobject) is needed:
+ *
+ * A Coverage instance is in fact always a PangoCoverage instance.
+ * Unfortunately, PangoCoverage cannot be a member of Coverage,
+ * because it is an opaque struct.  Also, the C interface does not provide
+ * any hooks to install a destroy notification handler, thus we cannot
+ * wrap it dynamically either.
+ *
+ * The cast works because Coverage does not have any member data, and
+ * it is impossible to derive from it.  This is ensured by not implementing
+ * the (protected) default constructor.  The ctor is protected rather than
+ * private just to avoid a compile warning.
+ */
+
+namespace Glib
+{
+
+Glib::RefPtr<Pango::Coverage> wrap(PangoCoverage* object, bool take_copy)
+{
+  if(take_copy && object)
+    pango_coverage_ref(object);
+
+  // See the comment at the top of this file, if you want to know why the cast works.
+  return Glib::RefPtr<Pango::Coverage>(reinterpret_cast<Pango::Coverage*>(object));
+}
+
+} // namespace Glib
+
+
+namespace Pango
+{
+
+
+// static
+Glib::RefPtr<Coverage> Coverage::create()
+{
+  // See the comment at the top of this file, if you want to know why the cast works.
+  return Glib::RefPtr<Coverage>(reinterpret_cast<Coverage*>(pango_coverage_new()));
+}
+
+void Coverage::reference() const
+{
+  // See the comment at the top of this file, if you want to know why the cast works.
+  pango_coverage_ref(reinterpret_cast<PangoCoverage*>(const_cast<Coverage*>(this)));
+}
+
+void Coverage::unreference() const
+{
+  // See the comment at the top of this file, if you want to know why the cast works.
+  pango_coverage_unref(reinterpret_cast<PangoCoverage*>(const_cast<Coverage*>(this)));
+}
+
+PangoCoverage* Coverage::gobj()
+{
+  // See the comment at the top of this file, if you want to know why the cast works.
+  return reinterpret_cast<PangoCoverage*>(this);
+}
+
+const PangoCoverage* Coverage::gobj() const
+{
+  // See the comment at the top of this file, if you want to know why the cast works.
+  return reinterpret_cast<const PangoCoverage*>(this);
+}
+
+PangoCoverage* Coverage::gobj_copy() const
+{
+  // See the comment at the top of this file, if you want to know why the cast works.
+  PangoCoverage *const gobject = reinterpret_cast<PangoCoverage*>(const_cast<Coverage*>(this));
+  pango_coverage_ref(gobject);
+  return gobject;
+}
+
+
+Glib::RefPtr<Coverage> Coverage::create(const guchar* bytes, int n_bytes)
+{
+  return Glib::wrap(pango_coverage_from_bytes(const_cast<guchar*>(bytes), n_bytes));
+}
+
+CoverageLevel Coverage::get(int index) const
+{
+  return ((CoverageLevel)(pango_coverage_get(const_cast<PangoCoverage*>(gobj()), index)));
+}
+
+void Coverage::set(int index, CoverageLevel level)
+{
+  pango_coverage_set(gobj(), index, ((PangoCoverageLevel)(level)));
+}
+
+void Coverage::max(const Glib::RefPtr<Coverage>& other) const
+{
+  pango_coverage_max(const_cast<PangoCoverage*>(gobj()), Glib::unwrap(other));
+}
+
+
+} // namespace Pango
+
+
diff --git a/libs/gtkmm2/pango/pangomm/coverage.h b/libs/gtkmm2/pango/pangomm/coverage.h
new file mode 100644
index 0000000000..eebbffd628
--- /dev/null
+++ b/libs/gtkmm2/pango/pangomm/coverage.h
@@ -0,0 +1,169 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _PANGOMM_COVERAGE_H
+#define _PANGOMM_COVERAGE_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* coverage.h
+ *
+ * Copyright (C) 1998-1999 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <glibmm/arrayhandle.h>
+#include <pango/pango-font.h>
+
+
+namespace Pango
+{
+
+
+/** @addtogroup pangommEnums Enums and Flags */
+
+/**
+ * @ingroup pangommEnums
+ */
+enum CoverageLevel
+{
+  COVERAGE_NONE,
+  COVERAGE_FALLBACK,
+  COVERAGE_APPROXIMATE,
+  COVERAGE_EXACT
+};
+
+} // namespace Pango
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Pango::CoverageLevel> : public Glib::Value_Enum<Pango::CoverageLevel>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Pango
+{
+
+
+/** A Pango::Coverage represents a map from ISO-10646 character point to Pango::CoverageLevel.
+ * It is often necessary in pango to determine if a particular font can represent a particular character,
+ * and also how well it can represent that character. Pango::Coverage holds this information.
+ */
+class Coverage
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Coverage CppObjectType;
+  typedef PangoCoverage BaseObjectType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  static Glib::RefPtr<Coverage> create();
+
+  // For use with Glib::RefPtr<> only.
+  void reference()   const;
+  void unreference() const;
+
+  ///Provides access to the underlying C instance.
+  PangoCoverage*       gobj();
+
+  ///Provides access to the underlying C instance.
+  const PangoCoverage* gobj() const;
+
+  ///Provides access to the underlying C instance. The caller is responsible for unrefing it. Use when directly setting fields in structs.
+  PangoCoverage* gobj_copy() const;
+
+protected:
+  // Do not derive this.  Pango::Coverage can neither be constructed nor deleted.
+  Coverage();
+  void operator delete(void*, size_t);
+
+private:
+  // noncopyable
+  Coverage(const Coverage&);
+  Coverage& operator=(const Coverage&);
+
+
+   //pango ref doc: "This function may now be unecessary since we refcount the structure. Mail otaylor redhat.com if you use it."
+  
+
+public:
+  
+  /** Convert data generated from pango_converage_to_bytes() back
+   * to a Pango::Coverage
+   * @param bytes Binary data representing a Pango::Coverage.
+   * @param n_bytes The size of @a bytes  in bytes.
+   * @return A newly allocated Pango::Coverage, or <tt>0</tt> if
+   * the data was invalid.
+   */
+  static Glib::RefPtr<Coverage> create(const guchar* bytes, int n_bytes);
+
+  //_WRAP_METHOD(Glib::RefPtr<Coverage> copy() const, pango_coverage_copy) //see above
+
+  
+  /** Determine whether a particular index is covered by @a coverage 
+   * @param index The index to check.
+   */
+  CoverageLevel get(int index) const;
+  
+  /** Modify a particular index within @a coverage 
+   * @param index The index to modify.
+   * @param level The new level for @a index .
+   */
+  void set(int index, CoverageLevel level);
+  
+  /** Set the coverage for each index in @a coverage  to be the max (better)
+   * value of the current coverage for the index and the coverage for
+   * the corresponding index in @a other .
+   * @param other Another Pango::Coverage.
+   */
+  void max(const Glib::RefPtr<Coverage>& other) const;
+
+  /** Convert the coverage map into a flat binary format.
+   * @return An array of bytes representing the coverage map.
+   */
+  Glib::ArrayHandle<unsigned char> to_bytes() const;
+
+
+};
+
+} // namespace Pango
+
+
+namespace Glib
+{
+
+  /** @relates Pango::Coverage
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Glib::RefPtr<Pango::Coverage> wrap(PangoCoverage* object, bool take_copy = false);
+
+} // namespace Glib
+
+#endif /* _PANGOMM_COVERAGE_H */
+
diff --git a/libs/gtkmm2/pango/pangomm/font.cc b/libs/gtkmm2/pango/pangomm/font.cc
new file mode 100644
index 0000000000..b126931536
--- /dev/null
+++ b/libs/gtkmm2/pango/pangomm/font.cc
@@ -0,0 +1,169 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <pangomm/font.h>
+#include <pangomm/private/font_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* 
+ *
+ * Copyright 1998-1999 The Gtk-- Development Team
+ * Copyright 2001      Free Software Foundation
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+namespace Pango
+{
+
+FontMetrics Font::get_metrics() const
+{
+  return FontMetrics(pango_font_get_metrics(const_cast<PangoFont*>(gobj()), 0));
+}
+
+Rectangle Font::get_glyph_ink_extents(Glyph glyph) const
+{
+  Rectangle ink_rect;
+  pango_font_get_glyph_extents(const_cast<PangoFont*>(gobj()), glyph, ink_rect.gobj(), 0);
+  return ink_rect;
+}
+
+Rectangle Font::get_glyph_logical_extents(Glyph glyph) const
+{
+  Rectangle logical_rect;
+  pango_font_get_glyph_extents(const_cast<PangoFont*>(gobj()), glyph, 0, logical_rect.gobj());
+  return logical_rect;
+}
+
+} /* namespace Pango */
+
+
+namespace
+{
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Glib::RefPtr<Pango::Font> wrap(PangoFont* object, bool take_copy)
+{
+  return Glib::RefPtr<Pango::Font>( dynamic_cast<Pango::Font*> (Glib::wrap_auto ((GObject*)(object), take_copy)) );
+  //We use dynamic_cast<> in case of multiple inheritance.
+}
+
+} /* namespace Glib */
+
+
+namespace Pango
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& Font_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &Font_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(pango_font_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void Font_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+}
+
+
+Glib::ObjectBase* Font_Class::wrap_new(GObject* object)
+{
+  return new Font((PangoFont*)object);
+}
+
+
+/* The implementation: */
+
+PangoFont* Font::gobj_copy()
+{
+  reference();
+  return gobj();
+}
+
+Font::Font(const Glib::ConstructParams& construct_params)
+:
+  Glib::Object(construct_params)
+{}
+
+Font::Font(PangoFont* castitem)
+:
+  Glib::Object((GObject*)(castitem))
+{}
+
+Font::~Font()
+{}
+
+
+Font::CppClassType Font::font_class_; // initialize static member
+
+GType Font::get_type()
+{
+  return font_class_.init().get_type();
+}
+
+GType Font::get_base_type()
+{
+  return pango_font_get_type();
+}
+
+
+FontDescription Font::describe() const
+{
+  return FontDescription((pango_font_describe(const_cast<PangoFont*>(gobj()))));
+}
+
+Glib::RefPtr<Coverage> Font::get_coverage(const Language& language) const
+{
+  return Glib::wrap(pango_font_get_coverage(const_cast<PangoFont*>(gobj()), const_cast<PangoLanguage*>((language).gobj())));
+}
+
+FontMetrics Font::get_metrics(const Language& language) const
+{
+  return FontMetrics((pango_font_get_metrics(const_cast<PangoFont*>(gobj()), const_cast<PangoLanguage*>((language).gobj()))));
+}
+
+void Font::get_glyph_extents(Glyph glyph, Rectangle& ink_rect, Rectangle& logical_rect) const
+{
+  pango_font_get_glyph_extents(const_cast<PangoFont*>(gobj()), glyph, (ink_rect).gobj(), (logical_rect).gobj());
+}
+
+
+} // namespace Pango
+
+
diff --git a/libs/gtkmm2/pango/pangomm/font.h b/libs/gtkmm2/pango/pangomm/font.h
new file mode 100644
index 0000000000..6aa53a1629
--- /dev/null
+++ b/libs/gtkmm2/pango/pangomm/font.h
@@ -0,0 +1,194 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _PANGOMM_FONT_H
+#define _PANGOMM_FONT_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* font.h
+ * 
+ * Copyright (C) 1998-1999 The gtkmm Development Team 
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+
+#include <glibmm/object.h>
+#include <pangomm/rectangle.h>
+#include <pangomm/language.h>
+#include <pangomm/glyph.h>
+#include <pangomm/fontdescription.h>
+#include <pangomm/fontmetrics.h>
+#include <pangomm/coverage.h>
+#include <pango/pango-font.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _PangoFont PangoFont;
+typedef struct _PangoFontClass PangoFontClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Pango
+{ class Font_Class; } // namespace Pango
+namespace Pango
+{
+
+const int    SCALE          = 1024;
+const double SCALE_XX_SMALL = 0.5787037037037;
+const double SCALE_X_SMALL  = 0.6444444444444;
+const double SCALE_SMALL    = 0.8333333333333;
+const double SCALE_MEDIUM   = 1.0;
+const double SCALE_LARGE    = 1.2;
+const double SCALE_X_LARGE  = 1.4399999999999;
+const double SCALE_XX_LARGE = 1.728;
+
+
+/** A Pango::Font is used to represent a font in a rendering-system-independent matter.
+ */
+
+class Font : public Glib::Object
+{
+  
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+public:
+  typedef Font CppObjectType;
+  typedef Font_Class CppClassType;
+  typedef PangoFont BaseObjectType;
+  typedef PangoFontClass BaseClassType;
+
+private:  friend class Font_Class;
+  static CppClassType font_class_;
+
+private:
+  // noncopyable
+  Font(const Font&);
+  Font& operator=(const Font&);
+
+protected:
+  explicit Font(const Glib::ConstructParams& construct_params);
+  explicit Font(PangoFont* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+  virtual ~Font();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GObject.
+  PangoFont*       gobj()       { return reinterpret_cast<PangoFont*>(gobject_); }
+
+  ///Provides access to the underlying C GObject.
+  const PangoFont* gobj() const { return reinterpret_cast<PangoFont*>(gobject_); }
+
+  ///Provides access to the underlying C instance. The caller is responsible for unrefing it. Use when directly setting fields in structs.
+  PangoFont* gobj_copy();
+
+private:
+
+   //This would return a PangoEngineShape* but the definition of the struct is surrounded by #define PANGO_ENABLE_BACKEND [...] #endif. So don't wrap it.
+
+public:
+  
+  /** Returns a description of the font.
+   * @return A newly-allocated Pango::FontDescription object.
+   */
+  FontDescription describe() const;
+  
+  /** Computes the coverage map for a given font and language tag.
+   * @param language The language tag.
+   * @return A newly-allocated Pango::Coverage object.
+   */
+  Glib::RefPtr<Coverage> get_coverage(const Language& language) const;
+
+  /** Gets overall metric information for a font.
+   * The metrics may be substantially different for different scripts.
+   * However, this function overload returns the metrics for the entire font.
+   */
+  FontMetrics get_metrics() const;
+  
+  /** Gets overall metric information for a font. Since the metrics may be
+   * substantially different for different scripts, a language tag can
+   * be provided to indicate that the metrics should be retrieved that
+   * correspond to the script(s) used by that language.
+   * @param language Language tag used to determine which script to get the metrics
+   * for.
+   * @return A Pango::Metrics object.
+   */
+  FontMetrics get_metrics(const Language& language) const;
+
+  
+  /** Gets the logical and ink extents of a glyph within a font. The
+   * coordinate system for each rectangle has its origin at the
+   * base line and horizontal origin of the character with increasing
+   * coordinates extending to the right and down. The macros PANGO_ASCENT(),
+   * PANGO_DESCENT(), PANGO_LBEARING(), and PANGO_RBEARING can be used to convert
+   * from the extents rectangle to more traditional font metrics. The units
+   * of the rectangles are in 1/PANGO_SCALE of a device unit.
+   * @param glyph The glyph index.
+   * @param ink_rect Rectangle used to store the extents of the glyph as drawn.
+   * @param logical_rect Rectangle used to store the logical extents of the glyph.
+   */
+  void get_glyph_extents(Glyph glyph, Rectangle& ink_rect, Rectangle& logical_rect) const;
+
+  /** Get the ink extents of a glyph within the font.
+   * @param glyph The glyph index.
+   * @return The extents of the glyph as drawn.
+   */
+  Rectangle get_glyph_ink_extents(Glyph glyph) const;
+
+  /** Gets the logical extents of a glyph within the font.
+   * @param glyph The glyph index.
+   * @return The logical extents of the glyph.
+   */
+  Rectangle get_glyph_logical_extents(Glyph glyph) const;
+
+
+public:
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+};
+
+} /* namespace Pango */
+
+
+namespace Glib
+{
+  /** @relates Pango::Font
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Glib::RefPtr<Pango::Font> wrap(PangoFont* object, bool take_copy = false);
+}
+
+
+#endif /* _PANGOMM_FONT_H */
+
diff --git a/libs/gtkmm2/pango/pangomm/fontdescription.cc b/libs/gtkmm2/pango/pangomm/fontdescription.cc
new file mode 100644
index 0000000000..af866dc9cb
--- /dev/null
+++ b/libs/gtkmm2/pango/pangomm/fontdescription.cc
@@ -0,0 +1,252 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <pangomm/fontdescription.h>
+#include <pangomm/private/fontdescription_p.h>
+
+#include <pango/pango-enum-types.h>
+// -*- c++ -*-
+/* $Id$ */
+
+/*
+ *
+ * Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <glibmm/utility.h>
+
+
+namespace Pango
+{
+
+FontDescription::FontDescription(const Glib::ustring& font_name)
+{
+  gobject_ = pango_font_description_from_string(font_name.c_str());
+}
+
+} // namespace Pango
+
+
+namespace
+{
+} // anonymous namespace
+
+// static
+GType Glib::Value<Pango::Style>::value_type()
+{
+  return pango_style_get_type();
+}
+
+// static
+GType Glib::Value<Pango::Variant>::value_type()
+{
+  return pango_variant_get_type();
+}
+
+// static
+GType Glib::Value<Pango::Stretch>::value_type()
+{
+  return pango_stretch_get_type();
+}
+
+// static
+GType Glib::Value<Pango::Weight>::value_type()
+{
+  return pango_weight_get_type();
+}
+
+// static
+GType Glib::Value<Pango::FontMask>::value_type()
+{
+  return pango_font_mask_get_type();
+}
+
+
+namespace Glib
+{
+
+Pango::FontDescription wrap(PangoFontDescription* object, bool take_copy)
+{
+  return Pango::FontDescription(object, take_copy);
+}
+
+} // namespace Glib
+
+
+namespace Pango
+{
+
+
+// static
+GType FontDescription::get_type()
+{
+  return pango_font_description_get_type();
+}
+
+FontDescription::FontDescription()
+:
+  gobject_ (pango_font_description_new())
+{}
+
+FontDescription::FontDescription(const FontDescription& other)
+:
+  gobject_ ((other.gobject_) ? pango_font_description_copy(other.gobject_) : 0)
+{}
+
+FontDescription::FontDescription(PangoFontDescription* gobject, bool make_a_copy)
+:
+  // For BoxedType wrappers, make_a_copy is true by default.  The static
+  // BoxedType wrappers must always take a copy, thus make_a_copy = true
+  // ensures identical behaviour if the default argument is used.
+  gobject_ ((make_a_copy && gobject) ? pango_font_description_copy(gobject) : gobject)
+{}
+
+FontDescription& FontDescription::operator=(const FontDescription& other)
+{
+  FontDescription temp (other);
+  swap(temp);
+  return *this;
+}
+
+FontDescription::~FontDescription()
+{
+  if(gobject_)
+    pango_font_description_free(gobject_);
+}
+
+void FontDescription::swap(FontDescription& other)
+{
+  PangoFontDescription *const temp = gobject_;
+  gobject_ = other.gobject_;
+  other.gobject_ = temp;
+}
+
+PangoFontDescription* FontDescription::gobj_copy() const
+{
+  return pango_font_description_copy(gobject_);
+}
+
+
+guint FontDescription::hash() const
+{
+  return pango_font_description_hash(const_cast<PangoFontDescription*>(gobj()));
+}
+
+void FontDescription::set_family(const Glib::ustring& family)
+{
+  pango_font_description_set_family(gobj(), family.c_str());
+}
+
+Glib::ustring FontDescription::get_family() const
+{
+  return Glib::convert_const_gchar_ptr_to_ustring(pango_font_description_get_family(const_cast<PangoFontDescription*>(gobj())));
+}
+
+void FontDescription::set_style(Style style)
+{
+  pango_font_description_set_style(gobj(), ((PangoStyle)(style)));
+}
+
+Style FontDescription::get_style() const
+{
+  return ((Style)(pango_font_description_get_style(const_cast<PangoFontDescription*>(gobj()))));
+}
+
+void FontDescription::set_variant(Variant variant)
+{
+  pango_font_description_set_variant(gobj(), ((PangoVariant)(variant)));
+}
+
+Variant FontDescription::get_variant() const
+{
+  return ((Variant)(pango_font_description_get_variant(const_cast<PangoFontDescription*>(gobj()))));
+}
+
+void FontDescription::set_weight(Weight weight)
+{
+  pango_font_description_set_weight(gobj(), ((PangoWeight)(weight)));
+}
+
+Weight FontDescription::get_weight() const
+{
+  return ((Weight)(pango_font_description_get_weight(const_cast<PangoFontDescription*>(gobj()))));
+}
+
+void FontDescription::set_stretch(Stretch stretch)
+{
+  pango_font_description_set_stretch(gobj(), ((PangoStretch)(stretch)));
+}
+
+Stretch FontDescription::get_stretch() const
+{
+  return ((Stretch)(pango_font_description_get_stretch(const_cast<PangoFontDescription*>(gobj()))));
+}
+
+void FontDescription::set_size(int size)
+{
+  pango_font_description_set_size(gobj(), size);
+}
+
+int FontDescription::get_size() const
+{
+  return pango_font_description_get_size(const_cast<PangoFontDescription*>(gobj()));
+}
+
+FontMask FontDescription::get_set_fields() const
+{
+  return ((FontMask)(pango_font_description_get_set_fields(const_cast<PangoFontDescription*>(gobj()))));
+}
+
+void FontDescription::unset_fields(FontMask to_unset)
+{
+  pango_font_description_unset_fields(gobj(), ((PangoFontMask)(to_unset)));
+}
+
+void FontDescription::merge(const FontDescription& desc_to_merge, bool replace_existing)
+{
+  pango_font_description_merge(gobj(), (desc_to_merge).gobj(), static_cast<int>(replace_existing));
+}
+
+bool FontDescription::better_match(const FontDescription& old_match, const FontDescription& new_match) const
+{
+  return pango_font_description_better_match(const_cast<PangoFontDescription*>(gobj()), (old_match).gobj(), (new_match).gobj());
+}
+
+Glib::ustring FontDescription::to_string() const
+{
+  return Glib::convert_return_gchar_ptr_to_ustring(pango_font_description_to_string(const_cast<PangoFontDescription*>(gobj())));
+}
+
+Glib::ustring FontDescription::to_filename() const
+{
+  return Glib::convert_return_gchar_ptr_to_ustring(pango_font_description_to_filename(const_cast<PangoFontDescription*>(gobj())));
+}
+
+
+bool operator==(const FontDescription& lhs, const FontDescription& rhs)
+{
+  return (pango_font_description_equal(lhs.gobj(), rhs.gobj()) != 0);
+}
+
+bool operator!=(const FontDescription& lhs, const FontDescription& rhs)
+{
+  return (pango_font_description_equal(lhs.gobj(), rhs.gobj()) == 0);
+}
+
+
+} // namespace Pango
+
+
diff --git a/libs/gtkmm2/pango/pangomm/fontdescription.h b/libs/gtkmm2/pango/pangomm/fontdescription.h
new file mode 100644
index 0000000000..1c51be840c
--- /dev/null
+++ b/libs/gtkmm2/pango/pangomm/fontdescription.h
@@ -0,0 +1,529 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _PANGOMM_FONTDESCRIPTION_H
+#define _PANGOMM_FONTDESCRIPTION_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* fontdescription.h
+ *
+ * Copyright (C) 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <pango/pango-font.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+extern "C" { typedef struct _PangoFontDescription PangoFontDescription; }
+#endif
+
+namespace Pango
+{
+
+
+/** @addtogroup pangommEnums Enums and Flags */
+
+/**
+ * @ingroup pangommEnums
+ */
+enum Style
+{
+  STYLE_NORMAL,
+  STYLE_OBLIQUE,
+  STYLE_ITALIC
+};
+
+} // namespace Pango
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Pango::Style> : public Glib::Value_Enum<Pango::Style>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Pango
+{
+
+/**
+ * @ingroup pangommEnums
+ */
+enum Variant
+{
+  VARIANT_NORMAL,
+  VARIANT_SMALL_CAPS
+};
+
+} // namespace Pango
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Pango::Variant> : public Glib::Value_Enum<Pango::Variant>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Pango
+{
+
+/**
+ * @ingroup pangommEnums
+ */
+enum Stretch
+{
+  STRETCH_ULTRA_CONDENSED,
+  STRETCH_EXTRA_CONDENSED,
+  STRETCH_CONDENSED,
+  STRETCH_SEMI_CONDENSED,
+  STRETCH_NORMAL,
+  STRETCH_SEMI_EXPANDED,
+  STRETCH_EXPANDED,
+  STRETCH_EXTRA_EXPANDED,
+  STRETCH_ULTRA_EXPANDED
+};
+
+} // namespace Pango
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Pango::Stretch> : public Glib::Value_Enum<Pango::Stretch>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Pango
+{
+
+/**
+ * @ingroup pangommEnums
+ */
+enum Weight
+{
+  WEIGHT_ULTRALIGHT = 200,
+  WEIGHT_LIGHT = 300,
+  WEIGHT_NORMAL = 400,
+  WEIGHT_BOLD = 700,
+  WEIGHT_ULTRABOLD = 800,
+  WEIGHT_HEAVY = 900
+};
+
+} // namespace Pango
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Pango::Weight> : public Glib::Value_Enum<Pango::Weight>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Pango
+{
+
+/**
+ * @ingroup pangommEnums
+ * @par Bitwise operators:
+ * <tt>%FontMask operator|(FontMask, FontMask)</tt><br>
+ * <tt>%FontMask operator&(FontMask, FontMask)</tt><br>
+ * <tt>%FontMask operator^(FontMask, FontMask)</tt><br>
+ * <tt>%FontMask operator~(FontMask)</tt><br>
+ * <tt>%FontMask& operator|=(FontMask&, FontMask)</tt><br>
+ * <tt>%FontMask& operator&=(FontMask&, FontMask)</tt><br>
+ * <tt>%FontMask& operator^=(FontMask&, FontMask)</tt><br>
+ */
+enum FontMask
+{
+  FONT_MASK_FAMILY = 1 << 0,
+  FONT_MASK_STYLE = 1 << 1,
+  FONT_MASK_VARIANT = 1 << 2,
+  FONT_MASK_WEIGHT = 1 << 3,
+  FONT_MASK_STRETCH = 1 << 4,
+  FONT_MASK_SIZE = 1 << 5
+};
+
+/** @ingroup pangommEnums */
+inline FontMask operator|(FontMask lhs, FontMask rhs)
+  { return static_cast<FontMask>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs)); }
+
+/** @ingroup pangommEnums */
+inline FontMask operator&(FontMask lhs, FontMask rhs)
+  { return static_cast<FontMask>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs)); }
+
+/** @ingroup pangommEnums */
+inline FontMask operator^(FontMask lhs, FontMask rhs)
+  { return static_cast<FontMask>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs)); }
+
+/** @ingroup pangommEnums */
+inline FontMask operator~(FontMask flags)
+  { return static_cast<FontMask>(~static_cast<unsigned>(flags)); }
+
+/** @ingroup pangommEnums */
+inline FontMask& operator|=(FontMask& lhs, FontMask rhs)
+  { return (lhs = static_cast<FontMask>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs))); }
+
+/** @ingroup pangommEnums */
+inline FontMask& operator&=(FontMask& lhs, FontMask rhs)
+  { return (lhs = static_cast<FontMask>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs))); }
+
+/** @ingroup pangommEnums */
+inline FontMask& operator^=(FontMask& lhs, FontMask rhs)
+  { return (lhs = static_cast<FontMask>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs))); }
+
+} // namespace Pango
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Pango::FontMask> : public Glib::Value_Flags<Pango::FontMask>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Pango
+{
+
+
+/** A Pango::FontDescription represents the description of an ideal font.
+ * It is used both to list what fonts are available on the system and also for specifying the characteristics of a font to load.
+ */
+class FontDescription
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef FontDescription CppObjectType;
+  typedef PangoFontDescription BaseObjectType;
+
+  static GType get_type() G_GNUC_CONST;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  FontDescription();
+
+  explicit FontDescription(PangoFontDescription* gobject, bool make_a_copy = true);
+
+  FontDescription(const FontDescription& other);
+  FontDescription& operator=(const FontDescription& other);
+
+  ~FontDescription();
+
+  void swap(FontDescription& other);
+
+  ///Provides access to the underlying C instance.
+  PangoFontDescription*       gobj()       { return gobject_; }
+
+  ///Provides access to the underlying C instance.
+  const PangoFontDescription* gobj() const { return gobject_; }
+
+  ///Provides access to the underlying C instance. The caller is responsible for freeing it. Use when directly setting fields in structs.
+  PangoFontDescription* gobj_copy() const;
+
+protected:
+  PangoFontDescription* gobject_;
+
+private:
+
+  
+  /* These functions are dangerous! The first casts the "const" from the parameter away
+   * copying the pointer and keep it hanging around.
+   * So desc.set_family_static("some_family") would lead to a segfault.
+   * The latter makes a shallow copy of the parameter's "family" data member.
+   * So if the FontDescription you passed in dies, a pointer to its (deleted)
+   * family data member still hangs around!
+   * This is why we can't wrap these functions!
+   */
+  
+
+public:
+  /** Constructs a font description from a string representation.
+   * @a font_name must have the form
+   * "[FAMILY-LIST] [STYLE-OPTIONS] [SIZE]", where FAMILY-LIST is a comma separated
+   * list of families optionally terminated by a comma, STYLE_OPTIONS is a whitespace
+   * separated list of words where each WORD describes one of style, variant, weight,
+   * or stretch, and SIZE is an decimal number (size in points). Any one of the
+   * options may be absent. If FAMILY-LIST is absent, then the family_name field
+   * of the resulting font description will be initialized to 0. If STYLE-OPTIONS
+   * is missing, then all style options will be set to the default values. If SIZE
+   * is missing, the size in the resulting font description will be set to 0.
+   * @param font_name String representation of a font description.
+   */
+  explicit FontDescription(const Glib::ustring& font_name);
+
+  
+  /** Computes a hash of a Pango::FontDescription structure suitable
+   * to be used, for example, as an argument to Glib::hash_table_new().
+   * @return The hash value.
+   */
+  guint hash() const;
+  
+  /** Sets the family name field of a font description. The family
+   * name represents a family of related font styles, and will
+   * resolve to a particular Pango::FontFamily. In some uses of
+   * Pango::FontDescription, it is also possible to use a comma
+   * separated list of family names for this field.
+   * @param family A string representing the family name.
+   */
+  void set_family(const Glib::ustring& family);
+  
+  /** Gets the family name field of a font description. See
+   * pango_font_description_set_family().
+   * @return The family name field. (Will be <tt>0</tt> if not previously set.).
+   */
+  Glib::ustring get_family() const;
+  
+  /** Sets the style field of a Pango::FontDescription. The
+   * Pango::Style enumeration describes whether the font is slanted and
+   * the manner in which it is slanted; it can be either
+   * Pango::STYLE_NORMAL, Pango::STYLE_ITALIC, or Pango::STYLE_OBLIQUE.
+   * Most fonts will either have a italic style or an oblique
+   * style, but not both, and font matching in Pango will 
+   * match italic specifications with oblique fonts and vice-versa
+   * if an exact match is not found.
+   * @param style The style for the font description.
+   */
+  void set_style(Style style);
+  
+  /** Gets the style field of a Pango::FontDescription. See
+   * pango_font_description_set_style().
+   * @return The style field for the font description. 
+   * Use pango_font_description_get_set_fields() to find out if
+   * the field was explicitely set or not.
+   */
+  Style get_style() const;
+  
+  /** Sets the variant field of a font description. The Pango::Variant
+   * can either be Pango::VARIANT_NORMAL or Pango::VARIANT_SMALL_CAPS.
+   * @param variant The variant type for the font description.
+   */
+  void set_variant(Variant variant);
+  
+  /** Gets the variant field of a Pango::FontDescription. See
+   * pango_font_description_set_variant().
+   * @return The variant field for the font description. Use
+   * pango_font_description_get_set_fields() to find out if
+   * the field was explicitely set or not.
+   */
+  Variant get_variant() const;
+  
+  /** Sets the weight field of a font description. The weight field
+   * specifies how bold or light the font should be. In addition
+   * to the values of the Pango::Weight enumeration, other intermediate
+   * numeric values are possible.
+   * @param weight The weight for the font description.
+   */
+  void set_weight(Weight weight);
+  
+  /** Gets the weight field of a font description. See
+   * pango_font_description_set_weight().
+   * @return The weight field for the font description. Use
+   * pango_font_description_get_set_fields() to find out if
+   * the field was explicitely set or not.
+   */
+  Weight get_weight() const;
+  
+  /** Sets the stretch field of a font description. The stretch field
+   * specifies how narrow or wide the font should be.
+   * @param stretch The stretch for the font description.
+   */
+  void set_stretch(Stretch stretch);
+  
+  /** Gets the stretch field of a font description.
+   * See pango_font_description_set_stretch().
+   * @return The stretch field for the font description. Use
+   * pango_font_description_get_set_fields() to find out if
+   * the field was explicitely set or not.
+   */
+  Stretch get_stretch() const;
+  
+  /** Sets the size field of a font description in fractional points. This is mutually
+   * exclusive with pango_font_description_set_absolute_size().
+   * @param size The size of the font in points, scaled by PANGO_SCALE. (That is,
+   * a @a size  value of 10 * PANGO_SCALE is a 10 point font. The conversion
+   * factor between points and device units depends on system configuration
+   * and the output device. For screen display, a logical DPI of 96 is
+   * common, in which case a 10 point font corresponds to a 10 * (96 / 72) = 13.3
+   * pixel font. Use pango_font_description_set_absolute_size() if you need
+   * a particular size in device units.
+   */
+  void set_size(int size);
+  
+  /** Gets the size field of a font description.
+   * See pango_font_description_get_size().
+   * @return The size field for the font description in points or device units.
+   * You must call pango_font_description_get_size_is_absolute()
+   * to find out which is the case. Returns 0 if the size field has not
+   * previously been set.  pango_font_description_get_set_fields() to
+   * find out if the field was explicitely set or not.
+   */
+  int get_size() const;
+  
+  /** Determines which fields in a font description have been set.
+   * @return A bitmask with bits set corresponding to the
+   * fields in @a desc  that have been set.
+   */
+  FontMask get_set_fields() const;
+  
+  /** Unsets some of the fields in a Pango::FontDescription. Note that
+   * this merely marks the fields cleared, it does not clear the
+   * settings for those fields, to clear a family name set with
+   * pango_font_description_set_family_static() so that it won't
+   * be returned by subsequent calls to pango_font_description_get_family(),
+   * you must actually call pango_font_description_set_family (desc, <tt>0</tt>);
+   * @param to_unset Bitmask of fields in the @a desc  to unset.
+   */
+  void unset_fields(FontMask to_unset);
+  
+  /** Merges the fields that are set in @a desc_to_merge  into the fields in
+   *  @a desc .  If @a replace_existing  is <tt>false</tt>, only fields in @a desc  that
+   * are not already set are affected. If <tt>true</tt>, then fields that are
+   * already set will be replaced as well.
+   * @param desc_to_merge The Pango::FontDescription to merge from.
+   * @param replace_existing If <tt>true</tt>, replace fields in @a desc  with the
+   * corresponding values from @a desc_to_merge , even if they
+   * are already exist.
+   */
+  void merge(const FontDescription& desc_to_merge, bool replace_existing);
+  
+  /** Determines if the style attributes of @a new_match  are a closer match
+   * for @a desc  than @a old_match , or if @a old_match  is <tt>0</tt>, determines if
+   *  @a new_match  is a match at all. Approximate matching is done for
+   * weight and style; other attributes must match exactly.
+   * @param old_match A Pango::FontDescription, or <tt>0</tt>.
+   * @param new_match A Pango::FontDescription.
+   * @return <tt>true</tt> if @a new_match  is a better match.
+   */
+  bool better_match(const FontDescription& old_match, const FontDescription& new_match) const;
+  
+  /** Creates a string representation of a font description. See
+   * description_from_string() for a description of the
+   * format of the string representation. The family list in the
+   * string description will only have a terminating comma if the
+   * last word of the list is a valid style option.
+   * @return The string.
+   */
+  Glib::ustring to_string() const;
+  
+  /** Creates a filename representation of a font description. The
+   * filename is identical to the result from calling
+   * pango_font_description_to_string(), but with underscores instead of
+   * characters that are untypical in filenames, and in lower case only.
+   * @return The filename.
+   */
+  Glib::ustring to_filename() const;
+
+
+};
+
+} //namespace Pango
+
+
+namespace Pango
+{
+
+/** @relates Pango::FontDescription
+ * @param lhs The left-hand side
+ * @param rhs The right-hand side
+ * @result The result
+ */
+bool operator==(const FontDescription& lhs, const FontDescription& rhs);
+
+/** @relates Pango::FontDescription
+ * @param lhs The left-hand side
+ * @param rhs The right-hand side
+ * @result The result
+ */
+bool operator!=(const FontDescription& lhs, const FontDescription& rhs);
+
+
+} // namespace Pango
+
+
+namespace Pango
+{
+
+/** @relates Pango::FontDescription
+ * @param lhs The left-hand side
+ * @param rhs The right-hand side
+ */
+inline void swap(FontDescription& lhs, FontDescription& rhs)
+  { lhs.swap(rhs); }
+
+} // namespace Pango
+
+namespace Glib
+{
+
+/** @relates Pango::FontDescription
+ * @param object The C instance
+ * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+ * @result A C++ instance that wraps this C instance.
+ */
+Pango::FontDescription wrap(PangoFontDescription* object, bool take_copy = false);
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+template <>
+class Value<Pango::FontDescription> : public Glib::Value_Boxed<Pango::FontDescription>
+{};
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+} // namespace Glib
+
+#endif /* _PANGOMM_FONTDESCRIPTION_H */
+
diff --git a/libs/gtkmm2/pango/pangomm/fontface.cc b/libs/gtkmm2/pango/pangomm/fontface.cc
new file mode 100644
index 0000000000..44c087aaef
--- /dev/null
+++ b/libs/gtkmm2/pango/pangomm/fontface.cc
@@ -0,0 +1,148 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <pangomm/fontface.h>
+#include <pangomm/private/fontface_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* 
+ *
+ * Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+namespace Pango
+{
+
+Glib::ArrayHandle<int> FontFace::list_sizes() const
+{
+  int* sizes = 0;
+  int n_sizes = 0;
+  pango_font_face_list_sizes(const_cast<PangoFontFace*>(gobj()), &sizes, &n_sizes);
+
+  return Glib::ArrayHandle<int>(sizes, n_sizes, Glib::OWNERSHIP_SHALLOW); //The ArrayHandle will free the array.
+}
+
+} //namespace Pango
+
+
+namespace
+{
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Glib::RefPtr<Pango::FontFace> wrap(PangoFontFace* object, bool take_copy)
+{
+  return Glib::RefPtr<Pango::FontFace>( dynamic_cast<Pango::FontFace*> (Glib::wrap_auto ((GObject*)(object), take_copy)) );
+  //We use dynamic_cast<> in case of multiple inheritance.
+}
+
+} /* namespace Glib */
+
+
+namespace Pango
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& FontFace_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &FontFace_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(pango_font_face_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void FontFace_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+}
+
+
+Glib::ObjectBase* FontFace_Class::wrap_new(GObject* object)
+{
+  return new FontFace((PangoFontFace*)object);
+}
+
+
+/* The implementation: */
+
+PangoFontFace* FontFace::gobj_copy()
+{
+  reference();
+  return gobj();
+}
+
+FontFace::FontFace(const Glib::ConstructParams& construct_params)
+:
+  Glib::Object(construct_params)
+{}
+
+FontFace::FontFace(PangoFontFace* castitem)
+:
+  Glib::Object((GObject*)(castitem))
+{}
+
+FontFace::~FontFace()
+{}
+
+
+FontFace::CppClassType FontFace::fontface_class_; // initialize static member
+
+GType FontFace::get_type()
+{
+  return fontface_class_.init().get_type();
+}
+
+GType FontFace::get_base_type()
+{
+  return pango_font_face_get_type();
+}
+
+
+FontDescription FontFace::describe() const
+{
+  return FontDescription((pango_font_face_describe(const_cast<PangoFontFace*>(gobj()))));
+}
+
+Glib::ustring FontFace::get_name() const
+{
+  return Glib::convert_const_gchar_ptr_to_ustring(pango_font_face_get_face_name(const_cast<PangoFontFace*>(gobj())));
+}
+
+
+} // namespace Pango
+
+
diff --git a/libs/gtkmm2/pango/pangomm/fontface.h b/libs/gtkmm2/pango/pangomm/fontface.h
new file mode 100644
index 0000000000..64b0317c7c
--- /dev/null
+++ b/libs/gtkmm2/pango/pangomm/fontface.h
@@ -0,0 +1,151 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _PANGOMM_FONTFACE_H
+#define _PANGOMM_FONTFACE_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* fontface.h
+ * 
+ * Copyright 2001      The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+
+#include <glibmm/object.h>
+#include <pangomm/fontdescription.h>
+#include <pango/pango-font.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _PangoFontFace PangoFontFace;
+typedef struct _PangoFontFaceClass PangoFontFaceClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Pango
+{ class FontFace_Class; } // namespace Pango
+namespace Pango
+{
+
+/** A Pango::FontFace is used to represent a group of fonts with the same family, slant, weight, width, but varying sizes.
+ */
+
+class FontFace : public Glib::Object
+{
+   
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+public:
+  typedef FontFace CppObjectType;
+  typedef FontFace_Class CppClassType;
+  typedef PangoFontFace BaseObjectType;
+  typedef PangoFontFaceClass BaseClassType;
+
+private:  friend class FontFace_Class;
+  static CppClassType fontface_class_;
+
+private:
+  // noncopyable
+  FontFace(const FontFace&);
+  FontFace& operator=(const FontFace&);
+
+protected:
+  explicit FontFace(const Glib::ConstructParams& construct_params);
+  explicit FontFace(PangoFontFace* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+  virtual ~FontFace();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GObject.
+  PangoFontFace*       gobj()       { return reinterpret_cast<PangoFontFace*>(gobject_); }
+
+  ///Provides access to the underlying C GObject.
+  const PangoFontFace* gobj() const { return reinterpret_cast<PangoFontFace*>(gobject_); }
+
+  ///Provides access to the underlying C instance. The caller is responsible for unrefing it. Use when directly setting fields in structs.
+  PangoFontFace* gobj_copy();
+
+private:
+
+
+public:
+  
+  /** Returns the family, style, variant, weight and stretch of
+   * a Pango::FontFace. The size field of the resulting font description
+   * will be unset.
+   * @return A  Pango::FontDescription 
+   * holding the description of the face.
+   */
+  FontDescription describe() const;
+  
+  /** Gets a name representing the style of this face among the
+   * different faces in the Pango::FontFamily for the face. This
+   * name is unique among all faces in the family and is suitable
+   * for displaying to users.
+   * @return The face name for the face. This string is
+   * owned by the face object and must not be modified or freed.
+   */
+  Glib::ustring get_name() const;
+
+  Glib::ArrayHandle<int> list_sizes() const;
+  
+  
+protected:
+  //We can't wrap the virtual functions because PangoFontFace has a hidden class.
+  //We probably don't need to subclass this anyway.
+  //_WRAP_VFUNC(const char* get_name() const, "get_face_name")
+  //_WRAP_VFUNC(PangoFontDescription* describe(), "describe")
+
+
+public:
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+};
+
+} /* namespace Pango */
+
+
+namespace Glib
+{
+  /** @relates Pango::FontFace
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Glib::RefPtr<Pango::FontFace> wrap(PangoFontFace* object, bool take_copy = false);
+}
+
+
+#endif /* _PANGOMM_FONTFACE_H */
+
diff --git a/libs/gtkmm2/pango/pangomm/fontfamily.cc b/libs/gtkmm2/pango/pangomm/fontfamily.cc
new file mode 100644
index 0000000000..da7f0be452
--- /dev/null
+++ b/libs/gtkmm2/pango/pangomm/fontfamily.cc
@@ -0,0 +1,149 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <pangomm/fontfamily.h>
+#include <pangomm/private/fontfamily_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* 
+ *
+ * Copyright 2001      The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+namespace Pango
+{
+
+Glib::ArrayHandle< Glib::RefPtr<FontFace> > FontFamily::list_faces() const
+{
+  //Get the array:
+  PangoFontFace** pFontFaces = 0;
+  int n_fonts = 0;
+  pango_font_family_list_faces(const_cast<PangoFontFamily*>(gobj()), &pFontFaces, &n_fonts);
+
+  return Glib::ArrayHandle<Glib::RefPtr <FontFace> > (pFontFaces, n_fonts, Glib::OWNERSHIP_SHALLOW);
+}
+
+} /* namespace Pango */
+
+
+namespace
+{
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Glib::RefPtr<Pango::FontFamily> wrap(PangoFontFamily* object, bool take_copy)
+{
+  return Glib::RefPtr<Pango::FontFamily>( dynamic_cast<Pango::FontFamily*> (Glib::wrap_auto ((GObject*)(object), take_copy)) );
+  //We use dynamic_cast<> in case of multiple inheritance.
+}
+
+} /* namespace Glib */
+
+
+namespace Pango
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& FontFamily_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &FontFamily_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(pango_font_family_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void FontFamily_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+}
+
+
+Glib::ObjectBase* FontFamily_Class::wrap_new(GObject* object)
+{
+  return new FontFamily((PangoFontFamily*)object);
+}
+
+
+/* The implementation: */
+
+PangoFontFamily* FontFamily::gobj_copy()
+{
+  reference();
+  return gobj();
+}
+
+FontFamily::FontFamily(const Glib::ConstructParams& construct_params)
+:
+  Glib::Object(construct_params)
+{}
+
+FontFamily::FontFamily(PangoFontFamily* castitem)
+:
+  Glib::Object((GObject*)(castitem))
+{}
+
+FontFamily::~FontFamily()
+{}
+
+
+FontFamily::CppClassType FontFamily::fontfamily_class_; // initialize static member
+
+GType FontFamily::get_type()
+{
+  return fontfamily_class_.init().get_type();
+}
+
+GType FontFamily::get_base_type()
+{
+  return pango_font_family_get_type();
+}
+
+
+Glib::ustring FontFamily::get_name() const
+{
+  return Glib::convert_const_gchar_ptr_to_ustring(pango_font_family_get_name(const_cast<PangoFontFamily*>(gobj())));
+}
+
+bool FontFamily::is_monospace() const
+{
+  return pango_font_family_is_monospace(const_cast<PangoFontFamily*>(gobj()));
+}
+
+
+} // namespace Pango
+
+
diff --git a/libs/gtkmm2/pango/pangomm/fontfamily.h b/libs/gtkmm2/pango/pangomm/fontfamily.h
new file mode 100644
index 0000000000..f763866a19
--- /dev/null
+++ b/libs/gtkmm2/pango/pangomm/fontfamily.h
@@ -0,0 +1,171 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _PANGOMM_FONTFAMILY_H
+#define _PANGOMM_FONTFAMILY_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* fontfamily.h
+ * 
+ * Copyright 2001      The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+
+#include <glibmm/object.h>
+#include <glibmm/arrayhandle.h>
+#include <pangomm/fontface.h>
+#include <pango/pango-font.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _PangoFontFamily PangoFontFamily;
+typedef struct _PangoFontFamilyClass PangoFontFamilyClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Pango
+{ class FontFamily_Class; } // namespace Pango
+namespace Pango
+{
+
+/** A Pango::FontFamily is used to represent a family of related font faces.
+ * The faces in a family share a common design, but differ in slant, weight, width and other aspects.
+ */
+
+class FontFamily : public Glib::Object
+{
+   
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+public:
+  typedef FontFamily CppObjectType;
+  typedef FontFamily_Class CppClassType;
+  typedef PangoFontFamily BaseObjectType;
+  typedef PangoFontFamilyClass BaseClassType;
+
+private:  friend class FontFamily_Class;
+  static CppClassType fontfamily_class_;
+
+private:
+  // noncopyable
+  FontFamily(const FontFamily&);
+  FontFamily& operator=(const FontFamily&);
+
+protected:
+  explicit FontFamily(const Glib::ConstructParams& construct_params);
+  explicit FontFamily(PangoFontFamily* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+  virtual ~FontFamily();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GObject.
+  PangoFontFamily*       gobj()       { return reinterpret_cast<PangoFontFamily*>(gobject_); }
+
+  ///Provides access to the underlying C GObject.
+  const PangoFontFamily* gobj() const { return reinterpret_cast<PangoFontFamily*>(gobject_); }
+
+  ///Provides access to the underlying C instance. The caller is responsible for unrefing it. Use when directly setting fields in structs.
+  PangoFontFamily* gobj_copy();
+
+private:
+
+   
+public:
+  /** Lists the different font faces that make up family.
+   * The faces in a family share a common design, but differ in slant, weight, width and other aspects.
+   * @return an array of pointers to Pango::FontFace objects.
+   */
+  Glib::ArrayHandle< Glib::RefPtr<FontFace> > list_faces() const;
+
+  
+  /** Gets the name of the family. The name is unique among all
+   * fonts for the font backend and can be used in a Pango::FontDescription
+   * to specify that a face from this family is desired.
+   * @return The name of the family. This string is owned
+   * by the family object and must not be modified or freed.
+   */
+  Glib::ustring get_name() const;
+  
+  /** A monospace font is a font designed for text display where the the
+   * characters form a regular grid. For Western languages this would
+   * mean that the advance width of all characters are the same, but
+   * this categorization also includes Asian fonts which include
+   * double-width characters: characters that occupy two grid cells.
+   * Glib::unichar_iswide() returns a result that indicates whether a
+   * character is typically double-width in a monospace font.
+   * 
+   * The best way to find out the grid-cell size is to call
+   * pango_font_metrics_get_approximate_digit_width(), since the results
+   * of pango_font_metrics_get_approximate_char_width() may be affected
+   * by double-width characters.
+   * @return <tt>true</tt> if the family is monospace.
+   */
+  bool is_monospace() const;
+
+
+public:
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+};
+
+/*
+struct FontFamilyRefPtrTraits
+{
+  typedef Glib::RefPtr<FontFamily> CppType;
+  typedef PangoFontFamily *        CType;
+  typedef PangoFontFamily *        CTypeNonConst;
+
+  static CType   to_c_type      (const CppType& ptr) { return Glib::unwrap (ptr);                   }
+  static CType   to_c_type      (CType          ptr) { return ptr;                                  }
+  static CppType to_cpp_type    (CType          ptr) { return FontFamily::wrap_specific_type (ptr); }
+  static void    release_c_type (CType          ptr) { g_object_unref (ptr);                        }
+};
+*/
+
+} // namespace Pango
+
+
+namespace Glib
+{
+  /** @relates Pango::FontFamily
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Glib::RefPtr<Pango::FontFamily> wrap(PangoFontFamily* object, bool take_copy = false);
+}
+
+
+#endif /* _PANGOMM_FONTFAMILY_H */
+
diff --git a/libs/gtkmm2/pango/pangomm/fontmap.cc b/libs/gtkmm2/pango/pangomm/fontmap.cc
new file mode 100644
index 0000000000..1e5caa8ab4
--- /dev/null
+++ b/libs/gtkmm2/pango/pangomm/fontmap.cc
@@ -0,0 +1,153 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <pangomm/fontmap.h>
+#include <pangomm/private/fontmap_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* 
+ *
+ * Copyright 2001      The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <pangomm/context.h>
+#include <pango/pango-fontmap.h>
+
+namespace Pango
+{
+
+Glib::ArrayHandle< Glib::RefPtr<FontFamily> > FontMap::list_families() const
+{
+  //Get the array:
+  PangoFontFamily** pFamilies = 0;
+  int n_families = 0;
+  pango_font_map_list_families(const_cast<PangoFontMap*>(gobj()), &pFamilies, &n_families);
+
+  return Glib::ArrayHandle< Glib::RefPtr<FontFamily> >
+      (pFamilies, n_families, Glib::OWNERSHIP_SHALLOW);
+}
+
+} /* namespace Pango */
+
+
+namespace
+{
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Glib::RefPtr<Pango::FontMap> wrap(PangoFontMap* object, bool take_copy)
+{
+  return Glib::RefPtr<Pango::FontMap>( dynamic_cast<Pango::FontMap*> (Glib::wrap_auto ((GObject*)(object), take_copy)) );
+  //We use dynamic_cast<> in case of multiple inheritance.
+}
+
+} /* namespace Glib */
+
+
+namespace Pango
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& FontMap_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &FontMap_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(pango_font_map_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void FontMap_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+}
+
+
+Glib::ObjectBase* FontMap_Class::wrap_new(GObject* object)
+{
+  return new FontMap((PangoFontMap*)object);
+}
+
+
+/* The implementation: */
+
+PangoFontMap* FontMap::gobj_copy()
+{
+  reference();
+  return gobj();
+}
+
+FontMap::FontMap(const Glib::ConstructParams& construct_params)
+:
+  Glib::Object(construct_params)
+{}
+
+FontMap::FontMap(PangoFontMap* castitem)
+:
+  Glib::Object((GObject*)(castitem))
+{}
+
+FontMap::~FontMap()
+{}
+
+
+FontMap::CppClassType FontMap::fontmap_class_; // initialize static member
+
+GType FontMap::get_type()
+{
+  return fontmap_class_.init().get_type();
+}
+
+GType FontMap::get_base_type()
+{
+  return pango_font_map_get_type();
+}
+
+
+Glib::RefPtr<Font> FontMap::load_font(const Glib::RefPtr<Context>& context, const FontDescription& desc) const
+{
+  return Glib::wrap(pango_font_map_load_font(const_cast<PangoFontMap*>(gobj()), Glib::unwrap(context), (desc).gobj()));
+}
+
+Glib::RefPtr<Fontset> FontMap::load_fontset(const Glib::RefPtr<Context>& context, const FontDescription& desc, const Language& language) const
+{
+  return Glib::wrap(pango_font_map_load_fontset(const_cast<PangoFontMap*>(gobj()), Glib::unwrap(context), (desc).gobj(), const_cast<PangoLanguage*>((language).gobj())));
+}
+
+
+} // namespace Pango
+
+
diff --git a/libs/gtkmm2/pango/pangomm/fontmap.h b/libs/gtkmm2/pango/pangomm/fontmap.h
new file mode 100644
index 0000000000..c05fe7cc44
--- /dev/null
+++ b/libs/gtkmm2/pango/pangomm/fontmap.h
@@ -0,0 +1,153 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _PANGOMM_FONTMAP_H
+#define _PANGOMM_FONTMAP_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* fontmap.h
+ *
+ * Copyright 2001      The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+
+#include <glibmm/object.h>
+#include <glibmm/arrayhandle.h>
+#include <pangomm/font.h>
+#include <pangomm/fontset.h>
+#include <pangomm/fontfamily.h>
+#include <pango/pango-fontmap.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _PangoFontMap PangoFontMap;
+typedef struct _PangoFontMapClass PangoFontMapClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Pango
+{ class FontMap_Class; } // namespace Pango
+namespace Pango
+{
+
+class Context;
+
+/** A Pango::FontMap represents the set of fonts available for a particular rendering system.
+ */
+
+class FontMap : public Glib::Object
+{
+   
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+public:
+  typedef FontMap CppObjectType;
+  typedef FontMap_Class CppClassType;
+  typedef PangoFontMap BaseObjectType;
+  typedef PangoFontMapClass BaseClassType;
+
+private:  friend class FontMap_Class;
+  static CppClassType fontmap_class_;
+
+private:
+  // noncopyable
+  FontMap(const FontMap&);
+  FontMap& operator=(const FontMap&);
+
+protected:
+  explicit FontMap(const Glib::ConstructParams& construct_params);
+  explicit FontMap(PangoFontMap* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+  virtual ~FontMap();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GObject.
+  PangoFontMap*       gobj()       { return reinterpret_cast<PangoFontMap*>(gobject_); }
+
+  ///Provides access to the underlying C GObject.
+  const PangoFontMap* gobj() const { return reinterpret_cast<PangoFontMap*>(gobject_); }
+
+  ///Provides access to the underlying C instance. The caller is responsible for unrefing it. Use when directly setting fields in structs.
+  PangoFontMap* gobj_copy();
+
+private:
+
+   
+public:
+  
+  /** Load the font in the fontmap that is the closest match for @a desc .
+   * @param context The Pango::Context the font will be used with.
+   * @param desc A Pango::FontDescription describing the font to load.
+   * @return The font loaded, or <tt>0</tt> if no font matched.
+   */
+  Glib::RefPtr<Font> load_font(const Glib::RefPtr<Context>& context, const FontDescription& desc) const;
+  
+  /** Load a set of fonts in the fontmap that can be used to render
+   * a font matching @a desc .
+   * @param context The Pango::Context the font will be used with.
+   * @param desc A Pango::FontDescription describing the font to load.
+   * @param language A Pango::Language the fonts will be used for.
+   * @return The fontset, or <tt>0</tt> if no font matched.
+   */
+  Glib::RefPtr<Fontset> load_fontset(const Glib::RefPtr<Context>& context, const FontDescription& desc, const Language& language) const;
+
+  /** List all families for the fontmap.
+   * @return an array of pointers to Pango::FontFamily objects.
+   */
+  Glib::ArrayHandle< Glib::RefPtr<FontFamily> > list_families() const;
+
+  //This is not used unless ENABLE_BACKEND is defined: _WRAP_METHOD(Glib::ustring get_shape_engine_type() const, pango_font_map_get_shape_engine_type)
+  
+
+public:
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+};
+
+} /* namespace Pango */
+
+
+namespace Glib
+{
+  /** @relates Pango::FontMap
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Glib::RefPtr<Pango::FontMap> wrap(PangoFontMap* object, bool take_copy = false);
+}
+
+
+#endif /* _PANGOMM_FONTMAP_H */
+
diff --git a/libs/gtkmm2/pango/pangomm/fontmetrics.cc b/libs/gtkmm2/pango/pangomm/fontmetrics.cc
new file mode 100644
index 0000000000..d9ba904f5b
--- /dev/null
+++ b/libs/gtkmm2/pango/pangomm/fontmetrics.cc
@@ -0,0 +1,143 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <pangomm/fontmetrics.h>
+#include <pangomm/private/fontmetrics_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/*
+ *
+ * Copyright 1998-1999 The Gtk-- Development Team
+ * Copyright 2001      Free Software Foundation
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+
+namespace
+{
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Pango::FontMetrics wrap(PangoFontMetrics* object, bool take_copy)
+{
+  return Pango::FontMetrics(object, take_copy);
+}
+
+} // namespace Glib
+
+
+namespace Pango
+{
+
+
+// static
+GType FontMetrics::get_type()
+{
+  return pango_font_metrics_get_type();
+}
+
+FontMetrics::FontMetrics()
+:
+  gobject_ (0) // Allows creation of invalid wrapper, e.g. for output arguments to methods.
+{}
+
+FontMetrics::FontMetrics(const FontMetrics& other)
+:
+  gobject_ ((other.gobject_) ? pango_font_metrics_ref(other.gobject_) : 0)
+{}
+
+FontMetrics::FontMetrics(PangoFontMetrics* gobject, bool make_a_copy)
+:
+  // For BoxedType wrappers, make_a_copy is true by default.  The static
+  // BoxedType wrappers must always take a copy, thus make_a_copy = true
+  // ensures identical behaviour if the default argument is used.
+  gobject_ ((make_a_copy && gobject) ? pango_font_metrics_ref(gobject) : gobject)
+{}
+
+FontMetrics& FontMetrics::operator=(const FontMetrics& other)
+{
+  FontMetrics temp (other);
+  swap(temp);
+  return *this;
+}
+
+FontMetrics::~FontMetrics()
+{
+  if(gobject_)
+    pango_font_metrics_unref(gobject_);
+}
+
+void FontMetrics::swap(FontMetrics& other)
+{
+  PangoFontMetrics *const temp = gobject_;
+  gobject_ = other.gobject_;
+  other.gobject_ = temp;
+}
+
+PangoFontMetrics* FontMetrics::gobj_copy() const
+{
+  return pango_font_metrics_ref(gobject_);
+}
+
+
+int FontMetrics::get_ascent() const
+{
+  return pango_font_metrics_get_ascent(const_cast<PangoFontMetrics*>(gobj()));
+}
+
+int FontMetrics::get_descent() const
+{
+  return pango_font_metrics_get_descent(const_cast<PangoFontMetrics*>(gobj()));
+}
+
+int FontMetrics::get_approximate_char_width() const
+{
+  return pango_font_metrics_get_approximate_char_width(const_cast<PangoFontMetrics*>(gobj()));
+}
+
+int FontMetrics::get_approximate_digit_width() const
+{
+  return pango_font_metrics_get_approximate_digit_width(const_cast<PangoFontMetrics*>(gobj()));
+}
+
+int FontMetrics::get_underline_position() const
+{
+  return pango_font_metrics_get_underline_position(const_cast<PangoFontMetrics*>(gobj()));
+}
+
+int FontMetrics::get_underline_thickness() const
+{
+  return pango_font_metrics_get_underline_thickness(const_cast<PangoFontMetrics*>(gobj()));
+}
+
+int FontMetrics::get_strikethrough_position() const
+{
+  return pango_font_metrics_get_strikethrough_position(const_cast<PangoFontMetrics*>(gobj()));
+}
+
+int FontMetrics::get_strikethrough_thickness() const
+{
+  return pango_font_metrics_get_strikethrough_thickness(const_cast<PangoFontMetrics*>(gobj()));
+}
+
+
+} // namespace Pango
+
+
diff --git a/libs/gtkmm2/pango/pangomm/fontmetrics.h b/libs/gtkmm2/pango/pangomm/fontmetrics.h
new file mode 100644
index 0000000000..8b66669f81
--- /dev/null
+++ b/libs/gtkmm2/pango/pangomm/fontmetrics.h
@@ -0,0 +1,187 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _PANGOMM_FONTMETRICS_H
+#define _PANGOMM_FONTMETRICS_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* fontmetrics.h
+ *
+ * Copyright (C) 1998-1999 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <pango/pango-font.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+extern "C" { typedef struct _PangoFontMetrics PangoFontMetrics; }
+#endif
+
+namespace Pango
+{
+
+/** A Pango::FontMetrics holds the overall metric information for a font (possibly restricted to a script).
+ */
+class FontMetrics
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef FontMetrics CppObjectType;
+  typedef PangoFontMetrics BaseObjectType;
+
+  static GType get_type() G_GNUC_CONST;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  FontMetrics();
+
+  explicit FontMetrics(PangoFontMetrics* gobject, bool make_a_copy = true);
+
+  FontMetrics(const FontMetrics& other);
+  FontMetrics& operator=(const FontMetrics& other);
+
+  ~FontMetrics();
+
+  void swap(FontMetrics& other);
+
+  ///Provides access to the underlying C instance.
+  PangoFontMetrics*       gobj()       { return gobject_; }
+
+  ///Provides access to the underlying C instance.
+  const PangoFontMetrics* gobj() const { return gobject_; }
+
+  ///Provides access to the underlying C instance. The caller is responsible for freeing it. Use when directly setting fields in structs.
+  PangoFontMetrics* gobj_copy() const;
+
+protected:
+  PangoFontMetrics* gobject_;
+
+private:
+
+  
+public:
+  
+  /** Gets the ascent from a font metrics structure. The ascent is
+   * the distance from the baseline to the logical top of a line
+   * of text. (The logical top may be above or below the top of the
+   * actual drawn ink. It is necessary to lay out the text to figure
+   * where the ink will be.)
+   * @return The ascent, in pango units. (1 point == Pango::SCALE pango units.).
+   */
+  int get_ascent() const;
+  
+  /** Gets the descent from a font metrics structure. The descent is
+   * the distance from the baseline to the logical bottom of a line
+   * of text. (The logical bottom may be above or below the bottom of the
+   * actual drawn ink. It is necessary to lay out the text to figure
+   * where the ink will be.)
+   * @return The descent, in pango units. (1 point == Pango::SCALE pango units.).
+   */
+  int get_descent() const;
+  
+  /** Gets the approximate character width for a font metrics structure.
+   * This is merely a representative value useful, for example, for
+   * determining the initial size for a window. Actual characters in
+   * text will be wider and narrower than this.
+   * @return The character width, in pango units. (1 point == Pango::SCALE pango units.).
+   */
+  int get_approximate_char_width() const;
+  
+  /** Gets the approximate digit width for a font metrics structure.
+   * This is merely a representative value useful, for example, for
+   * determining the initial size for a window. Actual digits in
+   * text can be wider and narrower than this, though this value
+   * is generally somewhat more accurate than the result of
+   * pango_font_metrics_get_approximate_digit_width().
+   * @return The digit width, in pango units. (1 point == Pango::SCALE pango units.).
+   */
+  int get_approximate_digit_width() const;
+
+  
+  /** Gets the suggested position to draw the underline.
+   * The value returned is the distance <em>above</em> the
+   * baseline of the top of the underline. Since most fonts have
+   * underline positions beneath the baseline, this value is typically
+   * negative.
+   * @return The suggested underline position, in Pango units.
+   * 
+   * Since: 1.6.
+   */
+  int get_underline_position() const;
+  
+  /** Gets the suggested thickness to draw for the underline.
+   * @return The suggested underline thickness, in Pango units.
+   * 
+   * Since: 1.6.
+   */
+  int get_underline_thickness() const;
+  
+  /** Gets the suggested position to draw the strikethrough.
+   * The value returned is the distance <em>above</em> the
+   * baseline of the top of the strikethrough.
+   * @return The suggested strikethrough position, in Pango units.
+   * 
+   * Since: 1.6.
+   */
+  int get_strikethrough_position() const;
+  
+  /** Gets the suggested thickness to draw for the strikethrough.
+   * @return The suggested strikethrough thickness, in Pango units.
+   * 
+   * Since: 1.6.
+   */
+  int get_strikethrough_thickness() const;
+
+
+};
+
+} //namespace Pango
+
+
+namespace Pango
+{
+
+/** @relates Pango::FontMetrics
+ * @param lhs The left-hand side
+ * @param rhs The right-hand side
+ */
+inline void swap(FontMetrics& lhs, FontMetrics& rhs)
+  { lhs.swap(rhs); }
+
+} // namespace Pango
+
+namespace Glib
+{
+
+/** @relates Pango::FontMetrics
+ * @param object The C instance
+ * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+ * @result A C++ instance that wraps this C instance.
+ */
+Pango::FontMetrics wrap(PangoFontMetrics* object, bool take_copy = false);
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+template <>
+class Value<Pango::FontMetrics> : public Glib::Value_Boxed<Pango::FontMetrics>
+{};
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+} // namespace Glib
+
+#endif /* _PANGOMM_FONTMETRICS_H */
+
diff --git a/libs/gtkmm2/pango/pangomm/fontset.cc b/libs/gtkmm2/pango/pangomm/fontset.cc
new file mode 100644
index 0000000000..2d684bde16
--- /dev/null
+++ b/libs/gtkmm2/pango/pangomm/fontset.cc
@@ -0,0 +1,166 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <pangomm/fontset.h>
+#include <pangomm/private/fontset_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* 
+ *
+ * Copyright 2001      The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+namespace { //anonymous
+
+gboolean fontset_foreach_callback(PangoFontset* /* fontset */, PangoFont* font, gpointer data)
+{
+  try
+  {
+    Pango::Fontset::ForeachSlot& slot = *static_cast<Pango::Fontset::ForeachSlot*>(data);
+    Glib::RefPtr<Pango::Font> cppFont = Glib::wrap(font, true /* take_copy */);
+    
+    return slot(cppFont);
+  }
+  catch(...)
+  {
+    Glib::exception_handlers_invoke();
+  }
+
+  return false; //arbitrary default
+}
+
+
+} //anonymous namespace
+
+namespace Pango
+{
+
+void Fontset::foreach(const ForeachSlot& slot)
+{
+  pango_fontset_foreach(gobj(), &fontset_foreach_callback, (void*)&slot); 
+}
+           
+} //namespace
+
+
+namespace
+{
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Glib::RefPtr<Pango::Fontset> wrap(PangoFontset* object, bool take_copy)
+{
+  return Glib::RefPtr<Pango::Fontset>( dynamic_cast<Pango::Fontset*> (Glib::wrap_auto ((GObject*)(object), take_copy)) );
+  //We use dynamic_cast<> in case of multiple inheritance.
+}
+
+} /* namespace Glib */
+
+
+namespace Pango
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& Fontset_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &Fontset_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(pango_fontset_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void Fontset_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+}
+
+
+Glib::ObjectBase* Fontset_Class::wrap_new(GObject* object)
+{
+  return new Fontset((PangoFontset*)object);
+}
+
+
+/* The implementation: */
+
+PangoFontset* Fontset::gobj_copy()
+{
+  reference();
+  return gobj();
+}
+
+Fontset::Fontset(const Glib::ConstructParams& construct_params)
+:
+  Glib::Object(construct_params)
+{}
+
+Fontset::Fontset(PangoFontset* castitem)
+:
+  Glib::Object((GObject*)(castitem))
+{}
+
+Fontset::~Fontset()
+{}
+
+
+Fontset::CppClassType Fontset::fontset_class_; // initialize static member
+
+GType Fontset::get_type()
+{
+  return fontset_class_.init().get_type();
+}
+
+GType Fontset::get_base_type()
+{
+  return pango_fontset_get_type();
+}
+
+
+Glib::RefPtr<Font> Fontset::get_font(guint wc) const
+{
+  return Glib::wrap(pango_fontset_get_font(const_cast<PangoFontset*>(gobj()), wc));
+}
+
+FontMetrics Fontset::get_metrics() const
+{
+  return FontMetrics((pango_fontset_get_metrics(const_cast<PangoFontset*>(gobj()))));
+}
+
+
+} // namespace Pango
+
+
diff --git a/libs/gtkmm2/pango/pangomm/fontset.h b/libs/gtkmm2/pango/pangomm/fontset.h
new file mode 100644
index 0000000000..d3baddfbea
--- /dev/null
+++ b/libs/gtkmm2/pango/pangomm/fontset.h
@@ -0,0 +1,154 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _PANGOMM_FONTSET_H
+#define _PANGOMM_FONTSET_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* fontset.h
+ *
+ * Copyright 2001      The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <glibmm/object.h>
+#include <pangomm/language.h>
+#include <pangomm/font.h>
+#include <pangomm/fontmetrics.h>
+#include <pango/pango-fontset.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _PangoFontset PangoFontset;
+typedef struct _PangoFontsetClass PangoFontsetClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Pango
+{ class Fontset_Class; } // namespace Pango
+namespace Pango
+{
+
+/** A Pango::Fontset is used to represent a set of fonts.
+ */
+
+class Fontset : public Glib::Object
+{
+  
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+public:
+  typedef Fontset CppObjectType;
+  typedef Fontset_Class CppClassType;
+  typedef PangoFontset BaseObjectType;
+  typedef PangoFontsetClass BaseClassType;
+
+private:  friend class Fontset_Class;
+  static CppClassType fontset_class_;
+
+private:
+  // noncopyable
+  Fontset(const Fontset&);
+  Fontset& operator=(const Fontset&);
+
+protected:
+  explicit Fontset(const Glib::ConstructParams& construct_params);
+  explicit Fontset(PangoFontset* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+  virtual ~Fontset();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GObject.
+  PangoFontset*       gobj()       { return reinterpret_cast<PangoFontset*>(gobject_); }
+
+  ///Provides access to the underlying C GObject.
+  const PangoFontset* gobj() const { return reinterpret_cast<PangoFontset*>(gobject_); }
+
+  ///Provides access to the underlying C instance. The caller is responsible for unrefing it. Use when directly setting fields in structs.
+  PangoFontset* gobj_copy();
+
+private:
+
+
+public:
+  
+  /** Returns the font in the fontset that contains the best glyph for the
+   * unicode character wc.
+   * @param wc A unicode character.
+   * @return A Pango::Font. The caller must call g_object_unref when finished
+   * with the font.
+   */
+  Glib::RefPtr<Font> get_font(guint wc) const;
+  
+  /** Get overall metric information for the fonts in the fontset.
+   * @return A Pango::FontMetrics object. The caller must call pango_font_metrics_unref()
+   * when finished using the object.
+   */
+  FontMetrics get_metrics() const;
+
+  /** For instance,
+   * bool on_foreach(const Glib::RefPtr<Pango::Font>& font);
+   */
+  typedef sigc::slot< bool, const Glib::RefPtr<Font>& > ForeachSlot;
+
+  /** Iterates through all the fonts in a fontset, calling @a slot for
+   * each one. If @a slot returns true, that stops the iteration.
+   *
+   * Since: 1.4
+   *
+   * @param slot Callback function
+   */
+  void foreach(const ForeachSlot& slot);
+  
+
+public:
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+};
+
+} /* namespace Pango */
+
+
+namespace Glib
+{
+  /** @relates Pango::Fontset
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Glib::RefPtr<Pango::Fontset> wrap(PangoFontset* object, bool take_copy = false);
+}
+
+
+#endif /* _PANGOMM_FONTSET_H */
+
diff --git a/libs/gtkmm2/pango/pangomm/glyph.cc b/libs/gtkmm2/pango/pangomm/glyph.cc
new file mode 100644
index 0000000000..bf595ec5b0
--- /dev/null
+++ b/libs/gtkmm2/pango/pangomm/glyph.cc
@@ -0,0 +1,145 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <pangomm/glyph.h>
+#include <pangomm/private/glyph_p.h>
+
+/*
+ * Copyright 2001      Free Software Foundation
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+namespace Pango
+{
+
+GlyphInfo::GlyphInfo()
+{
+  gobject_.glyph = 0;
+}
+
+
+GlyphGeometry::GlyphGeometry()
+{
+  gobject_.width = gobject_.x_offset = gobject_.y_offset = 0;
+}
+
+GlyphGeometry::GlyphGeometry(const PangoGlyphGeometry* src)
+{
+  gobject_.width = src->width;
+  gobject_.x_offset = src->x_offset;
+  gobject_.y_offset = src->y_offset;
+}
+
+
+/*GlyphVisAttr::GlyphVisAttr()
+{
+  gobject_.is_cluster_start = 0;
+}
+
+GlyphVisAttr::GlyphVisAttr(const PangoGlyphVisAttr* src)
+{
+  gobject_.is_cluster_start = src->is_cluster_start;
+}*/
+
+} //namespace Pango
+
+
+namespace Glib
+{
+
+Pango::GlyphInfo& wrap(PangoGlyphInfo* object)
+{
+  return *reinterpret_cast<Pango::GlyphInfo*>(object);
+}
+
+const Pango::GlyphInfo& wrap(const PangoGlyphInfo* object)
+{
+  return *reinterpret_cast<const Pango::GlyphInfo*>(object);
+}
+
+Pango::GlyphGeometry& wrap(PangoGlyphGeometry* object)
+{
+  return *reinterpret_cast<Pango::GlyphGeometry*>(object);
+}
+
+const Pango::GlyphGeometry& wrap(const PangoGlyphGeometry* object)
+{
+  return *reinterpret_cast<const Pango::GlyphGeometry*>(object);
+}
+
+/*Pango::GlyphVisAttr& wrap(PangoGlyphVisAttr* object)
+{
+  return *reinterpret_cast<Pango::GlyphVisAttr*>(object);
+}
+
+const Pango::GlyphVisAttr& wrap(const PangoGlyphVisAttr* object)
+{
+  return *reinterpret_cast<const Pango::GlyphVisAttr*>(object);
+}*/
+
+} //namespace Glib
+
+
+namespace
+{
+} // anonymous namespace
+
+
+namespace Pango
+{
+
+
+Glyph GlyphInfo::get_glyph() const
+{
+  return gobj()->glyph;
+}
+
+GlyphGeometry GlyphInfo::get_geometry() const
+{
+  return GlyphGeometry(&(gobj()->geometry));
+}
+
+GlyphVisAttr GlyphInfo::get_attr() const
+{
+  return gobj()->attr;
+}
+
+
+} // namespace Pango
+
+
+namespace Pango
+{
+
+
+GlyphUnit GlyphGeometry::get_width() const
+{
+  return gobj()->width;
+}
+
+GlyphUnit GlyphGeometry::get_x_offset() const
+{
+  return gobj()->x_offset;
+}
+
+GlyphUnit GlyphGeometry::get_y_offset() const
+{
+  return gobj()->y_offset;
+}
+
+
+} // namespace Pango
+
+
diff --git a/libs/gtkmm2/pango/pangomm/glyph.h b/libs/gtkmm2/pango/pangomm/glyph.h
new file mode 100644
index 0000000000..387999d306
--- /dev/null
+++ b/libs/gtkmm2/pango/pangomm/glyph.h
@@ -0,0 +1,222 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _PANGOMM_GLYPH_H
+#define _PANGOMM_GLYPH_H
+
+#include <glibmm.h>
+
+/* glyph.h
+ *
+ * Copyright (C) 1998-1999 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <pango/pango-glyph.h>
+
+
+namespace Pango
+{
+
+class GlyphInfo;
+class GlyphGeometry;
+
+
+/** A Pango::Glyph represents a single glyph in the output form of a string.
+ */
+typedef PangoGlyph Glyph; //This is defined as a guint32
+
+
+/** A Pango::GlyphUnit is used to store dimensions within Pango. Dimensions are stored in 1/64ths of a point.
+ */
+typedef PangoGlyphUnit GlyphUnit;
+
+
+/** A Pango::GlyphVisAttr is used to communicate information between the shaping phase and the rendering phase. It's contents are still evolving.
+ */
+typedef PangoGlyphVisAttr GlyphVisAttr;
+
+
+/** A Pango::GlyphInfo represents a single glyph together with positioning information and visual attributes.
+ */
+class GlyphInfo
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef GlyphInfo CppObjectType;
+  typedef PangoGlyphInfo BaseObjectType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+private:
+
+
+public:
+  GlyphInfo();
+
+  /** Gets the glyph itself.
+   * @return The glyph.
+   */
+  Glyph get_glyph() const;
+
+  /** Gets the positional information about the glyph.
+   * @return A GylphGeometry object.
+   */
+  GlyphGeometry get_geometry() const;
+
+  /** Gets the visual attributes of the glyph.
+   * @return A GlyphVisAttr structure.
+   */
+  GlyphVisAttr get_attr() const;
+
+//I don't think that we need these set_* functions!
+//TODO: Who wrote this? Investigate. murrayc.
+  /* Sets the glyph itself.
+   * @param glyph The new glyph.
+   */
+//  _MEMBER_SET(glyph, glyph, Glyph, PangoGlyph)
+
+  /* Sets the positional information about the glyph.
+   * @param geometry A GlyphGeometry object.
+   */
+//  _MEMBER_SET(geometry, geometry, GlyphGeometry, PangoGlyphGeometry)
+
+  /* Sets the visual attributes of the glyph.
+   * @param attr A GylphVisAttr structure.
+   */
+//  _MEMBER_SET(attr, attr, GlyphVisAttr, PangoGlyphVisAttr)
+
+  /// Provides access to the underlying C GObject.
+  PangoGlyphInfo*       gobj()       { return &gobject_; }
+  /// Provides access to the underlying C GObject.
+  const PangoGlyphInfo* gobj() const { return &gobject_; }
+
+protected:
+  PangoGlyphInfo gobject_;
+
+
+};
+
+
+/** A Pango::GlyphGeometry contains width and positioning information for a single glyph. Distances are in 1/64ths of a point.
+ */
+class GlyphGeometry
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef GlyphGeometry CppObjectType;
+  typedef PangoGlyphGeometry BaseObjectType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+private:
+
+
+public:
+  GlyphGeometry();
+  explicit GlyphGeometry(const PangoGlyphGeometry* src);
+
+  /** Gets the logical width to use for the character.
+   * @return The logical width.
+   */
+  GlyphUnit get_width() const;
+
+  /** Gets the horizontal offset from nominal character position.
+   * @return The horizontal offset.
+   */
+  GlyphUnit get_x_offset() const;
+
+  /** Gets the vertical offset from nominal character position.
+   * @return The vertical offset.
+   */
+  GlyphUnit get_y_offset() const;
+
+//I don't think that we need these set_* functions!
+  /* Sets the logical width to use for the character.
+   * @param width The new logical width.
+   */
+//  _MEMBER_SET(width, width, GlyphUnit, PangoGlyphUnit)
+
+  /* Sets the horizontal offset from nominal character position.
+   * @param x_offset The new horizontal offset.
+   */
+//  _MEMBER_SET(x_offset, x_offset, GlyphUnit, PangoGlyphUnit)
+
+  /* Sets the vertical offset from nominal character position.
+   * @param y_offset The new vertical offset.
+   */
+//  _MEMBER_SET(y_offset, y_offset, GlyphUnit, PangoGlyphUnit)
+
+  PangoGlyphGeometry*       gobj()       { return &gobject_; }
+  const PangoGlyphGeometry* gobj() const { return &gobject_; }
+
+protected:
+  PangoGlyphGeometry gobject_;
+
+
+};
+
+
+/* Since "the contents [of this struct] are still evolving" it might get necessary
+ * to create a wrapper class for PangoGlyphVisAttr in future. Currently, however,
+ * PangoGlyphVisAttr just contains one simple data field (guint is_cluster_start).
+ */
+/*class GlyphVisAttr
+{
+  _CLASS_GENERIC(GlyphVisAttr, PangoGlyphVisAttr)
+
+public:
+  GlyphVisAttr();
+  explicit GlyphVisAttr(const PangoGlyphVisAttr* src);
+
+  _MEMBER_GET(cluster_start, is_cluster_start, bool, guint)
+
+  _MEMBER_SET(cluster_start, is_cluster_start, bool, guint)
+
+  /// Provides access to the underlying C GObject.
+  PangoGlyphVisAttr*       gobj()       { return &gobject_; }
+  /// Provides access to the underlying C GObject.
+  const PangoGlyphVisAttr* gobj() const { return &gobject_; }
+
+protected:
+  PangoGlyphVisAttr gobject_;
+};*/
+
+} //namespace Pango
+
+
+namespace Glib
+{
+
+/** @relates Pango::GlyphInfo */
+Pango::GlyphInfo& wrap(PangoGlyphInfo* object);
+
+/** @relates Pango::GlyphInfo */
+const Pango::GlyphInfo& wrap(const PangoGlyphInfo* object);
+
+/** @relates Pango::GlyphGeometry */
+Pango::GlyphGeometry& wrap(PangoGlyphGeometry* object);
+
+/** @relates Pango::GlyphGeometry */
+const Pango::GlyphGeometry& wrap(const PangoGlyphGeometry* object);
+
+/* @relates Pango::GlyphVisAttr */
+//Pango::GlyphVisAttr& wrap(PangoGlyphVisAttr* object);
+
+/* @relates Pango::GlyphVisAttr */
+//const Pango::GlyphVisAttr& wrap(const PangoGlyphVisAttr* object);
+
+} //namespace Glib
+
+#endif /* _PANGOMM_GLYPH_H */
+
diff --git a/libs/gtkmm2/pango/pangomm/glyphstring.cc b/libs/gtkmm2/pango/pangomm/glyphstring.cc
new file mode 100644
index 0000000000..38ba283c70
--- /dev/null
+++ b/libs/gtkmm2/pango/pangomm/glyphstring.cc
@@ -0,0 +1,186 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <pangomm/glyphstring.h>
+#include <pangomm/private/glyphstring_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/*
+ *
+ * Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <glibmm/utility.h>
+
+
+namespace Pango
+{
+
+GlyphString::GlyphString(const Glib::ustring& text, const Analysis& analysis)
+:
+  gobject_(pango_glyph_string_new())
+{
+  pango_shape(text.c_str(), text.bytes(), const_cast<PangoAnalysis*>(analysis.gobj()), gobj());
+}
+
+Rectangle GlyphString::get_ink_extents(const Glib::RefPtr<const Font>& font) const
+{
+  Rectangle ink_rect;
+  pango_glyph_string_extents(const_cast<PangoGlyphString*>(gobj()), const_cast<PangoFont*>(font->gobj()), ink_rect.gobj(), 0);
+  return ink_rect;
+}
+
+Rectangle GlyphString::get_ink_extents(int start, int end, const Glib::RefPtr<const Font>& font) const
+{
+  Rectangle ink_rect;
+  pango_glyph_string_extents_range(const_cast<PangoGlyphString*>(gobj()), start, end, const_cast<PangoFont*>(font->gobj()), ink_rect.gobj(), 0);
+  return ink_rect;
+}
+
+Rectangle GlyphString::get_logical_extents(const Glib::RefPtr<const Font>& font) const
+{
+  Rectangle logical_rect;
+  pango_glyph_string_extents(const_cast<PangoGlyphString*>(gobj()), const_cast<PangoFont*>(font->gobj()), 0, logical_rect.gobj());
+  return logical_rect;
+}
+
+Rectangle GlyphString::get_logical_extents(int start, int end, const Glib::RefPtr<const Font>& font) const
+{
+  Rectangle logical_rect;
+  pango_glyph_string_extents_range(const_cast<PangoGlyphString*>(gobj()), start, end, const_cast<PangoFont*>(font->gobj()), 0, logical_rect.gobj());
+  return logical_rect;
+}
+
+Glib::ArrayHandle<int> GlyphString::get_logical_widths(const Glib::ustring& text, int embedding_level) const
+{
+  int* logical_widths = g_new(int, text.length());
+  pango_glyph_string_get_logical_widths(const_cast<PangoGlyphString*>(gobj()), text.c_str(), text.bytes(), embedding_level, logical_widths);
+  return Glib::ArrayHandle<int>(logical_widths, text.length(), Glib::OWNERSHIP_SHALLOW);
+}
+
+int GlyphString::index_to_x(const Glib::ustring& text, const Analysis& analysis, int index, bool trailing) const
+{
+  int x_pos;
+  pango_glyph_string_index_to_x(const_cast<PangoGlyphString*>(gobj()), const_cast<gchar*>(text.c_str()), text.bytes(), const_cast<PangoAnalysis*>(analysis.gobj()), index, static_cast<int>(trailing), &x_pos);
+  return x_pos;
+}
+
+void GlyphString::x_to_index(const Glib::ustring& text, const Analysis& analysis, int x_pos, int& index, bool& trailing) const
+{
+  gboolean trailing_temp = FALSE;
+  pango_glyph_string_x_to_index(const_cast<PangoGlyphString*>(gobj()), const_cast<char*>(text.c_str()), text.bytes(), const_cast<PangoAnalysis*>(analysis.gobj()), x_pos, &index, &trailing_temp);
+  trailing = trailing_temp;
+}
+
+Glib::ArrayHandle<GlyphInfo> GlyphString::get_glyphs() const
+{
+  return Glib::ArrayHandle<GlyphInfo>(reinterpret_cast<GlyphInfo*>(gobj()->glyphs), gobj()->num_glyphs, Glib::OWNERSHIP_NONE);
+}
+
+} //namespace Pango
+
+
+namespace
+{
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Pango::GlyphString wrap(PangoGlyphString* object, bool take_copy)
+{
+  return Pango::GlyphString(object, take_copy);
+}
+
+} // namespace Glib
+
+
+namespace Pango
+{
+
+
+// static
+GType GlyphString::get_type()
+{
+  return pango_glyph_string_get_type();
+}
+
+GlyphString::GlyphString()
+:
+  gobject_ (pango_glyph_string_new())
+{}
+
+GlyphString::GlyphString(const GlyphString& other)
+:
+  gobject_ ((other.gobject_) ? pango_glyph_string_copy(other.gobject_) : 0)
+{}
+
+GlyphString::GlyphString(PangoGlyphString* gobject, bool make_a_copy)
+:
+  // For BoxedType wrappers, make_a_copy is true by default.  The static
+  // BoxedType wrappers must always take a copy, thus make_a_copy = true
+  // ensures identical behaviour if the default argument is used.
+  gobject_ ((make_a_copy && gobject) ? pango_glyph_string_copy(gobject) : gobject)
+{}
+
+GlyphString& GlyphString::operator=(const GlyphString& other)
+{
+  GlyphString temp (other);
+  swap(temp);
+  return *this;
+}
+
+GlyphString::~GlyphString()
+{
+  if(gobject_)
+    pango_glyph_string_free(gobject_);
+}
+
+void GlyphString::swap(GlyphString& other)
+{
+  PangoGlyphString *const temp = gobject_;
+  gobject_ = other.gobject_;
+  other.gobject_ = temp;
+}
+
+PangoGlyphString* GlyphString::gobj_copy() const
+{
+  return pango_glyph_string_copy(gobject_);
+}
+
+
+void GlyphString::set_size(int new_len)
+{
+  pango_glyph_string_set_size(gobj(), new_len);
+}
+
+void GlyphString::get_extents(const Glib::RefPtr<const Font>& font, Rectangle& ink_rect, Rectangle& logical_rect) const
+{
+  pango_glyph_string_extents(const_cast<PangoGlyphString*>(gobj()), const_cast<PangoFont*>(Glib::unwrap<Font>(font)), (ink_rect).gobj(), (logical_rect).gobj());
+}
+
+void GlyphString::get_extents(int start, int end, const Glib::RefPtr<const Font>& font, Rectangle& ink_rect, Rectangle& logical_rect) const
+{
+  pango_glyph_string_extents_range(const_cast<PangoGlyphString*>(gobj()), start, end, const_cast<PangoFont*>(Glib::unwrap<Font>(font)), (ink_rect).gobj(), (logical_rect).gobj());
+}
+
+
+} // namespace Pango
+
+
diff --git a/libs/gtkmm2/pango/pangomm/glyphstring.h b/libs/gtkmm2/pango/pangomm/glyphstring.h
new file mode 100644
index 0000000000..7313e41766
--- /dev/null
+++ b/libs/gtkmm2/pango/pangomm/glyphstring.h
@@ -0,0 +1,223 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _PANGOMM_GLYPHSTRING_H
+#define _PANGOMM_GLYPHSTRING_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* glyphstring.h
+ *
+ * Copyright (C) 1998-1999 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <pangomm/font.h>
+#include <pangomm/glyph.h>
+#include <pangomm/item.h>
+#include <pango/pango-glyph.h>
+#include <pango/pango-item.h> //For PangoAnalysis.
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+extern "C" { typedef struct _PangoGlyphString PangoGlyphString; }
+#endif
+
+namespace Pango
+{
+
+/** A Pango::GlyphString is used to store strings of glyphs with geometry and visual attribute information.
+ * It can be measured or drawn to the screen.
+ */
+class GlyphString
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef GlyphString CppObjectType;
+  typedef PangoGlyphString BaseObjectType;
+
+  static GType get_type() G_GNUC_CONST;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  GlyphString();
+
+  explicit GlyphString(PangoGlyphString* gobject, bool make_a_copy = true);
+
+  GlyphString(const GlyphString& other);
+  GlyphString& operator=(const GlyphString& other);
+
+  ~GlyphString();
+
+  void swap(GlyphString& other);
+
+  ///Provides access to the underlying C instance.
+  PangoGlyphString*       gobj()       { return gobject_; }
+
+  ///Provides access to the underlying C instance.
+  const PangoGlyphString* gobj() const { return gobject_; }
+
+  ///Provides access to the underlying C instance. The caller is responsible for freeing it. Use when directly setting fields in structs.
+  PangoGlyphString* gobj_copy() const;
+
+protected:
+  PangoGlyphString* gobject_;
+
+private:
+
+  
+public:
+  /** Construct a string of glyphs from a string of characters.
+   * Given a segment of text and the corresponding Pango::Analysis structure
+   * returned from Pango::Context::itemize(), convert the characters into glyphs.
+   * You may also pass in only a sub-string of the item.
+   * @param text The text to process. You must pass the same string into those member functions expecting a const Glib::ustring&.
+   * @param analysis The analysis information return from Pango::Context::itemize().
+   */
+  GlyphString(const Glib::ustring& text, const Analysis& analysis);
+
+  
+  /** Resize a glyph string to the given length.
+   * @param new_len The new length of the string.
+   */
+  void set_size (int new_len);
+
+  
+  /** Compute the logical and ink extents of a glyph string. See the documentation
+   * for Pango::Font::get_glyph_extents() for details about the interpretation
+   * of the rectangles.
+   * @param font A Pango::Font.
+   * @param ink_rect Rectangle used to store the extents of the glyph string as drawn.
+   * @param logical_rect Rectangle used to store the logical extents of the glyph string.
+   */
+  void get_extents(const Glib::RefPtr<const Font>& font, Rectangle& ink_rect, Rectangle& logical_rect) const;
+  
+  /** Computes the extents of a sub-portion of a glyph string. The extents are
+   * relative to the start of the glyph string range (the origin of their
+   * coordinate system is at the start of the range, not at the start of the entire
+   * glyph string).
+   * @param start Start index.
+   * @param end End index (the range is the set of bytes with
+   *               indices such that start &lt;= index &lt; end).
+   * @param font A Pango::Font.
+   * @param ink_rect Rectangle used to store the extents of the glyph string range as drawn.
+   * @param logical_rect Rectangle used to store the logical extents of the glyph string range.
+   */
+  void get_extents(int start, int end, const Glib::RefPtr<const Font>& font, Rectangle& ink_rect, Rectangle& logical_rect) const;
+
+  /** Computes the extents of the glyph string as drawn.
+   * @param font A Pango::Font.
+   * @return The extents of the glyph string as drawn.
+   */
+  Rectangle get_ink_extents(const Glib::RefPtr<const Font>& font) const;
+
+  /** Computes the extents of a sub-portion of the glyph string as drawn.
+   * @param start The start index.
+   * @param end The end index.
+   * @param font A Panog::Font
+   * @return The extents of the sub-portion of the glyph string as drawn.
+   */
+  Rectangle get_ink_extents(int start, int end, const Glib::RefPtr<const Font>& font) const;
+
+  /** Computes the logical extents of a sub-portion of the glyph string.
+   * @param font A Pango::Font.
+   * @return The logical extents of the glyph string.
+   */
+  Rectangle get_logical_extents(const Glib::RefPtr<const Font>& font) const;
+
+  /** Computes the logical extents of a sub-portion of the glyph string.
+   * @param start The start index.
+   * @param end The end index.
+   * @param font A Pango::Font.
+   * @return The logical extents of the sub-portion of the glyph string.
+   */
+  Rectangle get_logical_extents(int start, int end, const Glib::RefPtr<const Font>& font) const;
+
+  /** Determine the screen width corresponding to each character.
+   * When multiple characters compose a single cluster, the width of the entire cluster
+   * is divided equally among the characters.
+   * @param text The text corresponding to the glyphs.
+   * @param embedding_level The embedding level of the string.
+   * @return An array of integers representing the resulting character widths.
+   */
+  Glib::ArrayHandle<int> get_logical_widths(const Glib::ustring& text, int embedding_level) const;
+
+  /** Converts from character position to x position.
+   * (X position is measured from the left edge of the run). Character positions are computed by dividing up each cluster into equal portions.
+   * @param text The text corresponding to the glyphs.
+   * @param analysis The analysis information return from Pango::Context::itemize().
+   * @param index The byte index within text.
+   * @param trailing Whether we should compute the result for the beginning or end of the character.
+   * @return The x position.
+   */
+  int index_to_x(const Glib::ustring& text, const Analysis& analysis, int index, bool trailing) const;
+
+  /** Convert from x offset to character position.
+   * Character positions are computed by dividing up each cluster into equal portions.
+   * In scripts where positioning within a cluster is not allowed (such as Thai),
+   * the returned value may not be a valid cursor position; the caller must combine the
+   * result with the logical attributes for the text to compute the valid cursor position.
+   * @param text The text corresponding to the glyphs.
+   * @param analysis The analysis information return from Pango::Context::itemize().
+   * @param x_pos The x offset (in thousands of a device unit).
+   * @param index The location to store calculated byte index within.
+   * @param trailing The location to store a boolean indicating whether the user clicked on the leading or trailing edge of the character.
+   */
+  void x_to_index(const Glib::ustring& text, const Analysis& analysis, int x_pos, int& index, bool& trailing) const;
+
+  /** Gharacter positions are computed by dividing up each cluster into equal portions.
+   * @return An array of Pango::GlyphInfo objects.
+   */
+  Glib::ArrayHandle<GlyphInfo> get_glyphs() const;
+
+
+};
+
+} //namespace Pango
+
+
+namespace Pango
+{
+
+/** @relates Pango::GlyphString
+ * @param lhs The left-hand side
+ * @param rhs The right-hand side
+ */
+inline void swap(GlyphString& lhs, GlyphString& rhs)
+  { lhs.swap(rhs); }
+
+} // namespace Pango
+
+namespace Glib
+{
+
+/** @relates Pango::GlyphString
+ * @param object The C instance
+ * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+ * @result A C++ instance that wraps this C instance.
+ */
+Pango::GlyphString wrap(PangoGlyphString* object, bool take_copy = false);
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+template <>
+class Value<Pango::GlyphString> : public Glib::Value_Boxed<Pango::GlyphString>
+{};
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+} // namespace Glib
+
+#endif /* _PANGOMM_GLYPHSTRING_H */
+
diff --git a/libs/gtkmm2/pango/pangomm/init.cc b/libs/gtkmm2/pango/pangomm/init.cc
new file mode 100644
index 0000000000..8ae697e967
--- /dev/null
+++ b/libs/gtkmm2/pango/pangomm/init.cc
@@ -0,0 +1,34 @@
+// -*- c++ -*-
+/* $Id$ */
+
+/* Copyright (C) 2003 The pangomm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <glibmm/init.h>
+#include <pangomm/wrap_init.h>
+
+namespace Pango
+{
+
+void init()
+{
+  Glib::init();
+  Pango::wrap_init();  
+}
+
+} // namespace Pango
+
diff --git a/libs/gtkmm2/pango/pangomm/init.h b/libs/gtkmm2/pango/pangomm/init.h
new file mode 100644
index 0000000000..955b8c2d83
--- /dev/null
+++ b/libs/gtkmm2/pango/pangomm/init.h
@@ -0,0 +1,40 @@
+// -*- c++ -*-
+#ifndef _PANGOMM_INIT_H
+#define _PANGOMM_INIT_H
+
+/* $Id$ */
+
+/* Copyright (C) 2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+namespace Pango
+{
+
+/** Initialize pangomm.
+ * You may call this more than once.
+ * You do not need to call this if you are using Gtk::Main,
+ * because it calls it for you.
+ */
+void init();
+
+} // namespace Pango
+
+
+
+#endif // _PANGOMM_INIT_H
+
+
diff --git a/libs/gtkmm2/pango/pangomm/item.cc b/libs/gtkmm2/pango/pangomm/item.cc
new file mode 100644
index 0000000000..f798552e1b
--- /dev/null
+++ b/libs/gtkmm2/pango/pangomm/item.cc
@@ -0,0 +1,201 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <pangomm/item.h>
+#include <pangomm/private/item_p.h>
+
+/* Copyright (C) 2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <pangomm/font.h>
+#include <pangomm/attributes.h>
+#include <pangomm/glyphstring.h>
+
+namespace Pango
+{
+
+Analysis::Analysis()
+{}
+
+Analysis::Analysis(const PangoAnalysis* src)
+:
+  gobject_ (*src)
+{}
+
+SListHandle_Attribute Analysis::get_extra_attrs() const
+{
+  return SListHandle_Attribute(gobj()->extra_attrs, Glib::OWNERSHIP_NONE);
+}
+
+
+Item::Item(const Item& src)
+:
+  gobject_ ((src.gobject_) ? pango_item_copy(src.gobject_) : 0)
+{}
+
+Item::Item(PangoItem* castitem, bool make_a_copy)
+{
+  // For BoxedType wrappers, make_a_copy is true by default.  The static
+  // BoxedType wrappers must always take a copy, thus make_a_copy = true
+  // ensures identical behaviour if the default argument is used.
+
+  if(make_a_copy)
+  {
+    if(castitem)
+      gobject_ = pango_item_copy(castitem);
+    else
+      gobject_ = 0;
+  }
+  else
+  {
+    // It was given to us by a function which has already made a copy for us to keep.
+    gobject_ = castitem;
+  }
+}
+
+Item& Item::operator=(const Item& src)
+{
+  PangoItem *const new_gobject = (src.gobject_) ? pango_item_copy(src.gobject_) : 0;
+
+  if(gobject_)
+    pango_item_free(gobject_);
+  gobject_ = new_gobject;
+
+  return *this;
+}
+
+Item::~Item()
+{
+  if(gobject_)
+    pango_item_free(gobject_);
+}
+
+PangoItem* Item::gobj_copy() const
+{
+  return pango_item_copy(gobject_);
+}
+
+Analysis Item::get_analysis() const
+{
+  return Analysis(&gobj()->analysis);
+}
+
+Glib::ustring Item::get_segment(const Glib::ustring& text) const
+{
+  const char *const start = text.data() + gobj()->offset;
+  return Glib::ustring(start, start + gobj()->length);
+}
+
+Pango::GlyphString Item::shape(const Glib::ustring& text) const
+{
+  return GlyphString(text, get_analysis());
+}
+
+} /* namespace Pango */
+
+
+namespace Glib
+{
+
+Pango::Analysis& wrap(PangoAnalysis* object)
+{
+  return *reinterpret_cast<Pango::Analysis*>(object);
+}
+
+const Pango::Analysis& wrap(const PangoAnalysis* object)
+{
+  return *reinterpret_cast<const Pango::Analysis*>(object);
+}
+
+Pango::Item wrap(PangoItem* object, bool take_copy)
+{
+  return Pango::Item(object, take_copy);
+}
+
+} /* namespace Glib */
+
+
+namespace
+{
+} // anonymous namespace
+
+
+namespace Pango
+{
+
+
+Glib::RefPtr<Font> Analysis::get_font()
+{
+  Glib::RefPtr<Font> ref_ptr(Glib::wrap(gobj()->font));
+
+  if(ref_ptr)
+    ref_ptr->reference();
+
+  return ref_ptr;
+}
+
+Glib::RefPtr<const Font> Analysis::get_font() const
+{
+  Glib::RefPtr<const Font> ref_ptr(Glib::wrap(gobj()->font));
+
+  if(ref_ptr)
+    ref_ptr->reference();
+
+  return ref_ptr;
+}
+
+guint8 Analysis::get_level() const
+{
+  return gobj()->level;
+}
+
+Language Analysis::get_language() const
+{
+  return Language(gobj()->language);
+}
+
+
+} // namespace Pango
+
+
+namespace Pango
+{
+
+
+Item Item::split(int split_index, int split_offset)
+{
+  return Item((pango_item_split(gobj(), split_index, split_offset)));
+}
+
+int Item::get_offset() const
+{
+  return gobj()->offset;
+}
+
+int Item::get_length() const
+{
+  return gobj()->length;
+}
+
+int Item::get_num_chars() const
+{
+  return gobj()->num_chars;
+}
+
+
+} // namespace Pango
+
+
diff --git a/libs/gtkmm2/pango/pangomm/item.h b/libs/gtkmm2/pango/pangomm/item.h
new file mode 100644
index 0000000000..3e58b9a069
--- /dev/null
+++ b/libs/gtkmm2/pango/pangomm/item.h
@@ -0,0 +1,225 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _PANGOMM_ITEM_H
+#define _PANGOMM_ITEM_H
+
+#include <glibmm.h>
+
+/* Copyright (C) 2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+ 
+#include <pangomm/attributes.h>
+#include <pangomm/language.h>
+#include <pango/pango-item.h>
+
+
+namespace Pango
+{
+
+class Font;
+class GlyphString;
+
+/** A Pango::Analysis stores information about the properties of a segment of text.
+ * Pango::Analysis is used as an output type only so there is no public default constructor.
+ * You can retrieve an object of this type from an object of type Pango::Item by
+ * calling Pango::Item::get_analysis(). Objects of this class can be used for some
+ * calculations in Pango::GlyphString.
+ */
+class Analysis
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Analysis CppObjectType;
+  typedef PangoAnalysis BaseObjectType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+private:
+
+
+protected:
+  // This class is only used as an output type.
+  Analysis();
+
+public:
+  explicit Analysis(const PangoAnalysis* src);
+
+public:
+//  _MEMBER_GET_PTR(engine_shape, shape_engine, EngineShape*, PangoEngineShape*) //We don't wrap the Engine* stuff.
+//  _MEMBER_GET_PTR(engine_lang, lang_engine, EngineLang*, PangoEngineLang*)
+
+  /** Gets the font used to render this segment.
+   * @return The font used to render this segment.
+   */
+  Glib::RefPtr<Font> get_font();
+  Glib::RefPtr<const Font> get_font() const;
+
+  /** Gets the bidrectional level for this segment.
+   * @return The bidirectional level for this segment.
+   */
+  guint8 get_level() const;
+
+  /** Gets the language of this segment.
+   * @return The language of this segment.
+   */
+  Language get_language() const;
+
+  /** Gets a list of non-font attributes for this segment.
+   * @return A list of non-font attributes for this segment.
+   */
+  SListHandle_Attribute get_extra_attrs() const;
+
+  /// Provides access to the underlying C GObject.
+  PangoAnalysis*       gobj()       { return &gobject_; }
+  /// Provides access to the underlying C GObject.
+  const PangoAnalysis* gobj() const { return &gobject_; }
+
+protected:
+  PangoAnalysis gobject_;
+
+
+};
+
+
+/** A Pango::Item stores information about a segment of text.
+ * Pango::Item is used as an output type only so there is no public default constructor.
+ * You retrieve objects of this type by calling Pango::Context::itemize() with some text.
+ * The actual rendering of the segment of text that corresponds to a particular Pango::Item
+ * (or some sub-string) into a string of glyphs is done with shape().
+ * The segment of text that corresponds to a Pango::Item can be computed from the
+ * text passed into Pango::Context::itemize() with get_segment(). Together with
+ * the Pango::Analysis data member that can be accessed with get_analysis()
+ * it is needed for further calculations in Pango::GlyphString.
+ */
+class Item
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Item CppObjectType;
+  typedef PangoItem BaseObjectType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+private:
+ //There is the whole set of functions for _CLASS_BOXEDTYPE but unfortunately PangoItem is not registered as a boxed type and lacks pango_item_get_type...
+  
+
+public:
+  // There is no default constructor. This class is only used as an output type.
+  explicit Item(PangoItem* castitem, bool make_a_copy = true);
+
+  Item(const Item& src);
+  Item& operator=(const Item& src);
+
+  ~Item();
+
+  /// Provides access to the underlying C GObject. The caller is responsible for freeing it. Use when directly setting fields in structs.
+  PangoItem* gobj_copy() const;
+
+public:
+  
+  /** Modifies @a orig  to cover only the text after @a split_index , and
+   * returns a new item that covers the text before @a split_index  that
+   * used to be in @a orig . You can think of @a split_index  as the length of
+   * the returned item. @a split_index  may not be 0, and it may not be
+   * greater than or equal to the length of @a orig  (that is, there must
+   * be at least one byte assigned to each item, you can't create a
+   * zero-length item). @a split_offset  is the length of the first item in
+   * chars, and must be provided because the text used to generate the
+   * item isn't available, so pango_item_split() can't count the char
+   * length of the split items itself.
+   * @param split_index Byte index of position to split item, relative to the start of the item.
+   * @param split_offset Number of chars between start of @a orig  and @a split_index .
+   * @return New item representing text before @a split_index .
+   */
+  Item split(int split_index, int split_offset);
+
+  /** Gets the offset of the segment from the beginning of the string in bytes.
+   * @return The offset of the segment from the beginning of the string in bytes.
+   */
+  int get_offset() const;
+
+  /** Gets the length of the segment in bytes.
+   * @return The length of the segment in bytes.
+   */
+  int get_length() const;
+
+  /** Gets the length of the segment in characters.
+   * @return The length of the semgment in characters.
+   */
+  int get_num_chars() const;
+
+  /** Gets the properties of the segment.
+   * @return The properties of the segment.
+   */
+  Analysis get_analysis() const;
+
+  /** Computes the segment of text that is represented by the item.
+   * @param text The text that has been passed into Pango::Context::itemize().
+   * @return The sub-string of @a text that corresponds to the item.
+   */
+  Glib::ustring get_segment(const Glib::ustring& text) const;
+
+  /** Convert a segment of text into a string of glyphs.
+   * @param text The text to process. This must either be the whole segment of text that corresponds to the item as returned by get_segment() or a sub-string of that segment. You need to pass the same text to the member functions of Pango::GlyphString for further calculations.
+   * @return A Pango::GlyphString object that can be measured or drawn.
+   */
+  GlyphString shape(const Glib::ustring& text) const;
+
+  /// Provides access to the underlying C GObject.  
+  PangoItem*       gobj()       { return gobject_; }
+  /// Provides access to the underlying C GObject.
+  const PangoItem* gobj() const { return gobject_; }
+
+protected:
+  PangoItem* gobject_;
+
+
+};
+
+struct ItemTraits
+{
+  typedef Pango::Item       CppType;
+  typedef const PangoItem*  CType;
+  typedef PangoItem*        CTypeNonConst;
+
+  static CType   to_c_type      (const CppType& obj) { return obj.gobj(); }
+  static CType   to_c_type      (CType ptr) { return ptr; }
+  static CppType to_cpp_type    (CType ptr) { return CppType(const_cast<CTypeNonConst>(ptr), true); }
+  static void    release_c_type (CType ptr) { pango_item_free(const_cast<CTypeNonConst>(ptr)); }
+};
+
+typedef Glib::ListHandle<Item, ItemTraits> ListHandle_Item;
+
+} // namespace Pango
+
+
+namespace Glib
+{
+
+/** @relates Pango::Analysis */
+Pango::Analysis& wrap(PangoAnalysis* object);
+
+/** @relates Pango::Analysis */
+const Pango::Analysis& wrap(const PangoAnalysis* object);
+
+/** @relates Pango::Item */
+Pango::Item wrap(PangoItem* object, bool take_copy=true);
+
+} // namespace Glib
+
+
+#endif /* _PANGOMM_ITEM_H */
+
diff --git a/libs/gtkmm2/pango/pangomm/language.cc b/libs/gtkmm2/pango/pangomm/language.cc
new file mode 100644
index 0000000000..db2fd1fde4
--- /dev/null
+++ b/libs/gtkmm2/pango/pangomm/language.cc
@@ -0,0 +1,158 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <pangomm/language.h>
+#include <pangomm/private/language_p.h>
+
+/* Copyright (C) 2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <pango/pango-enum-types.h>
+#include <pango/pango-script.h>
+
+namespace Pango
+{
+
+/* PangoLanguage is just another example of inconsistent coding in atk/pango/gtk:
+ * on the one hand it is defined and registered as a boxed type, on the other
+ * hand it is always a pointer to some statically allocated string and thus
+ * neither allocated by itself, nor copied by value, nor freed. Similar dummy
+ * functions as below are defined in pango/pango-util.c but they are not exported.
+ * Compare with pango/pango-util.c for reference. */
+ //(I wonder who wrote this - it wasn't me. murrayc)
+ 
+inline PangoLanguage* _pango_language_new()
+{
+  return 0;
+}
+
+inline PangoLanguage* _pango_language_copy(const PangoLanguage* language)
+{
+  return const_cast<PangoLanguage*>(language);
+}
+
+inline void _pango_language_free(PangoLanguage*)
+{
+  return;
+}
+
+Language::Language()
+:
+  gobject_(0)
+{}
+
+Language::Language(const Glib::ustring& language)
+:
+  gobject_(pango_language_from_string(language.c_str()))
+{}
+
+Glib::ustring Language::get_string() const
+{
+  if (gobject_)
+    return pango_language_to_string(const_cast<PangoLanguage*>(gobj()));
+  else
+    return Glib::ustring();
+}
+
+} /* namespace Pango */
+
+
+namespace
+{
+} // anonymous namespace
+
+// static
+GType Glib::Value<Pango::Script>::value_type()
+{
+  return pango_script_get_type();
+}
+
+
+namespace Glib
+{
+
+Pango::Language wrap(PangoLanguage* object, bool take_copy)
+{
+  return Pango::Language(object, take_copy);
+}
+
+} // namespace Glib
+
+
+namespace Pango
+{
+
+
+// static
+GType Language::get_type()
+{
+  return pango_language_get_type();
+}
+
+
+Language::Language(const Language& other)
+:
+  gobject_ ((other.gobject_) ? _pango_language_copy(other.gobject_) : 0)
+{}
+
+Language::Language(PangoLanguage* gobject, bool make_a_copy)
+:
+  // For BoxedType wrappers, make_a_copy is true by default.  The static
+  // BoxedType wrappers must always take a copy, thus make_a_copy = true
+  // ensures identical behaviour if the default argument is used.
+  gobject_ ((make_a_copy && gobject) ? _pango_language_copy(gobject) : gobject)
+{}
+
+Language& Language::operator=(const Language& other)
+{
+  Language temp (other);
+  swap(temp);
+  return *this;
+}
+
+Language::~Language()
+{
+  if(gobject_)
+    _pango_language_free(gobject_);
+}
+
+void Language::swap(Language& other)
+{
+  PangoLanguage *const temp = gobject_;
+  gobject_ = other.gobject_;
+  other.gobject_ = temp;
+}
+
+PangoLanguage* Language::gobj_copy() const
+{
+  return _pango_language_copy(gobject_);
+}
+
+
+bool Language::matches(const Glib::ustring & range_list) const
+{
+  return pango_language_matches(const_cast<PangoLanguage*>(gobj()), range_list.c_str());
+}
+
+bool Language::includes_script(Script script) const
+{
+  return pango_language_includes_script(const_cast<PangoLanguage*>(gobj()), ((PangoScript)(script)));
+}
+
+
+} // namespace Pango
+
+
diff --git a/libs/gtkmm2/pango/pangomm/language.h b/libs/gtkmm2/pango/pangomm/language.h
new file mode 100644
index 0000000000..f4f762eb39
--- /dev/null
+++ b/libs/gtkmm2/pango/pangomm/language.h
@@ -0,0 +1,245 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _PANGOMM_LANGUAGE_H
+#define _PANGOMM_LANGUAGE_H
+
+#include <glibmm.h>
+
+/* Copyright (C) 2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <pango/pango-attributes.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+extern "C" { typedef struct _PangoLanguage PangoLanguage; }
+#endif
+
+namespace Pango
+{
+
+/** @addtogroup pangommEnums Enums and Flags */
+
+/**
+ * @ingroup pangommEnums
+ */
+enum Script
+{
+  SCRIPT_INVALID_CODE = -1,
+  SCRIPT_COMMON,
+  SCRIPT_INHERITED,
+  SCRIPT_ARABIC,
+  SCRIPT_ARMENIAN,
+  SCRIPT_BENGALI,
+  SCRIPT_BOPOMOFO,
+  SCRIPT_CHEROKEE,
+  SCRIPT_COPTIC,
+  SCRIPT_CYRILLIC,
+  SCRIPT_DESERET,
+  SCRIPT_DEVANAGARI,
+  SCRIPT_ETHIOPIC,
+  SCRIPT_GEORGIAN,
+  SCRIPT_GOTHIC,
+  SCRIPT_GREEK,
+  SCRIPT_GUJARATI,
+  SCRIPT_GURMUKHI,
+  SCRIPT_HAN,
+  SCRIPT_HANGUL,
+  SCRIPT_HEBREW,
+  SCRIPT_HIRAGANA,
+  SCRIPT_KANNADA,
+  SCRIPT_KATAKANA,
+  SCRIPT_KHMER,
+  SCRIPT_LAO,
+  SCRIPT_LATIN,
+  SCRIPT_MALAYALAM,
+  SCRIPT_MONGOLIAN,
+  SCRIPT_MYANMAR,
+  SCRIPT_OGHAM,
+  SCRIPT_OLD_ITALIC,
+  SCRIPT_ORIYA,
+  SCRIPT_RUNIC,
+  SCRIPT_SINHALA,
+  SCRIPT_SYRIAC,
+  SCRIPT_TAMIL,
+  SCRIPT_TELUGU,
+  SCRIPT_THAANA,
+  SCRIPT_THAI,
+  SCRIPT_TIBETAN,
+  SCRIPT_CANADIAN_ABORIGINAL,
+  SCRIPT_YI,
+  SCRIPT_TAGALOG,
+  SCRIPT_HANUNOO,
+  SCRIPT_BUHID,
+  SCRIPT_TAGBANWA,
+  SCRIPT_BRAILLE,
+  SCRIPT_CYPRIOT,
+  SCRIPT_LIMBU,
+  SCRIPT_OSMANYA,
+  SCRIPT_SHAVIAN,
+  SCRIPT_LINEAR_B,
+  SCRIPT_TAI_LE,
+  SCRIPT_UGARITIC
+};
+
+} // namespace Pango
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Pango::Script> : public Glib::Value_Enum<Pango::Script>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Pango
+{
+
+
+/** A Pango::Language is used to represent a language.
+ */
+class Language
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Language CppObjectType;
+  typedef PangoLanguage BaseObjectType;
+
+  static GType get_type() G_GNUC_CONST;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+  explicit Language(PangoLanguage* gobject, bool make_a_copy = true);
+
+  Language(const Language& other);
+  Language& operator=(const Language& other);
+
+  ~Language();
+
+  void swap(Language& other);
+
+  ///Provides access to the underlying C instance.
+  PangoLanguage*       gobj()       { return gobject_; }
+
+  ///Provides access to the underlying C instance.
+  const PangoLanguage* gobj() const { return gobject_; }
+
+  ///Provides access to the underlying C instance. The caller is responsible for freeing it. Use when directly setting fields in structs.
+  PangoLanguage* gobj_copy() const;
+
+protected:
+  PangoLanguage* gobject_;
+
+private:
+
+   //This function is a bad hack for internal use by renderers and Pango (from pango/pango-utils.c)
+   //This is defined as a macro
+  
+
+public:
+  /** Constructs an empty language tag.
+   */
+  Language();
+
+  /** Constructs a Pango::Language object from a RFC-3066 format language tag.
+   * This function first canonicalizes the string by converting it to lowercase,
+   * mapping '_' to '-', and stripping all characters other than letters and '-'.
+   */
+  Language(const Glib::ustring& language);
+
+  /** Gets a RFC-3066 format string representing the given language tag.
+   * @return A string representing the language tag. An empty string is returned if the language tag is empty.
+   */
+  Glib::ustring get_string() const;
+
+  
+  /** Checks if a language tag matches one of the elements in a list of
+   * language ranges. A language tag is considered to match a range
+   * in the list if the range is '*', the range is exactly the tag,
+   * or the range is a prefix of the tag, and the character after the
+   * tag is '-'.
+   * @param range_list A list of language ranges, separated by ';' characters.
+   * each element must either be '*', or a RFC 3066 language range
+   * canonicalized as by pango_language_from_string().
+   * @return <tt>true</tt> if a match was found.
+   */
+  bool matches(const Glib::ustring & range_list) const;
+  
+  /** Determines if @a script  is one of the scripts used to
+   * write @a language . The returned value is conservative;
+   * if nothing is known about the language tag @a language ,
+   * <tt>true</tt> will be returned, since, as far as Pango knows,
+   *  @a script  might be used to write @a language .
+   * 
+   * This routine is used in Pango's itemization process when
+   * determining if a supplied language tag is relevant to
+   * a particular section of text. It probably is not useful for
+   * applications in most circumstances.
+   * @param script A Pango::Script.
+   * @return <tt>true</tt> if @a script  is one of the scripts used
+   * to write @a language , or if nothing is known about @a language .
+   * 
+   * Since: 1.4.
+   */
+  bool includes_script(Script script) const;
+
+
+};
+
+} /* namespace Pango */
+
+
+namespace Pango
+{
+
+/** @relates Pango::Language
+ * @param lhs The left-hand side
+ * @param rhs The right-hand side
+ */
+inline void swap(Language& lhs, Language& rhs)
+  { lhs.swap(rhs); }
+
+} // namespace Pango
+
+namespace Glib
+{
+
+/** @relates Pango::Language
+ * @param object The C instance
+ * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+ * @result A C++ instance that wraps this C instance.
+ */
+Pango::Language wrap(PangoLanguage* object, bool take_copy = false);
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+template <>
+class Value<Pango::Language> : public Glib::Value_Boxed<Pango::Language>
+{};
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+} // namespace Glib
+
+#endif /* _PANGOMM_LANGUAGE_H */
+
diff --git a/libs/gtkmm2/pango/pangomm/layout.cc b/libs/gtkmm2/pango/pangomm/layout.cc
new file mode 100644
index 0000000000..96d45e2037
--- /dev/null
+++ b/libs/gtkmm2/pango/pangomm/layout.cc
@@ -0,0 +1,451 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <pangomm/layout.h>
+#include <pangomm/private/layout_p.h>
+
+#include <pango/pango-enum-types.h>
+// -*- c++ -*-
+/* $Id$ */
+
+/* 
+ *
+ * Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+namespace Pango
+{
+
+Layout::Layout(const Glib::RefPtr<Context>& context)
+:
+  Glib::Object(G_OBJECT(pango_layout_new(context->gobj())))
+{}
+
+void Layout::set_text(const Glib::ustring& text)
+{
+  pango_layout_set_text(gobj(), text.c_str(), text.bytes());
+}
+
+void Layout::set_markup(const Glib::ustring& markup)
+{
+  return pango_layout_set_markup(gobj(), markup.c_str(), markup.bytes());
+}
+
+void Layout::set_markup(const Glib::ustring& markup, gunichar accel_marker, gunichar& accel_char)
+{
+  return pango_layout_set_markup_with_accel(gobj(), markup.c_str(), markup.bytes(), accel_marker, &accel_char);
+}
+
+Glib::ArrayHandle<PangoLogAttr> Layout::get_log_attrs() const
+{
+  //Get array:
+  PangoLogAttr* pAttrs = 0;
+  int n_attrs = 0;
+  pango_layout_get_log_attrs(const_cast<PangoLayout*>(gobj()), &pAttrs, &n_attrs);
+
+  return Glib::ArrayHandle<PangoLogAttr>(pAttrs, n_attrs, Glib::OWNERSHIP_SHALLOW);
+}
+
+Rectangle Layout::index_to_pos(int index) const
+{
+  Rectangle pos;
+  pango_layout_index_to_pos(const_cast<PangoLayout*>(gobj()), index, pos.gobj());
+  return pos;
+}
+
+Rectangle Layout::get_cursor_strong_pos(int index) const
+{
+  Rectangle strong_pos;
+  pango_layout_get_cursor_pos(const_cast<PangoLayout*>(gobj()), index, strong_pos.gobj(), 0);
+  return strong_pos;
+}
+
+Rectangle Layout::get_cursor_weak_pos(int index) const
+{
+  Rectangle weak_pos;
+  pango_layout_get_cursor_pos(const_cast<PangoLayout*>(gobj()), index, 0, weak_pos.gobj());
+  return weak_pos;
+}
+
+Rectangle Layout::get_ink_extents() const
+{
+  Rectangle ink_extents;
+  pango_layout_get_extents(const_cast<PangoLayout*>(gobj()), ink_extents.gobj(), 0);
+  return ink_extents;
+}
+
+Rectangle Layout::get_logical_extents() const
+{
+  Rectangle logical_extents;
+  pango_layout_get_extents(const_cast<PangoLayout*>(gobj()), 0, logical_extents.gobj());
+  return logical_extents;
+}
+
+Rectangle Layout::get_pixel_ink_extents() const
+{
+  Rectangle ink_extents;
+  pango_layout_get_pixel_extents(const_cast<PangoLayout*>(gobj()), ink_extents.gobj(), 0);
+  return ink_extents;
+}
+
+Rectangle Layout::get_pixel_logical_extents() const
+{
+  Rectangle logical_extents;
+  pango_layout_get_pixel_extents(const_cast<PangoLayout*>(gobj()), 0, logical_extents.gobj());
+  return logical_extents;
+}
+
+void Layout::get_iter(LayoutIter& iter)
+{
+  iter.assign_gobj(pango_layout_get_iter(gobj()));
+}
+
+void Layout::unset_font_description()
+{
+  pango_layout_set_font_description(gobj(), 0);
+}
+
+} /* namespace Pango */
+
+
+namespace
+{
+} // anonymous namespace
+
+// static
+GType Glib::Value<Pango::Alignment>::value_type()
+{
+  return pango_alignment_get_type();
+}
+
+// static
+GType Glib::Value<Pango::WrapMode>::value_type()
+{
+  return pango_wrap_mode_get_type();
+}
+
+// static
+GType Glib::Value<Pango::EllipsizeMode>::value_type()
+{
+  return pango_ellipsize_mode_get_type();
+}
+
+
+namespace Glib
+{
+
+Glib::RefPtr<Pango::Layout> wrap(PangoLayout* object, bool take_copy)
+{
+  return Glib::RefPtr<Pango::Layout>( dynamic_cast<Pango::Layout*> (Glib::wrap_auto ((GObject*)(object), take_copy)) );
+  //We use dynamic_cast<> in case of multiple inheritance.
+}
+
+} /* namespace Glib */
+
+
+namespace Pango
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& Layout_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &Layout_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(pango_layout_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void Layout_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+}
+
+
+Glib::ObjectBase* Layout_Class::wrap_new(GObject* object)
+{
+  return new Layout((PangoLayout*)object);
+}
+
+
+/* The implementation: */
+
+PangoLayout* Layout::gobj_copy()
+{
+  reference();
+  return gobj();
+}
+
+Layout::Layout(const Glib::ConstructParams& construct_params)
+:
+  Glib::Object(construct_params)
+{}
+
+Layout::Layout(PangoLayout* castitem)
+:
+  Glib::Object((GObject*)(castitem))
+{}
+
+Layout::~Layout()
+{}
+
+
+Layout::CppClassType Layout::layout_class_; // initialize static member
+
+GType Layout::get_type()
+{
+  return layout_class_.init().get_type();
+}
+
+GType Layout::get_base_type()
+{
+  return pango_layout_get_type();
+}
+
+
+Glib::RefPtr<Layout> Layout::create(const Glib::RefPtr<Context>& context)
+{
+  return Glib::RefPtr<Layout>( new Layout(context) );
+}
+Glib::RefPtr<Layout> Layout::copy()
+{
+  return Glib::wrap(pango_layout_copy(gobj()));
+}
+
+Glib::RefPtr<Context> Layout::get_context() const
+{
+
+  Glib::RefPtr<Context> retvalue = Glib::wrap(pango_layout_get_context(const_cast<PangoLayout*>(gobj())));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+void Layout::set_attributes(AttrList& attrs)
+{
+  pango_layout_set_attributes(gobj(), (attrs).gobj());
+}
+
+AttrList Layout::get_attributes() const
+{
+  return AttrList((pango_layout_get_attributes(const_cast<PangoLayout*>(gobj()))));
+}
+
+Glib::ustring Layout::get_text() const
+{
+  return Glib::convert_const_gchar_ptr_to_ustring(pango_layout_get_text(const_cast<PangoLayout*>(gobj())));
+}
+
+void Layout::set_font_description(const FontDescription& desc)
+{
+  pango_layout_set_font_description(gobj(), (desc).gobj());
+}
+
+void Layout::set_width(int width)
+{
+  pango_layout_set_width(gobj(), width);
+}
+
+int Layout::get_width() const
+{
+  return pango_layout_get_width(const_cast<PangoLayout*>(gobj()));
+}
+
+void Layout::set_wrap(WrapMode wrap)
+{
+  pango_layout_set_wrap(gobj(), ((PangoWrapMode)(wrap)));
+}
+
+WrapMode Layout::get_wrap() const
+{
+  return ((WrapMode)(pango_layout_get_wrap(const_cast<PangoLayout*>(gobj()))));
+}
+
+void Layout::set_indent(int indent)
+{
+  pango_layout_set_indent(gobj(), indent);
+}
+
+int Layout::get_indent() const
+{
+  return pango_layout_get_indent(const_cast<PangoLayout*>(gobj()));
+}
+
+void Layout::set_spacing(int spacing)
+{
+  pango_layout_set_spacing(gobj(), spacing);
+}
+
+int Layout::get_spacing() const
+{
+  return pango_layout_get_spacing(const_cast<PangoLayout*>(gobj()));
+}
+
+void Layout::set_justify(bool justify)
+{
+  pango_layout_set_justify(gobj(), static_cast<int>(justify));
+}
+
+bool Layout::get_justify() const
+{
+  return pango_layout_get_justify(const_cast<PangoLayout*>(gobj()));
+}
+
+bool Layout::get_auto_dir() const
+{
+  return pango_layout_get_auto_dir(const_cast<PangoLayout*>(gobj()));
+}
+
+void Layout::set_auto_dir(bool auto_dir)
+{
+  pango_layout_set_auto_dir(gobj(), static_cast<int>(auto_dir));
+}
+
+void Layout::set_alignment(Alignment alignment)
+{
+  pango_layout_set_alignment(gobj(), ((PangoAlignment)(alignment)));
+}
+
+Alignment Layout::get_alignment() const
+{
+  return ((Alignment)(pango_layout_get_alignment(const_cast<PangoLayout*>(gobj()))));
+}
+
+void Layout::set_tabs(TabArray& tabs)
+{
+  pango_layout_set_tabs(gobj(), (tabs).gobj());
+}
+
+TabArray Layout::get_tabs() const
+{
+  return TabArray((pango_layout_get_tabs(const_cast<PangoLayout*>(gobj()))));
+}
+
+void Layout::set_single_paragraph_mode(bool setting)
+{
+  pango_layout_set_single_paragraph_mode(gobj(), static_cast<int>(setting));
+}
+
+bool Layout::get_single_paragraph_mode() const
+{
+  return pango_layout_get_single_paragraph_mode(const_cast<PangoLayout*>(gobj()));
+}
+
+void Layout::set_ellipsize(EllipsizeMode ellipsize)
+{
+  pango_layout_set_ellipsize(gobj(), ((PangoEllipsizeMode)(ellipsize)));
+}
+
+EllipsizeMode Layout::get_ellipsize() const
+{
+  return ((EllipsizeMode)(pango_layout_get_ellipsize(const_cast<PangoLayout*>(gobj()))));
+}
+
+void Layout::context_changed()
+{
+  pango_layout_context_changed(gobj());
+}
+
+void Layout::get_cursor_pos(int index, Rectangle& strong_pos, Rectangle& weak_pos) const
+{
+  pango_layout_get_cursor_pos(const_cast<PangoLayout*>(gobj()), index, (strong_pos).gobj(), (weak_pos).gobj());
+}
+
+void Layout::move_cursor_visually(bool strong, int old_index, int old_trailing, int direction, int& new_index, int& new_trailing) const
+{
+  pango_layout_move_cursor_visually(const_cast<PangoLayout*>(gobj()), static_cast<int>(strong), old_index, old_trailing, direction, &new_index, &new_trailing);
+}
+
+bool Layout::xy_to_index(int x, int y, int& index, int& trailing) const
+{
+  return pango_layout_xy_to_index(const_cast<PangoLayout*>(gobj()), x, y, &index, &trailing);
+}
+
+void Layout::get_extents(Rectangle& ink_rect, Rectangle& logical_rect) const
+{
+  pango_layout_get_extents(const_cast<PangoLayout*>(gobj()), (ink_rect).gobj(), (logical_rect).gobj());
+}
+
+void Layout::get_pixel_extents(Rectangle& ink_rect, Rectangle& logical_rect) const
+{
+  pango_layout_get_pixel_extents(const_cast<PangoLayout*>(gobj()), (ink_rect).gobj(), (logical_rect).gobj());
+}
+
+void Layout::get_size(int& width, int& height) const
+{
+  pango_layout_get_size(const_cast<PangoLayout*>(gobj()), &width, &height);
+}
+
+void Layout::get_pixel_size(int& width, int& height) const
+{
+  pango_layout_get_pixel_size(const_cast<PangoLayout*>(gobj()), &width, &height);
+}
+
+int Layout::get_line_count() const
+{
+  return pango_layout_get_line_count(const_cast<PangoLayout*>(gobj()));
+}
+
+Glib::RefPtr<LayoutLine> Layout::get_line(int line)
+{
+
+  Glib::RefPtr<LayoutLine> retvalue = Glib::wrap(pango_layout_get_line(gobj(), line));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::RefPtr<const LayoutLine> Layout::get_line(int line) const
+{
+
+  Glib::RefPtr<const LayoutLine> retvalue = Glib::wrap(pango_layout_get_line(const_cast<PangoLayout*>(gobj()), line));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+SListHandle_LayoutLine Layout::get_lines()
+{
+  return SListHandle_LayoutLine(pango_layout_get_lines(gobj()), Glib::OWNERSHIP_SHALLOW);
+}
+
+SListHandle_ConstLayoutLine Layout::get_lines() const
+{
+  return SListHandle_ConstLayoutLine(pango_layout_get_lines(const_cast<PangoLayout*>(gobj())), Glib::OWNERSHIP_SHALLOW);
+}
+
+
+} // namespace Pango
+
+
diff --git a/libs/gtkmm2/pango/pangomm/layout.h b/libs/gtkmm2/pango/pangomm/layout.h
new file mode 100644
index 0000000000..dceee8c358
--- /dev/null
+++ b/libs/gtkmm2/pango/pangomm/layout.h
@@ -0,0 +1,687 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _PANGOMM_LAYOUT_H
+#define _PANGOMM_LAYOUT_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* layout.h
+ *
+ * Copyright(C) 1998-1999 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+
+#include <glibmm/object.h>
+#include <glibmm/slisthandle.h>
+#include <pangomm/font.h>
+#include <pangomm/fontdescription.h>
+#include <pangomm/context.h>
+#include <pangomm/attrlist.h>
+#include <pangomm/tabarray.h>
+#include <pangomm/layoutline.h>
+#include <pangomm/layoutiter.h>
+#include <pango/pango-layout.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _PangoLayout PangoLayout;
+typedef struct _PangoLayoutClass PangoLayoutClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Pango
+{ class Layout_Class; } // namespace Pango
+namespace Pango
+{
+
+
+/** @addtogroup pangommEnums Enums and Flags */
+
+/**
+ * @ingroup pangommEnums
+ */
+enum Alignment
+{
+  ALIGN_LEFT,
+  ALIGN_CENTER,
+  ALIGN_RIGHT
+};
+
+} // namespace Pango
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Pango::Alignment> : public Glib::Value_Enum<Pango::Alignment>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Pango
+{
+
+/**
+ * @ingroup pangommEnums
+ */
+enum WrapMode
+{
+  WRAP_WORD,
+  WRAP_CHAR,
+  WRAP_WORD_CHAR
+};
+
+} // namespace Pango
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Pango::WrapMode> : public Glib::Value_Enum<Pango::WrapMode>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Pango
+{
+
+/**
+ * @ingroup pangommEnums
+ */
+enum EllipsizeMode
+{
+  ELLIPSIZE_NONE,
+  ELLIPSIZE_START,
+  ELLIPSIZE_MIDDLE,
+  ELLIPSIZE_END
+};
+
+} // namespace Pango
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Pango::EllipsizeMode> : public Glib::Value_Enum<Pango::EllipsizeMode>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Pango
+{
+
+
+/** A Pango::Layout represents an entire paragraph of text.
+ * It is initialized with a Pango::Context, UTF-8 string and set of attributes for that string.
+ * Once that is done, the set of formatted lines can be extracted from the object,
+ * the layout can be rendered, and conversion between logical character positions
+ * within the layout's text, and the physical position of the resulting glyphs can be made.
+ */
+
+class Layout : public Glib::Object
+{
+  
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+public:
+  typedef Layout CppObjectType;
+  typedef Layout_Class CppClassType;
+  typedef PangoLayout BaseObjectType;
+  typedef PangoLayoutClass BaseClassType;
+
+private:  friend class Layout_Class;
+  static CppClassType layout_class_;
+
+private:
+  // noncopyable
+  Layout(const Layout&);
+  Layout& operator=(const Layout&);
+
+protected:
+  explicit Layout(const Glib::ConstructParams& construct_params);
+  explicit Layout(PangoLayout* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+  virtual ~Layout();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GObject.
+  PangoLayout*       gobj()       { return reinterpret_cast<PangoLayout*>(gobject_); }
+
+  ///Provides access to the underlying C GObject.
+  const PangoLayout* gobj() const { return reinterpret_cast<PangoLayout*>(gobject_); }
+
+  ///Provides access to the underlying C instance. The caller is responsible for unrefing it. Use when directly setting fields in structs.
+  PangoLayout* gobj_copy();
+
+private:
+
+  
+protected:
+  explicit Layout(const Glib::RefPtr<Context>& context);
+
+public:
+  
+  static Glib::RefPtr<Layout> create(const Glib::RefPtr<Context>& context);
+
+
+  /** Does a deep copy-by-value of the @a src  layout. The attribute list,
+   * tab array, and text from the original layout are all copied by
+   * value.
+   * @return A new Pango::Layout identical to @a src .
+   */
+  Glib::RefPtr<Layout> copy();
+  
+  /** Retrieves the Pango::Context used for this layout.
+   * @return The Pango::Context for the layout. This does not
+   * have an additional refcount added, so if you want to keep
+   * a copy of this around, you must reference it yourself.
+   */
+  Glib::RefPtr<Context> get_context() const;
+  
+  /** Sets the text attributes for a layout object.
+   * @param attrs A Pango::AttrList.
+   */
+  void set_attributes(AttrList& attrs);
+  
+  /** Gets the attribute list for the layout, if any.
+   * @return A Pango::AttrList.
+   */
+  AttrList get_attributes() const;
+
+  /** Set the text of the layout.
+   * @param text The text for the layout.
+   */
+  void set_text(const Glib::ustring& text);
+
+  
+  /** Gets the text in the layout. The returned text should not
+   * be freed or modified.
+   * @return The text in the @a layout .
+   */
+  Glib::ustring get_text() const;
+
+  /** Sets the layout text and attribute list from marked-up text (see markup format).
+   * Replaces the current text and attribute list.
+   * @param markup Some marked-up text.
+   */
+  void set_markup(const Glib::ustring& markup);
+
+  /** Sets the layout text and attribute list from marked-up text (see markup format).
+   * Replaces the current text and attribute list.
+   *
+   * If @a accel_marker is nonzero, the given character will mark the character following
+   * it as an accelerator. For example, the accel marker might be an ampersand or
+   * underscore. All characters marked as an accelerator will receive a
+   * Pango::UNDERLINE_LOW attribute, and the first character so marked will be returned
+   * in @a accel_char. Two @a accel_marker characters following each other produce a
+   * single literal @a accel_marker character.
+   * @param markup Some marked-up text.
+   * @param accel_marker Marker for accelerators in the text.
+   * @param accel_char Return location for any located accelerators.
+   */
+  void set_markup(const Glib::ustring& markup, gunichar accel_marker, gunichar& accel_char);
+
+  
+  /** Set the default font description for the layout. If no font
+   * description is set on the layout, the font description from
+   * the layout's context is used.
+   * @param desc The new pango font description.
+   */
+  void set_font_description(const FontDescription& desc);
+  void unset_font_description();
+
+  
+  /** Sets the width to which the lines of the Pango::Layout should be wrapped.
+   * @param width The desired width, or -1 to indicate that no wrapping should be
+   * performed.
+   */
+  void set_width(int width);
+  
+  /** Gets the width to which the lines of the Pango::Layout should be wrapped.
+   * @return The width.
+   */
+  int get_width() const;
+  
+  /** Sets the wrap mode; the wrap mode only has an effect if a width
+   * is set on the layout with pango_layout_set_width(). To turn off wrapping,
+   * set the width to -1.
+   * @param wrap The wrap mode.
+   */
+  void set_wrap(WrapMode wrap);
+  
+  /** Gets the wrap mode for the layout.
+   * @return Active wrap mode.
+   */
+  WrapMode get_wrap() const;
+  
+  /** Sets the width in pango units to indent each paragraph. A negative value
+   * of @a indent  will produce a hanging indent. That is, the first line will
+   * have the full width, and subsequent lines will be indented by the
+   * absolute value of @a indent .
+   * @param indent The amount by which to indentset.
+   */
+  void set_indent(int indent);
+  
+  /** Gets the paragraph indent width in pango units. A negative value
+   * indicates a hanging indent.
+   * @return The indent.
+   */
+  int get_indent() const;
+  
+  /** Sets the amount of spacing between the lines of the layout.
+   * @param spacing The amount of spacing.
+   */
+  void set_spacing(int spacing);
+  
+  /** Gets the amount of spacing between the lines of the layout.
+   * @return The spacing (in Pango::GlyphUnit).
+   */
+  int get_spacing() const;
+  
+  /** Sets whether or not each complete line should be stretched to
+   * fill the entire width of the layout. This stretching is typically
+   * done by adding whitespace, but for some scripts (such as Arabic),
+   * the justification is done by extending the characters.
+   * 
+   * Note that as of Pango-1.4, this functionality is not yet implemented.
+   * @param justify Whether the lines in the layout should be justified.
+   */
+  void set_justify(bool justify = true);
+  
+  /** Gets whether or not each complete line should be stretched to
+   * fill the entire width of the layout.
+   * @return The justify.
+   */
+  bool get_justify() const;
+
+  
+  /** Gets whether to calculate the bidirectional base direction
+   * for the layout according to the contents of the layout.
+   * See pango_layout_set_auto_dir().
+   * @return If <tt>true</tt>, the bidirectional base direction
+   * is computed from the layout's contents.
+   */
+  bool get_auto_dir() const;
+  
+  /** Sets whether to calculate the bidirectional base direction
+   * for the layout according to the contents of the layout;
+   * when this flag is on (the default), then paragraphs in
+   *    @a layout  that begin with strong right-to-left characters
+   * (Arabic and Hebrew principally), will have right-to-left
+   * layout, paragraphs with letters from other scripts will
+   * have left-to-right layout. Paragraphs with only neutral
+   * characters get their direction from the surrounding paragraphs.
+   * 
+   * When <tt>false</tt>, the choice between left-to-right and
+   * right-to-left layout is done by according to the base direction
+   * of the layout's Pango::Context. (See pango_context_set_base_dir()).
+   * 
+   * When the auto-computed direction or a paragraph differs from the
+   * base direction of the context, then the interpretation of
+   * Pango::ALIGN_LEFT and Pango::ALIGN_RIGHT are swapped.
+   * @param auto_dir If <tt>true</tt>, compute the bidirectional base direction
+   * from the layout's contents.
+   */
+  void set_auto_dir(bool auto_dir = true);
+  
+  
+  /** Sets the alignment for the layout (how partial lines are
+   * positioned within the horizontal space available.)
+   * @param alignment The new alignment.
+   */
+  void set_alignment(Alignment alignment);
+  
+  /** Sets the alignment for the layout (how partial lines are
+   * positioned within the horizontal space available.)
+   * @return The alignment value.
+   */
+  Alignment get_alignment() const;
+
+  
+  /** Sets the tabs to use for @a layout , overriding the default tabs
+   * (by default, tabs are every 8 spaces). If @a tabs  is <tt>0</tt>, the default
+   * tabs are reinstated. @a tabs  is copied into the layout; you must
+   * free your copy of @a tabs  yourself.
+   * @param tabs A Pango::TabArray.
+   */
+  void set_tabs(TabArray& tabs);
+  
+  /** Get the current Pango::TabArray used by this layout. If no
+   * Pango::TabArray has been set, then the default tabs are in use
+   * and an invalid instance is returned. Default tabs are every 8 spaces.
+   * @return A copy of the tabs for this layout.
+   */
+  TabArray get_tabs() const;
+
+  
+  /** If @a setting  is <tt>true</tt>, do not treat newlines and similar characters
+   * as paragraph separators; instead, keep all text in a single paragraph,
+   * and display a glyph for paragraph separator characters. Used when
+   * you want to allow editing of newlines on a single text line.
+   * @param setting New setting.
+   */
+  void set_single_paragraph_mode(bool setting = true);
+  
+  /** Obtains the value set by pango_layout_set_single_paragraph_mode().
+   * @return <tt>true</tt> if the layout does not break paragraphs at 
+   * paragraph separator characters.
+   */
+  bool get_single_paragraph_mode() const;
+
+  
+  /** Sets the type of ellipsization being performed for @a layout .
+   * Depending on the ellipsization mode @a ellipsize  text is
+   * removed from the start, middle, or end of lines so they
+   * fit within the width of layout set with pango_layout_set_width().
+   * 
+   * If the layout contains characters such as newlines that
+   * force it to be layed out in multiple lines, then each line
+   * is ellipsized separately.
+   * 
+   * Since: 1.6
+   * @param ellipsize The new ellipsization mode for @a layout .
+   */
+  void set_ellipsize(EllipsizeMode ellipsize);
+  
+  /** Gets the type of ellipsization being performed for @a layout .
+   * See pango_layout_set_ellipsize()
+   * @return The current ellipsization mode for @a layout 
+   * 
+   * Since: 1.6.
+   */
+  EllipsizeMode get_ellipsize() const;
+
+  
+  /** Forces recomputation of any state in the Pango::Layout that
+   * might depend on the layout's context. This function should
+   * be called if you make changes to the context subsequent
+   * to creating the layout.
+   */
+  void context_changed();
+
+  /** Retrieve an array of logical attributes for each character in the layout.
+   * @return An array of logical attributes.
+   */
+  Glib::ArrayHandle<LogAttr> get_log_attrs() const;
+
+  /** Convert from an index within the layout to the onscreen position corresponding to the grapheme at that index, which is represented as rectangle.
+   * Note that @a x in the returned rectangle is always the leading edge of the grapheme
+   * and @a x + @a width the trailing edge of the grapheme.
+   * If the directionality of the grapheme is right-to-left, then @a width will be negative.
+   * @param index Byte index within layout.
+   * @return The position of the grapheme.
+   */
+  Rectangle index_to_pos(int index) const;
+
+  
+  /** Given an index within a layout, determines the positions that of the
+   * strong and weak cursors if the insertion point is at that
+   * index. The position of each cursor is stored as a zero-width
+   * rectangle. The strong cursor location is the location where
+   * characters of the directionality equal to the base direction of the
+   * layout are inserted.  The weak cursor location is the location
+   * where characters of the directionality opposite to the base
+   * direction of the layout are inserted.
+   * @param index The byte index of the cursor.
+   * @param strong_pos Location to store the strong cursor position (may be <tt>0</tt>).
+   * @param weak_pos Location to store the weak cursor position (may be <tt>0</tt>).
+   */
+  void get_cursor_pos(int index, Rectangle& strong_pos, Rectangle& weak_pos) const;
+
+  /** Given an index within the layout, determine the positions that of the strong cursors if the insertion point is at that index.
+   * @param index The byte index of the cursor.
+   * @return The strong cursor position.
+   */
+  Rectangle get_cursor_strong_pos(int index) const;
+
+  /** Given an index within the layout, determine the positions that of the weak cursors if the insertion point is at that index.
+   * @param index The byte index of the cursor.
+   * @return The weak cursor position.
+   */
+  Rectangle get_cursor_weak_pos(int index) const;
+
+  
+  /** Computes a new cursor position from an old position and
+   * a count of positions to move visually. If @a count  is positive,
+   * then the new strong cursor position will be one position
+   * to the right of the old cursor position. If @a count  is position
+   * then the new strong cursor position will be one position
+   * to the left of the old cursor position. 
+   * 
+   * In the presence of bidirection text, the correspondence
+   * between logical and visual order will depend on the direction
+   * of the current run, and there may be jumps when the cursor
+   * is moved off of the end of a run.
+   * 
+   * Motion here is in cursor positions, not in characters, so a
+   * single call to pango_layout_move_cursor_visually() may move the
+   * cursor over multiple characters when multiple characters combine
+   * to form a single grapheme.
+   * @param strong Whether the moving cursor is the strong cursor or the
+   * weak cursor. The strong cursor is the cursor corresponding
+   * to text insertion in the base direction for the layout.
+   * @param old_index The byte index of the grapheme for the old index.
+   * @param old_trailing If 0, the cursor was at the trailing edge of the 
+   * grapheme indicated by @a old_index , if &gt; 0, the cursor
+   * was at the leading edge.
+   * @param direction Direction to move cursor. A negative
+   * value indicates motion to the left.
+   * @param new_index Location to store the new cursor byte index. A value of -1 
+   * indicates that the cursor has been moved off the beginning
+   * of the layout. A value of G_MAXINT indicates that
+   * the cursor has been moved off the end of the layout.
+   * @param new_trailing Number of characters to move forward from the location returned
+   * for @a new_index  to get the position where the cursor should
+   * be displayed. This allows distinguishing the position at
+   * the beginning of one line from the position at the end
+   * of the preceding line. @a new_index  is always on the line
+   * where the cursor should be displayed.
+   */
+  void move_cursor_visually(bool strong,
+     int old_index, int old_trailing, int direction,
+     int& new_index, int& new_trailing) const;
+
+  
+  /** Converts from X and Y position within a layout to the byte 
+   * index to the character at that logical position. If the
+   * Y position is not inside the layout, the closest position is chosen
+   * (the position will be clamped inside the layout). If the
+   * X position is not within the layout, then the start or the
+   * end of the line is chosen as  described for pango_layout_x_to_index().
+   * If either the X or Y positions were not inside the layout, then the
+   * function returns <tt>false</tt>; on an exact hit, it returns <tt>true</tt>.
+   * @param x The X offset (in Pango::GlyphUnit)
+   * from the left edge of the layout.
+   * @param y The Y offset (in Pango::GlyphUnit)
+   * from the top edge of the layout.
+   * @param index Location to store calculated byte index.
+   * @param trailing Location to store a integer indicating where
+   * in the grapheme the user clicked. It will either
+   * be zero, or the number of characters in the
+   * grapheme. 0 represents the trailing edge of the grapheme.
+   * @return <tt>true</tt> if the coordinates were inside text.
+   */
+  bool xy_to_index(int x, int y, int& index, int& trailing) const;
+
+  
+  /** Compute the logical and ink extents of @a layout . Logical extents
+   * are usually what you want for positioning things. The extents
+   * are given in layout coordinates; layout coordinates begin at the
+   * top left corner of the layout.
+   * @param ink_rect Rectangle used to store the extents of the layout as drawn.
+   * @param logical_rect Rectangle used to store the logical extents of the layout.
+   */
+  void get_extents(Rectangle& ink_rect, Rectangle& logical_rect) const;
+
+  /** Compute the ink extents of layout.
+   * @return The extents of the layout as drawn.
+   */
+  Rectangle get_ink_extents() const;
+
+  /** Compute the logical extents of layout.
+   * @return The logical extents of the layout.
+   */
+  Rectangle get_logical_extents() const;
+
+  
+  /** Compute the logical and ink extents of @a layout  in device units.
+   * See pango_layout_get_extents(); this function just calls
+   * pango_layout_get_extents() and then converts the extents to
+   * pixels using the Pango::SCALE factor.
+   * @param ink_rect Rectangle used to store the extents of the layout as drawn.
+   * @param logical_rect Rectangle used to store the logical extents of the
+   * layout.
+   */
+  void get_pixel_extents(Rectangle& ink_rect, Rectangle& logical_rect) const;
+
+  /** Compute the ink extents of the layout in device units.
+   * @return The extents of the layout as drawn.
+   */
+  Rectangle get_pixel_ink_extents() const;
+
+  /** Compute the logical extents of the layout in device units.
+   * @return The logical extents of the layout.
+   */
+  Rectangle get_pixel_logical_extents() const;
+
+  
+  /** Determines the logical width and height of a Pango::Layout
+   * in Pango units. (device units divided by Pango::SCALE). This
+   * is simply a convenience function around pango_layout_get_extents().
+   * @param width Location to store the logical width, or <tt>0</tt>.
+   * @param height Location to store the logical height, or <tt>0</tt>.
+   */
+  void get_size(int& width, int& height) const;
+  
+  /** Determines the logical width and height of a Pango::Layout
+   * in device units. (pango_layout_get_size() returns the width
+   * and height in thousandths of a device unit.) This
+   * is simply a convenience function around pango_layout_get_extents().
+   * @param width Location to store the logical width, or <tt>0</tt>.
+   * @param height Location to store the logical height, or <tt>0</tt>.
+   */
+  void get_pixel_size(int& width, int& height) const;
+
+  
+  /** Retrieves the count of lines for the @a layout .
+   * @return The line count.
+   */
+  int get_line_count() const;
+  
+  
+  /** Retrieves a particular line from a Pango::Layout.
+   * @param line The index of a line, which must be between 0 and
+   * <tt>pango_layout_get_line_count(layout) - 1</tt>, inclusive.
+   * @return The requested Pango::LayoutLine, or <tt>0</tt> if the
+   * index is out of range. This layout line can
+   * be ref'ed and retained, but will become invalid
+   * if changes are made to the Pango::Layout.
+   */
+  Glib::RefPtr<LayoutLine> get_line(int line);
+  
+  /** Retrieves a particular line from a Pango::Layout.
+   * @param line The index of a line, which must be between 0 and
+   * <tt>pango_layout_get_line_count(layout) - 1</tt>, inclusive.
+   * @return The requested Pango::LayoutLine, or <tt>0</tt> if the
+   * index is out of range. This layout line can
+   * be ref'ed and retained, but will become invalid
+   * if changes are made to the Pango::Layout.
+   */
+  Glib::RefPtr<const LayoutLine> get_line(int line) const;
+  
+  
+  /** Returns the lines of the @a layout  as a list.
+   * @return A G::SList containing the lines in the layout. This
+   * points to internal data of the Pango::Layout and must be used with
+   * care. It will become invalid on any change to the layout's
+   * text or properties.
+   */
+  SListHandle_LayoutLine get_lines();
+  
+  /** Returns the lines of the @a layout  as a list.
+   * @return A G::SList containing the lines in the layout. This
+   * points to internal data of the Pango::Layout and must be used with
+   * care. It will become invalid on any change to the layout's
+   * text or properties.
+   */
+  SListHandle_ConstLayoutLine get_lines() const;
+  
+  /** Gets an iterator to iterate over the visual extents of the layout.
+   * @param iter Location to store the iterator.
+   */
+  void get_iter(LayoutIter& iter);
+
+
+public:
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+};
+
+} /* namespace Pango */
+
+
+namespace Glib
+{
+  /** @relates Pango::Layout
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Glib::RefPtr<Pango::Layout> wrap(PangoLayout* object, bool take_copy = false);
+}
+
+
+#endif /* _PANGOMM_LAYOUT_H */
+
diff --git a/libs/gtkmm2/pango/pangomm/layoutiter.cc b/libs/gtkmm2/pango/pangomm/layoutiter.cc
new file mode 100644
index 0000000000..4ba4620c3e
--- /dev/null
+++ b/libs/gtkmm2/pango/pangomm/layoutiter.cc
@@ -0,0 +1,206 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <pangomm/layoutiter.h>
+#include <pangomm/private/layoutiter_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/*
+ *
+ * Copyright 2001-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+namespace Pango
+{
+
+LayoutIter::LayoutIter()
+:
+  gobject_ (0)
+{}
+
+LayoutIter::~LayoutIter()
+{
+  if(gobject_)
+    pango_layout_iter_free(gobject_);
+}
+
+void LayoutIter::assign_gobj(PangoLayoutIter* src)
+{
+  if(src != gobject_)
+  {
+    if(gobject_)
+      pango_layout_iter_free(gobject_);
+
+    gobject_ = src;
+  }
+}
+
+Rectangle LayoutIter::get_char_extents() const
+{
+  Rectangle logical_rect;
+  pango_layout_iter_get_char_extents(const_cast<PangoLayoutIter*>(gobj()), logical_rect.gobj());
+  return logical_rect;
+}
+
+Rectangle LayoutIter::get_cluster_ink_extents() const
+{
+  Rectangle ink_rect;
+  pango_layout_iter_get_cluster_extents(const_cast<PangoLayoutIter*>(gobj()), ink_rect.gobj(), 0);
+  return ink_rect;
+}
+
+Rectangle LayoutIter::get_cluster_logical_extents() const
+{
+  Rectangle logical_rect;
+  pango_layout_iter_get_cluster_extents(const_cast<PangoLayoutIter*>(gobj()), 0, logical_rect.gobj());
+  return logical_rect;
+}
+
+Rectangle LayoutIter::get_run_ink_extents() const
+{
+  Rectangle ink_rect;
+  pango_layout_iter_get_run_extents(const_cast<PangoLayoutIter*>(gobj()), ink_rect.gobj(), 0);
+  return ink_rect;
+}
+
+Rectangle LayoutIter::get_run_logical_extents() const
+{
+  Rectangle logical_rect;
+  pango_layout_iter_get_run_extents(const_cast<PangoLayoutIter*>(gobj()), 0, logical_rect.gobj());
+  return logical_rect;
+}
+
+Rectangle LayoutIter::get_line_ink_extents() const
+{
+  Rectangle ink_rect;
+  pango_layout_iter_get_line_extents(const_cast<PangoLayoutIter*>(gobj()), ink_rect.gobj(), 0);
+  return ink_rect;
+}
+
+Rectangle LayoutIter::get_line_logical_extents() const
+{
+  Rectangle logical_rect;
+  pango_layout_iter_get_line_extents(const_cast<PangoLayoutIter*>(gobj()), 0, logical_rect.gobj());
+  return logical_rect;
+}
+
+Rectangle LayoutIter::get_layout_ink_extents() const
+{
+  Rectangle ink_rect;
+  pango_layout_iter_get_layout_extents(const_cast<PangoLayoutIter*>(gobj()), ink_rect.gobj(), 0);
+  return ink_rect;
+}
+
+Rectangle LayoutIter::get_layout_logical_extents() const
+{
+  Rectangle logical_rect;
+  pango_layout_iter_get_layout_extents(const_cast<PangoLayoutIter*>(gobj()), 0, logical_rect.gobj());
+  return logical_rect;
+}
+
+} // namespace Pango
+
+
+namespace
+{
+} // anonymous namespace
+
+
+namespace Pango
+{
+
+
+int LayoutIter::get_index() const
+{
+  return pango_layout_iter_get_index(const_cast<PangoLayoutIter*>(gobj()));
+}
+
+LayoutRun LayoutIter::get_run() const
+{
+  return Glib::wrap(pango_layout_iter_get_run(const_cast<PangoLayoutIter*>(gobj())));
+}
+
+Glib::RefPtr<LayoutLine> LayoutIter::get_line() const
+{
+
+  Glib::RefPtr<LayoutLine> retvalue = Glib::wrap(pango_layout_iter_get_line(const_cast<PangoLayoutIter*>(gobj())));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+bool LayoutIter::at_last_line() const
+{
+  return pango_layout_iter_at_last_line(const_cast<PangoLayoutIter*>(gobj()));
+}
+
+bool LayoutIter::next_char()
+{
+  return pango_layout_iter_next_char(gobj());
+}
+
+bool LayoutIter::next_cluster()
+{
+  return pango_layout_iter_next_cluster(gobj());
+}
+
+bool LayoutIter::next_run()
+{
+  return pango_layout_iter_next_run(gobj());
+}
+
+bool LayoutIter::next_line()
+{
+  return pango_layout_iter_next_line(gobj());
+}
+
+void LayoutIter::get_cluster_extents(Rectangle& ink_rect, Rectangle& logical_rect) const
+{
+  pango_layout_iter_get_cluster_extents(const_cast<PangoLayoutIter*>(gobj()), (ink_rect).gobj(), (logical_rect).gobj());
+}
+
+void LayoutIter::get_run_extents(Rectangle& ink_rect, Rectangle& logical_rect) const
+{
+  pango_layout_iter_get_run_extents(const_cast<PangoLayoutIter*>(gobj()), (ink_rect).gobj(), (logical_rect).gobj());
+}
+
+void LayoutIter::get_line_extents(Rectangle& ink_rect, Rectangle& logical_rect) const
+{
+  pango_layout_iter_get_line_extents(const_cast<PangoLayoutIter*>(gobj()), (ink_rect).gobj(), (logical_rect).gobj());
+}
+
+void LayoutIter::get_line_yrange(int& y0, int& y1) const
+{
+  pango_layout_iter_get_line_yrange(const_cast<PangoLayoutIter*>(gobj()), &y0, &y1);
+}
+
+void LayoutIter::get_layout_extents(Rectangle& ink_rect, Rectangle& logical_rect) const
+{
+  pango_layout_iter_get_layout_extents(const_cast<PangoLayoutIter*>(gobj()), (ink_rect).gobj(), (logical_rect).gobj());
+}
+
+int LayoutIter::get_baseline() const
+{
+  return pango_layout_iter_get_baseline(const_cast<PangoLayoutIter*>(gobj()));
+}
+
+
+} // namespace Pango
+
+
diff --git a/libs/gtkmm2/pango/pangomm/layoutiter.h b/libs/gtkmm2/pango/pangomm/layoutiter.h
new file mode 100644
index 0000000000..ccb24ded81
--- /dev/null
+++ b/libs/gtkmm2/pango/pangomm/layoutiter.h
@@ -0,0 +1,235 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _PANGOMM_LAYOUTITER_H
+#define _PANGOMM_LAYOUTITER_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* layoutiter.h
+ *
+ * Copyright 2001-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <pangomm/layoutline.h>
+#include <pangomm/layoutrun.h>
+#include <pango/pango-layout.h>
+
+
+namespace Pango
+{
+
+/** A Pango::LayoutIter can be used to iterate over the visual extents of a Pango::Layout.
+ */
+class LayoutIter
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef LayoutIter CppObjectType;
+  typedef PangoLayoutIter BaseObjectType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+private:
+
+  
+public:
+  // There's no other ctor, and the default ctor creates an invalid object.
+  // Therefore, Pango::LayoutIter is usable only as output argument.
+  LayoutIter();
+  ~LayoutIter();
+
+  
+  /** Gets the current byte index. Note that iterating forward by char
+   * moves in visual order, not logical order, so indexes may not be
+   * sequential. Also, the index may be equal to the length of the text
+   * in the layout, if on the <tt>0</tt> run (see pango_layout_iter_get_run()).
+   * @return Current byte index.
+   */
+  int get_index() const;
+  
+  /** Gets the current run. When iterating by run, at the end of each
+   * line, there's a position with a <tt>0</tt> run, so this function can return
+   * <tt>0</tt>. The <tt>0</tt> run at the end of each line ensures that all lines have
+   * at least one run, even lines consisting of only a newline.
+   * @return The current run.
+   */
+  LayoutRun get_run() const;
+  
+  /** Gets the current line.
+   * @return The current line.
+   */
+  Glib::RefPtr<LayoutLine> get_line() const;
+  
+  /** Determines whether @a iter  is on the last line of the layout.
+   * @return <tt>true</tt> if @a iter  is on the last line.
+   */
+  bool at_last_line() const;
+
+  
+  /** Moves @a iter  forward to the next character in visual order. If @a iter  was already at
+   * the end of the layout, returns <tt>false</tt>.
+   * @return Whether motion was possible.
+   */
+  bool next_char();
+  
+  /** Moves @a iter  forward to the next cluster in visual order. If @a iter 
+   * was already at the end of the layout, returns <tt>false</tt>.
+   * @return Whether motion was possible.
+   */
+  bool next_cluster();
+  
+  /** Moves @a iter  forward to the next run in visual order. If @a iter  was
+   * already at the end of the layout, returns <tt>false</tt>.
+   * @return Whether motion was possible.
+   */
+  bool next_run();
+  
+  /** Moves @a iter  forward to the start of the next line. If @a iter  is
+   * already on the last line, returns <tt>false</tt>.
+   * @return Whether motion was possible.
+   */
+  bool next_line();
+
+  /** Gets the extents of the current character, in layout coordinates (origin is the top left of the entire layout).
+   * Only logical extents can sensibly be obtained for characters; ink extents make sense only down to the level of clusters.
+   * @return The logical extents of the current character.
+   */
+  Rectangle get_char_extents() const;
+
+  
+  /** Gets the extents of the current cluster, in layout coordinates
+   * (origin is the top left of the entire layout).
+   * @param ink_rect Rectangle to fill with ink extents.
+   * @param logical_rect Rectangle to fill with logical extents.
+   */
+  void get_cluster_extents(Rectangle& ink_rect, Rectangle& logical_rect) const;
+
+  /** Gets the ink extents of the current cluster, in layout coordinates (origin is the top left of the entire layout).
+   * @return The extents of the current cluster as drawn.
+   */
+  Rectangle get_cluster_ink_extents() const;
+
+  /** Gets the logical extents of the current cluster, in layout coordinates (origin is the top left of the entire layout).
+   * @return The logical extents of the current cluster.
+   */
+  Rectangle get_cluster_logical_extents() const;
+
+  
+  /** Gets the extents of the current run in layout coordinates
+   * (origin is the top left of the entire layout).
+   * @param ink_rect Rectangle to fill with ink extents.
+   * @param logical_rect Rectangle to fill with logical extents.
+   */
+  void get_run_extents(Rectangle& ink_rect, Rectangle& logical_rect) const;
+
+  /** Gets the ink extents of the current run in layout coordinates (origin is the top left of the entire layout).
+   * @return The extents of the current run as drawn.
+   */
+  Rectangle get_run_ink_extents() const;
+
+  /** Gets the logical extents of the current run in layout coordinates (origin is the top left of the entire layout).
+   * @return The logical extents of the current run.
+   */
+  Rectangle get_run_logical_extents() const;
+
+  
+  /** Obtains the extents of the current line. @a ink_rect  or @a logical_rect 
+   * can be <tt>0</tt> if you aren't interested in them. Extents are in layout
+   * coordinates (origin is the top-left corner of the entire
+   * Pango::Layout).  Thus the extents returned by this function will be
+   * the same width/height but not at the same x/y as the extents
+   * returned from pango_layout_line_get_extents().
+   * @param ink_rect Rectangle to fill with ink extents.
+   * @param logical_rect Rectangle to fill with logical extents.
+   */
+  void get_line_extents(Rectangle& ink_rect, Rectangle& logical_rect) const;
+
+  /** Obtains the ink extents of the current line.
+   * @return The extents of the current line as drawn.
+   */
+  Rectangle get_line_ink_extents() const;
+
+  /** Obtains the logical extents of the current line.
+   * @return The logical extents of the current line.
+   */
+  Rectangle get_line_logical_extents() const;
+
+  
+  /** Divides the vertical space in the Pango::Layout being iterated over
+   * between the lines in the layout, and returns the space belonging to
+   * the current line.  A line's range includes the line's logical
+   * extents, plus half of the spacing above and below the line, if
+   * pango_layout_set_spacing() has been called to set layout spacing.
+   * The y positions are in layout coordinates (origin at top left of the
+   * entire layout).
+   * @param y0 Start of line.
+   * @param y1 End of line.
+   */
+  void get_line_yrange(int& y0, int& y1) const;
+
+  
+  /** Obtains the extents of the Pango::Layout being iterated
+   * over. @a ink_rect  or @a logical_rect  can be <tt>0</tt> if you
+   * aren't interested in them.
+   * @param ink_rect Rectangle to fill with ink extents.
+   * @param logical_rect Rectangle to fill with logical extents.
+   */
+  void get_layout_extents(Rectangle& ink_rect, Rectangle& logical_rect) const;
+
+  /** Obtains the ink extents of the Pango::Layout being iterated over.
+   * @return The extents of the layout as drawn.
+   */
+  Rectangle get_layout_ink_extents() const;
+
+  /** Obtains the logical extents of the Pango::Layout being iterated over.
+   * @return The logical extents of the layout.
+   */
+  Rectangle get_layout_logical_extents() const;
+
+  
+  /** Gets the y position of the current line's baseline, in layout
+   * coordinates (origin at top left of the entire layout).
+   * @return Baseline of current line.
+   */
+  int get_baseline() const;
+
+  /// Provides access to the underlying C GObject.  
+  PangoLayoutIter*       gobj()       { return gobject_; }
+  /// Provides access to the underlying C GObject.
+  const PangoLayoutIter* gobj() const { return gobject_; }
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  void assign_gobj(PangoLayoutIter* src);
+#endif
+
+protected:
+  PangoLayoutIter* gobject_;
+
+private:
+  // noncopyable
+  LayoutIter(const LayoutIter&);
+  LayoutIter& operator=(const LayoutIter&);
+
+
+};
+
+} //namespace Pango
+
+
+#endif /* _PANGOMM_LAYOUTITER_H */
+
diff --git a/libs/gtkmm2/pango/pangomm/layoutline.cc b/libs/gtkmm2/pango/pangomm/layoutline.cc
new file mode 100644
index 0000000000..f3ff372461
--- /dev/null
+++ b/libs/gtkmm2/pango/pangomm/layoutline.cc
@@ -0,0 +1,197 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <pangomm/layoutline.h>
+#include <pangomm/private/layoutline_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/*
+ *
+ * Copyright 1998-2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <pangomm/layout.h>
+
+namespace Pango {
+
+Rectangle LayoutLine::get_ink_extents() const
+{
+  Rectangle ink_rect;
+  pango_layout_line_get_extents(const_cast<PangoLayoutLine*>(gobj()), ink_rect.gobj(), 0);
+  return ink_rect;
+}
+
+Rectangle LayoutLine::get_logical_extents() const
+{
+  Rectangle logical_rect;
+  pango_layout_line_get_extents(const_cast<PangoLayoutLine*>(gobj()), 0, logical_rect.gobj());
+  return logical_rect;
+}
+
+Rectangle LayoutLine::get_pixel_ink_extents() const
+{
+  Rectangle ink_rect;
+  pango_layout_line_get_pixel_extents(const_cast<PangoLayoutLine*>(gobj()), ink_rect.gobj(), 0);
+  return ink_rect;
+}
+
+Rectangle LayoutLine::get_pixel_logical_extents() const
+{
+  Rectangle logical_rect;
+  pango_layout_line_get_pixel_extents(const_cast<PangoLayoutLine*>(gobj()), 0, logical_rect.gobj());
+  return logical_rect;
+}
+
+int LayoutLine::index_to_x(int index, bool trailing) const
+{
+  int x_pos;
+  pango_layout_line_index_to_x(const_cast<PangoLayoutLine*>(gobj()), index, trailing, &x_pos);
+  return x_pos;
+}
+
+Glib::ArrayHandle<std::pair<int,int> > LayoutLine::get_x_ranges(int start_index, int end_index) const
+{
+  int* ranges = 0;
+  int n_ranges = 0;
+  pango_layout_line_get_x_ranges(const_cast<PangoLayoutLine*>(gobj()), start_index, end_index, &ranges, &n_ranges);
+  return Glib::ArrayHandle<std::pair<int,int> >(reinterpret_cast<std::pair<int,int>*>(ranges), n_ranges, Glib::OWNERSHIP_SHALLOW);
+}
+
+} /* namespace Pango */
+
+
+namespace
+{
+} // anonymous namespace
+
+
+/* Why reinterpret_cast<LayoutLine*>(gobject) is needed:
+ *
+ * A LayoutLine instance is in fact always a PangoLayoutLine instance.
+ * Unfortunately, PangoLayoutLine cannot be a member of LayoutLine,
+ * because it is an opaque struct.  Also, the C interface does not provide
+ * any hooks to install a destroy notification handler, thus we cannot
+ * wrap it dynamically either.
+ *
+ * The cast works because LayoutLine does not have any member data, and
+ * it is impossible to derive from it.  This is ensured by not implementing
+ * the (protected) default constructor.  The ctor is protected rather than
+ * private just to avoid a compile warning.
+ */
+
+namespace Glib
+{
+
+Glib::RefPtr<Pango::LayoutLine> wrap(PangoLayoutLine* object, bool take_copy)
+{
+  if(take_copy && object)
+    pango_layout_line_ref(object);
+
+  // See the comment at the top of this file, if you want to know why the cast works.
+  return Glib::RefPtr<Pango::LayoutLine>(reinterpret_cast<Pango::LayoutLine*>(object));
+}
+
+} // namespace Glib
+
+
+namespace Pango
+{
+
+
+void LayoutLine::reference() const
+{
+  // See the comment at the top of this file, if you want to know why the cast works.
+  pango_layout_line_ref(reinterpret_cast<PangoLayoutLine*>(const_cast<LayoutLine*>(this)));
+}
+
+void LayoutLine::unreference() const
+{
+  // See the comment at the top of this file, if you want to know why the cast works.
+  pango_layout_line_unref(reinterpret_cast<PangoLayoutLine*>(const_cast<LayoutLine*>(this)));
+}
+
+PangoLayoutLine* LayoutLine::gobj()
+{
+  // See the comment at the top of this file, if you want to know why the cast works.
+  return reinterpret_cast<PangoLayoutLine*>(this);
+}
+
+const PangoLayoutLine* LayoutLine::gobj() const
+{
+  // See the comment at the top of this file, if you want to know why the cast works.
+  return reinterpret_cast<const PangoLayoutLine*>(this);
+}
+
+PangoLayoutLine* LayoutLine::gobj_copy() const
+{
+  // See the comment at the top of this file, if you want to know why the cast works.
+  PangoLayoutLine *const gobject = reinterpret_cast<PangoLayoutLine*>(const_cast<LayoutLine*>(this));
+  pango_layout_line_ref(gobject);
+  return gobject;
+}
+
+
+bool LayoutLine::x_to_index(int x_pos, int& index, int& trailing) const
+{
+  return pango_layout_line_x_to_index(const_cast<PangoLayoutLine*>(gobj()), x_pos, &index, &trailing);
+}
+
+void LayoutLine::get_extents(Rectangle& ink_rect, Rectangle& logical_rect) const
+{
+  pango_layout_line_get_extents(const_cast<PangoLayoutLine*>(gobj()), (ink_rect).gobj(), (logical_rect).gobj());
+}
+
+void LayoutLine::get_pixel_extents(Rectangle& ink_rect, Rectangle& logical_rect) const
+{
+  pango_layout_line_get_pixel_extents(const_cast<PangoLayoutLine*>(gobj()), (ink_rect).gobj(), (logical_rect).gobj());
+}
+
+Glib::RefPtr<Pango::Layout> LayoutLine::get_layout()
+{
+  Glib::RefPtr<Pango::Layout> ref_ptr(Glib::wrap(gobj()->layout));
+
+  if(ref_ptr)
+    ref_ptr->reference();
+
+  return ref_ptr;
+}
+
+Glib::RefPtr<const Pango::Layout> LayoutLine::get_layout() const
+{
+  Glib::RefPtr<const Pango::Layout> ref_ptr(Glib::wrap(gobj()->layout));
+
+  if(ref_ptr)
+    ref_ptr->reference();
+
+  return ref_ptr;
+}
+
+int LayoutLine::get_length() const
+{
+  return gobj()->length;
+}
+
+int LayoutLine::get_start_index() const
+{
+  return gobj()->start_index;
+}
+
+
+} // namespace Pango
+
+
diff --git a/libs/gtkmm2/pango/pangomm/layoutline.h b/libs/gtkmm2/pango/pangomm/layoutline.h
new file mode 100644
index 0000000000..594d5cc7a3
--- /dev/null
+++ b/libs/gtkmm2/pango/pangomm/layoutline.h
@@ -0,0 +1,222 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _PANGOMM_LAYOUTLINE_H
+#define _PANGOMM_LAYOUTLINE_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* layoutline.h
+ *
+ * Copyright (C) 1998-1999 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <glibmm/slisthandle.h> // For the Glib::SListHandle typedef
+#include <pangomm/rectangle.h>
+#include <pango/pango-layout.h>
+
+
+namespace Pango
+{
+
+class Layout;
+
+/** A Pango::LayoutLine represents one of the lines resulting from laying out a paragraph via Pango::Layout.
+ * Pango::LayoutLine objects are obtained by calling Pango::Layout::get_line()
+ * and are only valid until the text, attributes, or settings of the parent Pango::Layout are modified.
+ * Routines for rendering Pango::Layout objects are provided in code specific to each rendering system.
+ */
+class LayoutLine
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef LayoutLine CppObjectType;
+  typedef PangoLayoutLine BaseObjectType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+  // For use with Glib::RefPtr<> only.
+  void reference()   const;
+  void unreference() const;
+
+  ///Provides access to the underlying C instance.
+  PangoLayoutLine*       gobj();
+
+  ///Provides access to the underlying C instance.
+  const PangoLayoutLine* gobj() const;
+
+  ///Provides access to the underlying C instance. The caller is responsible for unrefing it. Use when directly setting fields in structs.
+  PangoLayoutLine* gobj_copy() const;
+
+protected:
+  // Do not derive this.  Pango::LayoutLine can neither be constructed nor deleted.
+  LayoutLine();
+  void operator delete(void*, size_t);
+
+private:
+  // noncopyable
+  LayoutLine(const LayoutLine&);
+  LayoutLine& operator=(const LayoutLine&);
+
+
+public:
+
+  
+  /** Converts from x offset to the byte index of the corresponding
+   * character within the text of the layout. If @a x_pos  is outside the line,
+   *  @a index  and @a trailing  will point to the very first or very last position
+   * in the line. This determination is based on the resolved direction
+   * of the paragraph; for example, if the resolved direction is
+   * right-to-left, then an X position to the right of the line (after it)
+   * results in 0 being stored in @a index  and @a trailing . An X position to the
+   * left of the line results in @a index  pointing to the (logical) last
+   * grapheme in the line and @a trailing  being set to the number of characters
+   * in that grapheme. The reverse is true for a left-to-right line.
+   * @param x_pos The x offset (in Pango::GlyphUnit)
+   * from the left edge of the line.
+   * @param index Location to store calculated byte index for
+   * the grapheme in which the user clicked.
+   * @param trailing Location to store a integer indicating where
+   * in the grapheme the user clicked. It will either
+   * be zero, or the number of characters in the
+   * grapheme. 0 represents the trailing edge of the grapheme.
+   * @return <tt>false</tt> if @a x_pos  was outside the line, <tt>true</tt> if inside.
+   */
+  bool x_to_index(int x_pos, int& index, int& trailing) const;
+
+  /** Converts an index within a line to a @a x position.
+   * @param index Byte offset of a grapheme within the layout.
+   * @param trailing  A boolean indicating the edge of the grapheme to retrieve the position of. If <tt>false</tt>, the trailing edge of the grapheme, if <tt>true</tt> the leading of the grapheme. 
+   * @return The x offset (in thousands of a device unit).
+   */
+  int index_to_x(int index, bool trailing) const;
+  
+
+  /** Get a list of visual ranges corresponding to a given logical range.
+   * This list is not necessarily minimal - there may be consecutive ranges which are adjacent.
+   * The ranges will be sorted from left to right. The ranges are with respect to the
+   * left edge of the entire layout, not with respect to the line.
+   * @param start_index The start byte index of the logical range.
+   * If the value of @a start_index is less than the start index for the line,
+   * then the first range will extend all the way to the leading edge of the layout.
+   * Otherwise it will start at the leading edge of the first character.
+   * @param end_index The end byte index of the logical range.
+   * If the value of @a end_index is greater than the end index for the line,
+   * then the last range will extend all the way to the trailing edge of the layout.
+   * Otherwise, it will end at the trailing edge of the last character.
+   * @return An array of ranges represented by pairs of integers marking the start and end pixel coordinates of the ranges.
+   */
+  Glib::ArrayHandle<std::pair<int,int> > get_x_ranges(int start_index, int end_index) const;
+
+  
+  /** Compute the logical and ink extents of a layout line. See the documentation
+   * for Pango::Font::get_glyph_extents() for details about the interpretation
+   * of the rectangles.
+   * @param ink_rect Rectangle used to store the extents of the glyph string as drawn.
+   * @param logical_rect Rectangle used to store the logical extents of the glyph string.
+   */
+  void get_extents(Rectangle& ink_rect, Rectangle& logical_rect) const;
+
+  /** Compute the ink extents of a layout line.
+   * @return The extents of the layout line as drawn.
+   */
+  Rectangle get_ink_extents() const;
+
+  /** Compute the logical extents of a layout line.
+   * @return The logical extents of the layout line.
+   */
+  Rectangle get_logical_extents() const;
+
+  
+  /** Compute the logical and ink extents of a layout line. See the documentation
+   * for Pango::Font::get_glyph_extents() for details about the interpretation
+   * of the rectangles. The returned rectangles are in device units, as
+   * opposed to pango_layout_line_get_extents(), which returns the extents in
+   * units of device unit / PANGO_SCALE.
+   * @param ink_rect Rectangle used to store the extents of the glyph string as drawn.
+   * @param logical_rect Rectangle used to store the logical extents of the glyph string.
+   */
+  void get_pixel_extents(Rectangle& ink_rect, Rectangle& logical_rect) const;
+
+  /** Compute the ink extents of a layout line in device units.
+   * @return The extents of the layout line as drawn.
+   */
+  Rectangle get_pixel_ink_extents() const;
+
+  /** Compute the logical extents of a layout line in device units.
+   * @return The logical extents of the layout line.
+   */
+  Rectangle get_pixel_logical_extents() const;
+
+  Glib::RefPtr<Pango::Layout> get_layout();
+  Glib::RefPtr<const Pango::Layout> get_layout() const;
+  //_MEMBER_SET_GOBJECT(layout, layout, Pango::Layout, PangoLayout*)
+  int get_length() const;
+  int get_start_index() const;
+    
+
+};
+
+} // namespace Pango
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+// forward declaration needed by LayoutLineTraits
+Glib::RefPtr<Pango::LayoutLine> wrap(PangoLayoutLine* object, bool take_copy /* = false */);
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Pango
+{
+
+struct LayoutLineTraits
+{
+  typedef Glib::RefPtr<LayoutLine>  CppType;
+  typedef PangoLayoutLine *         CType;
+  typedef PangoLayoutLine *         CTypeNonConst;
+
+  static CType   to_c_type      (const CppType& ptr) { return Glib::unwrap(ptr);     }
+  static CType   to_c_type      (CType          ptr) { return ptr;                   }
+  static CppType to_cpp_type    (CType          ptr) { return Glib::wrap(ptr, true); }
+  static void    release_c_type (CType          ptr) { pango_layout_line_unref(ptr); }
+};
+
+typedef Glib::SListHandle< Glib::RefPtr<LayoutLine>, LayoutLineTraits > SListHandle_LayoutLine;
+typedef Glib::SListHandle< Glib::RefPtr<const LayoutLine>, LayoutLineTraits > SListHandle_ConstLayoutLine;
+
+} // namespace Pango
+
+
+namespace Glib
+{
+
+  /** @relates Pango::LayoutLine
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Glib::RefPtr<Pango::LayoutLine> wrap(PangoLayoutLine* object, bool take_copy = false);
+
+} // namespace Glib
+
+#endif /* _PANGOMM_LAYOUTLINE_H */
+
diff --git a/libs/gtkmm2/pango/pangomm/layoutrun.cc b/libs/gtkmm2/pango/pangomm/layoutrun.cc
new file mode 100644
index 0000000000..6d797fc02c
--- /dev/null
+++ b/libs/gtkmm2/pango/pangomm/layoutrun.cc
@@ -0,0 +1,79 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <pangomm/layoutrun.h>
+#include <pangomm/private/layoutrun_p.h>
+
+/*
+ * Copyright 2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <pangomm/item.h>
+#include <pangomm/glyphstring.h>
+
+namespace Pango
+{
+
+LayoutRun::LayoutRun()
+{}
+
+LayoutRun::LayoutRun(const PangoLayoutRun* src)
+{
+  gobject_ = *src;
+}
+
+} /* namespace Pango */
+
+
+namespace Glib
+{
+
+Pango::LayoutRun& wrap(PangoLayoutRun* object)
+{
+  return *reinterpret_cast<Pango::LayoutRun*>(object);
+}
+
+const Pango::LayoutRun& wrap(const PangoLayoutRun* object)
+{
+  return *reinterpret_cast<const Pango::LayoutRun*>(object);
+}
+
+} /* namespace Glib */
+
+
+namespace
+{
+} // anonymous namespace
+
+
+namespace Pango
+{
+
+
+Item LayoutRun::get_item() const
+{
+  return Item((gobj()->item));
+}
+
+GlyphString LayoutRun::get_glyphs() const
+{
+  return GlyphString((gobj()->glyphs));
+}
+
+
+} // namespace Pango
+
+
diff --git a/libs/gtkmm2/pango/pangomm/layoutrun.h b/libs/gtkmm2/pango/pangomm/layoutrun.h
new file mode 100644
index 0000000000..8a150646fa
--- /dev/null
+++ b/libs/gtkmm2/pango/pangomm/layoutrun.h
@@ -0,0 +1,92 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _PANGOMM_LAYOUTRUN_H
+#define _PANGOMM_LAYOUTRUN_H
+
+#include <glibmm.h>
+
+/* layoutrun.h
+ *
+ * Copyright (C) 1998-1999 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <pango/pango-layout.h>
+
+
+namespace Pango
+{
+
+class Item;
+class GlyphString;
+
+/** A Pango::LayoutRun represents a single run within a PangoLayoutLine.
+ */
+class LayoutRun
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef LayoutRun CppObjectType;
+  typedef PangoLayoutRun BaseObjectType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+private:
+
+
+protected:
+  LayoutRun();
+
+public:
+  explicit LayoutRun(const PangoLayoutRun* src);
+
+  /** Gets the Pango::Item object that provides information about the segment of text in this run.
+   * @return A Pango::Item object.
+   */
+  Item get_item() const;
+
+  /** Gets the string of glyphs obtained by shaping the text for this item.
+   * @return A Pango::GlyphString object.
+   */
+  GlyphString get_glyphs() const;
+
+  /// Provides access to the underlying C GObject.  
+  PangoLayoutRun*       gobj()       { return &gobject_; }
+  /// Provides access to the underlying C GObject.
+  const PangoLayoutRun* gobj() const { return &gobject_; }
+
+protected:
+  PangoLayoutRun gobject_;
+
+
+};
+
+} /* namespace Pango */
+
+
+namespace Glib
+{
+
+/** @relates Pango::LayoutRun */
+Pango::LayoutRun& wrap(PangoLayoutRun* object);
+
+/** @relates Pango::LayoutRun */
+const Pango::LayoutRun& wrap(const PangoLayoutRun* object);
+
+} /* namepspace Glib */
+
+
+#endif /* _PANGOMM_LAYOUTRUN_H */
+
diff --git a/libs/gtkmm2/pango/pangomm/private/attributes_p.h b/libs/gtkmm2/pango/pangomm/private/attributes_p.h
new file mode 100644
index 0000000000..a2c62c09a6
--- /dev/null
+++ b/libs/gtkmm2/pango/pangomm/private/attributes_p.h
@@ -0,0 +1,6 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _PANGOMM_ATTRIBUTES_P_H
+#define _PANGOMM_ATTRIBUTES_P_H
+#endif /* _PANGOMM_ATTRIBUTES_P_H */
+
diff --git a/libs/gtkmm2/pango/pangomm/private/attriter_p.h b/libs/gtkmm2/pango/pangomm/private/attriter_p.h
new file mode 100644
index 0000000000..d8cc2fd346
--- /dev/null
+++ b/libs/gtkmm2/pango/pangomm/private/attriter_p.h
@@ -0,0 +1,6 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _PANGOMM_ATTRITER_P_H
+#define _PANGOMM_ATTRITER_P_H
+#endif /* _PANGOMM_ATTRITER_P_H */
+
diff --git a/libs/gtkmm2/pango/pangomm/private/attrlist_p.h b/libs/gtkmm2/pango/pangomm/private/attrlist_p.h
new file mode 100644
index 0000000000..4c05d959d2
--- /dev/null
+++ b/libs/gtkmm2/pango/pangomm/private/attrlist_p.h
@@ -0,0 +1,6 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _PANGOMM_ATTRLIST_P_H
+#define _PANGOMM_ATTRLIST_P_H
+#endif /* _PANGOMM_ATTRLIST_P_H */
+
diff --git a/libs/gtkmm2/pango/pangomm/private/color_p.h b/libs/gtkmm2/pango/pangomm/private/color_p.h
new file mode 100644
index 0000000000..945c38bedb
--- /dev/null
+++ b/libs/gtkmm2/pango/pangomm/private/color_p.h
@@ -0,0 +1,6 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _PANGOMM_COLOR_P_H
+#define _PANGOMM_COLOR_P_H
+#endif /* _PANGOMM_COLOR_P_H */
+
diff --git a/libs/gtkmm2/pango/pangomm/private/context_p.h b/libs/gtkmm2/pango/pangomm/private/context_p.h
new file mode 100644
index 0000000000..a54c181ffd
--- /dev/null
+++ b/libs/gtkmm2/pango/pangomm/private/context_p.h
@@ -0,0 +1,44 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _PANGOMM_CONTEXT_P_H
+#define _PANGOMM_CONTEXT_P_H
+#include <glibmm/private/object_p.h>
+
+#include <glibmm/class.h>
+
+namespace Pango
+{
+
+class Context_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Context CppObjectType;
+  typedef PangoContext BaseObjectType;
+  typedef PangoContextClass BaseClassType;
+  typedef Glib::Object_Class CppClassParent;
+  typedef GObjectClass BaseClassParent;
+
+  friend class Context;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Pango
+
+#endif /* _PANGOMM_CONTEXT_P_H */
+
diff --git a/libs/gtkmm2/pango/pangomm/private/coverage_p.h b/libs/gtkmm2/pango/pangomm/private/coverage_p.h
new file mode 100644
index 0000000000..129cefb95d
--- /dev/null
+++ b/libs/gtkmm2/pango/pangomm/private/coverage_p.h
@@ -0,0 +1,6 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _PANGOMM_COVERAGE_P_H
+#define _PANGOMM_COVERAGE_P_H
+#endif /* _PANGOMM_COVERAGE_P_H */
+
diff --git a/libs/gtkmm2/pango/pangomm/private/font_p.h b/libs/gtkmm2/pango/pangomm/private/font_p.h
new file mode 100644
index 0000000000..6ff30d4ddf
--- /dev/null
+++ b/libs/gtkmm2/pango/pangomm/private/font_p.h
@@ -0,0 +1,44 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _PANGOMM_FONT_P_H
+#define _PANGOMM_FONT_P_H
+#include <glibmm/private/object_p.h>
+
+#include <glibmm/class.h>
+
+namespace Pango
+{
+
+class Font_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Font CppObjectType;
+  typedef PangoFont BaseObjectType;
+  typedef PangoFontClass BaseClassType;
+  typedef Glib::Object_Class CppClassParent;
+  typedef GObjectClass BaseClassParent;
+
+  friend class Font;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Pango
+
+#endif /* _PANGOMM_FONT_P_H */
+
diff --git a/libs/gtkmm2/pango/pangomm/private/fontdescription_p.h b/libs/gtkmm2/pango/pangomm/private/fontdescription_p.h
new file mode 100644
index 0000000000..12ec7e662d
--- /dev/null
+++ b/libs/gtkmm2/pango/pangomm/private/fontdescription_p.h
@@ -0,0 +1,6 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _PANGOMM_FONTDESCRIPTION_P_H
+#define _PANGOMM_FONTDESCRIPTION_P_H
+#endif /* _PANGOMM_FONTDESCRIPTION_P_H */
+
diff --git a/libs/gtkmm2/pango/pangomm/private/fontface_p.h b/libs/gtkmm2/pango/pangomm/private/fontface_p.h
new file mode 100644
index 0000000000..66bddd9298
--- /dev/null
+++ b/libs/gtkmm2/pango/pangomm/private/fontface_p.h
@@ -0,0 +1,44 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _PANGOMM_FONTFACE_P_H
+#define _PANGOMM_FONTFACE_P_H
+#include <glibmm/private/object_p.h>
+
+#include <glibmm/class.h>
+
+namespace Pango
+{
+
+class FontFace_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef FontFace CppObjectType;
+  typedef PangoFontFace BaseObjectType;
+  typedef PangoFontFaceClass BaseClassType;
+  typedef Glib::Object_Class CppClassParent;
+  typedef GObjectClass BaseClassParent;
+
+  friend class FontFace;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Pango
+
+#endif /* _PANGOMM_FONTFACE_P_H */
+
diff --git a/libs/gtkmm2/pango/pangomm/private/fontfamily_p.h b/libs/gtkmm2/pango/pangomm/private/fontfamily_p.h
new file mode 100644
index 0000000000..657f7b266a
--- /dev/null
+++ b/libs/gtkmm2/pango/pangomm/private/fontfamily_p.h
@@ -0,0 +1,44 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _PANGOMM_FONTFAMILY_P_H
+#define _PANGOMM_FONTFAMILY_P_H
+#include <glibmm/private/object_p.h>
+
+#include <glibmm/class.h>
+
+namespace Pango
+{
+
+class FontFamily_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef FontFamily CppObjectType;
+  typedef PangoFontFamily BaseObjectType;
+  typedef PangoFontFamilyClass BaseClassType;
+  typedef Glib::Object_Class CppClassParent;
+  typedef GObjectClass BaseClassParent;
+
+  friend class FontFamily;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Pango
+
+#endif /* _PANGOMM_FONTFAMILY_P_H */
+
diff --git a/libs/gtkmm2/pango/pangomm/private/fontmap_p.h b/libs/gtkmm2/pango/pangomm/private/fontmap_p.h
new file mode 100644
index 0000000000..88e898e016
--- /dev/null
+++ b/libs/gtkmm2/pango/pangomm/private/fontmap_p.h
@@ -0,0 +1,44 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _PANGOMM_FONTMAP_P_H
+#define _PANGOMM_FONTMAP_P_H
+#include <glibmm/private/object_p.h>
+
+#include <glibmm/class.h>
+
+namespace Pango
+{
+
+class FontMap_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef FontMap CppObjectType;
+  typedef PangoFontMap BaseObjectType;
+  typedef PangoFontMapClass BaseClassType;
+  typedef Glib::Object_Class CppClassParent;
+  typedef GObjectClass BaseClassParent;
+
+  friend class FontMap;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Pango
+
+#endif /* _PANGOMM_FONTMAP_P_H */
+
diff --git a/libs/gtkmm2/pango/pangomm/private/fontmetrics_p.h b/libs/gtkmm2/pango/pangomm/private/fontmetrics_p.h
new file mode 100644
index 0000000000..80670d0639
--- /dev/null
+++ b/libs/gtkmm2/pango/pangomm/private/fontmetrics_p.h
@@ -0,0 +1,6 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _PANGOMM_FONTMETRICS_P_H
+#define _PANGOMM_FONTMETRICS_P_H
+#endif /* _PANGOMM_FONTMETRICS_P_H */
+
diff --git a/libs/gtkmm2/pango/pangomm/private/fontset_p.h b/libs/gtkmm2/pango/pangomm/private/fontset_p.h
new file mode 100644
index 0000000000..ed012a1cbb
--- /dev/null
+++ b/libs/gtkmm2/pango/pangomm/private/fontset_p.h
@@ -0,0 +1,44 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _PANGOMM_FONTSET_P_H
+#define _PANGOMM_FONTSET_P_H
+#include <glibmm/private/object_p.h>
+
+#include <glibmm/class.h>
+
+namespace Pango
+{
+
+class Fontset_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Fontset CppObjectType;
+  typedef PangoFontset BaseObjectType;
+  typedef PangoFontsetClass BaseClassType;
+  typedef Glib::Object_Class CppClassParent;
+  typedef GObjectClass BaseClassParent;
+
+  friend class Fontset;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Pango
+
+#endif /* _PANGOMM_FONTSET_P_H */
+
diff --git a/libs/gtkmm2/pango/pangomm/private/glyph_p.h b/libs/gtkmm2/pango/pangomm/private/glyph_p.h
new file mode 100644
index 0000000000..8c4b42f6c7
--- /dev/null
+++ b/libs/gtkmm2/pango/pangomm/private/glyph_p.h
@@ -0,0 +1,6 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _PANGOMM_GLYPH_P_H
+#define _PANGOMM_GLYPH_P_H
+#endif /* _PANGOMM_GLYPH_P_H */
+
diff --git a/libs/gtkmm2/pango/pangomm/private/glyphstring_p.h b/libs/gtkmm2/pango/pangomm/private/glyphstring_p.h
new file mode 100644
index 0000000000..6d9535bcda
--- /dev/null
+++ b/libs/gtkmm2/pango/pangomm/private/glyphstring_p.h
@@ -0,0 +1,6 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _PANGOMM_GLYPHSTRING_P_H
+#define _PANGOMM_GLYPHSTRING_P_H
+#endif /* _PANGOMM_GLYPHSTRING_P_H */
+
diff --git a/libs/gtkmm2/pango/pangomm/private/item_p.h b/libs/gtkmm2/pango/pangomm/private/item_p.h
new file mode 100644
index 0000000000..a2015d337d
--- /dev/null
+++ b/libs/gtkmm2/pango/pangomm/private/item_p.h
@@ -0,0 +1,6 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _PANGOMM_ITEM_P_H
+#define _PANGOMM_ITEM_P_H
+#endif /* _PANGOMM_ITEM_P_H */
+
diff --git a/libs/gtkmm2/pango/pangomm/private/language_p.h b/libs/gtkmm2/pango/pangomm/private/language_p.h
new file mode 100644
index 0000000000..f9921544be
--- /dev/null
+++ b/libs/gtkmm2/pango/pangomm/private/language_p.h
@@ -0,0 +1,6 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _PANGOMM_LANGUAGE_P_H
+#define _PANGOMM_LANGUAGE_P_H
+#endif /* _PANGOMM_LANGUAGE_P_H */
+
diff --git a/libs/gtkmm2/pango/pangomm/private/layout_p.h b/libs/gtkmm2/pango/pangomm/private/layout_p.h
new file mode 100644
index 0000000000..d87fb6de2f
--- /dev/null
+++ b/libs/gtkmm2/pango/pangomm/private/layout_p.h
@@ -0,0 +1,44 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _PANGOMM_LAYOUT_P_H
+#define _PANGOMM_LAYOUT_P_H
+#include <glibmm/private/object_p.h>
+
+#include <glibmm/class.h>
+
+namespace Pango
+{
+
+class Layout_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Layout CppObjectType;
+  typedef PangoLayout BaseObjectType;
+  typedef PangoLayoutClass BaseClassType;
+  typedef Glib::Object_Class CppClassParent;
+  typedef GObjectClass BaseClassParent;
+
+  friend class Layout;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Pango
+
+#endif /* _PANGOMM_LAYOUT_P_H */
+
diff --git a/libs/gtkmm2/pango/pangomm/private/layoutiter_p.h b/libs/gtkmm2/pango/pangomm/private/layoutiter_p.h
new file mode 100644
index 0000000000..e43c4334d2
--- /dev/null
+++ b/libs/gtkmm2/pango/pangomm/private/layoutiter_p.h
@@ -0,0 +1,6 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _PANGOMM_LAYOUTITER_P_H
+#define _PANGOMM_LAYOUTITER_P_H
+#endif /* _PANGOMM_LAYOUTITER_P_H */
+
diff --git a/libs/gtkmm2/pango/pangomm/private/layoutline_p.h b/libs/gtkmm2/pango/pangomm/private/layoutline_p.h
new file mode 100644
index 0000000000..2bccde57d1
--- /dev/null
+++ b/libs/gtkmm2/pango/pangomm/private/layoutline_p.h
@@ -0,0 +1,6 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _PANGOMM_LAYOUTLINE_P_H
+#define _PANGOMM_LAYOUTLINE_P_H
+#endif /* _PANGOMM_LAYOUTLINE_P_H */
+
diff --git a/libs/gtkmm2/pango/pangomm/private/layoutrun_p.h b/libs/gtkmm2/pango/pangomm/private/layoutrun_p.h
new file mode 100644
index 0000000000..3d9bb774f1
--- /dev/null
+++ b/libs/gtkmm2/pango/pangomm/private/layoutrun_p.h
@@ -0,0 +1,6 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _PANGOMM_LAYOUTRUN_P_H
+#define _PANGOMM_LAYOUTRUN_P_H
+#endif /* _PANGOMM_LAYOUTRUN_P_H */
+
diff --git a/libs/gtkmm2/pango/pangomm/private/rectangle_p.h b/libs/gtkmm2/pango/pangomm/private/rectangle_p.h
new file mode 100644
index 0000000000..4b3e6f2481
--- /dev/null
+++ b/libs/gtkmm2/pango/pangomm/private/rectangle_p.h
@@ -0,0 +1,6 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _PANGOMM_RECTANGLE_P_H
+#define _PANGOMM_RECTANGLE_P_H
+#endif /* _PANGOMM_RECTANGLE_P_H */
+
diff --git a/libs/gtkmm2/pango/pangomm/private/renderer_p.h b/libs/gtkmm2/pango/pangomm/private/renderer_p.h
new file mode 100644
index 0000000000..1c24c86970
--- /dev/null
+++ b/libs/gtkmm2/pango/pangomm/private/renderer_p.h
@@ -0,0 +1,44 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _PANGOMM_RENDERER_P_H
+#define _PANGOMM_RENDERER_P_H
+#include <glibmm/private/object_p.h>
+
+#include <glibmm/class.h>
+
+namespace Pango
+{
+
+class Renderer_Class : public Glib::Class
+{
+public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Renderer CppObjectType;
+  typedef PangoRenderer BaseObjectType;
+  typedef PangoRendererClass BaseClassType;
+  typedef Glib::Object_Class CppClassParent;
+  typedef GObjectClass BaseClassParent;
+
+  friend class Renderer;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  const Glib::Class& init();
+
+  static void class_init_function(void* g_class, void* class_data);
+
+  static Glib::ObjectBase* wrap_new(GObject*);
+
+protected:
+
+  //Callbacks (default signal handlers):
+  //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
+  //You could prevent the original default signal handlers being called by overriding the *_impl method.
+
+  //Callbacks (virtual functions):
+};
+
+
+} // namespace Pango
+
+#endif /* _PANGOMM_RENDERER_P_H */
+
diff --git a/libs/gtkmm2/pango/pangomm/private/tabarray_p.h b/libs/gtkmm2/pango/pangomm/private/tabarray_p.h
new file mode 100644
index 0000000000..d27ae8534a
--- /dev/null
+++ b/libs/gtkmm2/pango/pangomm/private/tabarray_p.h
@@ -0,0 +1,6 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _PANGOMM_TABARRAY_P_H
+#define _PANGOMM_TABARRAY_P_H
+#endif /* _PANGOMM_TABARRAY_P_H */
+
diff --git a/libs/gtkmm2/pango/pangomm/rectangle.cc b/libs/gtkmm2/pango/pangomm/rectangle.cc
new file mode 100644
index 0000000000..4686d3a7d0
--- /dev/null
+++ b/libs/gtkmm2/pango/pangomm/rectangle.cc
@@ -0,0 +1,84 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <pangomm/rectangle.h>
+#include <pangomm/private/rectangle_p.h>
+
+/* Copyright (C) 2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+namespace Pango
+{
+
+Rectangle::Rectangle()
+{
+  gobject_.x = gobject_.y = 0;
+  gobject_.width = gobject_.height = 0;
+}
+
+Rectangle::Rectangle(int x, int y, int width, int height)
+{
+  gobject_.x = x;
+  gobject_.y = y;
+  gobject_.width = width;
+  gobject_.height = height;
+}
+
+Rectangle::Rectangle(const PangoRectangle* src)
+{
+  gobject_.x = src->x;
+  gobject_.y = src->y;
+  gobject_.width = src->width;
+  gobject_.height = src->height;
+}
+
+bool Rectangle::equal(const Rectangle& rhs) const
+{
+  return (get_x() == rhs.get_x() && get_y() == rhs.get_y() &&
+          get_width() == rhs.get_width() && get_height() == rhs.get_height());
+}
+
+} /* namespace Pango */
+
+
+namespace Glib
+{
+
+Pango::Rectangle& wrap(PangoRectangle* object)
+{
+  return *reinterpret_cast<Pango::Rectangle*>(object);
+}
+
+const Pango::Rectangle& wrap(const PangoRectangle* object)
+{
+  return *reinterpret_cast<const Pango::Rectangle*>(object);
+}
+
+} /* namespace Glib */
+
+
+namespace
+{
+} // anonymous namespace
+
+
+namespace Pango
+{
+
+
+} // namespace Pango
+
+
diff --git a/libs/gtkmm2/pango/pangomm/rectangle.h b/libs/gtkmm2/pango/pangomm/rectangle.h
new file mode 100644
index 0000000000..beb6825406
--- /dev/null
+++ b/libs/gtkmm2/pango/pangomm/rectangle.h
@@ -0,0 +1,163 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _PANGOMM_RECTANGLE_H
+#define _PANGOMM_RECTANGLE_H
+
+#include <glibmm.h>
+
+/* Copyright (C) 2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <pango/pango-types.h>
+
+
+namespace Pango
+{
+
+/** A Pango::Rectangle represents a rectangle.
+ * It is frequently used to represent the logical or ink extents of a single glyph or section of text.
+ * The coordinate system for each rectangle has its origin at the base line and the horizontal
+ * origin of the character with increasing coordinates extending to the right and down.
+ * get_ascent(), get_descent(), get_lbearing(), and get_rbearing() can be used to convert
+ * from the extents rectangle to more traditional font metrics.
+ * The units of rectangles usually are in 1/Pango::SCALE of a device unit.
+ */
+class Rectangle
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef Rectangle CppObjectType;
+  typedef PangoRectangle BaseObjectType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+private:
+
+
+public:
+  Rectangle();
+  Rectangle(int x, int y, int width, int height);
+  explicit Rectangle(const PangoRectangle* src);
+
+  /** Sets the X coordinate of the left side of the rectangle.
+   * @param x The new X coordinate.
+   */
+  void set_x(int x)        { gobject_.x = x; }
+
+  /** Sets the Y coordinate of the top side of the rectangle.
+   * @param y The new Y coordinate.
+   */
+  void set_y(int y)        { gobject_.y = y; }
+
+  /** Sets the width of the rectangle.
+   * @param w The new width.
+   */
+  void set_width(int w)    { gobject_.width = w; }
+
+  /** Sets the height of the rectangle.
+   * @param h The new height.
+   */
+  void set_height(int h)   { gobject_.height = h; }
+
+  /** Gets the X coordinate of the left side of the rectangle.
+   * @return The X coordinate.
+   */
+  int get_x() const        { return gobject_.x; }
+
+  /** Gets the Y coordinate of the top side of the rectangle.
+   * @return The Y coordinate.
+   */
+  int get_y() const        { return gobject_.y; }
+
+  /** Gets the width of the rectangle.
+   * @return The width.
+   */
+  int get_width() const    { return gobject_.width; }
+
+  /** Gets the height of the rectangle.
+   * @return The height.
+   */
+  int get_height() const   { return gobject_.height; }
+
+  /** Extracts the ascent from a Pango::Rectangle representing glyph extents.
+   * The ascent is the distance from the baseline to the highest point of the character.
+   * This is positive if the glyph ascends above the baseline.
+   * @return The ascent of the character.
+   */
+  int get_ascent() const   { return PANGO_ASCENT(*gobj()); }
+
+  /** Extracts the descent from a Pango::Rectangle representing glyph extents.
+   * The descent is the distance from the baseline to the lowest point of the character.
+   * This is positive if the glyph descends below the baseline.
+   * @return The descent of the character.
+   */
+  int get_descent() const  { return PANGO_DESCENT(*gobj()); }
+
+  /** Extracts the left bearing from a Pango::Rectangle representing glyph extents.
+   * The left bearing is the distance from the horizontal origin to the farthest left point of the character.
+   * This is positive for characters drawn completely to the right of the glyph origin.
+   * @return The left bearing of the character.
+   */
+  int get_lbearing() const { return PANGO_LBEARING(*gobj()); }
+
+  /** Extracts the right bearing from a Pango::Rectangle representing glyph extents.
+   * The right bearing is the distance from the horizontal origin to the farthest right point of the character.
+   * This is positive except for characters drawn completely to the left of the horizontal origin.
+   * @return The right bearing of the character.
+   */
+  int get_rbearing() const { return PANGO_RBEARING(*gobj()); }
+
+  /** Checks for equality of two Pango::Rectangles.
+   * @param rhs The Pango::Rectangle to compare with.
+   * @return true if @a rhs is equal with the rectangle.
+   */
+  bool equal(const Rectangle& rhs) const;
+
+  /// Provides access to the underlying C GObject.  
+  PangoRectangle*       gobj()       { return &gobject_; }
+  /// Provides access to the underlying C GObject.
+  const PangoRectangle* gobj() const { return &gobject_; }
+
+protected:
+  PangoRectangle gobject_;
+
+
+};
+
+/** @relates Pango::Rectangle */
+inline bool operator==(const Rectangle& lhs, const Rectangle& rhs)
+  { return lhs.equal(rhs); }
+
+/** @relates Pango::Rectangle */
+inline bool operator!=(const Rectangle& lhs, const Rectangle& rhs)
+  { return !lhs.equal(rhs); }
+
+} /* namespace Pango */
+
+
+namespace Glib
+{
+
+/** @relates Pango::Rectangle */
+Pango::Rectangle& wrap(PangoRectangle* object);
+
+/** @relates Pango::Rectangle */
+const Pango::Rectangle& wrap(const PangoRectangle* object);
+
+} /* namespace Glib */
+
+#endif /* _PANGOMM_RECTANGLE_H */
+
diff --git a/libs/gtkmm2/pango/pangomm/renderer.cc b/libs/gtkmm2/pango/pangomm/renderer.cc
new file mode 100644
index 0000000000..e456fc19cf
--- /dev/null
+++ b/libs/gtkmm2/pango/pangomm/renderer.cc
@@ -0,0 +1,203 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <pangomm/renderer.h>
+#include <pangomm/private/renderer_p.h>
+
+#include <pango/pango-enum-types.h>
+// -*- c++ -*-
+/* $Id$ */
+
+/* 
+ *
+ * Copyright 2004 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <pango/pango-renderer.h>
+
+namespace Pango
+{
+
+} /* namespace Pango */
+
+
+namespace
+{
+} // anonymous namespace
+
+// static
+GType Glib::Value<Pango::RenderPart>::value_type()
+{
+  return pango_render_part_get_type();
+}
+
+
+namespace Glib
+{
+
+Glib::RefPtr<Pango::Renderer> wrap(PangoRenderer* object, bool take_copy)
+{
+  return Glib::RefPtr<Pango::Renderer>( dynamic_cast<Pango::Renderer*> (Glib::wrap_auto ((GObject*)(object), take_copy)) );
+  //We use dynamic_cast<> in case of multiple inheritance.
+}
+
+} /* namespace Glib */
+
+
+namespace Pango
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& Renderer_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &Renderer_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(pango_renderer_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void Renderer_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+}
+
+
+Glib::ObjectBase* Renderer_Class::wrap_new(GObject* object)
+{
+  return new Renderer((PangoRenderer*)object);
+}
+
+
+/* The implementation: */
+
+PangoRenderer* Renderer::gobj_copy()
+{
+  reference();
+  return gobj();
+}
+
+Renderer::Renderer(const Glib::ConstructParams& construct_params)
+:
+  Glib::Object(construct_params)
+{}
+
+Renderer::Renderer(PangoRenderer* castitem)
+:
+  Glib::Object((GObject*)(castitem))
+{}
+
+Renderer::~Renderer()
+{}
+
+
+Renderer::CppClassType Renderer::renderer_class_; // initialize static member
+
+GType Renderer::get_type()
+{
+  return renderer_class_.init().get_type();
+}
+
+GType Renderer::get_base_type()
+{
+  return pango_renderer_get_type();
+}
+
+
+void Renderer::draw_layout(const Glib::RefPtr<Layout>& layout, int x, int y)
+{
+  pango_renderer_draw_layout(gobj(), Glib::unwrap(layout), x, y);
+}
+
+void Renderer::draw_layout_line(const Glib::RefPtr<LayoutLine>& line, int x, int y)
+{
+  pango_renderer_draw_layout_line(gobj(), Glib::unwrap(line), x, y);
+}
+
+void Renderer::draw_glyphs(const Glib::RefPtr<Font>& font, const GlyphString& glyphs, int x, int y)
+{
+  pango_renderer_draw_glyphs(gobj(), Glib::unwrap(font), const_cast<PangoGlyphString*>(glyphs.gobj()), x, y);
+}
+
+void Renderer::draw_rectangle(RenderPart part, int x, int y, int width, int height)
+{
+  pango_renderer_draw_rectangle(gobj(), ((PangoRenderPart)(part)), x, y, width, height);
+}
+
+void Renderer::draw_error_underline(int x, int y, int width, int height)
+{
+  pango_renderer_draw_error_underline(gobj(), x, y, width, height);
+}
+
+void Renderer::draw_trapezoid(RenderPart part, double y1, double x11, double x21, double y2, double x12, double x22)
+{
+  pango_renderer_draw_trapezoid(gobj(), ((PangoRenderPart)(part)), y1, x11, x21, y2, x12, x22);
+}
+
+void Renderer::draw_glyph(const Glib::RefPtr<Font>& font, Glyph glyph, double x, double y)
+{
+  pango_renderer_draw_glyph(gobj(), Glib::unwrap(font), glyph, x, y);
+}
+
+void Renderer::activate()
+{
+  pango_renderer_activate(gobj());
+}
+
+void Renderer::deactivate()
+{
+  pango_renderer_deactivate(gobj());
+}
+
+void Renderer::part_changed(RenderPart part)
+{
+  pango_renderer_part_changed(gobj(), ((PangoRenderPart)(part)));
+}
+
+void Renderer::set_color(RenderPart part, const Color& color)
+{
+  pango_renderer_set_color(gobj(), ((PangoRenderPart)(part)), (color).gobj());
+}
+
+Color Renderer::get_color(RenderPart part) const
+{
+  return Color(pango_renderer_get_color(const_cast<PangoRenderer*>(gobj()), ((PangoRenderPart)(part))));
+}
+
+void Renderer::set_matrix(const Matrix& matrix)
+{
+  pango_renderer_set_matrix(gobj(), &(matrix));
+}
+
+
+} // namespace Pango
+
+
diff --git a/libs/gtkmm2/pango/pangomm/renderer.h b/libs/gtkmm2/pango/pangomm/renderer.h
new file mode 100644
index 0000000000..8428c15b50
--- /dev/null
+++ b/libs/gtkmm2/pango/pangomm/renderer.h
@@ -0,0 +1,322 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _PANGOMM_RENDERER_H
+#define _PANGOMM_RENDERER_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* renderer.h
+ *
+ * Copyright(C) 2004 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+
+#include <glibmm/object.h>
+#include <pangomm/context.h>
+#include <pangomm/glyphstring.h>
+#include <pangomm/layout.h>
+#include <pangomm/layoutline.h>
+#include <pangomm/types.h> //For Matrix.
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _PangoRenderer PangoRenderer;
+typedef struct _PangoRendererClass PangoRendererClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Pango
+{ class Renderer_Class; } // namespace Pango
+namespace Pango
+{
+
+
+/** @addtogroup pangommEnums Enums and Flags */
+
+/**
+ * @ingroup pangommEnums
+ */
+enum RenderPart
+{
+  RENDER_PART_FOREGROUND,
+  RENDER_PART_BACKGROUND,
+  RENDER_PART_UNDERLINE,
+  RENDER_PART_STRIKETHROUGH
+};
+
+} // namespace Pango
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Pango::RenderPart> : public Glib::Value_Enum<Pango::RenderPart>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Pango
+{
+
+
+/** TODO.
+ */
+
+class Renderer : public Glib::Object
+{
+  
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+public:
+  typedef Renderer CppObjectType;
+  typedef Renderer_Class CppClassType;
+  typedef PangoRenderer BaseObjectType;
+  typedef PangoRendererClass BaseClassType;
+
+private:  friend class Renderer_Class;
+  static CppClassType renderer_class_;
+
+private:
+  // noncopyable
+  Renderer(const Renderer&);
+  Renderer& operator=(const Renderer&);
+
+protected:
+  explicit Renderer(const Glib::ConstructParams& construct_params);
+  explicit Renderer(PangoRenderer* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+  virtual ~Renderer();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  static GType get_type()      G_GNUC_CONST;
+  static GType get_base_type() G_GNUC_CONST;
+#endif
+
+  ///Provides access to the underlying C GObject.
+  PangoRenderer*       gobj()       { return reinterpret_cast<PangoRenderer*>(gobject_); }
+
+  ///Provides access to the underlying C GObject.
+  const PangoRenderer* gobj() const { return reinterpret_cast<PangoRenderer*>(gobject_); }
+
+  ///Provides access to the underlying C instance. The caller is responsible for unrefing it. Use when directly setting fields in structs.
+  PangoRenderer* gobj_copy();
+
+private:
+
+ 
+protected:
+ 
+public:
+
+  
+  /** Draws @a layout  with the specified Pango::Renderer.
+   * 
+   * Since: 1.8
+   * @param layout A Pango::Layout.
+   * @param x X position of left edge of baseline, in user space coordinates
+   * in Pango units.
+   * @param y X position of left edge of baseline, in user space coordinates
+   * in Pango units.
+   */
+  void draw_layout(const Glib::RefPtr<Layout>& layout, int x, int y);
+  
+  /** Draws @a line  with the specified Pango::Renderer.
+   * 
+   * Since: 1.8
+   * @param line A Pango::LayoutLine.
+   * @param x X position of left edge of baseline, in user space coordinates
+   * in Pango units.
+   * @param y X position of left edge of baseline, in user space coordinates
+   * in Pango units.
+   */
+  void draw_layout_line(const Glib::RefPtr<LayoutLine>& line, int x, int y);
+  
+  /** Draws the glyphs in @a glyphs  with the specified Pango::Renderer.
+   * 
+   * Since: 1.8
+   * @param font A Pango::Font.
+   * @param glyphs A Pango::GlyphString.
+   * @param x X position of left edge of baseline, in user space coordinates
+   * in Pango units.
+   * @param y X position of left edge of baseline, in user space coordinates
+   * in Pango units.
+   */
+  void draw_glyphs(const Glib::RefPtr<Font>& font, const GlyphString& glyphs, int x, int y);
+  
+  /** Draws an axis-aligned rectangle in user space coordinates with the
+   * specified Pango::Renderer.
+   * 
+   * Since: 1.8
+   * @param part Type of object this rectangle is part of.
+   * @param x X position at which to draw rectangle, in user space coordinates in Pango units.
+   * @param y Y position at which to draw rectangle, in user space coordinates in Pango units.
+   * @param width Width of rectangle in PangoUnits in user space coordinates.
+   * @param height Height of rectangle in PangoUnits in user space coordinates.
+   */
+  void draw_rectangle(RenderPart part, int x, int y, int width, int height);
+  
+  /** Draw a squiggly line that approximately covers the given rectangle
+   * in the style of an underline used to indicate a spelling error.
+   * (The width of the underline is rounded to an integer number
+   * of up/down segments and the resulting rectangle is centered
+   * in the original rectangle)
+   * 
+   * Since: 1.8
+   * @param x X coordinate of underline, in Pango units in user coordinate system.
+   * @param y Y coordinate of underline, in Pango units in user coordinate system.
+   * @param width Width of underline, in Pango units in user coordinate system.
+   * @param height Height of underline, in Pango units in user coordinate system.
+   */
+  void draw_error_underline(int x, int y, int width, int height);
+  
+  /** Draws a trapezoid with the parallel sides aligned with the X axis
+   * using the given Pango::Renderer; coordinates are in device space.
+   * 
+   * Since: 1.8
+   * @param part Type of object this trapezoid is part of.
+   * @param y1 Y coordinate of top of trapezoid.
+   * @param x11 X coordinate of left end of top of trapezoid.
+   * @param x21 X coordinate of right end of top of trapezoid.
+   * @param y2 X coordinate of top of trapezoid.
+   * @param x12 X coordinate of left end of top of trapezoid.
+   * @param x22 Y coordinate of left end of top of trapezoid.
+   */
+  void draw_trapezoid(RenderPart part, double y1, double x11, double x21, double y2, double x12, double x22);
+  
+  /** Draws a single glyph with coordinates in device space.
+   * 
+   * Since: 1.8
+   * @param font A Pango::Font.
+   * @param glyph The glyph index of a single glyph.
+   * @param x X coordinate of left edge of baseline of glyph.
+   * @param y Y coordinate of left edge of baseline of glyph.
+   */
+  void draw_glyph(const Glib::RefPtr<Font>& font, Glyph glyph, double x, double y);
+
+  
+  /** Does initial setup before rendering operations on @a renderer .
+   * deactivate() should be called when done drawing.
+   * Calls such as draw_layout() automatically
+   * activate the layout before drawing on it. Calls to
+   * activate() and deactivate() can
+   * be nested and the renderer will only be initialized and
+   * deinitialized once.
+   * 
+   * Since: 1.8
+   */
+  void activate();
+  
+  /** Cleans up after rendering operations on @a renderer . See
+   * docs for activate().
+   * 
+   * Since: 1.8
+   */
+  void deactivate();
+
+  
+  /** Informs Pango that the way that the renderering is done
+   * for @a part  has changed in a way that would prevent multiple
+   * pieces being joined together into one drawing call. For
+   * instance, if a subclass of Pango::Renderer was to add a stipple
+   * option for drawing underlines, it needs to call
+   * 
+   * @code
+   * pango_renderer_part_changed (render, PANGO_RENDER_PART_UNDERLINE);
+   * @endcode
+   * 
+   * When the stipple changes or underlines with different stipples
+   * might be joined together. Pango automatically calls this for
+   * changes to colors. (See set_color())
+   * 
+   * Since: 1.8
+   * @param part The part for which rendering has changed.
+   */
+  void part_changed(RenderPart part);
+
+  
+  /** Sets the color for part of the rendering.
+   * 
+   * Since: 1.8
+   * @param part The part to change the color of.
+   * @param color The new color or <tt>0</tt> to unset the current color.
+   */
+  void set_color(RenderPart part, const Color& color);
+  
+ 
+  /** Gets the current rendering color for the specified part.
+   * @param part The part to get the color for.
+   * @return The color for the specified part, or <tt>0</tt>
+   * if it hasn't been set and should be inherited from the
+   * environment.
+   * 
+   * Since: 1.8.
+   */
+  Color get_color(RenderPart part) const;
+
+  
+  /** Sets the transformation matrix that will be applied when rendering.
+   * 
+   * Since: 1.8
+   * @param matrix A Pango::Matrix, or <tt>0</tt> to unset any existing matrix.
+   * (No matrix set is the same as setting the identity matrix.).
+   */
+  void set_matrix(const Matrix& matrix);
+  //TOOD: _WRAP_METHOD(Matrix get_matrix(), pango_renderer_get_matrix)
+  //Note: The returned matrix is owned by Pango and must not be modified or freed.
+
+
+public:
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+};
+
+} /* namespace Pango */
+
+
+namespace Glib
+{
+  /** @relates Pango::Renderer
+   * @param object The C instance
+   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+   * @result A C++ instance that wraps this C instance.
+   */
+  Glib::RefPtr<Pango::Renderer> wrap(PangoRenderer* object, bool take_copy = false);
+}
+
+
+#endif /* _PANGOMM_RENDERER_H */
+
diff --git a/libs/gtkmm2/pango/pangomm/tabarray.cc b/libs/gtkmm2/pango/pangomm/tabarray.cc
new file mode 100644
index 0000000000..57353f418a
--- /dev/null
+++ b/libs/gtkmm2/pango/pangomm/tabarray.cc
@@ -0,0 +1,181 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <pangomm/tabarray.h>
+#include <pangomm/private/tabarray_p.h>
+
+#include <pango/pango-enum-types.h>
+// -*- c++ -*-
+/* $Id$ */
+
+/*
+ *
+ * Copyright 2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+namespace Pango
+{
+
+TabArray::TabArray(int initial_size, bool positions_in_pixels)
+{
+  gobject_ = pango_tab_array_new(initial_size, (gboolean)positions_in_pixels);
+}
+
+std::pair<TabAlign,int> TabArray::get_tab(int tab_index) const
+{
+  TabAlign alignment;
+  int location;
+  pango_tab_array_get_tab(const_cast<PangoTabArray*>(gobj()), tab_index, (PangoTabAlign*)&alignment, &location);
+  return std::pair<TabAlign,int>(alignment, location);
+}
+
+Glib::ArrayHandle< std::pair<TabAlign,int> > TabArray::get_tabs() const
+{
+  typedef std::pair<TabAlign,int> PairType;
+
+  PairType* pair_buffer = 0;
+  const int size = pango_tab_array_get_size(const_cast<PangoTabArray*>(gobj()));
+
+  if(size > 0)
+  {
+    // Get arrays
+    PangoTabAlign* pAlignments = 0;
+    int*           pLocations  = 0;
+    pango_tab_array_get_tabs(const_cast<PangoTabArray*>(gobj()), &pAlignments, &pLocations);
+
+    if(pAlignments && pLocations)
+    {
+      // Create temporary C array.  Fortunately, the C++ type is POD,
+      // so we can safely store it in the array.
+      pair_buffer = g_new(PairType, size);
+
+      for(int i = 0; i < size; ++i)
+      {
+        pair_buffer[i].first  = (TabAlign)(pAlignments[i]);
+        pair_buffer[i].second = pLocations[i];
+      }
+    }
+
+    g_free(pAlignments);
+    g_free(pLocations);
+  }
+
+  return Glib::ArrayHandle<PairType>(pair_buffer, size, Glib::OWNERSHIP_SHALLOW);
+}
+
+} /* namespace Pango */
+
+
+namespace
+{
+} // anonymous namespace
+
+// static
+GType Glib::Value<Pango::TabAlign>::value_type()
+{
+  return pango_tab_align_get_type();
+}
+
+
+namespace Glib
+{
+
+Pango::TabArray wrap(PangoTabArray* object, bool take_copy)
+{
+  return Pango::TabArray(object, take_copy);
+}
+
+} // namespace Glib
+
+
+namespace Pango
+{
+
+
+// static
+GType TabArray::get_type()
+{
+  return pango_tab_array_get_type();
+}
+
+TabArray::TabArray()
+:
+  gobject_ (0) // Allows creation of invalid wrapper, e.g. for output arguments to methods.
+{}
+
+TabArray::TabArray(const TabArray& other)
+:
+  gobject_ ((other.gobject_) ? pango_tab_array_copy(other.gobject_) : 0)
+{}
+
+TabArray::TabArray(PangoTabArray* gobject, bool make_a_copy)
+:
+  // For BoxedType wrappers, make_a_copy is true by default.  The static
+  // BoxedType wrappers must always take a copy, thus make_a_copy = true
+  // ensures identical behaviour if the default argument is used.
+  gobject_ ((make_a_copy && gobject) ? pango_tab_array_copy(gobject) : gobject)
+{}
+
+TabArray& TabArray::operator=(const TabArray& other)
+{
+  TabArray temp (other);
+  swap(temp);
+  return *this;
+}
+
+TabArray::~TabArray()
+{
+  if(gobject_)
+    pango_tab_array_free(gobject_);
+}
+
+void TabArray::swap(TabArray& other)
+{
+  PangoTabArray *const temp = gobject_;
+  gobject_ = other.gobject_;
+  other.gobject_ = temp;
+}
+
+PangoTabArray* TabArray::gobj_copy() const
+{
+  return pango_tab_array_copy(gobject_);
+}
+
+
+int TabArray::get_size() const
+{
+  return pango_tab_array_get_size(const_cast<PangoTabArray*>(gobj()));
+}
+
+void TabArray::resize(int new_size)
+{
+  pango_tab_array_resize(gobj(), new_size);
+}
+
+void TabArray::set_tab(int tab_index, TabAlign alignment, int location)
+{
+  pango_tab_array_set_tab(gobj(), tab_index, ((PangoTabAlign)(alignment)), location);
+}
+
+bool TabArray::get_positions_in_pixels() const
+{
+  return pango_tab_array_get_positions_in_pixels(const_cast<PangoTabArray*>(gobj()));
+}
+
+
+} // namespace Pango
+
+
diff --git a/libs/gtkmm2/pango/pangomm/tabarray.h b/libs/gtkmm2/pango/pangomm/tabarray.h
new file mode 100644
index 0000000000..7a5850c663
--- /dev/null
+++ b/libs/gtkmm2/pango/pangomm/tabarray.h
@@ -0,0 +1,195 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _PANGOMM_TABARRAY_H
+#define _PANGOMM_TABARRAY_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* tabarray.h
+ *
+ * Copyright (C) 1998-1999 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <pangomm/attrlist.h>
+#include <pango/pango-tabs.h>
+#include <pango/pango-break.h> //For PangoLogAttrs.
+
+#include <utility>
+#include <glibmmconfig.h>
+GLIBMM_USING_STD(pair)
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+extern "C" { typedef struct _PangoTabArray PangoTabArray; }
+#endif
+
+namespace Pango
+{
+
+
+/** @addtogroup pangommEnums Enums and Flags */
+
+/**
+ * @ingroup pangommEnums
+ */
+enum TabAlign
+{
+  TAB_LEFT
+};
+
+} // namespace Pango
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Pango::TabAlign> : public Glib::Value_Enum<Pango::TabAlign>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Pango
+{
+
+
+/** A Pango::TabArray contains an array of tab stops.
+ * Each tab stop has an alignment and a position.
+ */
+class TabArray
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef TabArray CppObjectType;
+  typedef PangoTabArray BaseObjectType;
+
+  static GType get_type() G_GNUC_CONST;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  TabArray();
+
+  explicit TabArray(PangoTabArray* gobject, bool make_a_copy = true);
+
+  TabArray(const TabArray& other);
+  TabArray& operator=(const TabArray& other);
+
+  ~TabArray();
+
+  void swap(TabArray& other);
+
+  ///Provides access to the underlying C instance.
+  PangoTabArray*       gobj()       { return gobject_; }
+
+  ///Provides access to the underlying C instance.
+  const PangoTabArray* gobj() const { return gobject_; }
+
+  ///Provides access to the underlying C instance. The caller is responsible for freeing it. Use when directly setting fields in structs.
+  PangoTabArray* gobj_copy() const;
+
+protected:
+  PangoTabArray* gobject_;
+
+private:
+
+  
+public:
+  explicit TabArray(int initial_size, bool positions_in_pixels = true);
+
+  
+  /** Gets the number of tab stops in @a tab_array .
+   * @return The number of tab stops in the array.
+   */
+  int get_size() const;
+  
+  /** Resizes a tab array. You must subsequently initialize any tabs that
+   * were added as a result of growing the array.
+   * @param new_size New size of the array.
+   */
+  void resize(int new_size);
+  
+  /** Sets the alignment and location of a tab stop.
+   *  @a alignment  must always be Pango::TAB_LEFT in the current
+   * implementation.
+   * @param tab_index The index of a tab stop.
+   * @param alignment Tab alignment.
+   * @param location Tab location in pango units.
+   */
+  void set_tab(int tab_index, TabAlign alignment, int location);
+
+  /** Gets the alignment and position of a tab stop.
+   * @return An std::pair<TabAlign, int>. The first element represents the tab stop alignment, the second one is the tab position.
+   */
+  std::pair<TabAlign,int> get_tab(int tab_index) const;
+
+  /** Gets an array of std::pairs containing the tab stop alignments and tab positions.
+   * @return An array of std::pair<TabAlign, int>. The first element in each pair represents the tab stop alignment, the second one is the tab position.
+   */
+  Glib::ArrayHandle< std::pair<TabAlign,int> > get_tabs() const;
+
+  
+  /** Returns <tt>true</tt> if the tab positions are in pixels, <tt>false</tt> if they are
+   * in Pango units.
+   * @return Whether positions are in pixels.
+   */
+  bool get_positions_in_pixels() const;
+
+
+};
+
+} //namespace Pango
+
+
+namespace Pango
+{
+
+/** @relates Pango::TabArray
+ * @param lhs The left-hand side
+ * @param rhs The right-hand side
+ */
+inline void swap(TabArray& lhs, TabArray& rhs)
+  { lhs.swap(rhs); }
+
+} // namespace Pango
+
+namespace Glib
+{
+
+/** @relates Pango::TabArray
+ * @param object The C instance
+ * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
+ * @result A C++ instance that wraps this C instance.
+ */
+Pango::TabArray wrap(PangoTabArray* object, bool take_copy = false);
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+template <>
+class Value<Pango::TabArray> : public Glib::Value_Boxed<Pango::TabArray>
+{};
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+} // namespace Glib
+
+#endif /* _PANGOMM_TABARRAY_H */
+
diff --git a/libs/gtkmm2/pango/pangomm/types.h b/libs/gtkmm2/pango/pangomm/types.h
new file mode 100644
index 0000000000..4ed2f12783
--- /dev/null
+++ b/libs/gtkmm2/pango/pangomm/types.h
@@ -0,0 +1,34 @@
+/* $Id$ */
+
+/* Copyright (C) 2002 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#ifndef _PANGOMM_TYPES_H
+#define _PANGOMM_TYPES_H
+
+#include <pango/pango-types.h>
+
+namespace Pango
+{
+
+typedef PangoMatrix Matrix;
+
+} // namespace Pango
+
+
+#endif /* _PANGOMM_TYPES_H */
+
diff --git a/libs/gtkmm2/pango/pangomm/wrap_init.cc b/libs/gtkmm2/pango/pangomm/wrap_init.cc
new file mode 100644
index 0000000000..348d28fabd
--- /dev/null
+++ b/libs/gtkmm2/pango/pangomm/wrap_init.cc
@@ -0,0 +1,100 @@
+
+#include <glib.h>
+
+// Disable the 'const' function attribute of the get_type() functions.
+// GCC would optimize them out because we don't use the return value.
+#undef  G_GNUC_CONST
+#define G_GNUC_CONST /* empty */
+
+#include <pangomm/wrap_init.h>
+#include <glibmm/error.h>
+#include <glibmm/object.h>
+
+// #include the widget headers so that we can call the get_type() static methods:
+
+#include "attributes.h"
+#include "attriter.h"
+#include "attrlist.h"
+#include "color.h"
+#include "context.h"
+#include "coverage.h"
+#include "font.h"
+#include "fontdescription.h"
+#include "fontface.h"
+#include "fontfamily.h"
+#include "fontmap.h"
+#include "fontmetrics.h"
+#include "fontset.h"
+#include "glyph.h"
+#include "glyphstring.h"
+#include "item.h"
+#include "language.h"
+#include "layout.h"
+#include "layoutiter.h"
+#include "layoutline.h"
+#include "layoutrun.h"
+#include "rectangle.h"
+#include "renderer.h"
+#include "tabarray.h"
+
+extern "C"
+{
+
+//Declarations of the *_get_type() functions:
+
+GType pango_context_get_type(void);
+GType pango_font_get_type(void);
+GType pango_font_face_get_type(void);
+GType pango_font_family_get_type(void);
+GType pango_font_map_get_type(void);
+GType pango_fontset_get_type(void);
+GType pango_layout_get_type(void);
+GType pango_renderer_get_type(void);
+
+//Declarations of the *_error_quark() functions:
+
+} // extern "C"
+
+
+//Declarations of the *_Class::wrap_new() methods, instead of including all the private headers:
+
+namespace Pango {  class Context_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Pango {  class Font_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Pango {  class FontFace_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Pango {  class FontFamily_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Pango {  class FontMap_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Pango {  class Fontset_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Pango {  class Layout_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+namespace Pango {  class Renderer_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
+
+namespace Pango { 
+
+void wrap_init()
+{
+  // Register Error domains:
+
+// Map gtypes to gtkmm wrapper-creation functions:
+  Glib::wrap_register(pango_context_get_type(), &Pango::Context_Class::wrap_new);
+  Glib::wrap_register(pango_font_get_type(), &Pango::Font_Class::wrap_new);
+  Glib::wrap_register(pango_font_face_get_type(), &Pango::FontFace_Class::wrap_new);
+  Glib::wrap_register(pango_font_family_get_type(), &Pango::FontFamily_Class::wrap_new);
+  Glib::wrap_register(pango_font_map_get_type(), &Pango::FontMap_Class::wrap_new);
+  Glib::wrap_register(pango_fontset_get_type(), &Pango::Fontset_Class::wrap_new);
+  Glib::wrap_register(pango_layout_get_type(), &Pango::Layout_Class::wrap_new);
+  Glib::wrap_register(pango_renderer_get_type(), &Pango::Renderer_Class::wrap_new);
+
+  // Register the gtkmm gtypes:
+  Pango::Context::get_type();
+  Pango::Font::get_type();
+  Pango::FontFace::get_type();
+  Pango::FontFamily::get_type();
+  Pango::FontMap::get_type();
+  Pango::Fontset::get_type();
+  Pango::Layout::get_type();
+  Pango::Renderer::get_type();
+
+} // wrap_init()
+
+} //Pango
+
+
diff --git a/libs/gtkmm2/pango/pangomm/wrap_init.h b/libs/gtkmm2/pango/pangomm/wrap_init.h
new file mode 100644
index 0000000000..fd4cd217dd
--- /dev/null
+++ b/libs/gtkmm2/pango/pangomm/wrap_init.h
@@ -0,0 +1,32 @@
+#ifndef _PANGOMM_WRAP_INIT_H
+#define _PANGOMM_WRAP_INIT_H
+
+/* wrap_init.h
+ *
+ * Copyright (C) 1998-2001 The Gtk-- Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+// wrap_init.cc is generated by tools/generate_wrap_init.pl
+
+namespace Pango
+{
+
+void wrap_init();
+
+} /* namespace Pango */
+
+#endif // _PANGOMM_WRAP_INIT_H