treeview.h

Go to the documentation of this file.

// -*- c++ -*-
// Generated by gmmproc 2.45.3 -- DO NOT MODIFY!
#ifndef _GTKMM_TREEVIEW_H
#define _GTKMM_TREEVIEW_H
 
#include <gtkmmconfig.h>
 
 
#include <glibmm/ustring.h>
#include <sigc++/sigc++.h>
 
/* Copyright(C) 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.
 */
 
 // This is for including the config header before any code (such as
// the #ifndef GTKMM_DISABLE_DEPRECATED in deprecated classes) is generated:
 
 
#include <glibmm/listhandle.h>
#include <gtkmm/container.h>
#include <gtkmm/adjustment.h>
#include <gdkmm/pixmap.h>
#include <gtkmm/treeviewcolumn.h>
#include <gtkmm/treeselection.h>
#include <gtkmm/treemodelcolumn.h>
#include <gtkmm/cellrenderer.h>
#include <gtkmm/targetentry.h>
#include <gtkmm/entry.h>
#include <gtkmm/tooltip.h>
 
 
#include <cstdlib>
 
using std::strtod;
 
#ifndef DOXYGEN_SHOULD_SKIP_THIS
typedef struct _GtkTreeView GtkTreeView;
typedef struct _GtkTreeViewClass GtkTreeViewClass;
#endif /* DOXYGEN_SHOULD_SKIP_THIS */
 
 
namespace Gtk
{ class TreeView_Class; } // namespace Gtk
namespace Gtk
{
 
 
enum TreeViewDropPosition
{
  TREE_VIEW_DROP_BEFORE,
  TREE_VIEW_DROP_AFTER,
  TREE_VIEW_DROP_INTO_OR_BEFORE,
  TREE_VIEW_DROP_INTO_OR_AFTER
};
 
} // namespace Gtk
 
 
#ifndef DOXYGEN_SHOULD_SKIP_THIS
namespace Glib
{
 
template <>
class Value<Gtk::TreeViewDropPosition> : public Glib::Value_Enum<Gtk::TreeViewDropPosition>
{
public:
  static GType value_type() G_GNUC_CONST;
};
 
} // namespace Glib
#endif /* DOXYGEN_SHOULD_SKIP_THIS */
 
 
namespace Gtk
{
 
enum TreeViewGridLines
{
  TREE_VIEW_GRID_LINES_NONE,
  TREE_VIEW_GRID_LINES_HORIZONTAL,
  TREE_VIEW_GRID_LINES_VERTICAL,
  TREE_VIEW_GRID_LINES_BOTH
};
 
} // namespace Gtk
 
 
#ifndef DOXYGEN_SHOULD_SKIP_THIS
namespace Glib
{
 
template <>
class Value<Gtk::TreeViewGridLines> : public Glib::Value_Enum<Gtk::TreeViewGridLines>
{
public:
  static GType value_type() G_GNUC_CONST;
};
 
} // namespace Glib
#endif /* DOXYGEN_SHOULD_SKIP_THIS */
 
 
namespace Gtk
{
 
 
#ifndef DOXYGEN_SHOULD_SKIP_THIS
 
class TreeView;
 
namespace TreeView_Private
{
/* This helper function is not a member of TreeView just for the reason that
 * there are compilers that have problems compiling it otherwise. E.g. in gcc
 * 2.95.3 a compiler bug prevents member functions from refering to specialized
 * member function templates and that's what we do here: In function
 * _connect_auto_store_editable_signal_handler we build a slot from
 * TreeView::_auto_store_on_cellrenderer_*_edited. (The latter must be member
 * functions of TreeView since we connect them to signals and we want the
 * connections to vanish when the TreeView dies, of course.)
 */
  template <class ColumnType> inline
  void _connect_auto_store_editable_signal_handler(Gtk::TreeView* this_p, Gtk::CellRenderer* pCellRenderer, const Gtk::TreeModelColumn<ColumnType>& model_column);
 
  template<class ColumnType> inline
  void _auto_store_on_cellrenderer_text_edited_string(const Glib::ustring& path_string, const Glib::ustring& new_text, int model_column, const Glib::RefPtr<Gtk::TreeModel>& model);
 
  template <class ColumnType> inline
  void _auto_store_on_cellrenderer_text_edited_numerical(const Glib::ustring& path_string, const Glib::ustring& new_text, int model_column, const Glib::RefPtr<Gtk::TreeModel>& model);
 
  template <class ColumnType> inline
  void _auto_cell_data_func(Gtk::CellRenderer* cell, const Gtk::TreeModel::iterator& iter, int model_column, const Glib::ustring& format);
}
 
#endif //DOXYGEN_SHOULD_SKIP_THIS
 
 
//class TreeViewColumn;
class TreeModel;
 
class TreeView : public Container
{
  public:
#ifndef DOXYGEN_SHOULD_SKIP_THIS
  typedef TreeView CppObjectType;
  typedef TreeView_Class CppClassType;
  typedef GtkTreeView BaseObjectType;
  typedef GtkTreeViewClass BaseClassType;
#endif /* DOXYGEN_SHOULD_SKIP_THIS */
 
  virtual ~TreeView();
 
#ifndef DOXYGEN_SHOULD_SKIP_THIS
 
private:
  friend class TreeView_Class;
  static CppClassType treeview_class_;
 
  // noncopyable
  TreeView(const TreeView&);
  TreeView& operator=(const TreeView&);
 
protected:
  explicit TreeView(const Glib::ConstructParams& construct_params);
  explicit TreeView(GtkTreeView* 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
 
  GtkTreeView*       gobj()       { return reinterpret_cast<GtkTreeView*>(gobject_); }
 
  const GtkTreeView* gobj() const { return reinterpret_cast<GtkTreeView*>(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_set_scroll_adjustments(Adjustment* hadjustment, Adjustment* vadjustment);
  virtual void on_row_activated(const TreeModel::Path& path, TreeViewColumn* column);
  virtual bool on_test_expand_row(const TreeModel::iterator& iter, const TreeModel::Path& path);
  virtual bool on_test_collapse_row(const TreeModel::iterator& iter, const TreeModel::Path& path);
  virtual void on_row_expanded(const TreeModel::iterator& iter, const TreeModel::Path& path);
  virtual void on_row_collapsed(const TreeModel::iterator& iter, const TreeModel::Path& path);
  virtual void on_cursor_changed();
  virtual void on_columns_changed();
 
 
private:
 
  
public:
  typedef TreeViewColumn Column;
 
  typedef TreeSelection Selection;
  TreeView();
    explicit TreeView(const Glib::RefPtr<TreeModel>& model);
 
 
  Glib::RefPtr<TreeModel> get_model();
  
  Glib::RefPtr<const TreeModel> get_model() const;
  
  void set_model(const Glib::RefPtr<TreeModel>& model);
 
  void unset_model();
 
  
  Glib::RefPtr<TreeSelection> get_selection();
  
  Glib::RefPtr<const TreeSelection> get_selection() const;
  
  Adjustment* get_hadjustment();
  
  const Adjustment* get_hadjustment() const;
  
  void set_hadjustment(Adjustment& adjustment);
 
  void unset_hadjustment();
 
  
  Adjustment* get_vadjustment();
  
  const Adjustment* get_vadjustment() const;
  
  void set_vadjustment(Adjustment& adjustment);
 
  void unset_vadjustment();
 
  
  bool get_headers_visible() const;
  
  void set_headers_visible(bool headers_visible =  true);
  
  void columns_autosize();
  
  bool get_headers_clickable() const;
  
  void set_headers_clickable(bool setting =  true);
  
  void set_rules_hint(bool setting =  true);
  
  bool get_rules_hint() const;
 
  
  int append_column(TreeViewColumn& column);
 
  template <class ColumnType> inline
  int append_column(const Glib::ustring& title, const TreeModelColumn<ColumnType>& model_column);
 
  template <class ColumnType> inline
  int append_column_numeric(const Glib::ustring& title, const TreeModelColumn<ColumnType>& model_column, const Glib::ustring& format);
 
  //TODO: danielk suggested use of Glib::Value to simplify/improve this.
  template <class ColumnType> inline
  int append_column_editable(const Glib::ustring& title, const TreeModelColumn<ColumnType>& model_column);
 
  template <class ColumnType> inline
  int append_column_numeric_editable(const Glib::ustring& title, const TreeModelColumn<ColumnType>& model_column, const Glib::ustring& format);
 
 
  int append_column(const Glib::ustring& title, CellRenderer& cell);
 
  
  int remove_column(TreeViewColumn& column);
 
  void remove_all_columns();
 
  
  int insert_column(TreeViewColumn& column, int position);
 
  int insert_column(const Glib::ustring& title, CellRenderer& cell, int position);
 
  
  template <class ColumnType> inline
  int insert_column(const Glib::ustring& title, const TreeModelColumn<ColumnType>& model_column, int position);
 
  template <class ColumnType> inline
  int insert_column_editable(const Glib::ustring& title, const TreeModelColumn<ColumnType>& model_column, int position);
 
  typedef TreeViewColumn::SlotCellData SlotCellData;
 
  int insert_column_with_data_func(int position, const Glib::ustring& title, CellRenderer& cell, const SlotCellData& slot);
 
  
  TreeViewColumn* get_column(int n);
  
  const TreeViewColumn* get_column(int n) const;
 
  //The column index is of the view, not the model, so we do not need TreeViewColumn* get_column(TreeViewColumn& base_column).
 
  CellRenderer* get_column_cell_renderer(int n);
 
 //TODO: Add TreeViewColumn* get_column_cell_renderer(TreeViewColumn& base_column); and a const one.
 
 
  const CellRenderer* get_column_cell_renderer(int n) const;
 
  
  Glib::ListHandle<TreeViewColumn*> get_columns();
  
  Glib::ListHandle<const TreeViewColumn*> get_columns() const;
 
  
  void move_column_after(TreeViewColumn& column, TreeViewColumn& base_column);
 
  void move_column_to_start(TreeViewColumn& column);
 
  
  void set_expander_column(TreeViewColumn& column);
 
  void reset_expander_column();
 
  
  TreeViewColumn* get_expander_column();
  
  const TreeViewColumn* get_expander_column() const;
 
  typedef sigc::slot<bool, TreeView*, TreeViewColumn*,  TreeViewColumn*, TreeViewColumn*> SlotColumnDrop;
 
  void set_column_drag_function(const SlotColumnDrop& slot);
  
 
  void unset_column_drag_function();
 
  
  void scroll_to_point(int tree_x, int tree_y);
 
  void scroll_to_cell(const TreeModel::Path& path, TreeViewColumn& column, float row_align, float col_align);
  
 
  void scroll_to_cell(const TreeModel::Path& path, TreeViewColumn& column);
 
  void scroll_to_row(const TreeModel::Path& path, float row_align);
 
  void scroll_to_row(const TreeModel::Path& path);
 
  void scroll_to_column(TreeViewColumn& column, float col_align);
 
  void scroll_to_column(TreeViewColumn& column);
 
  
  void row_activated(const TreeModel::Path& path, TreeViewColumn& column);
  
  void expand_all();
  
  void collapse_all();
  
  void expand_to_path(const TreeModel::Path& path);
  
  bool expand_row(const TreeModel::Path& path, bool open_all);
  
  bool collapse_row(const TreeModel::Path& path);
 
  typedef sigc::slot<void, TreeView*, const TreeModel::Path&> SlotMapping;
 
  void map_expanded_rows(const SlotMapping& slot);
  
 
  bool row_expanded(const TreeModel::Path& path);
  
  void set_reorderable(bool reorderable =  true);
  
  bool get_reorderable() const;
 
  //TODO: Add set_cursor(path, ModelColumnBase&, start_editing)?
  
  void set_cursor(const TreeModel::Path& path, TreeViewColumn& focus_column, bool start_editing =  false);
 
  
  void set_cursor(const TreeModel::Path& path, TreeViewColumn& focus_column, CellRenderer& focus_cell, bool start_editing =  false);
 
 
  void set_cursor(const TreeModel::Path& path);
 
  void get_cursor(TreeModel::Path& path, TreeViewColumn*& focus_column);
 
/* Layout information */
  
  Glib::RefPtr<Gdk::Window> get_bin_window();
  
  Glib::RefPtr<const Gdk::Window> get_bin_window() const;
 
  #ifndef GTKMM_DISABLE_DEPRECATED
 
  bool get_path_at_pos(int x, int y, TreeModel::Path& path, TreeViewColumn*& column, int& cell_x, int& cell_y);
  #endif // GTKMM_DISABLE_DEPRECATED
 
 
  bool get_path_at_pos(int x, int y, TreeModel::Path& path, TreeViewColumn*& column, int& cell_x, int& cell_y) const;
 
  bool get_path_at_pos(int x, int y, TreeModel::Path& path) const;
 
  
#ifndef GTKMM_DISABLE_DEPRECATED
 
  void get_cell_area(const TreeModel::Path& path, TreeViewColumn& column, Gdk::Rectangle& rect);
#endif // GTKMM_DISABLE_DEPRECATED
 
 
//We ignore the fact that one of the arguments can be 0 - it does not seem useful.
 
  
  void get_cell_area(const TreeModel::Path& path, TreeViewColumn& column, Gdk::Rectangle& rect) const;
 
   
#ifndef GTKMM_DISABLE_DEPRECATED
 
  void get_background_area(const TreeModel::Path& path, TreeViewColumn& column, Gdk::Rectangle& rect);
#endif // GTKMM_DISABLE_DEPRECATED
 
 
  void get_background_area(const TreeModel::Path& path, TreeViewColumn& column, Gdk::Rectangle& rect) const;
  //We ignore the fact that one of the arguments can be 0 - it does not seem useful.
 
  
#ifndef GTKMM_DISABLE_DEPRECATED
 
  void get_visible_rect(Gdk::Rectangle& visible_rect);
#endif // GTKMM_DISABLE_DEPRECATED
 
 
  void get_visible_rect(Gdk::Rectangle& visible_rect) const;
 
  
#ifndef GTKMM_DISABLE_DEPRECATED
 
  void widget_to_tree_coords(int wx, int wy, int& tx, int& ty);
#endif // GTKMM_DISABLE_DEPRECATED
 
 
#ifndef GTKMM_DISABLE_DEPRECATED
 
  void widget_to_tree_coords(int wx, int wy, int& tx, int& ty) const;
#endif // GTKMM_DISABLE_DEPRECATED
 
 
#ifndef GTKMM_DISABLE_DEPRECATED
 
  void tree_to_widget_coords(int tx, int ty, int& wx, int& wy);
#endif // GTKMM_DISABLE_DEPRECATED
 
 
#ifndef GTKMM_DISABLE_DEPRECATED
 
  void tree_to_widget_coords(int tx, int ty, int& wx, int& wy) const;
#endif // GTKMM_DISABLE_DEPRECATED
 
 
   bool get_visible_range(TreeModel::Path& start_path, TreeModel::Path& end_path) const;
  
 
/* Drag-and-Drop support */
  
 
  void enable_model_drag_source(const ArrayHandle_TargetEntry& targets,
                                Gdk::ModifierType start_button_mask = Gdk::MODIFIER_MASK,
                                Gdk::DragAction actions = Gdk::ACTION_COPY | Gdk::ACTION_MOVE);
 
  // Uses the default "GTK_TREE_MODEL_ROW" target, which the TreeView can handle automatically.
 
  void enable_model_drag_source(Gdk::ModifierType start_button_mask = Gdk::MODIFIER_MASK,
                                Gdk::DragAction actions = Gdk::ACTION_COPY | Gdk::ACTION_MOVE);
 
  
  void enable_model_drag_dest(const ArrayHandle_TargetEntry& targets, Gdk::DragAction actions = Gdk::ACTION_COPY | Gdk::ACTION_MOVE);
 
  void enable_model_drag_dest(Gdk::DragAction actions = Gdk::ACTION_COPY | Gdk::ACTION_MOVE);
 
  
  void unset_rows_drag_source();
 
  
  void unset_rows_drag_dest();
 
 
  /* These are useful to implement your own custom stuff. */
 
  
  void set_drag_dest_row(const TreeModel::Path& path, TreeViewDropPosition pos);
 
  void get_drag_dest_row(TreeModel::Path& path, TreeViewDropPosition& pos) const;
 
  bool get_dest_row_at_pos(int drag_x, int drag_y, TreeModel::Path& path, TreeViewDropPosition& pos) const;
 
  
  Glib::RefPtr<Gdk::Pixmap> create_row_drag_icon(const TreeModel::Path& path);
 
/* Interactive search */
  
  void set_enable_search(bool enable_search =  true);
  
  bool get_enable_search() const;
  
  int get_search_column() const;
  
  void set_search_column(const TreeModelColumnBase& column);
  
  void set_search_column(int column);
 
  typedef sigc::slot<bool, const Glib::RefPtr<TreeModel>&, int, const Glib::ustring&, const TreeModel::iterator&> SlotSearchEqual;
  //SlotSearchEqual get_search_equal_func();
  
 
  void set_search_equal_func(const SlotSearchEqual& slot);
  
 
  Entry* get_search_entry();
  
  const Entry* get_search_entry() const;
  
  void set_search_entry(Entry& entry);
 
  typedef sigc::slot<void, Gtk::Widget* /* search_dialog */> SlotSearchPosition;
  void set_search_position_func(const SlotSearchPosition& slot);
  
 
  void convert_widget_to_tree_coords(int wx, int wy, int& tx, int& ty) const;
  
  void convert_tree_to_widget_coords(int tx, int ty, int& wx, int& wy) const;
  
  void convert_widget_to_bin_window_coords(int wx, int wy, int& bx, int& by) const;
  
  void convert_bin_window_to_widget_coords(int bx, int by, int& wx, int& wy) const;
  
  void convert_tree_to_bin_window_coords(int tx, int ty, int& bx, int& by) const;
  
  void convert_bin_window_to_tree_coords(int bx, int by, int& tx, int& ty) const;
 
 
  void set_fixed_height_mode(bool enable =  true);
  
  bool get_fixed_height_mode() const;
  
  void set_hover_selection(bool hover =  true);
  
  bool get_hover_selection() const;
  
  void set_hover_expand(bool expand =  true);
  
  bool get_hover_expand() const;
  
  void set_rubber_banding(bool enable =  true);
  
  bool get_rubber_banding() const;
 
  //TODO: Rename to get_is?
  
  bool is_rubber_banding_active() const;
 
  typedef sigc::slot<bool, const Glib::RefPtr<TreeModel>&, const TreeModel::iterator&> SlotRowSeparator;
 
  void set_row_separator_func(const SlotRowSeparator& slot);
  
 
  void set_grid_lines(TreeViewGridLines grid_lines);
  
  TreeViewGridLines get_grid_lines() const;
 
  
  void set_enable_tree_lines(bool enable =  true);
  
  bool get_enable_tree_lines() const;
 
  
  void set_show_expanders(bool enabled =  true);
  
  bool get_show_expanders() const;
  
  void set_level_indentation(int indentation);
  
  int get_level_indentation() const;
 
  
  void set_tooltip_row(const Glib::RefPtr<Tooltip>& tooltip, const TreePath& path);
 
  //Note that we use pointers instead of references because any one of the 3 arguments may be NULL, and we don't want that many method overloads:
 
 
  void set_tooltip_cell(const Glib::RefPtr<Tooltip>& tooltip, const TreeModel::Path* path, TreeViewColumn* column, CellRenderer* cell);
 
  
  bool get_tooltip_context_path(int& x, int& y,
                                bool keyboard_tip,
                                TreeModel::Path& path);
 
  bool get_tooltip_context_iter(int& x, int& y,
                                bool keyboard_tip,
                                Gtk::TreeModel::iterator& iter);
 
  
  void set_tooltip_column(int column);
  
  int get_tooltip_column() const;
 
 
//TODO: Ignore this? It's in many widgets and seems internals.
  
  Glib::SignalProxy2< void,Adjustment*,Adjustment* > signal_set_scroll_adjustments();
 
 
  Glib::SignalProxy2< void,const TreeModel::Path&,TreeViewColumn* > signal_row_activated();
 
  
  Glib::SignalProxy2< bool,const TreeModel::iterator&,const TreeModel::Path& > signal_test_expand_row();
 
  
  Glib::SignalProxy2< bool,const TreeModel::iterator&,const TreeModel::Path& > signal_test_collapse_row();
 
  
  Glib::SignalProxy2< void,const TreeModel::iterator&,const TreeModel::Path& > signal_row_expanded();
 
  
  Glib::SignalProxy2< void,const TreeModel::iterator&,const TreeModel::Path& > signal_row_collapsed();
 
  
  Glib::SignalProxy0< void > signal_cursor_changed();
 
  
  Glib::SignalProxy0< void > signal_columns_changed();
 
 
  //Don't wrap these. They are keybinding signals, and their API broke for GTK+ 2.2.
  
  
  Glib::PropertyProxy< Glib::RefPtr<TreeModel> > property_model() ;
 
  Glib::PropertyProxy_ReadOnly< Glib::RefPtr<TreeModel> > property_model() const;
 
  Glib::PropertyProxy< Adjustment* > property_hadjustment() ;
 
  Glib::PropertyProxy_ReadOnly< Adjustment* > property_hadjustment() const;
 
  Glib::PropertyProxy< Adjustment* > property_vadjustment() ;
 
  Glib::PropertyProxy_ReadOnly< Adjustment* > property_vadjustment() const;
 
  Glib::PropertyProxy< bool > property_headers_visible() ;
 
  Glib::PropertyProxy_ReadOnly< bool > property_headers_visible() const;
 
  Glib::PropertyProxy< bool > property_headers_clickable() ;
 
  Glib::PropertyProxy_ReadOnly< bool > property_headers_clickable() const;
 
  Glib::PropertyProxy< TreeViewColumn* > property_expander_column() ;
 
  Glib::PropertyProxy_ReadOnly< TreeViewColumn* > property_expander_column() const;
 
  Glib::PropertyProxy< bool > property_reorderable() ;
 
  Glib::PropertyProxy_ReadOnly< bool > property_reorderable() const;
 
  Glib::PropertyProxy< bool > property_rules_hint() ;
 
  Glib::PropertyProxy_ReadOnly< bool > property_rules_hint() const;
 
  Glib::PropertyProxy< bool > property_enable_search() ;
 
  Glib::PropertyProxy_ReadOnly< bool > property_enable_search() const;
 
  Glib::PropertyProxy< int > property_search_column() ;
 
  Glib::PropertyProxy_ReadOnly< int > property_search_column() const;
 
  Glib::PropertyProxy< bool > property_fixed_height_mode() ;
 
  Glib::PropertyProxy_ReadOnly< bool > property_fixed_height_mode() const;
 
  Glib::PropertyProxy< bool > property_hover_selection() ;
 
  Glib::PropertyProxy_ReadOnly< bool > property_hover_selection() const;
 
  Glib::PropertyProxy< bool > property_hover_expand() ;
 
  Glib::PropertyProxy_ReadOnly< bool > property_hover_expand() const;
 
  Glib::PropertyProxy< bool > property_show_expanders() ;
 
  Glib::PropertyProxy_ReadOnly< bool > property_show_expanders() const;
 
  Glib::PropertyProxy< bool > property_level_indentation() ;
 
  Glib::PropertyProxy_ReadOnly< bool > property_level_indentation() const;
 
  Glib::PropertyProxy< bool > property_rubber_banding() ;
 
  Glib::PropertyProxy_ReadOnly< bool > property_rubber_banding() const;
 
  Glib::PropertyProxy< bool > property_enable_grid_lines() ;
 
  Glib::PropertyProxy_ReadOnly< bool > property_enable_grid_lines() const;
 
  Glib::PropertyProxy< bool > property_enable_tree_lines() ;
 
  Glib::PropertyProxy_ReadOnly< bool > property_enable_tree_lines() const;
 
  Glib::PropertyProxy< int > property_tooltip_column() ;
 
  Glib::PropertyProxy_ReadOnly< int > property_tooltip_column() const;
 
 
  Glib::RefPtr<Gtk::TreeModel> _get_base_model();
 
protected:
 
#ifndef DOXYGEN_SHOULD_SKIP_THIS
  template<class ColumnType> friend
  void _auto_store_on_cellrenderer_text_edited_string(const Glib::ustring& path_string, const Glib::ustring& new_text, int model_column, const Glib::RefPtr<Gtk::TreeModel>& model);
 
  template <class ColumnType> friend
  void _auto_store_on_cellrenderer_text_edited_numerical(const Glib::ustring& path_string, const Glib::ustring& new_text, int model_column, const Glib::RefPtr<Gtk::TreeModel>& model);
 
  void _auto_store_on_cellrenderer_toggle_edited_with_model(const Glib::ustring& path_string, int model_column, const Glib::RefPtr<Gtk::TreeModel>& model);
 
  // This is no longer used, but we must keep it to prevent linker errors with already-compiled applications,
  // For instance, applications that were compiled with the older versions of the templates that did use this method.
  // TODO: Remove this when we can break API.
  void _auto_store_on_cellrenderer_toggle_edited(const Glib::ustring& path_string, int model_column);
 
  template<class ColumnType> friend
  void TreeView_Private::_connect_auto_store_editable_signal_handler(TreeView*, CellRenderer*, const TreeModelColumn<ColumnType>&);
 
#endif //DOXYGEN_SHOULD_SKIP_THIS
 
 
};
 
 
template <class ColumnType> inline
int TreeView::append_column(const Glib::ustring& title, const TreeModelColumn<ColumnType>& model_column)
{
  // compilation will fail if there is no appropriate TreeViewColumn
  // constructor for this model column type.
  TreeViewColumn *const pViewColumn = Gtk::manage( new TreeViewColumn(title, model_column) );
 
  return append_column(*pViewColumn);
}
 
//This is here because sigc::bind once did not work on all platforms, but now it does..
#define GTKMM_HAVE_SIGC_BIND 1
 
#ifdef GTKMM_HAVE_SIGC_BIND
 
template <class ColumnType> inline
int TreeView::append_column_numeric(const Glib::ustring& title, const TreeModelColumn<ColumnType>& model_column, const Glib::ustring& format)
{
  TreeViewColumn* const pViewColumn = Gtk::manage( new TreeViewColumn(title) );
 
  //Use a CellRendererText:
  //We don't use TreeView::Column::append_column(model_column) to generate an appropriate CellRenderer,
  //because that uses set_renderer(), which renders the model value using the automatic glib "transformations" (number-string conversions). As well as being unnecessary here, those automatic conversions can't handle all numeric types.
  CellRenderer* pCellRenderer = manage( new CellRendererText() );
  pViewColumn->pack_start(*pCellRenderer);
 
 
  //Some compilers don't like us to give the pointer to a template function directly to sigc::ptr_fun():
  typedef void (*type_fptr)(Gtk::CellRenderer* cell, const Gtk::TreeModel::iterator& iter, int model_column, const Glib::ustring& format);
  type_fptr fptr = TreeView_Private::_auto_cell_data_func<ColumnType>;
 
  //Connect a cell_data callback, to show the number's text representation in the specified format:
  //We use sigc::bind<-1> twice here, instead of sigc::bind() once, because some compilers need the extra hint.
  Gtk::TreeViewColumn::SlotCellData slot = sigc::bind<-1>(
    sigc::bind<-1>( sigc::ptr_fun(fptr), format),
    model_column.index()
  );
 
  pViewColumn->set_cell_data_func(*pCellRenderer, slot);
 
  return append_column(*pViewColumn);
}
 
#endif //GTKMM_HAVE_SIGC_BIND
 
template <class ColumnType> inline
int TreeView::append_column_numeric_editable(const Glib::ustring& title, const TreeModelColumn<ColumnType>& model_column, const Glib::ustring& format)
{
  int cols_count = append_column_numeric(title, model_column, format);
 
  //connect signal handlers for auto-storing of edited cell data
  //Note: This will only work for base-10 (decimal) formatted numbers:
  CellRenderer *const cell = get_column_cell_renderer(cols_count - 1);
  if(cell)
  {
    TreeView_Private::_connect_auto_store_editable_signal_handler<ColumnType>(this, cell, model_column);
  }
 
  return cols_count;
}
 
template <class ColumnType> inline
int TreeView::append_column_editable(const Glib::ustring& title, const TreeModelColumn<ColumnType>& model_column)
{
  //Don't use this in a header, because it gives warnings when disabled: g_assert(model_column.type() != 0);
 
  // compilation will fail if there is no appropriate TreeViewColumn
  // constructor for this model column type.
  TreeViewColumn *const pViewColumn = Gtk::manage( new TreeViewColumn(title, model_column) );
 
  //connect signal handlers for auto-storing of edited cell data
  CellRenderer* pCellRender = pViewColumn->get_first_cell();
  TreeView_Private::_connect_auto_store_editable_signal_handler<ColumnType>(this, pCellRender, model_column);
 
  return append_column(*pViewColumn);
}
 
template <class ColumnType> inline
int TreeView::insert_column(const Glib::ustring& title, const TreeModelColumn<ColumnType>& model_column, int position)
{
  // compilation will fail if there is no appropriate TreeViewColumn
  // constructor for this model column type.
  TreeViewColumn *const pViewColumn = Gtk::manage( new TreeViewColumn(title, model_column) );
 
  return insert_column(*pViewColumn, position);
}
 
template <class ColumnType> inline
int TreeView::insert_column_editable(const Glib::ustring& title, const TreeModelColumn<ColumnType>& model_column, int position)
{
  // compilation will fail if there is no appropriate TreeViewColumn
  // constructor for this model column type.
  TreeViewColumn *const pViewColumn = Gtk::manage( new TreeViewColumn(title, model_column) );
 
   //connect signal handlers for auto-storing of edited cell data
  CellRenderer* pCellRender = pViewColumn->get_first_cell();
  TreeView_Private::_connect_auto_store_editable_signal_handler(this, pCellRender, model_column);
 
  return insert_column(*pViewColumn, position);
}
 
 
#ifndef DOXYGEN_SHOULD_SKIP_THIS
namespace TreeView_Private
{
 
//Template specializations, for different model column types:
//TODO: Move these specializations into the .ccg file - I tried, but the int specialization was not used by the compiler. murrayc.
 
#ifdef GTKMM_HAVE_SIGC_BIND
 
//bool specialization:
template<> inline
void _connect_auto_store_editable_signal_handler(Gtk::TreeView* this_p, Gtk::CellRenderer* pCellRenderer, const Gtk::TreeModelColumn<bool>& model_column)
{
  Gtk::CellRendererToggle* pCellToggle = dynamic_cast<Gtk::CellRendererToggle*>(pCellRenderer);
  if(pCellToggle)
  {
    //Set the appropriate property,
    pCellToggle->property_activatable() = true;
 
    //Connect to the appropriate signal, sending the model_column too
 
    sigc::slot<void, const Glib::ustring&, int> slot_temp =
      sigc::bind<-1>(
        sigc::mem_fun(*this_p, &Gtk::TreeView::_auto_store_on_cellrenderer_toggle_edited_with_model),
        this_p->_get_base_model()
      );
 
    pCellToggle->signal_toggled().connect(
      sigc::bind<-1>(
        slot_temp,
        model_column.index()
      )
    );
 
    //We use bind<1> instead of bind because some compilers need the extra hint.
  }
}
 
//int specialization:
template<> inline
void _connect_auto_store_editable_signal_handler(Gtk::TreeView* this_p, Gtk::CellRenderer* pCellRenderer,  const Gtk::TreeModelColumn<int>& model_column)
{
  Gtk::CellRendererText* pCellText = dynamic_cast<Gtk::CellRendererText*>(pCellRenderer);
  if(pCellText)
  {
    //Set the appropriate property,
    pCellText->property_editable() = true;
 
    //Some compilers don't like us to give the pointer to a template function directly to sigc::ptr_fun():
    typedef void (*type_fptr)(const Glib::ustring& path_string, const Glib::ustring& new_text, int model_column, const Glib::RefPtr<Gtk::TreeModel>& model);
    type_fptr fptr = _auto_store_on_cellrenderer_text_edited_numerical<int>;
 
    //Connect to the appropriate signal, sending the model_column too,
    //We use bind<-1> twice here, instead of using bind() once, because some compilers need the extra hint.
    pCellText->signal_edited().connect(
      sigc::bind<-1>(
        sigc::bind<-1>(
          sigc::ptr_fun(fptr),
          this_p->_get_base_model() ),
        model_column.index()
      )
    );
 
  }
}
 
//unsigned int specialization:
template<> inline
void _connect_auto_store_editable_signal_handler(Gtk::TreeView* this_p, Gtk::CellRenderer* pCellRenderer,  const Gtk::TreeModelColumn<unsigned int>& model_column)
{
  Gtk::CellRendererText* pCellText = dynamic_cast<Gtk::CellRendererText*>(pCellRenderer);
  if(pCellText)
  {
    //Set the appropriate property,
    pCellText->property_editable() = true;
 
    //Some compilers don't like us to give the pointer to a template function directly to sigc::ptr_fun():
    typedef void (*type_fptr)(const Glib::ustring& path_string, const Glib::ustring& new_text, int model_column, const Glib::RefPtr<Gtk::TreeModel>& model);
    type_fptr fptr = _auto_store_on_cellrenderer_text_edited_numerical<unsigned int>;
 
    //Connect to the appropriate signal, sending the model_column too,
    //We use bind<-1> twice here, instead of using bind() once, because some compilers need the extra hint.
    pCellText->signal_edited().connect(
      sigc::bind<-1>(
        sigc::bind<-1>(
          sigc::ptr_fun(fptr),
          this_p->_get_base_model() ),
        model_column.index()
      )
    );
 
  }
}
 
//long specialization:
template<> inline
void _connect_auto_store_editable_signal_handler(Gtk::TreeView* this_p, Gtk::CellRenderer* pCellRenderer,  const Gtk::TreeModelColumn<long>& model_column)
{
  Gtk::CellRendererText* pCellText = dynamic_cast<Gtk::CellRendererText*>(pCellRenderer);
  if(pCellText)
  {
    //Set the appropriate property,
    pCellText->property_editable() = true;
 
    //Some compilers don't like us to give the pointer to a template function directly to sigc::ptr_fun():
    typedef void (*type_fptr)(const Glib::ustring& path_string, const Glib::ustring& new_text, int model_column, const Glib::RefPtr<Gtk::TreeModel>& model);
    type_fptr fptr = _auto_store_on_cellrenderer_text_edited_numerical<long>;
 
    //Connect to the appropriate signal, sending the model_column too,
    //We use bind<-1> twice here, instead of using bind() once, because some compilers need the extra hint.
    pCellText->signal_edited().connect(
      sigc::bind<-1>(
        sigc::bind<-1>(
          sigc::ptr_fun(fptr),
          this_p->_get_base_model() ),
        model_column.index()
      )
    );
 
  }
}
 
//unsigned long specialization:
template<> inline
void _connect_auto_store_editable_signal_handler(Gtk::TreeView* this_p, Gtk::CellRenderer* pCellRenderer,  const Gtk::TreeModelColumn<unsigned long>& model_column)
{
  Gtk::CellRendererText* pCellText = dynamic_cast<Gtk::CellRendererText*>(pCellRenderer);
  if(pCellText)
  {
    //Set the appropriate property,
    pCellText->property_editable() = true;
 
    //Some compilers don't like us to give the pointer to a template function directly to sigc::ptr_fun():
    typedef void (*type_fptr)(const Glib::ustring& path_string, const Glib::ustring& new_text, int model_column, const Glib::RefPtr<Gtk::TreeModel>& model);
    type_fptr fptr = _auto_store_on_cellrenderer_text_edited_numerical<unsigned long>;
 
    //Connect to the appropriate signal, sending the model_column too,
    //We use bind<-1> twice here, instead of using bind() once, because some compilers need the extra hint.
    pCellText->signal_edited().connect(
      sigc::bind<-1>(
        sigc::bind<-1>(
          sigc::ptr_fun(fptr),
          this_p->_get_base_model() ),
        model_column.index()
      )
    );
 
  }
}
 
//float specialization:
template<> inline
void _connect_auto_store_editable_signal_handler(Gtk::TreeView* this_p, Gtk::CellRenderer* pCellRenderer,  const Gtk::TreeModelColumn<float>& model_column)
{
  Gtk::CellRendererText* pCellText = dynamic_cast<Gtk::CellRendererText*>(pCellRenderer);
  if(pCellText)
  {
    //Set the appropriate property,
    pCellText->property_editable() = true;
 
    //Some compilers don't like us to give the pointer to a template function directly to sigc::ptr_fun():
    typedef void (*type_fptr)(const Glib::ustring& path_string, const Glib::ustring& new_text, int model_column, const Glib::RefPtr<Gtk::TreeModel>& model);
    type_fptr fptr = _auto_store_on_cellrenderer_text_edited_numerical<float>;
 
    //Connect to the appropriate signal, sending the model_column too,
    //We use bind<-1> twice here, instead of using bind() once, because some compilers need the extra hint.
    pCellText->signal_edited().connect(
      sigc::bind<-1>(
        sigc::bind<-1>(
          sigc::ptr_fun(fptr),
          this_p->_get_base_model() ),
        model_column.index()
      )
    );
  }
}
 
//double specialization:
template<> inline
void _connect_auto_store_editable_signal_handler(Gtk::TreeView* this_p, Gtk::CellRenderer* pCellRenderer,  const Gtk::TreeModelColumn<double>& model_column)
{
  Gtk::CellRendererText* pCellText = dynamic_cast<Gtk::CellRendererText*>(pCellRenderer);
  if(pCellText)
  {
    //Set the appropriate property,
    pCellText->property_editable() = true;
 
    //Some compilers don't like us to give the pointer to a template function directly to sigc::ptr_fun():
    typedef void (*type_fptr)(const Glib::ustring& path_string, const Glib::ustring& new_text, int model_column, const Glib::RefPtr<Gtk::TreeModel>& model);
    type_fptr fptr = _auto_store_on_cellrenderer_text_edited_numerical<double>;
 
    //Connect to the appropriate signal, sending the model_column too,
    //We use bind<-1> twice here, instead of using bind() once, because some compilers need the extra hint.
    pCellText->signal_edited().connect(
      sigc::bind<-1>(
        sigc::bind<-1>(
          sigc::ptr_fun(fptr),
          this_p->_get_base_model() ),
        model_column.index()
      )
    );
  }
}
 
#endif //GTKMM_HAVE_SIGC_BIND
 
} // namespace TreeView_Private
#endif //DOXYGEN_SHOULD_SKIP_THIS
 
 
#ifndef DOXYGEN_SHOULD_SKIP_THIS
namespace TreeView_Private
{
 
#ifdef GTKMM_HAVE_SIGC_BIND
 
template <class ColumnType> inline
void _connect_auto_store_editable_signal_handler(Gtk::TreeView* this_p, Gtk::CellRenderer* pCellRenderer, const Gtk::TreeModelColumn<ColumnType>& model_column)
{
  //Don't use this in a header, because it gives warnings when disabled: g_assert(model_column.type() != 0);
 
  //The different CellRenderers have different "edited" signals,
  //and numerical values need to convert the text value to a number,
  //so there are specializations for this tempate.
 
  Gtk::CellRendererText* pCellText = dynamic_cast<Gtk::CellRendererText*>(pCellRenderer);
 
  //Set the appropriate property,
  //and connect to the appropriate signal, sending the model_column too,
  if(pCellText)
  {
    pCellText->property_editable() = true;
 
    //Some compilers (IRIX MipsPro) don't like us to give the pointer to a template function directly to sigc::ptr_fun():
    typedef void (*type_func)(const Glib::ustring&, const Glib::ustring&, int, const Glib::RefPtr<Gtk::TreeModel>&);
    type_func func = &(_auto_store_on_cellrenderer_text_edited_string<ColumnType>);
    sigc::slot<void, const Glib::ustring&, const Glib::ustring&, int, const Glib::RefPtr<Gtk::TreeModel>&> theslot  =
      sigc::ptr_fun(func);
 
    //We use bind<-1> twice here, instead of using bind() once, because some compilers need the extra hint.
    pCellText->signal_edited().connect(
      sigc::bind<-1>(
        sigc::bind<-1>( theslot, this_p->_get_base_model()),
        model_column.index()
      )
    );
  }
}
 
#endif //GTKMM_HAVE_SIGC_BIND
 
template <class ColumnType> inline
void _auto_store_on_cellrenderer_text_edited_string(const Glib::ustring& path_string, const Glib::ustring& new_text, int model_column, const Glib::RefPtr<Gtk::TreeModel>& model)
{
  Gtk::TreePath path(path_string);
 
  //Get the row from the path:
  if(model)
  {
    Gtk::TreeModel::iterator iter = model->get_iter(path);
    if(iter)
    {
        //Store the user's new text in the model:
        Gtk::TreeRow row = *iter;
        row.set_value(model_column, (ColumnType)new_text);
    }
  }
}
 
template <class ColumnType> inline
void _auto_store_on_cellrenderer_text_edited_numerical(const Glib::ustring& path_string, const Glib::ustring& new_text, int model_column, const Glib::RefPtr<Gtk::TreeModel>& model)
{
  //This is used on numerical model columns:
 
  Gtk::TreePath path(path_string);
 
  //Get the row from the path:
  if(model)
  {
    Gtk::TreeModel::iterator iter = model->get_iter(path);
    if(iter)
    {
      //std::istringstream astream(new_text); //Put it in a stream.
      //ColumnType new_value = ColumnType();
      //new_value << astream; //Get it out of the stream as the numerical type.
 
      //Convert the text to a number, using the same logic used by GtkCellRendererText when it stores numbers.
      char* pchEnd = 0;
      ColumnType new_value = static_cast<ColumnType>( strtod(new_text.c_str(), &pchEnd) );
 
      //Store the user's new text in the model:
      Gtk::TreeRow row = *iter;
      row.set_value(model_column, (ColumnType)new_value);
    }
  }
}
 
template <class ColumnType> inline
void _auto_cell_data_func(Gtk::CellRenderer* cell, const Gtk::TreeModel::iterator& iter, int model_column, const Glib::ustring& format)
{
  Gtk::CellRendererText* pTextRenderer = dynamic_cast<Gtk::CellRendererText*>(cell);
  if(!pTextRenderer)
  {
    g_warning("gtkmm: TextView: append_column_numeric() was used with a non-numeric type.");
  }
  else
  {
    if(iter)
    {
      //Get the value from the model.
      Gtk::TreeModel::Row row = *iter;
      ColumnType value = ColumnType();
      row.get_value(model_column, value);
 
      //Convert it to a string representation:
      char buff[20];
      int used = g_snprintf(buff, sizeof(buff), format.c_str(), value); //value must be a numeric type.
      if(used > 0)
      {
        //Show the text representation in the view:
        pTextRenderer->property_text() = buff;
      }
    }
  }
}
 
} // namespace TreeView_Private
#endif //DOXYGEN_SHOULD_SKIP_THIS
 
} // namespace Gtk
 
 
namespace Glib
{
  Gtk::TreeView* wrap(GtkTreeView* object, bool take_copy = false);
} //namespace Glib
 
 
#endif /* _GTKMM_TREEVIEW_H */