tk/ytkmm/ytkmm/gtkmm/box.h

Go to the documentation of this file.

// -*- c++ -*-
// Generated by gmmproc 2.45.3 -- DO NOT MODIFY!
#ifndef _GTKMM_BOX_H
#define _GTKMM_BOX_H
 
 
#include <glibmm/ustring.h>
#include <sigc++/sigc++.h>
 
/* $Id: box.hg,v 1.10 2006/01/28 18:49:13 jjongsma Exp $ */
 
/* 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 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.
 */
 
 
// Temporarily undef GTK_DISABLE_DEPRECATED, redefining it later if appropriate.
// We need this to use _GtkBoxChild, which we use in our (deprecated) API.
#if defined(GTK_DISABLE_DEPRECATED) && !defined(GTKMM_GTK_DISABLE_DEPRECATED_UNDEFED)
#undef GTK_DISABLE_DEPRECATED
#define GTKMM_GTK_DISABLE_DEPRECATED_UNDEFED 1
#endif
 
// This is needed for gdkregion.h, for GdkSpanFunc, which we indirectly include.
// Otherwise application code must be very careful of the include order.
#if defined(GDK_DISABLE_DEPRECATED) && !defined(GTKMM_GDK_DISABLE_DEPRECATED_UNDEFED)
#undef GDK_DISABLE_DEPRECATED
#define GTKMM_GDK_DISABLE_DEPRECATED_UNDEFED 1
#endif
 
#include <gtk/gtk.h>  /* For _GtkBoxChild */
 
// Redefine GTK_DISABLE_DEPRECATED if it was defined before we temporarily undefed it:
#if defined(GTKMM_GTK_DISABLE_DEPRECATED_UNDEFED)
#define GTK_DISABLE_DEPRECATED 1
#undef GTKMM_GTK_DISABLE_DEPRECATED_UNDEFED
#endif
 
// Redefine GDK_DISABLE_DEPRECATED if it was defined before we temporarily undefed it:
#if defined(GTKMM_GDK_DISABLE_DEPRECATED_UNDEFED)
#define GDK_DISABLE_DEPRECATED 1
#undef GTKMM_GDK_DISABLE_DEPRECATED_UNDEFED
#endif
 
 
#include <gtkmm/container.h>
#include <glibmm/helperlist.h>
 
#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
{
 
enum PackOptions
{
  PACK_SHRINK, 
  PACK_EXPAND_PADDING, 
  PACK_EXPAND_WIDGET 
};
 
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:
  inline _GtkBoxChild* gobj() { return this; }
  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*) (gtk_widget_get_parent(gobj()->widget)); }
 
  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
 
  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 */
 
 
//TODO: Inherit/Implement Orientation when we can break ABI.
 
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
 
  GtkBox*       gobj()       { return reinterpret_cast<GtkBox*>(gobject_); }
 
  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:
 
  
  void pack_start(Widget& child, bool expand, bool fill, guint padding =  0);
 
  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);
 
  void pack_end(Widget& child, PackOptions options = PACK_EXPAND_WIDGET, guint padding = 0);
 
  
  void set_homogeneous(bool homogeneous =  true);
  
  bool get_homogeneous() const;
 
  
  void set_spacing(int spacing);
  
  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;
 
  Glib::PropertyProxy< int > property_spacing() ;
 
  Glib::PropertyProxy_ReadOnly< int > property_spacing() const;
 
  Glib::PropertyProxy< bool > property_homogeneous() ;
 
  Glib::PropertyProxy_ReadOnly< bool > property_homogeneous() const;
 
 
protected:
#ifndef DOXYGEN_SHOULD_SKIP_THIS
  mutable BoxList children_proxy_;
#endif /* DOXYGEN_SHOULD_SKIP_THIS */
 
 
};
 
 
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
 
  GtkVBox*       gobj()       { return reinterpret_cast<GtkVBox*>(gobject_); }
 
  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:
 
    explicit VBox(bool homogeneous =  false, int spacing =  0);
 
 
};
 
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
 
  GtkHBox*       gobj()       { return reinterpret_cast<GtkHBox*>(gobject_); }
 
  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:
 
    explicit HBox(bool homogeneous =  false, int spacing =  0);
 
 
};
 
} // namespace Gtk
 
 
namespace Glib
{
  Gtk::Box* wrap(GtkBox* object, bool take_copy = false);
} //namespace Glib
 
 
namespace Glib
{
  Gtk::VBox* wrap(GtkVBox* object, bool take_copy = false);
} //namespace Glib
 
 
namespace Glib
{
  Gtk::HBox* wrap(GtkHBox* object, bool take_copy = false);
} //namespace Glib
 
 
#endif /* _GTKMM_BOX_H */