/* gtktreeviewcolumn.c

 * Copyright (C) 2000  Red Hat, Inc.,  Jonathan Blandford <jrb@redhat.com>

 *

 * 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., 59 Temple Place - Suite 330,

 * Boston, MA 02111-1307, USA.

 */

#include "config.h"

#include <string.h>

#include "gtktreeviewcolumn.h"

#include "gtktreeview.h"

#include "gtktreeprivate.h"

#include "gtkcelllayout.h"

#include "gtkbutton.h"

#include "gtkalignment.h"

#include "gtklabel.h"

#include "gtkhbox.h"

#include "gtkmarshalers.h"

#include "gtkarrow.h"

#include "gtkprivate.h"

#include "gtkintl.h"

#include "gtkalias.h"

enum

{

  PROP_0,

  PROP_VISIBLE,

  PROP_RESIZABLE,

  PROP_WIDTH,

  PROP_SPACING,

  PROP_SIZING,

  PROP_FIXED_WIDTH,

  PROP_MIN_WIDTH,

  PROP_MAX_WIDTH,

  PROP_TITLE,

  PROP_EXPAND,

  PROP_CLICKABLE,

  PROP_WIDGET,

  PROP_ALIGNMENT,

  PROP_REORDERABLE,

  PROP_SORT_INDICATOR,

  PROP_SORT_ORDER,

  PROP_SORT_COLUMN_ID

};

enum

{

  CLICKED,

  LAST_SIGNAL

};

typedef struct _GtkTreeViewColumnCellInfo GtkTreeViewColumnCellInfo;

struct _GtkTreeViewColumnCellInfo

{

  GtkCellRenderer *cell;

  GSList *attributes;

  GtkTreeCellDataFunc func;

  gpointer func_data;

  GDestroyNotify destroy;

  gint requested_width;

  gint real_width;

  guint expand : 1;

  guint pack : 1;

  guint has_focus : 1;

  guint in_editing_mode : 1;

};

/* Type methods */

static void gtk_tree_view_column_cell_layout_init              (GtkCellLayoutIface      *iface);

/* GObject methods */

static void gtk_tree_view_column_set_property                  (GObject                 *object,

								guint                    prop_id,

								const GValue            *value,

								GParamSpec              *pspec);

static void gtk_tree_view_column_get_property                  (GObject                 *object,

								guint                    prop_id,

								GValue                  *value,

								GParamSpec              *pspec);

static void gtk_tree_view_column_finalize                      (GObject                 *object);

/* GtkCellLayout implementation */

static void gtk_tree_view_column_cell_layout_pack_start         (GtkCellLayout         *cell_layout,

                                                                 GtkCellRenderer       *cell,

                                                                 gboolean               expand);

static void gtk_tree_view_column_cell_layout_pack_end           (GtkCellLayout         *cell_layout,

                                                                 GtkCellRenderer       *cell,

                                                                 gboolean               expand);

static void gtk_tree_view_column_cell_layout_clear              (GtkCellLayout         *cell_layout);

static void gtk_tree_view_column_cell_layout_add_attribute      (GtkCellLayout         *cell_layout,

                                                                 GtkCellRenderer       *cell,

                                                                 const gchar           *attribute,

                                                                 gint                   column);

static void gtk_tree_view_column_cell_layout_set_cell_data_func (GtkCellLayout         *cell_layout,

                                                                 GtkCellRenderer       *cell,

                                                                 GtkCellLayoutDataFunc  func,

                                                                 gpointer               func_data,

                                                                 GDestroyNotify         destroy);

static void gtk_tree_view_column_cell_layout_clear_attributes   (GtkCellLayout         *cell_layout,

                                                                 GtkCellRenderer       *cell);

static void gtk_tree_view_column_cell_layout_reorder            (GtkCellLayout         *cell_layout,

                                                                 GtkCellRenderer       *cell,

                                                                 gint                   position);

static GList *gtk_tree_view_column_cell_layout_get_cells        (GtkCellLayout         *cell_layout);

/* Button handling code */

static void gtk_tree_view_column_create_button                 (GtkTreeViewColumn       *tree_column);

static void gtk_tree_view_column_update_button                 (GtkTreeViewColumn       *tree_column);

/* Button signal handlers */

static gint gtk_tree_view_column_button_event                  (GtkWidget               *widget,

								GdkEvent                *event,

								gpointer                 data);

static void gtk_tree_view_column_button_clicked                (GtkWidget               *widget,

								gpointer                 data);

static gboolean gtk_tree_view_column_mnemonic_activate         (GtkWidget *widget,

					                        gboolean   group_cycling,

								gpointer   data);

/* Property handlers */

static void gtk_tree_view_model_sort_column_changed            (GtkTreeSortable         *sortable,

								GtkTreeViewColumn       *tree_column);

/* Internal functions */

static void gtk_tree_view_column_sort                          (GtkTreeViewColumn       *tree_column,

								gpointer                 data);

static void gtk_tree_view_column_setup_sort_column_id_callback (GtkTreeViewColumn       *tree_column);

static void gtk_tree_view_column_set_attributesv               (GtkTreeViewColumn       *tree_column,

								GtkCellRenderer         *cell_renderer,

								va_list                  args);

static GtkTreeViewColumnCellInfo *gtk_tree_view_column_get_cell_info (GtkTreeViewColumn *tree_column,

								      GtkCellRenderer   *cell_renderer);

/* cell list manipulation */

static GList *gtk_tree_view_column_cell_first                  (GtkTreeViewColumn      *tree_column);

static GList *gtk_tree_view_column_cell_last                   (GtkTreeViewColumn      *tree_column);

static GList *gtk_tree_view_column_cell_next                   (GtkTreeViewColumn      *tree_column,

								GList                  *current);

static GList *gtk_tree_view_column_cell_prev                   (GtkTreeViewColumn      *tree_column,

								GList                  *current);

static void gtk_tree_view_column_clear_attributes_by_info      (GtkTreeViewColumn      *tree_column,

					                        GtkTreeViewColumnCellInfo *info);

/* GtkBuildable implementation */

static void gtk_tree_view_column_buildable_init                 (GtkBuildableIface     *iface);

static guint tree_column_signals[LAST_SIGNAL] = { 0 };

G_DEFINE_TYPE_WITH_CODE (GtkTreeViewColumn, gtk_tree_view_column, GTK_TYPE_OBJECT,

			 G_IMPLEMENT_INTERFACE (GTK_TYPE_CELL_LAYOUT,

						gtk_tree_view_column_cell_layout_init)

			 G_IMPLEMENT_INTERFACE (GTK_TYPE_BUILDABLE,

						gtk_tree_view_column_buildable_init))

static void

gtk_tree_view_column_class_init (GtkTreeViewColumnClass *class)

{

  GObjectClass *object_class;

  object_class = (GObjectClass*) class;

  class->clicked = NULL;

  object_class->finalize = gtk_tree_view_column_finalize;

  object_class->set_property = gtk_tree_view_column_set_property;

  object_class->get_property = gtk_tree_view_column_get_property;

  tree_column_signals[CLICKED] =

    g_signal_new (I_("clicked"),

                  G_OBJECT_CLASS_TYPE (object_class),

                  G_SIGNAL_RUN_LAST,

                  G_STRUCT_OFFSET (GtkTreeViewColumnClass, clicked),

                  NULL, NULL,

                  _gtk_marshal_VOID__VOID,

                  G_TYPE_NONE, 0);

  g_object_class_install_property (object_class,

                                   PROP_VISIBLE,

                                   g_param_spec_boolean ("visible",

                                                        P_("Visible"),

                                                        P_("Whether to display the column"),

                                                         TRUE,

                                                         GTK_PARAM_READWRITE));

  g_object_class_install_property (object_class,

                                   PROP_RESIZABLE,

                                   g_param_spec_boolean ("resizable",

							 P_("Resizable"),

							 P_("Column is user-resizable"),

                                                         FALSE,

                                                         GTK_PARAM_READWRITE));

  g_object_class_install_property (object_class,

                                   PROP_WIDTH,

                                   g_param_spec_int ("width",

						     P_("Width"),

						     P_("Current width of the column"),

						     0,

						     G_MAXINT,

						     0,

						     GTK_PARAM_READABLE));

  g_object_class_install_property (object_class,

                                   PROP_SPACING,

                                   g_param_spec_int ("spacing",

						     P_("Spacing"),

						     P_("Space which is inserted between cells"),

						     0,

						     G_MAXINT,

						     0,

						     GTK_PARAM_READWRITE));

  g_object_class_install_property (object_class,

                                   PROP_SIZING,

                                   g_param_spec_enum ("sizing",

                                                      P_("Sizing"),

                                                      P_("Resize mode of the column"),

                                                      GTK_TYPE_TREE_VIEW_COLUMN_SIZING,

                                                      GTK_TREE_VIEW_COLUMN_GROW_ONLY,

                                                      GTK_PARAM_READWRITE));

  g_object_class_install_property (object_class,

                                   PROP_FIXED_WIDTH,

                                   g_param_spec_int ("fixed-width",

                                                     P_("Fixed Width"),

                                                     P_("Current fixed width of the column"),

                                                     1,

                                                     G_MAXINT,

                                                     1, /* not useful */

                                                     GTK_PARAM_READWRITE));

  g_object_class_install_property (object_class,

                                   PROP_MIN_WIDTH,

                                   g_param_spec_int ("min-width",

                                                     P_("Minimum Width"),

                                                     P_("Minimum allowed width of the column"),

                                                     -1,

                                                     G_MAXINT,

                                                     -1,

                                                     GTK_PARAM_READWRITE));

  g_object_class_install_property (object_class,

                                   PROP_MAX_WIDTH,

                                   g_param_spec_int ("max-width",

                                                     P_("Maximum Width"),

                                                     P_("Maximum allowed width of the column"),

                                                     -1,

                                                     G_MAXINT,

                                                     -1,

                                                     GTK_PARAM_READWRITE));

  g_object_class_install_property (object_class,

                                   PROP_TITLE,

                                   g_param_spec_string ("title",

                                                        P_("Title"),

                                                        P_("Title to appear in column header"),

                                                        "",

                                                        GTK_PARAM_READWRITE));

  g_object_class_install_property (object_class,

                                   PROP_EXPAND,

                                   g_param_spec_boolean ("expand",

							 P_("Expand"),

							 P_("Column gets share of extra width allocated to the widget"),

							 FALSE,

							 GTK_PARAM_READWRITE));

  g_object_class_install_property (object_class,

                                   PROP_CLICKABLE,

                                   g_param_spec_boolean ("clickable",

                                                        P_("Clickable"),

                                                        P_("Whether the header can be clicked"),

                                                         FALSE,

                                                         GTK_PARAM_READWRITE));

  g_object_class_install_property (object_class,

                                   PROP_WIDGET,

                                   g_param_spec_object ("widget",

                                                        P_("Widget"),

                                                        P_("Widget to put in column header button instead of column title"),

                                                        GTK_TYPE_WIDGET,

                                                        GTK_PARAM_READWRITE));

  g_object_class_install_property (object_class,

                                   PROP_ALIGNMENT,

                                   g_param_spec_float ("alignment",

                                                       P_("Alignment"),

                                                       P_("X Alignment of the column header text or widget"),

                                                       0.0,

                                                       1.0,

                                                       0.0,

                                                       GTK_PARAM_READWRITE));

  g_object_class_install_property (object_class,

                                   PROP_REORDERABLE,

                                   g_param_spec_boolean ("reorderable",

							 P_("Reorderable"),

							 P_("Whether the column can be reordered around the headers"),

							 FALSE,

							 GTK_PARAM_READWRITE));

  g_object_class_install_property (object_class,

                                   PROP_SORT_INDICATOR,

                                   g_param_spec_boolean ("sort-indicator",

                                                        P_("Sort indicator"),

                                                        P_("Whether to show a sort indicator"),

                                                         FALSE,

                                                         GTK_PARAM_READWRITE));

  g_object_class_install_property (object_class,

                                   PROP_SORT_ORDER,

                                   g_param_spec_enum ("sort-order",

                                                      P_("Sort order"),

                                                      P_("Sort direction the sort indicator should indicate"),

                                                      GTK_TYPE_SORT_TYPE,

                                                      GTK_SORT_ASCENDING,

                                                      GTK_PARAM_READWRITE));

  /**

   * GtkTreeViewColumn:sort-column-id:

   *

   * Logical sort column ID this column sorts on when selected for sorting. Setting the sort column ID makes the column header

   * clickable. Set to %-1 to make the column unsortable.

   *

   * Since: 2.18

   **/

  g_object_class_install_property (object_class,

                                   PROP_SORT_COLUMN_ID,

                                   g_param_spec_int ("sort-column-id",

                                                     P_("Sort column ID"),

                                                     P_("Logical sort column ID this column sorts on when selected for sorting"),

                                                     -1,

                                                     G_MAXINT,

                                                     -1,

                                                     GTK_PARAM_READWRITE));

}

static void

gtk_tree_view_column_buildable_init (GtkBuildableIface *iface)

{

  iface->add_child = _gtk_cell_layout_buildable_add_child;

  iface->custom_tag_start = _gtk_cell_layout_buildable_custom_tag_start;

  iface->custom_tag_end = _gtk_cell_layout_buildable_custom_tag_end;

}

static void

gtk_tree_view_column_cell_layout_init (GtkCellLayoutIface *iface)

{

  iface->pack_start = gtk_tree_view_column_cell_layout_pack_start;

  iface->pack_end = gtk_tree_view_column_cell_layout_pack_end;

  iface->clear = gtk_tree_view_column_cell_layout_clear;

  iface->add_attribute = gtk_tree_view_column_cell_layout_add_attribute;

  iface->set_cell_data_func = gtk_tree_view_column_cell_layout_set_cell_data_func;

  iface->clear_attributes = gtk_tree_view_column_cell_layout_clear_attributes;

  iface->reorder = gtk_tree_view_column_cell_layout_reorder;

  iface->get_cells = gtk_tree_view_column_cell_layout_get_cells;

}

static void

gtk_tree_view_column_init (GtkTreeViewColumn *tree_column)

{

  tree_column->button = NULL;

  tree_column->xalign = 0.0;

  tree_column->width = 0;

  tree_column->spacing = 0;

  tree_column->requested_width = -1;

  tree_column->min_width = -1;

  tree_column->max_width = -1;

  tree_column->resized_width = 0;

  tree_column->column_type = GTK_TREE_VIEW_COLUMN_GROW_ONLY;

  tree_column->visible = TRUE;

  tree_column->resizable = FALSE;

  tree_column->expand = FALSE;

  tree_column->clickable = FALSE;

  tree_column->dirty = TRUE;

  tree_column->sort_order = GTK_SORT_ASCENDING;

  tree_column->show_sort_indicator = FALSE;

  tree_column->property_changed_signal = 0;

  tree_column->sort_clicked_signal = 0;

  tree_column->sort_column_changed_signal = 0;

  tree_column->sort_column_id = -1;

  tree_column->reorderable = FALSE;

  tree_column->maybe_reordered = FALSE;

  tree_column->fixed_width = 1;

  tree_column->use_resized_width = FALSE;

  tree_column->title = g_strdup ("");

}

static void

gtk_tree_view_column_finalize (GObject *object)

{

  GtkTreeViewColumn *tree_column = (GtkTreeViewColumn *) object;

  GList *list;

  for (list = tree_column->cell_list; list; list = list->next)

    {

      GtkTreeViewColumnCellInfo *info = (GtkTreeViewColumnCellInfo *) list->data;

      if (info->destroy)

	{

	  GDestroyNotify d = info->destroy;

	  info->destroy = NULL;

	  d (info->func_data);

	}

      gtk_tree_view_column_clear_attributes_by_info (tree_column, info);

      g_object_unref (info->cell);

      g_free (info);

    }

  g_free (tree_column->title);

  g_list_free (tree_column->cell_list);

  if (tree_column->child)

    g_object_unref (tree_column->child);

  G_OBJECT_CLASS (gtk_tree_view_column_parent_class)->finalize (object);

}

static void

gtk_tree_view_column_set_property (GObject         *object,

                                   guint            prop_id,

                                   const GValue    *value,

                                   GParamSpec      *pspec)

{

  GtkTreeViewColumn *tree_column;

  tree_column = GTK_TREE_VIEW_COLUMN (object);

  switch (prop_id)

    {

    case PROP_VISIBLE:

      gtk_tree_view_column_set_visible (tree_column,

                                        g_value_get_boolean (value));

      break;

    case PROP_RESIZABLE:

      gtk_tree_view_column_set_resizable (tree_column,

					  g_value_get_boolean (value));

      break;

    case PROP_SIZING:

      gtk_tree_view_column_set_sizing (tree_column,

                                       g_value_get_enum (value));

      break;

    case PROP_FIXED_WIDTH:

      gtk_tree_view_column_set_fixed_width (tree_column,

					    g_value_get_int (value));

      break;

    case PROP_MIN_WIDTH:

      gtk_tree_view_column_set_min_width (tree_column,

                                          g_value_get_int (value));

      break;

    case PROP_MAX_WIDTH:

      gtk_tree_view_column_set_max_width (tree_column,

                                          g_value_get_int (value));

      break;

    case PROP_SPACING:

      gtk_tree_view_column_set_spacing (tree_column,

					g_value_get_int (value));

      break;

    case PROP_TITLE:

      gtk_tree_view_column_set_title (tree_column,

                                      g_value_get_string (value));

      break;

    case PROP_EXPAND:

      gtk_tree_view_column_set_expand (tree_column,

				       g_value_get_boolean (value));

      break;

    case PROP_CLICKABLE:

      gtk_tree_view_column_set_clickable (tree_column,

                                          g_value_get_boolean (value));

      break;

    case PROP_WIDGET:

      gtk_tree_view_column_set_widget (tree_column,

                                       (GtkWidget*) g_value_get_object (value));

      break;

    case PROP_ALIGNMENT:

      gtk_tree_view_column_set_alignment (tree_column,

                                          g_value_get_float (value));

      break;

    case PROP_REORDERABLE:

      gtk_tree_view_column_set_reorderable (tree_column,

					    g_value_get_boolean (value));

      break;

    case PROP_SORT_INDICATOR:

      gtk_tree_view_column_set_sort_indicator (tree_column,

                                               g_value_get_boolean (value));

      break;

    case PROP_SORT_ORDER:

      gtk_tree_view_column_set_sort_order (tree_column,

                                           g_value_get_enum (value));

      break;

    case PROP_SORT_COLUMN_ID:

      gtk_tree_view_column_set_sort_column_id (tree_column,

                                               g_value_get_int (value));

      break;

    default:

      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

      break;

    }

}

static void

gtk_tree_view_column_get_property (GObject         *object,

                                   guint            prop_id,

                                   GValue          *value,

                                   GParamSpec      *pspec)

{

  GtkTreeViewColumn *tree_column;

  tree_column = GTK_TREE_VIEW_COLUMN (object);

  switch (prop_id)

    {

    case PROP_VISIBLE:

      g_value_set_boolean (value,

                           gtk_tree_view_column_get_visible (tree_column));

      break;

    case PROP_RESIZABLE:

      g_value_set_boolean (value,

                           gtk_tree_view_column_get_resizable (tree_column));

      break;

    case PROP_WIDTH:

      g_value_set_int (value,

                       gtk_tree_view_column_get_width (tree_column));

      break;

    case PROP_SPACING:

      g_value_set_int (value,

                       gtk_tree_view_column_get_spacing (tree_column));

      break;

    case PROP_SIZING:

      g_value_set_enum (value,

                        gtk_tree_view_column_get_sizing (tree_column));

      break;

    case PROP_FIXED_WIDTH:

      g_value_set_int (value,

                       gtk_tree_view_column_get_fixed_width (tree_column));

      break;

    case PROP_MIN_WIDTH:

      g_value_set_int (value,

                       gtk_tree_view_column_get_min_width (tree_column));

      break;

    case PROP_MAX_WIDTH:

      g_value_set_int (value,

                       gtk_tree_view_column_get_max_width (tree_column));

      break;

    case PROP_TITLE:

      g_value_set_string (value,

                          gtk_tree_view_column_get_title (tree_column));

      break;

    case PROP_EXPAND:

      g_value_set_boolean (value,

                          gtk_tree_view_column_get_expand (tree_column));

      break;

    case PROP_CLICKABLE:

      g_value_set_boolean (value,

                           gtk_tree_view_column_get_clickable (tree_column));

      break;

    case PROP_WIDGET:

      g_value_set_object (value,

                          (GObject*) gtk_tree_view_column_get_widget (tree_column));

      break;

    case PROP_ALIGNMENT:

      g_value_set_float (value,

                         gtk_tree_view_column_get_alignment (tree_column));

      break;

    case PROP_REORDERABLE:

      g_value_set_boolean (value,

			   gtk_tree_view_column_get_reorderable (tree_column));

      break;

    case PROP_SORT_INDICATOR:

      g_value_set_boolean (value,

                           gtk_tree_view_column_get_sort_indicator (tree_column));

      break;

    case PROP_SORT_ORDER:

      g_value_set_enum (value,

                        gtk_tree_view_column_get_sort_order (tree_column));

      break;

    case PROP_SORT_COLUMN_ID:

      g_value_set_int (value,

                       gtk_tree_view_column_get_sort_column_id (tree_column));

      break;

    default:

      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

      break;

    }

}

/* Implementation of GtkCellLayout interface

 */

static void

gtk_tree_view_column_cell_layout_pack_start (GtkCellLayout   *cell_layout,

                                             GtkCellRenderer *cell,

                                             gboolean         expand)

{

  GtkTreeViewColumn *column;

  GtkTreeViewColumnCellInfo *cell_info;

  g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (cell_layout));

  column = GTK_TREE_VIEW_COLUMN (cell_layout);

  g_return_if_fail (! gtk_tree_view_column_get_cell_info (column, cell));

  g_object_ref_sink (cell);

  cell_info = g_new0 (GtkTreeViewColumnCellInfo, 1);

  cell_info->cell = cell;

  cell_info->expand = expand ? TRUE : FALSE;

  cell_info->pack = GTK_PACK_START;

  cell_info->has_focus = 0;

  cell_info->attributes = NULL;

  column->cell_list = g_list_append (column->cell_list, cell_info);

}

static void

gtk_tree_view_column_cell_layout_pack_end (GtkCellLayout   *cell_layout,

                                           GtkCellRenderer *cell,

                                           gboolean         expand)

{

  GtkTreeViewColumn *column;

  GtkTreeViewColumnCellInfo *cell_info;

  g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (cell_layout));

  column = GTK_TREE_VIEW_COLUMN (cell_layout);

  g_return_if_fail (! gtk_tree_view_column_get_cell_info (column, cell));

  g_object_ref_sink (cell);

  cell_info = g_new0 (GtkTreeViewColumnCellInfo, 1);

  cell_info->cell = cell;

  cell_info->expand = expand ? TRUE : FALSE;

  cell_info->pack = GTK_PACK_END;

  cell_info->has_focus = 0;

  cell_info->attributes = NULL;

  column->cell_list = g_list_append (column->cell_list, cell_info);

}

static void

gtk_tree_view_column_cell_layout_clear (GtkCellLayout *cell_layout)

{

  GtkTreeViewColumn *column;

  g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (cell_layout));

  column = GTK_TREE_VIEW_COLUMN (cell_layout);

  while (column->cell_list)

    {

      GtkTreeViewColumnCellInfo *info = (GtkTreeViewColumnCellInfo *)column->cell_list->data;

      gtk_tree_view_column_cell_layout_clear_attributes (cell_layout, info->cell);

      g_object_unref (info->cell);

      g_free (info);

      column->cell_list = g_list_delete_link (column->cell_list, 

					      column->cell_list);

    }

}

static void

gtk_tree_view_column_cell_layout_add_attribute (GtkCellLayout   *cell_layout,

                                                GtkCellRenderer *cell,

                                                const gchar     *attribute,

                                                gint             column)

{

  GtkTreeViewColumn *tree_column;

  GtkTreeViewColumnCellInfo *info;

  g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (cell_layout));

  tree_column = GTK_TREE_VIEW_COLUMN (cell_layout);

  info = gtk_tree_view_column_get_cell_info (tree_column, cell);

  g_return_if_fail (info != NULL);

  info->attributes = g_slist_prepend (info->attributes, GINT_TO_POINTER (column));

  info->attributes = g_slist_prepend (info->attributes, g_strdup (attribute));

  if (tree_column->tree_view)

    _gtk_tree_view_column_cell_set_dirty (tree_column, TRUE);

}

static void

gtk_tree_view_column_cell_layout_set_cell_data_func (GtkCellLayout         *cell_layout,

                                                     GtkCellRenderer       *cell,

                                                     GtkCellLayoutDataFunc  func,

                                                     gpointer               func_data,

                                                     GDestroyNotify         destroy)

{

  GtkTreeViewColumn *column;

  GtkTreeViewColumnCellInfo *info;

  g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (cell_layout));

  column = GTK_TREE_VIEW_COLUMN (cell_layout);

  info = gtk_tree_view_column_get_cell_info (column, cell);

  g_return_if_fail (info != NULL);

  if (info->destroy)

    {

      GDestroyNotify d = info->destroy;

      info->destroy = NULL;

      d (info->func_data);

    }

  info->func = (GtkTreeCellDataFunc)func;

  info->func_data = func_data;

  info->destroy = destroy;

  if (column->tree_view)

    _gtk_tree_view_column_cell_set_dirty (column, TRUE);

}

static void

gtk_tree_view_column_cell_layout_clear_attributes (GtkCellLayout    *cell_layout,

                                                   GtkCellRenderer  *cell_renderer)

{

  GtkTreeViewColumn *column;

  GtkTreeViewColumnCellInfo *info;

  g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (cell_layout));

  column = GTK_TREE_VIEW_COLUMN (cell_layout);

  info = gtk_tree_view_column_get_cell_info (column, cell_renderer);

  if (info)

    gtk_tree_view_column_clear_attributes_by_info (column, info);

}

static void

gtk_tree_view_column_cell_layout_reorder (GtkCellLayout   *cell_layout,

                                          GtkCellRenderer *cell,

                                          gint             position)

{

  GList *link;

  GtkTreeViewColumn *column;

  GtkTreeViewColumnCellInfo *info;

  g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (cell_layout));

  column = GTK_TREE_VIEW_COLUMN (cell_layout);

  info = gtk_tree_view_column_get_cell_info (column, cell);

  g_return_if_fail (info != NULL);

  g_return_if_fail (position >= 0);

  link = g_list_find (column->cell_list, info);

  g_return_if_fail (link != NULL);

  column->cell_list = g_list_delete_link (column->cell_list, link);

  column->cell_list = g_list_insert (column->cell_list, info, position);

  if (column->tree_view)

    gtk_widget_queue_draw (column->tree_view);

}

static void

gtk_tree_view_column_clear_attributes_by_info (GtkTreeViewColumn *tree_column,

					       GtkTreeViewColumnCellInfo *info)

{

  GSList *list;

  list = info->attributes;

  while (list && list->next)

    {

      g_free (list->data);

      list = list->next->next;

    }

  g_slist_free (info->attributes);

  info->attributes = NULL;

  if (tree_column->tree_view)

    _gtk_tree_view_column_cell_set_dirty (tree_column, TRUE);

}

/* Helper functions

 */

/* Button handling code

 */

static void

gtk_tree_view_column_create_button (GtkTreeViewColumn *tree_column)

{

  GtkTreeView *tree_view;

  GtkWidget *child;

  GtkWidget *hbox;

  tree_view = (GtkTreeView *) tree_column->tree_view;

  g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));

  g_return_if_fail (tree_column->button == NULL);

  gtk_widget_push_composite_child ();

  tree_column->button = gtk_button_new ();

  gtk_widget_add_events (tree_column->button, GDK_POINTER_MOTION_MASK);

  gtk_widget_pop_composite_child ();

  /* make sure we own a reference to it as well. */

  if (tree_view->priv->header_window)

    gtk_widget_set_parent_window (tree_column->button, tree_view->priv->header_window);

  gtk_widget_set_parent (tree_column->button, GTK_WIDGET (tree_view));

  g_signal_connect (tree_column->button, "event",

		    G_CALLBACK (gtk_tree_view_column_button_event),

		    tree_column);

  g_signal_connect (tree_column->button, "clicked",

		    G_CALLBACK (gtk_tree_view_column_button_clicked),

		    tree_column);

  tree_column->alignment = gtk_alignment_new (tree_column->xalign, 0.5, 0.0, 0.0);

  hbox = gtk_hbox_new (FALSE, 2);

  tree_column->arrow = gtk_arrow_new (GTK_ARROW_DOWN, GTK_SHADOW_IN);

  if (tree_column->child)

    child = tree_column->child;

  else

    {

      child = gtk_label_new (tree_column->title);

      gtk_widget_show (child);

    }

  g_signal_connect (child, "mnemonic-activate",

		    G_CALLBACK (gtk_tree_view_column_mnemonic_activate),

		    tree_column);

  if (tree_column->xalign <= 0.5)

    gtk_box_pack_end (GTK_BOX (hbox), tree_column->arrow, FALSE, FALSE, 0);

  else

    gtk_box_pack_start (GTK_BOX (hbox), tree_column->arrow, FALSE, FALSE, 0);

  gtk_box_pack_start (GTK_BOX (hbox), tree_column->alignment, TRUE, TRUE, 0);

  gtk_container_add (GTK_CONTAINER (tree_column->alignment), child);

  gtk_container_add (GTK_CONTAINER (tree_column->button), hbox);