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

// -*- c++ -*-
// Generated by gtkmmproc -- DO NOT MODIFY!
#ifndef _GTKMM_CELLLAYOUT_H
#define _GTKMM_CELLLAYOUT_H

#include <glibmm.h>

/* $Id$ */

/* Copyright (C) 2003 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 <glibmm/interface.h>
#include <gtkmm/cellrenderer.h>
#include <gtkmm/cellrenderer_generation.h>
#include <gtkmm/treemodel.h>


#ifndef DOXYGEN_SHOULD_SKIP_THIS
extern "C"
{
typedef struct _GtkCellLayoutIface GtkCellLayoutIface;
}
#endif /* DOXYGEN_SHOULD_SKIP_THIS */


#ifndef DOXYGEN_SHOULD_SKIP_THIS
typedef struct _GtkCellLayout GtkCellLayout;
typedef struct _GtkCellLayoutClass GtkCellLayoutClass;
#endif /* DOXYGEN_SHOULD_SKIP_THIS */


namespace Gtk
{ class CellLayout_Class; } // namespace Gtk
namespace Gtk
{

/** An interface for packing cells.
 * CellLayout is an interface to be implemented by all objects which want to provide a TreeView::Column-like API 
 * for packing cells, setting attributes and data funcs.
 */

class CellLayout : public Glib::Interface
{
  
#ifndef DOXYGEN_SHOULD_SKIP_THIS

public:
  typedef CellLayout CppObjectType;
  typedef CellLayout_Class CppClassType;
  typedef GtkCellLayout BaseObjectType;
  typedef GtkCellLayoutIface BaseClassType;

private:
  friend class CellLayout_Class;
  static CppClassType celllayout_class_;

  // noncopyable
  CellLayout(const CellLayout&);
  CellLayout& operator=(const CellLayout&);

protected:
  CellLayout(); // you must derive from this class
  explicit CellLayout(GtkCellLayout* castitem);

#endif /* DOXYGEN_SHOULD_SKIP_THIS */

public:
  virtual ~CellLayout();

  static void add_interface(GType gtype_implementer);

#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 GObject.
  GtkCellLayout*       gobj()       { return reinterpret_cast<GtkCellLayout*>(gobject_); }

  ///Provides access to the underlying C GObject.  
  const GtkCellLayout* gobj() const { return reinterpret_cast<GtkCellLayout*>(gobject_); }

private:


public:

  template <class ColumnType> inline
  void pack_start(const TreeModelColumn<ColumnType>& model_column, bool expand = true);
  

  /** Packs the @a cell  into the beginning of @a cell_layout . If @a expand  is <tt>false</tt>,
   * then the @a cell  is allocated no more space than it needs. Any unused space
   * is divided evenly between cells for which @a expand  is <tt>true</tt>.
   * 
   * Since: 2.4
   * @param cell A Gtk::CellRenderer.
   * @param expand <tt>true</tt> if @a cell  is to be given extra space allocated to @a cell_layout .
   */
  void pack_start(CellRenderer& cell, bool expand = true);
  
  /** Adds the @a cell  to the end of @a cell_layout . If @a expand  is <tt>false</tt>, then the
   *  @a cell  is allocated no more space than it needs. Any unused space is
   * divided evenly between cells for which @a expand  is <tt>true</tt>.
   * 
   * Since: 2.4
   * @param cell A Gtk::CellRenderer.
   * @param expand <tt>true</tt> if @a cell  is to be given extra space allocated to @a cell_layout .
   */
  void pack_end(CellRenderer& cell, bool expand = true);
  
  /** Unsets all the mappings on all renderers on @a cell_layout  and
   * removes all renderers from @a cell_layout .
   * 
   * Since: 2.4
   */
  void clear();
  
   //I think this is just a convenience method, equivalent to clear() and multiple add_attribute()s. murrayc.

  
  /** Adds an attribute mapping to the list in @a cell_layout . The @a column  is the
   * column of the model to get a value from, and the @a attribute  is the
   * parameter on @a cell  to be set from the value. So for example if column 2
   * of the model contains strings, you could have the "text" attribute of a
   * Gtk::CellRendererText get its values from column 2.
   * 
   * Since: 2.4
   * @param cell A Gtk::CellRenderer.
   * @param attribute An attribute on the renderer.
   * @param column The column position on the model to get the attribute from.
   */
  void add_attribute(CellRenderer& cell, const Glib::ustring& attribute, int column);
  void add_attribute(const Glib::PropertyProxy_Base& property, const TreeModelColumnBase& column);

  //For instance, void on_cell_data(const TreeModel::const_iterator& iter)                                        
  typedef sigc::slot<void, const TreeModel::const_iterator&> SlotCellData;

  void set_cell_data_func(CellRenderer& cell, const SlotCellData& slot);
  
                                                                                  
  /** Clears all existing attributes previously set with
   * set_attributes().
   * 
   * Since: 2.4
   * @param cell A Gtk::CellRenderer to clear the attribute mapping on.
   */
  void clear_attributes(CellRenderer& cell);

  
  /** Re-inserts @a cell  at @a position . Note that @a cell  has already to be packed
   * into @a cell_layout  for this to function properly.
   * 
   * Since: 2.4
   * @param cell A Gtk::CellRenderer to reorder.
   * @param position New position to insert @a cell  at.
   */
  void reorder(CellRenderer& cell, int position);

protected:
    virtual void pack_start_vfunc(CellRenderer* cell, bool expand);
    virtual void pack_end_vfunc(CellRenderer* cell, bool expand);
    virtual void clear_vfunc();
    virtual void add_attribute_vfunc(CellRenderer* cell, const Glib::ustring& attribute, int column);
//TODO:  _WRAP_VFUNC(void set_cell_data_func(CellRenderer* cell, GtkCellLayoutDataFunc func, gpointer func_data, GDestroyNotify destroy), set_cell_data_func)
    virtual void clear_attributes_vfunc(CellRenderer* cell);
    virtual void reorder_vfunc(CellRenderer* cell, int position);
                                 

public:

public:
  //C++ methods used to invoke GTK+ virtual functions:

protected:
  //GTK+ Virtual Functions (override these to change behaviour):

  //Default Signal Handlers::


};

template<class T_ModelColumnType>
void CellLayout::pack_start(const TreeModelColumn<T_ModelColumnType>& column, bool expand)
{
  //Generate appropriate Renderer for the column:
  CellRenderer* pCellRenderer = manage( CellRenderer_Generation::generate_cellrenderer<T_ModelColumnType>() );

  //Use the renderer:
  pack_start(*pCellRenderer, expand);

  //Make the renderer render the column:
  add_attribute(pCellRenderer->_property_renderable(), column);
}

} // namespace Gtk


namespace Glib
{
  /** @relates Gtk::CellLayout
   * @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.
   */
  Glib::RefPtr<Gtk::CellLayout> wrap(GtkCellLayout* object, bool take_copy = false);

} // namespace Glib

#endif /* _GTKMM_CELLLAYOUT_H */