440 files changed, 123441 insertions, 0 deletions

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 */
+