// -*- c++ -*-
/*  Generated by gensig from box.gen_h. DO NOT MODIFY!!! */
#ifndef GTKMM_BOX_HEADER
#define GTKMM_BOX_HEADER
/* $Id: box.gen_h,v 1.35.2.1 1999/03/20 04:59:10 terop Exp $ */

/* box.h
 * 
 * Copyright (C) 1998-1999 
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library 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--/container.h>
#include <gtk/gtkbox.h>
#include <gtk/gtkvbox.h>
#include <gtk/gtkhbox.h>
class Gtk_Box_Class;
class Gtk_VBox_Class;
class Gtk_HBox_Class;
#line 26 "box.gen_h"


#ifdef GTKMM_CXX_HAVE_AUTO_PTR
template<class T> class Gtk_ObjectHandle;
#endif

//: {\class Gtk_Box} is a base class for horizontal or vertical 
//: boxes, which layout widgets inserted to them next to each other.
//- {\class Gtk_Box} is an abstract class and it defers choice of which
//- way the widgets are packed to the screen to the derived classes.
//- {\class Gtk_Box} provides common interface for inserting widgets
//- to a box indepenently of how it is shown in the screen.
//-
//- The most common use of {\class Gtk_Box} is like this:
//- {\example
//- 
//- class mywindow : public Gtk_Window {
//-    Gtk_Label label1,label2;
//-    Gtk_VBox vbox;
//- public:
//-    mywindow();
//- };
//- mywindow::mywindow() 
//- {
//-    add(vbox);
//-    vbox.pack_end(label1, true, true, 0);
//-    vbox.pack_end(label2, true, true, 0);
//- }
//- 
//- }
class Gtk_Box : public Gtk_Container {
public:
protected:
  typedef Gtk_Box_Class    CppClassType;
  typedef GtkBox           BaseObjectType;
  typedef GtkBoxClass      BaseClassType;

  virtual void *get_parent_class();

private:
  friend CppClassType;
  static CppClassType box_class; 
  GtkType get_type(); 

public:


  Gtk_Box(GtkBox *castitem);

  //: pack_start inserts 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
  //- alloted to it ({\key true}). Or the box is shrunk to just fit the widgets
  //- ({\key false}).  Setting expand to false 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 fill argument to the {pack_start()}/{pack_end()} functions control whether the
  //- extra space is allocated to the objects themselves ({\key true}), or as extra
  //- padding in the box around these objects (\key{false}). It only has an effect
  //- if the expand argument is also {\key true}.
  //- 
  //- What's the difference between spacing (set when the box is created)
  //- and padding (set when elements are packed)? Spacing is added between
  //- objects, and padding is added on either side of an object.
  //-
  void pack_start                      (const Gtk_Widget &child,
					bool expand=true,
					bool fill=true,
					gint padding=0);

  void pack_end                        (const Gtk_Widget &child,
					bool expand=true,
					bool fill=true,
					gint padding=0);

  void pack_start                      (const Gtk_ObjectHandle<Gtk_Widget> &child,
					bool expand=true,
					bool fill=true,
					gint padding=0);

  void pack_end                        (const Gtk_ObjectHandle<Gtk_Widget> &child,
					bool expand=true,
					bool fill=true,
					gint padding=0);


/* why was these implemented, we have default arguments
  void pack_start_defaults             (const Gtk_Widget &child);
  void pack_end_defaults               (const Gtk_Widget &child);
*/
  //- allows setting homongeneous afterwards. This is usually given on 
  //- {Gtk_VBox::Gtk_VBox()} or {Gtk_HBox::Gtk_HBox()}
  void set_homogeneous                 (bool homogeneous);
  void set_spacing                     (gint spacing);

#line 112 "box.gen_h"

  void reorder_child                   (const Gtk_Widget &child, gint pos);

  void query_child_packing             (const Gtk_Widget &child,
					bool         *expand,
					bool         *fill,
					guint        *padding,
					GtkPackType  *pack_type) const;
  void set_child_packing               (const Gtk_Widget &child,
					bool         expand,
					bool         fill,
					guint        padding,
					GtkPackType  pack_type);
#line 139 "box.gen_h"

protected:
  /* impl functions */
public:
  GtkBox* gtkobj() { return GTK_BOX(gtkobject); }
  const GtkBox* gtkobj() const { return GTK_BOX(gtkobject); }
  static bool isGtkBox(Gtk_Object *checkcast);
#line 140 "box.gen_h"


protected:
  Gtk_Box();
};


//: vertical box which can contain widgets and they're layouted
//: to a vertical row.
//- You should create these objects, but it is more confortable to
//- pass around pointers of {\class Gtk_Box}. All the methods that do anything
//- are in {\class Gtk_Box} class and this allows you to later change
//- the direction of the box, when there's no dependencies to hbox and
//- vbox classes.
//-
//- See {\class Gtk_Box}.
class Gtk_VBox : public Gtk_Box
{
public:
protected:
  typedef Gtk_VBox_Class    CppClassType;
  typedef GtkVBox           BaseObjectType;
  typedef GtkVBoxClass      BaseClassType;

  virtual void *get_parent_class();

private:
  friend CppClassType;
  static CppClassType vbox_class; 
  GtkType get_type(); 

public:


  // See {Gtk_HBox::Gtk_HBox()}. 
  Gtk_VBox(bool homogeneous=false, gint spacing=0);
  Gtk_VBox(GtkVBox *castitem);
protected:
  /* impl functions */
public:
  GtkVBox* gtkobj() { return GTK_VBOX(gtkobject); }
  const GtkVBox* gtkobj() const { return GTK_VBOX(gtkobject); }
  static bool isGtkVBox(Gtk_Object *checkcast);
#line 164 "box.gen_h"

};

//: horizontal box which can contain widgets and they're layouted to
//: horizontal row.
//- You should create these objects, but it is more confortable to
//- pass around pointers of {\class Gtk_Box}. All the methods that do anything
//- are in {\class Gtk_Box} class and this allows you to later change
//- the direction of the box, when there's no dependencies to hbox and
//- vbox classes.
//-
//- See {\class Gtk_Box}.
class Gtk_HBox : public Gtk_Box
{
public:
protected:
  typedef Gtk_HBox_Class    CppClassType;
  typedef GtkHBox           BaseObjectType;
  typedef GtkHBoxClass      BaseClassType;

  virtual void *get_parent_class();

private:
  friend CppClassType;
  static CppClassType hbox_class; 
  GtkType get_type(); 

public:


  //: creates a new horizontal box
  //- The homogeneous argument to \{class Gtk_HBox}::Gtk_HBox '
  //- (and the same for {\class Gtk_VBox}) controls whether each object 
  //- in the box has the same
  //- size (i.e. the same width in an hbox, or the same height in a
  //- vbox). If it is set, the expand argument to the gtk_box_pack routines
  //- is always turned on.
  //-
  //- Spacing determines which 
  Gtk_HBox(bool homogeneous=false, gint spacing=0);
  //- See {page docs/castitem}
  Gtk_HBox(GtkHBox *castitem);
protected:
  /* impl functions */
public:
  GtkHBox* gtkobj() { return GTK_HBOX(gtkobject); }
  const GtkHBox* gtkobj() const { return GTK_HBOX(gtkobject); }
  static bool isGtkHBox(Gtk_Object *checkcast);
#line 193 "box.gen_h"

};


#endif
