// Generated by gmmproc 2.62.0 -- DO NOT MODIFY!
#ifndef _GTKMM_CELLLAYOUT_H
#define _GTKMM_CELLLAYOUT_H


#include <glibmm/ustring.h>
#include <sigc++/sigc++.h>

/* 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 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 */

#include <vector>

#include <glibmm/interface.h>
//#include <gtkmm/cellarea.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
using GtkCellLayout = struct _GtkCellLayout;
using GtkCellLayoutClass = struct _GtkCellLayoutClass;
#endif /* DOXYGEN_SHOULD_SKIP_THIS */


#ifndef DOXYGEN_SHOULD_SKIP_THIS
namespace Gtk
{ class CellLayout_Class; } // namespace Gtk
#endif // DOXYGEN_SHOULD_SKIP_THIS

namespace Gtk
{

class CellArea;

/** 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 GTKMM_API CellLayout : public Glib::Interface
{
  
#ifndef DOXYGEN_SHOULD_SKIP_THIS

public:
  using CppObjectType = CellLayout;
  using CppClassType = CellLayout_Class;
  using BaseObjectType = GtkCellLayout;
  using BaseClassType = GtkCellLayoutIface;

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

private:
  friend class CellLayout_Class;
  static CppClassType celllayout_class_;

#endif /* DOXYGEN_SHOULD_SKIP_THIS */
protected:
  /**
   * You should derive from this class to use it.
   */
  CellLayout();

#ifndef DOXYGEN_SHOULD_SKIP_THIS
  /** Called by constructors of derived classes. Provide the result of
   * the Class init() function to ensure that it is properly
   * initialized.
   *
   * @param interface_class The Class object for the derived type.
   */
  explicit CellLayout(const Glib::Interface_Class& interface_class);

public:
  // This is public so that C++ wrapper instances can be
  // created for C instances of unwrapped types.
  // For instance, if an unexpected C type implements the C interface.
  explicit CellLayout(GtkCellLayout* castitem);

protected:
#endif /* DOXYGEN_SHOULD_SKIP_THIS */

public:

  CellLayout(CellLayout&& src) noexcept;
  CellLayout& operator=(CellLayout&& src) noexcept;

  ~CellLayout() noexcept override;

  static void add_interface(GType gtype_implementer);

  /** Get the GType for this class, for use with the underlying GObject type system.
   */
  static GType get_type()      G_GNUC_CONST;

#ifndef DOXYGEN_SHOULD_SKIP_THIS
  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>.
   * 
   * Note that reusing the same cell renderer is not supported.
   * 
   * @newin{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>.
   * 
   * Note that reusing the same cell renderer is not supported.
   * 
   * @newin{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);

 
  /** Return value: a list of cell renderers.
   * 
   * @newin{2,12}
   * 
   * @return A list of cell renderers.
   */
  std::vector<CellRenderer*> get_cells();
  
  /** Return value: a list of cell renderers.
   * 
   * @newin{2,12}
   * 
   * @return A list of cell renderers.
   */
  std::vector<const CellRenderer*> get_cells() const;

  /** Gets the CellRenderer for the first column if any has been added, or
    * nullptr otherwise.
    * You should dynamic_cast<> to the expected derived CellRenderer type.
    */
  CellRenderer* get_first_cell();

  /** Gets the CellRenderer for the first column if any has been added, or
    * nullptr otherwise.
    * You should dynamic_cast<> to the expected derived CellRenderer type.
    */
  const CellRenderer* get_first_cell() const;

  
  /** Unsets all the mappings on all renderers on @a cell_layout and
   * removes all renderers from @a cell_layout.
   * 
   * @newin{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.
   * 
   * @newin{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);

  void add_attribute(CellRenderer& cell, const Glib::ustring& attribute, 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().
   * 
   * @newin{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.
   * 
   * @newin{2,4}
   * 
   * @param cell A Gtk::CellRenderer to reorder.
   * @param position New position to insert @a cell at.
   */
  void reorder(CellRenderer& cell, int position);

  
  /** Returns the underlying Gtk::CellArea which might be @a cell_layout
   * if called on a Gtk::CellArea or might be <tt>nullptr</tt> if no Gtk::CellArea
   * is used by @a cell_layout.
   * 
   * @newin{3,0}
   * 
   * @return The cell area used by @a cell_layout,
   * or <tt>nullptr</tt> in case no cell area is used.
   */
  Glib::RefPtr<CellArea> get_area();
  
  /** Returns the underlying Gtk::CellArea which might be @a cell_layout
   * if called on a Gtk::CellArea or might be <tt>nullptr</tt> if no Gtk::CellArea
   * is used by @a cell_layout.
   * 
   * @newin{3,0}
   * 
   * @return The cell area used by @a cell_layout,
   * or <tt>nullptr</tt> in case no cell area is used.
   */
  Glib::RefPtr<const CellArea> get_area() const;

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 when we can break ABI(added in GTK+ 2.4):  _WRAP_VFUNC(void set_cell_data_func(CellRenderer* cell, GtkCellLayoutDataFunc func, gpointer func_data, GDestroyNotify destroy), gtk_cell_layout_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
{
  /** A Glib::wrap() method for this object.
   *
   * @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.
   *
   * @relates Gtk::CellLayout
   */
  Glib::RefPtr<Gtk::CellLayout> wrap(GtkCellLayout* object, bool take_copy = false);

} // namespace Glib


#endif /* _GTKMM_CELLLAYOUT_H */

