notebook.h

Go to the documentation of this file.

// -*- c++ -*-
// Generated by gmmproc 2.45.3 -- DO NOT MODIFY!
#ifndef _GTKMM_NOTEBOOK_H
#define _GTKMM_NOTEBOOK_H
 
#include <ytkmm/ytkmmconfig.h>
 
 
#include <glibmm/ustring.h>
#include <sigc++/sigc++.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 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 <ytkmm/container.h>
#include <ytkmm/label.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
{
 
 
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;
};
 
inline bool operator==(const PageIterator& lhs, const PageIterator& rhs)
  { return lhs.equal(rhs); }
 
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:
  #ifndef GTKMM_DISABLE_DEPRECATED
 
  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);
  #endif // GTKMM_DISABLE_DEPRECATED
 
};
 
//We don't put PageList in a deprecation ifdef because it is used by a member variable and we don't want to break ABI.
 
// 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_;
};
 
#ifndef GTKMM_DISABLE_DEPRECATED
 
 
// 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);
};
 
#endif // GTKMM_DISABLE_DEPRECATED
 
 
/*********************************************************************
***** List properties
*********************************************************************/
 
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;
#ifndef GTKMM_DISABLE_DEPRECATED
 
  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();
#endif // GTKMM_DISABLE_DEPRECATED
 
 
protected:
  iterator begin_() const;
  iterator end_() const;
 
  GtkNotebook* gparent_;
};
 
} // Notebook_Helpers
 
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
 
  GtkNotebook*       gobj()       { return reinterpret_cast<GtkNotebook*>(gobject_); }
 
  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:
 
//We don't put PageList in a deprecation ifdef because it is used by a member variable and we don't want to break ABI.
  typedef Notebook_Helpers::PageList PageList;
 
 
  Notebook();
 
  
  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);
  
  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);
 
  
  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);
 
  
  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);
 
  
  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);
  
  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);
 
  
  void remove_page(int page_num =  0);
  void remove_page(Widget& child);
 
#ifndef GTKMM_DISABLE_DEPRECATED
 
  typedef sigc::slot<Notebook*, Widget*, int, int> SlotWindowCreation;
 
  static void set_window_creation_hook(const SlotWindowCreation& slot);
  
#endif // GTKMM_DISABLE_DEPRECATED
 
 
#ifndef GTKMM_DISABLE_DEPRECATED
 
  void set_group_id(int group_id);
#endif // GTKMM_DISABLE_DEPRECATED
 
 
#ifndef GTKMM_DISABLE_DEPRECATED
 
  int get_group_id() const;
#endif // GTKMM_DISABLE_DEPRECATED
 
 
  //TODO: Use something nicer than void*/gpointer?
  
#ifndef GTKMM_DISABLE_DEPRECATED
 
  void set_group(void* group);
#endif // GTKMM_DISABLE_DEPRECATED
 
 
#ifndef GTKMM_DISABLE_DEPRECATED
 
  void* get_group();
#endif // GTKMM_DISABLE_DEPRECATED
 
 
#ifndef GTKMM_DISABLE_DEPRECATED
 
  const void* get_group() const;
#endif // GTKMM_DISABLE_DEPRECATED
 
 
  void set_group_name(const Glib::ustring& group_name);
  
  Glib::ustring get_group_name() const;
  
  
  int get_current_page() const;
  
  Widget* get_nth_page(int page_num);
  
  const Widget* get_nth_page(int page_num) const;
  
#ifndef GTKMM_DISABLE_DEPRECATED
 
  int get_n_pages();
#endif // GTKMM_DISABLE_DEPRECATED
 
 
  int get_n_pages() const;
  /*Widget* get_current_page();*/ /*inconsistency with set_current_page*/
  
#ifndef GTKMM_DISABLE_DEPRECATED
 
  int page_num(const Widget& child);
#endif // GTKMM_DISABLE_DEPRECATED
 
 
  int page_num(const Widget& child) const;
 
  
  void set_current_page(int page_num);
  
  void next_page();
  
  void prev_page();
 
  
  void set_show_border(bool show_border =  true);
 
  
  bool get_show_border() const;
  
  void set_show_tabs(bool show_tabs =  true);
  
  bool get_show_tabs() const;
 
 
  void set_tab_pos(PositionType pos);
  
  PositionType get_tab_pos() const;
 
  
  void set_scrollable(bool scrollable =  true);
  
  bool get_scrollable() const;
 
  
  guint16 get_tab_hborder() const;
  
  guint16 get_tab_vborder() const;
 
  
  void popup_enable();
 
  
  void popup_disable();
 
  
  Widget* get_tab_label(Widget& child);
  
  const Widget* get_tab_label(Widget& child) const;
  
  void set_tab_label(Widget& child, Widget& tab_label);
  
  void set_tab_label_text(Widget& child, const Glib::ustring& tab_text);
  
  Glib::ustring get_tab_label_text(Widget& child) const;
  
  Widget* get_menu_label(Widget& child);
  
  const Widget* get_menu_label(Widget& child) const;
  
  void set_menu_label(Widget& child, Widget& menu_label);
  
  void set_menu_label_text(Widget& child, const Glib::ustring& menu_text);
  
  Glib::ustring get_menu_label_text(Widget& child) const;
 
  #ifndef GTKMM_DISABLE_DEPRECATED
 
  void query_tab_label_packing(Widget& child, bool& expand, bool& fill, PackType& pack_type);
  
  #endif // GTKMM_DISABLE_DEPRECATED
 
 
#ifndef GTKMM_DISABLE_DEPRECATED
 
  void set_tab_label_packing(Widget& child, bool expand, bool fill, PackType pack_type);
#endif // GTKMM_DISABLE_DEPRECATED
 
 
  void reorder_child(Widget& child, int position);
 
  
  bool get_tab_reorderable(Widget& child) const;
  
  void set_tab_reorderable(Widget& child, bool reorderable =  true);
  
  bool get_tab_detachable(Widget& child) const;
  
  void set_tab_detachable(Widget& child, bool detachable =  true);
 
  
  Widget* get_action_widget(PackType pack_type =  PACK_START);
  
  void set_action_widget(Widget* widget, PackType pack_type =  PACK_START);
 
#ifndef GTKMM_DISABLE_DEPRECATED
 
  PageList::iterator get_current();
 
  PageList& pages();
 
  const PageList& pages() const;
#endif // GTKMM_DISABLE_DEPRECATED
 
 
  Glib::SignalProxy2< void,GtkNotebookPage*,guint > signal_switch_page();
 
  
  Glib::SignalProxy2< void,Widget*,guint > signal_page_reordered();
 
  
  Glib::SignalProxy2< void,Widget*,guint > signal_page_removed();
 
  
  Glib::SignalProxy2< void,Widget*,guint > signal_page_added();
 
 
  //Key-binding signals:
  
  
  //This doesn't seem generally useful:
  
 
  Glib::PropertyProxy< PositionType > property_tab_pos() ;
 
  Glib::PropertyProxy_ReadOnly< PositionType > property_tab_pos() const;
 
  Glib::PropertyProxy< bool > property_show_tabs() ;
 
  Glib::PropertyProxy_ReadOnly< bool > property_show_tabs() const;
 
  Glib::PropertyProxy< bool > property_show_border() ;
 
  Glib::PropertyProxy_ReadOnly< bool > property_show_border() const;
 
  Glib::PropertyProxy< bool > property_scrollable() ;
 
  Glib::PropertyProxy_ReadOnly< bool > property_scrollable() const;
 
  Glib::PropertyProxy_WriteOnly< guint > property_tab_border() ;
 
 
  Glib::PropertyProxy< guint > property_tab_hborder() ;
 
  Glib::PropertyProxy_ReadOnly< guint > property_tab_hborder() const;
 
  Glib::PropertyProxy< guint > property_tab_vborder() ;
 
  Glib::PropertyProxy_ReadOnly< guint > property_tab_vborder() const;
 
  Glib::PropertyProxy< int > property_page() ;
 
  Glib::PropertyProxy_ReadOnly< int > property_page() const;
 
  Glib::PropertyProxy< bool > property_enable_popup() ;
 
  Glib::PropertyProxy_ReadOnly< bool > property_enable_popup() const;
 
  Glib::PropertyProxy< bool > property_homogeneous() ;
 
  Glib::PropertyProxy_ReadOnly< bool > property_homogeneous() const;
 
  Glib::PropertyProxy< int > property_group_id() ;
 
  Glib::PropertyProxy_ReadOnly< int > property_group_id() const;
 
  Glib::PropertyProxy< void* > property_group() ;
 
  Glib::PropertyProxy_ReadOnly< void* > property_group() const;
 //TODO: What is this?
 
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);
}
 
} // namespace Notebook_Helpers
 
#endif /* DOXYGEN_SHOULD_SKIP_THIS */
 
} // namespace Gtk
 
 
namespace Glib
{
  Gtk::Notebook* wrap(GtkNotebook* object, bool take_copy = false);
} //namespace Glib
 
 
#endif /* _GTKMM_NOTEBOOK_H */