livetrax/libs/gtkmm2/gtk/gtkmm/notebook.h

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