[gtkmm/wrapbox] Added generated wrapbox source files in this branch just to store them somewhere.

[Murray Cumming <murrayc src gnome org>]

commit 62693822734413044c648b049fb209c008b0b532
Author: Murray Cumming <murrayc murrayc com>
Date:   Thu Oct 14 11:56:52 2010 +0200

    Added generated wrapbox source files in this branch just to store them somewhere.

 gtk/gtkmm/wrapbox.cc |  345 ++++++++++++++++++++++++++++++++++
 gtk/gtkmm/wrapbox.h  |  500 ++++++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 845 insertions(+), 0 deletions(-)
---
diff --git a/gtk/gtkmm/wrapbox.cc b/gtk/gtkmm/wrapbox.cc
new file mode 100644
index 0000000..6aef380
--- /dev/null
+++ b/gtk/gtkmm/wrapbox.cc
@@ -0,0 +1,345 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+
+#include <gtkmm/wrapbox.h>
+#include <gtkmm/private/wrapbox_p.h>
+
+// -*- c++ -*-
+/* $Id: wrapbox.ccg,v 1.6 2004/03/03 18:48:04 murrayc Exp $ */
+
+/*
+ *
+ * Copyright 2010 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <glib.h>
+#include <gtk/gtk.h>
+
+namespace Gtk
+{
+
+void WrapBox::append_child(Widget& widget, WrapBoxPacking packing)
+{
+  insert_child(widget, -1 /* see the C documentation */, packing);
+}
+
+} // namespace Gtk
+
+namespace
+{
+} // anonymous namespace
+
+// static
+GType Glib::Value<Gtk::WrapAllocationMode>::value_type()
+{
+  return gtk_wrap_allocation_mode_get_type();
+}
+
+// static
+GType Glib::Value<Gtk::WrapBoxSpreading>::value_type()
+{
+  return gtk_wrap_box_spreading_get_type();
+}
+
+// static
+GType Glib::Value<Gtk::WrapBoxPacking>::value_type()
+{
+  return gtk_wrap_box_packing_get_type();
+}
+
+
+namespace Glib
+{
+
+Gtk::WrapBox* wrap(GtkWrapBox* object, bool take_copy)
+{
+  return dynamic_cast<Gtk::WrapBox *> (Glib::wrap_auto ((GObject*)(object), take_copy));
+}
+
+} /* namespace Glib */
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& WrapBox_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &WrapBox_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_wrap_box_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  Orientable::add_interface(get_type());
+
+  }
+
+  return *this;
+}
+
+
+void WrapBox_Class::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* WrapBox_Class::wrap_new(GObject* o)
+{
+  return manage(new WrapBox((GtkWrapBox*)(o)));
+
+}
+
+
+/* The implementation: */
+
+WrapBox::WrapBox(const Glib::ConstructParams& construct_params)
+:
+  Gtk::Container(construct_params)
+{
+  }
+
+WrapBox::WrapBox(GtkWrapBox* castitem)
+:
+  Gtk::Container((GtkContainer*)(castitem))
+{
+  }
+
+WrapBox::~WrapBox()
+{
+  destroy_();
+}
+
+WrapBox::CppClassType WrapBox::wrapbox_class_; // initialize static member
+
+GType WrapBox::get_type()
+{
+  return wrapbox_class_.init().get_type();
+}
+
+
+GType WrapBox::get_base_type()
+{
+  return gtk_wrap_box_get_type();
+}
+
+
+WrapBox::WrapBox(WrapAllocationMode mode, WrapBoxSpreading horizontal_spreading, WrapBoxSpreading vertical_spreading, guint horizontal_spacing, guint vertical_spacing)
+:
+  // Mark this class as non-derived to allow C++ vfuncs to be skipped.
+  Glib::ObjectBase(0),
+  Gtk::Container(Glib::ConstructParams(wrapbox_class_.init(), "mode", ((GtkWrapAllocationMode)(mode)), "horizontal_spreading", ((GtkWrapBoxSpreading)(horizontal_spreading)), "vertical_spreading", ((GtkWrapBoxSpreading)(vertical_spreading)), "horizontal_spacing", horizontal_spacing, "vertical_spacing", vertical_spacing, static_cast<char*>(0)))
+{
+  
+
+}
+
+void WrapBox::set_allocation_mode(WrapAllocationMode mode)
+{
+gtk_wrap_box_set_allocation_mode(gobj(), ((GtkWrapAllocationMode)(mode))); 
+}
+
+WrapAllocationMode WrapBox::get_allocation_mode() const
+{
+  return ((WrapAllocationMode)(gtk_wrap_box_get_allocation_mode(const_cast<GtkWrapBox*>(gobj()))));
+}
+
+void WrapBox::set_vertical_spreading(WrapBoxSpreading spreading)
+{
+gtk_wrap_box_set_vertical_spreading(gobj(), ((GtkWrapBoxSpreading)(spreading))); 
+}
+
+WrapBoxSpreading WrapBox::get_vertical_spreading() const
+{
+  return ((WrapBoxSpreading)(gtk_wrap_box_get_vertical_spreading(const_cast<GtkWrapBox*>(gobj()))));
+}
+
+void WrapBox::set_horizontal_spreading(WrapBoxSpreading spreading)
+{
+gtk_wrap_box_set_horizontal_spreading(gobj(), ((GtkWrapBoxSpreading)(spreading))); 
+}
+
+WrapBoxSpreading WrapBox::get_horizontal_spreading() const
+{
+  return ((WrapBoxSpreading)(gtk_wrap_box_get_horizontal_spreading(const_cast<GtkWrapBox*>(gobj()))));
+}
+
+void WrapBox::set_vertical_spacing(guint spacing)
+{
+gtk_wrap_box_set_vertical_spacing(gobj(), spacing); 
+}
+
+guint WrapBox::get_vertical_spacing() const
+{
+  return gtk_wrap_box_get_vertical_spacing(const_cast<GtkWrapBox*>(gobj()));
+}
+
+void WrapBox::set_horizontal_spacing(guint spacing)
+{
+gtk_wrap_box_set_horizontal_spacing(gobj(), spacing); 
+}
+
+guint WrapBox::get_horizontal_spacing() const
+{
+  return gtk_wrap_box_get_horizontal_spacing(const_cast<GtkWrapBox*>(gobj()));
+}
+
+void WrapBox::set_minimum_line_children(guint n_children)
+{
+gtk_wrap_box_set_minimum_line_children(gobj(), n_children); 
+}
+
+guint WrapBox::get_minimum_line_children() const
+{
+  return gtk_wrap_box_get_minimum_line_children(const_cast<GtkWrapBox*>(gobj()));
+}
+
+void WrapBox::set_natural_line_children(guint n_children)
+{
+gtk_wrap_box_set_natural_line_children(gobj(), n_children); 
+}
+
+guint WrapBox::get_natural_line_children() const
+{
+  return gtk_wrap_box_get_natural_line_children(const_cast<GtkWrapBox*>(gobj()));
+}
+
+void WrapBox::insert_child(Widget& widget, int index, WrapBoxPacking packing)
+{
+gtk_wrap_box_insert_child(gobj(), (widget).gobj(), index, ((GtkWrapBoxPacking)(packing))); 
+}
+
+void WrapBox::reorder_child(Widget& widget, guint index)
+{
+gtk_wrap_box_reorder_child(gobj(), (widget).gobj(), index); 
+}
+
+
+#ifdef GLIBMM_PROPERTIES_ENABLED
+Glib::PropertyProxy<WrapAllocationMode> WrapBox::property_allocation_mode() 
+{
+  return Glib::PropertyProxy<WrapAllocationMode>(this, "allocation-mode");
+}
+#endif //GLIBMM_PROPERTIES_ENABLED
+
+#ifdef GLIBMM_PROPERTIES_ENABLED
+Glib::PropertyProxy_ReadOnly<WrapAllocationMode> WrapBox::property_allocation_mode() const
+{
+  return Glib::PropertyProxy_ReadOnly<WrapAllocationMode>(this, "allocation-mode");
+}
+#endif //GLIBMM_PROPERTIES_ENABLED
+
+#ifdef GLIBMM_PROPERTIES_ENABLED
+Glib::PropertyProxy<WrapBoxSpreading> WrapBox::property_vertical_spreading() 
+{
+  return Glib::PropertyProxy<WrapBoxSpreading>(this, "vertical-spreading");
+}
+#endif //GLIBMM_PROPERTIES_ENABLED
+
+#ifdef GLIBMM_PROPERTIES_ENABLED
+Glib::PropertyProxy_ReadOnly<WrapBoxSpreading> WrapBox::property_vertical_spreading() const
+{
+  return Glib::PropertyProxy_ReadOnly<WrapBoxSpreading>(this, "vertical-spreading");
+}
+#endif //GLIBMM_PROPERTIES_ENABLED
+
+#ifdef GLIBMM_PROPERTIES_ENABLED
+Glib::PropertyProxy<WrapBoxSpreading> WrapBox::property_horizontal_spreading() 
+{
+  return Glib::PropertyProxy<WrapBoxSpreading>(this, "horizontal-spreading");
+}
+#endif //GLIBMM_PROPERTIES_ENABLED
+
+#ifdef GLIBMM_PROPERTIES_ENABLED
+Glib::PropertyProxy_ReadOnly<WrapBoxSpreading> WrapBox::property_horizontal_spreading() const
+{
+  return Glib::PropertyProxy_ReadOnly<WrapBoxSpreading>(this, "horizontal-spreading");
+}
+#endif //GLIBMM_PROPERTIES_ENABLED
+
+#ifdef GLIBMM_PROPERTIES_ENABLED
+Glib::PropertyProxy<guint> WrapBox::property_minimum_line_children() 
+{
+  return Glib::PropertyProxy<guint>(this, "minimum-line-children");
+}
+#endif //GLIBMM_PROPERTIES_ENABLED
+
+#ifdef GLIBMM_PROPERTIES_ENABLED
+Glib::PropertyProxy_ReadOnly<guint> WrapBox::property_minimum_line_children() const
+{
+  return Glib::PropertyProxy_ReadOnly<guint>(this, "minimum-line-children");
+}
+#endif //GLIBMM_PROPERTIES_ENABLED
+
+#ifdef GLIBMM_PROPERTIES_ENABLED
+Glib::PropertyProxy<guint> WrapBox::property_natural_line_children() 
+{
+  return Glib::PropertyProxy<guint>(this, "natural-line-children");
+}
+#endif //GLIBMM_PROPERTIES_ENABLED
+
+#ifdef GLIBMM_PROPERTIES_ENABLED
+Glib::PropertyProxy_ReadOnly<guint> WrapBox::property_natural_line_children() const
+{
+  return Glib::PropertyProxy_ReadOnly<guint>(this, "natural-line-children");
+}
+#endif //GLIBMM_PROPERTIES_ENABLED
+
+#ifdef GLIBMM_PROPERTIES_ENABLED
+Glib::PropertyProxy<guint> WrapBox::property_vertical_spacing() 
+{
+  return Glib::PropertyProxy<guint>(this, "vertical-spacing");
+}
+#endif //GLIBMM_PROPERTIES_ENABLED
+
+#ifdef GLIBMM_PROPERTIES_ENABLED
+Glib::PropertyProxy_ReadOnly<guint> WrapBox::property_vertical_spacing() const
+{
+  return Glib::PropertyProxy_ReadOnly<guint>(this, "vertical-spacing");
+}
+#endif //GLIBMM_PROPERTIES_ENABLED
+
+#ifdef GLIBMM_PROPERTIES_ENABLED
+Glib::PropertyProxy<guint> WrapBox::property_horizontal_spacing() 
+{
+  return Glib::PropertyProxy<guint>(this, "horizontal-spacing");
+}
+#endif //GLIBMM_PROPERTIES_ENABLED
+
+#ifdef GLIBMM_PROPERTIES_ENABLED
+Glib::PropertyProxy_ReadOnly<guint> WrapBox::property_horizontal_spacing() const
+{
+  return Glib::PropertyProxy_ReadOnly<guint>(this, "horizontal-spacing");
+}
+#endif //GLIBMM_PROPERTIES_ENABLED
+
+
+} // namespace Gtk
+
+
diff --git a/gtk/gtkmm/wrapbox.h b/gtk/gtkmm/wrapbox.h
new file mode 100644
index 0000000..d1b184f
--- /dev/null
+++ b/gtk/gtkmm/wrapbox.h
@@ -0,0 +1,500 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _GTKMM_WRAPBOX_H
+#define _GTKMM_WRAPBOX_H
+
+
+#include <glibmm.h>
+
+/* Copyright (C) 2010 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtkmm/container.h>
+#include <gtkmm/toolitem.h>
+#include <gtkmm/orientable.h>
+#include <gtkmm/adjustment.h>
+#include <gtkmm/toolitemgroup.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GtkWrapBox GtkWrapBox;
+typedef struct _GtkWrapBoxClass GtkWrapBoxClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{ class WrapBox_Class; } // namespace Gtk
+namespace Gtk
+{
+
+/** @addtogroup gtkmmEnums gtkmm Enums and Flags */
+
+/**
+ * @ingroup gtkmmEnums
+ */
+enum WrapAllocationMode
+{
+  WRAP_ALLOCATE_FREE,
+  WRAP_ALLOCATE_ALIGNED,
+  WRAP_ALLOCATE_HOMOGENEOUS
+};
+
+} // namespace Gtk
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Gtk::WrapAllocationMode> : public Glib::Value_Enum<Gtk::WrapAllocationMode>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{
+
+/**
+ * @ingroup gtkmmEnums
+ */
+enum WrapBoxSpreading
+{
+  WRAP_BOX_SPREAD_START,
+  WRAP_BOX_SPREAD_END,
+  WRAP_BOX_SPREAD_EVEN,
+  WRAP_BOX_SPREAD_EXPAND
+};
+
+} // namespace Gtk
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Gtk::WrapBoxSpreading> : public Glib::Value_Enum<Gtk::WrapBoxSpreading>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{
+
+/**
+ * @ingroup gtkmmEnums
+ * @par Bitwise operators:
+ * <tt>%WrapBoxPacking operator|(WrapBoxPacking, WrapBoxPacking)</tt><br>
+ * <tt>%WrapBoxPacking operator&(WrapBoxPacking, WrapBoxPacking)</tt><br>
+ * <tt>%WrapBoxPacking operator^(WrapBoxPacking, WrapBoxPacking)</tt><br>
+ * <tt>%WrapBoxPacking operator~(WrapBoxPacking)</tt><br>
+ * <tt>%WrapBoxPacking& operator|=(WrapBoxPacking&, WrapBoxPacking)</tt><br>
+ * <tt>%WrapBoxPacking& operator&=(WrapBoxPacking&, WrapBoxPacking)</tt><br>
+ * <tt>%WrapBoxPacking& operator^=(WrapBoxPacking&, WrapBoxPacking)</tt><br>
+ */
+enum WrapBoxPacking
+{
+  WRAP_BOX_H_EXPAND = 1 << 0,
+  WRAP_BOX_V_EXPAND = 1 << 1
+};
+
+/** @ingroup gtkmmEnums */
+inline WrapBoxPacking operator|(WrapBoxPacking lhs, WrapBoxPacking rhs)
+  { return static_cast<WrapBoxPacking>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs)); }
+
+/** @ingroup gtkmmEnums */
+inline WrapBoxPacking operator&(WrapBoxPacking lhs, WrapBoxPacking rhs)
+  { return static_cast<WrapBoxPacking>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs)); }
+
+/** @ingroup gtkmmEnums */
+inline WrapBoxPacking operator^(WrapBoxPacking lhs, WrapBoxPacking rhs)
+  { return static_cast<WrapBoxPacking>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs)); }
+
+/** @ingroup gtkmmEnums */
+inline WrapBoxPacking operator~(WrapBoxPacking flags)
+  { return static_cast<WrapBoxPacking>(~static_cast<unsigned>(flags)); }
+
+/** @ingroup gtkmmEnums */
+inline WrapBoxPacking& operator|=(WrapBoxPacking& lhs, WrapBoxPacking rhs)
+  { return (lhs = static_cast<WrapBoxPacking>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs))); }
+
+/** @ingroup gtkmmEnums */
+inline WrapBoxPacking& operator&=(WrapBoxPacking& lhs, WrapBoxPacking rhs)
+  { return (lhs = static_cast<WrapBoxPacking>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs))); }
+
+/** @ingroup gtkmmEnums */
+inline WrapBoxPacking& operator^=(WrapBoxPacking& lhs, WrapBoxPacking rhs)
+  { return (lhs = static_cast<WrapBoxPacking>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs))); }
+
+} // namespace Gtk
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+namespace Glib
+{
+
+template <>
+class Value<Gtk::WrapBoxPacking> : public Glib::Value_Flags<Gtk::WrapBoxPacking>
+{
+public:
+  static GType value_type() G_GNUC_CONST;
+};
+
+} // namespace Glib
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gtk
+{
+
+
+/** TODO
+ *
+ * @newin{3,0}
+ *
+ * @ingroup Widgets
+ * @ingroup Containers
+ */
+
+class WrapBox
+: public Container
+{
+  public:
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  typedef WrapBox CppObjectType;
+  typedef WrapBox_Class CppClassType;
+  typedef GtkWrapBox BaseObjectType;
+  typedef GtkWrapBoxClass BaseClassType;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+  virtual ~WrapBox();
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+private:
+  friend class WrapBox_Class;
+  static CppClassType wrapbox_class_;
+
+  // noncopyable
+  WrapBox(const WrapBox&);
+  WrapBox& operator=(const WrapBox&);
+
+protected:
+  explicit WrapBox(const Glib::ConstructParams& construct_params);
+  explicit WrapBox(GtkWrapBox* 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.
+  GtkWrapBox*       gobj()       { return reinterpret_cast<GtkWrapBox*>(gobject_); }
+
+  ///Provides access to the underlying C GtkObject.
+  const GtkWrapBox* gobj() const { return reinterpret_cast<GtkWrapBox*>(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 WrapBox(WrapAllocationMode mode = WRAP_ALLOCATE_FREE, WrapBoxSpreading horizontal_spreading = WRAP_BOX_SPREAD_START, WrapBoxSpreading vertical_spreading = WRAP_BOX_SPREAD_START, guint horizontal_spacing = 0, guint vertical_spacing = 0);
+
+  
+  /** Sets the allocation mode for @a box's children.
+   * @param mode The Gtk::WrapAllocationMode to use.
+   */
+  void set_allocation_mode(WrapAllocationMode mode);
+  
+  /** Gets the allocation mode.
+   * @return The Gtk::WrapAllocationMode for @a box.
+   */
+  WrapAllocationMode get_allocation_mode() const;
+
+  
+  void set_vertical_spreading(WrapBoxSpreading spreading);
+  
+  WrapBoxSpreading get_vertical_spreading() const;
+
+  
+  void set_horizontal_spreading(WrapBoxSpreading spreading);
+  
+  WrapBoxSpreading get_horizontal_spreading() const;
+
+  
+  /** Sets the vertical space to add between children.
+   * @param spacing The spacing to use.
+   */
+  void set_vertical_spacing(guint spacing);
+  
+  /** Gets the vertical spacing.
+   * @return The vertical spacing.
+   */
+  guint get_vertical_spacing() const;
+
+  
+  /** Sets the horizontal space to add between children.
+   * @param spacing The spacing to use.
+   */
+  void set_horizontal_spacing(guint spacing);
+  
+  /** Gets the horizontal spacing.
+   * @return The horizontal spacing.
+   */
+  guint get_horizontal_spacing() const;
+
+  
+  /** Sets the minimum amount of children to line up
+   * in @a box's orientation before wrapping.
+   * @param n_children The minimum amount of children per line.
+   */
+  void set_minimum_line_children(guint n_children);
+  
+  /** Gets the minimum amount of children per line.
+   * @return The minimum amount of children per line.
+   */
+  guint get_minimum_line_children() const;
+
+  
+  /** Sets the natural length of items to request and
+   * allocate space for in @a box's orientation.
+   * 
+   * Setting the natural amount of children per line 
+   * limits the overall natural size request to be no more 
+   * than @a n_children items long in the given orientation.
+   * @param n_children The natural amount of children per line.
+   */
+  void set_natural_line_children(guint n_children);
+  
+  /** Gets the natural amount of children per line.
+   * @return The natural amount of children per line.
+   */
+  guint get_natural_line_children() const;
+
+  //TODO: Is the default packing appropriate (and like the default for a Box::pack_start())?
+  
+  /** Adds a child to an Gtk::WrapBox with its packing options set
+   * @param widget The child Gtk::Widget to add.
+   * @param index The position in the child list to insert, specify -1 to append to the list.
+   * @param xpad Horizontal spacing for this child.
+   * @param ypad Vertical spacing for this child.
+   * @param xexpand Whether this child expands horizontally.
+   * @param yexpand Whether this child expands vertically.
+   * @param xfill Whether this child fills its horizontal allocation.
+   * @param yfill Whether this child fills its vertical allocation.
+   */
+  void insert_child(Widget& widget, int index, WrapBoxPacking packing = WrapBoxPacking(0));
+
+  //TODO: Documentation
+  void append_child(Widget& widget, WrapBoxPacking packing = WrapBoxPacking(0));
+
+  
+  /** Reorders the child @a widget in @a box's list of children.
+   * @param widget The child to reorder.
+   * @param index The new child position.
+   */
+  void reorder_child(Widget& widget, guint index);
+
+
+  #ifdef GLIBMM_PROPERTIES_ENABLED
+/** The allocation mode 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<WrapAllocationMode> property_allocation_mode() ;
+#endif //#GLIBMM_PROPERTIES_ENABLED
+
+#ifdef GLIBMM_PROPERTIES_ENABLED
+/** The allocation mode 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<WrapAllocationMode> property_allocation_mode() const;
+#endif //#GLIBMM_PROPERTIES_ENABLED
+
+  #ifdef GLIBMM_PROPERTIES_ENABLED
+/** The spreading mode to use vertically.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<WrapBoxSpreading> property_vertical_spreading() ;
+#endif //#GLIBMM_PROPERTIES_ENABLED
+
+#ifdef GLIBMM_PROPERTIES_ENABLED
+/** The spreading mode to use vertically.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<WrapBoxSpreading> property_vertical_spreading() const;
+#endif //#GLIBMM_PROPERTIES_ENABLED
+
+  #ifdef GLIBMM_PROPERTIES_ENABLED
+/** The spreading mode to use horizontally.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy<WrapBoxSpreading> property_horizontal_spreading() ;
+#endif //#GLIBMM_PROPERTIES_ENABLED
+
+#ifdef GLIBMM_PROPERTIES_ENABLED
+/** The spreading mode to use horizontally.
+   *
+   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
+   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
+   * the value of the property changes.
+   */
+  Glib::PropertyProxy_ReadOnly<WrapBoxSpreading> property_horizontal_spreading() const;
+#endif //#GLIBMM_PROPERTIES_ENABLED
+
+  #ifdef GLIBMM_PROPERTIES_ENABLED
+/** The minimum number of children to allocate consecutively in the given 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<guint> property_minimum_line_children() ;
+#endif //#GLIBMM_PROPERTIES_ENABLED
+
+#ifdef GLIBMM_PROPERTIES_ENABLED
+/** The minimum number of children to allocate consecutively in the given 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<guint> property_minimum_line_children() const;
+#endif //#GLIBMM_PROPERTIES_ENABLED
+
+  #ifdef GLIBMM_PROPERTIES_ENABLED
+/** The maximum amount of children to request space for consecutively in the given 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<guint> property_natural_line_children() ;
+#endif //#GLIBMM_PROPERTIES_ENABLED
+
+#ifdef GLIBMM_PROPERTIES_ENABLED
+/** The maximum amount of children to request space for consecutively in the given 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<guint> property_natural_line_children() const;
+#endif //#GLIBMM_PROPERTIES_ENABLED
+
+  #ifdef GLIBMM_PROPERTIES_ENABLED
+/** The amount of vertical space between two 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_vertical_spacing() ;
+#endif //#GLIBMM_PROPERTIES_ENABLED
+
+#ifdef GLIBMM_PROPERTIES_ENABLED
+/** The amount of vertical space between two 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_vertical_spacing() const;
+#endif //#GLIBMM_PROPERTIES_ENABLED
+
+  #ifdef GLIBMM_PROPERTIES_ENABLED
+/** The amount of horizontal space between two 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_horizontal_spacing() ;
+#endif //#GLIBMM_PROPERTIES_ENABLED
+
+#ifdef GLIBMM_PROPERTIES_ENABLED
+/** The amount of horizontal space between two 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_horizontal_spacing() const;
+#endif //#GLIBMM_PROPERTIES_ENABLED
+
+
+};
+
+} // namespace Gtk
+
+
+namespace Glib
+{
+  /** A Glib::wrap() method for this 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.
+   *
+   * @relates Gtk::WrapBox
+   */
+  Gtk::WrapBox* wrap(GtkWrapBox* object, bool take_copy = false);
+} //namespace Glib
+
+
+#endif /* _GTKMM_WRAPBOX_H */
+