X-Git-Url: http://pileus.org/git/?a=blobdiff_plain;f=gtk%2Fgtktreeviewcolumn.c;h=9bfd446621352de07468aaf23c51f717dd5ab8d1;hb=60207c37621eb8670aff6817a0c90dd24fd7bc60;hp=28d7d6452b726699e81b2c1578e93f8e3559b51f;hpb=2970a2feeece3e2c93760099394f2587379ddb09;p=~andy%2Fgtk diff --git a/gtk/gtktreeviewcolumn.c b/gtk/gtktreeviewcolumn.c index 28d7d6452..9bfd44662 100644 --- a/gtk/gtktreeviewcolumn.c +++ b/gtk/gtktreeviewcolumn.c @@ -17,26 +17,26 @@ * Boston, MA 02111-1307, USA. */ +#include #include "gtktreeviewcolumn.h" #include "gtktreeview.h" #include "gtktreeprivate.h" -#include "gtksignal.h" #include "gtkbutton.h" #include "gtkalignment.h" #include "gtklabel.h" #include "gtkhbox.h" +#include "gtkmarshalers.h" #include "gtkarrow.h" #include "gtkintl.h" -#include enum { PROP_0, - - PROP_CELL_RENDERER, PROP_VISIBLE, - PROP_SIZING, + PROP_RESIZABLE, PROP_WIDTH, + PROP_SIZING, + PROP_FIXED_WIDTH, PROP_MIN_WIDTH, PROP_MAX_WIDTH, PROP_TITLE, @@ -54,6 +54,21 @@ enum LAST_SIGNAL }; +typedef struct _GtkTreeViewColumnCellInfo GtkTreeViewColumnCellInfo; +struct _GtkTreeViewColumnCellInfo +{ + GtkCellRenderer *cell; + GSList *attributes; + GtkTreeCellDataFunc func; + gpointer func_data; + GtkDestroyNotify 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_init (GtkTreeViewColumn *tree_column); @@ -70,31 +85,21 @@ static void gtk_tree_view_column_get_property (GObject GParamSpec *pspec); static void gtk_tree_view_column_finalize (GObject *object); -/* Button handling code */ +/* 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_passive_func (GtkWidget *widget, +static gint gtk_tree_view_column_button_event (GtkWidget *widget, GdkEvent *event, gpointer data); -static void gtk_tree_view_column_button_realize (GtkWidget *widget, - gpointer data); -static void gtk_tree_view_column_button_pressed (GtkWidget *widget, - gpointer data); -static void gtk_tree_view_column_button_released (GtkWidget *widget, - gpointer data); static void gtk_tree_view_column_button_clicked (GtkWidget *widget, gpointer data); -static gint gtk_tree_view_column_button_motion_event (GtkWidget *widget, - GdkEventMotion *event, - 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_property_changed (GtkTreeView *view, - guint n_pspecs, - GParamSpec **pspecs, - GtkTreeViewColumn *tree_column); static void gtk_tree_view_model_sort_column_changed (GtkTreeSortable *sortable, GtkTreeViewColumn *tree_column); @@ -102,21 +107,30 @@ static void gtk_tree_view_model_sort_column_changed (GtkTreeSortable 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_clickable_real (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); static GtkObjectClass *parent_class = NULL; static guint tree_column_signals[LAST_SIGNAL] = { 0 }; -GtkType +GType gtk_tree_view_column_get_type (void) { - static GtkType tree_column_type = 0; + static GType tree_column_type = 0; if (!tree_column_type) { @@ -133,7 +147,9 @@ gtk_tree_view_column_get_type (void) (GInstanceInitFunc) gtk_tree_view_column_init, }; - tree_column_type = g_type_register_static (GTK_TYPE_OBJECT, "GtkTreeViewColumn", &tree_column_info, 0); + tree_column_type = + g_type_register_static (GTK_TYPE_OBJECT, "GtkTreeViewColumn", + &tree_column_info, 0); } return tree_column_type; @@ -155,30 +171,39 @@ gtk_tree_view_column_class_init (GtkTreeViewColumnClass *class) object_class->get_property = gtk_tree_view_column_get_property; tree_column_signals[CLICKED] = - g_signal_newc ("clicked", - GTK_CLASS_TYPE (object_class), - G_SIGNAL_RUN_LAST, - G_STRUCT_OFFSET (GtkTreeViewColumnClass, clicked), - NULL, NULL, - gtk_marshal_VOID__VOID, - GTK_TYPE_NONE, 0); + g_signal_new ("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_CELL_RENDERER, - g_param_spec_object ("cell_renderer", - _("Cell renderer"), - _("Cell renderer object to use for rendering the cell"), - GTK_TYPE_CELL_RENDERER, - G_PARAM_READABLE | G_PARAM_WRITABLE)); - g_object_class_install_property (object_class, PROP_VISIBLE, g_param_spec_boolean ("visible", _("Visible"), - _("Whether to display the colomn"), + _("Whether to display the column"), TRUE, G_PARAM_READABLE | G_PARAM_WRITABLE)); + g_object_class_install_property (object_class, + PROP_RESIZABLE, + g_param_spec_boolean ("resizable", + _("Resizable"), + _("Column is user-resizable"), + FALSE, + G_PARAM_READABLE | G_PARAM_WRITABLE)); + + g_object_class_install_property (object_class, + PROP_WIDTH, + g_param_spec_int ("width", + _("Width"), + _("Current width of the column"), + 0, + G_MAXINT, + 0, + G_PARAM_READABLE)); g_object_class_install_property (object_class, PROP_SIZING, g_param_spec_enum ("sizing", @@ -189,10 +214,10 @@ gtk_tree_view_column_class_init (GtkTreeViewColumnClass *class) G_PARAM_READABLE | G_PARAM_WRITABLE)); g_object_class_install_property (object_class, - PROP_WIDTH, - g_param_spec_int ("width", - _("Width"), - _("Current width of the column"), + PROP_FIXED_WIDTH, + g_param_spec_int ("fixed_width", + _("Fixed Width"), + _("Current fixed width of the column"), 1, G_MAXINT, 1, /* not useful */ @@ -205,7 +230,7 @@ gtk_tree_view_column_class_init (GtkTreeViewColumnClass *class) _("Minimum allowed width of the column"), -1, G_MAXINT, - 1, + -1, G_PARAM_READABLE | G_PARAM_WRITABLE)); g_object_class_install_property (object_class, @@ -215,7 +240,7 @@ gtk_tree_view_column_class_init (GtkTreeViewColumnClass *class) _("Maximum allowed width of the column"), -1, G_MAXINT, - G_MAXINT, + -1, G_PARAM_READABLE | G_PARAM_WRITABLE)); g_object_class_install_property (object_class, @@ -247,7 +272,7 @@ gtk_tree_view_column_class_init (GtkTreeViewColumnClass *class) PROP_ALIGNMENT, g_param_spec_float ("alignment", _("Alignment"), - _("Alignment of the column header text or widget"), + _("X Alignment of the column header text or widget"), 0.0, 1.0, 0.5, @@ -257,7 +282,7 @@ gtk_tree_view_column_class_init (GtkTreeViewColumnClass *class) PROP_REORDERABLE, g_param_spec_boolean ("reorderable", _("Reorderable"), - _("Wether the column can be reordered around the headers"), + _("Whether the column can be reordered around the headers"), FALSE, G_PARAM_READABLE | G_PARAM_WRITABLE)); @@ -274,8 +299,8 @@ gtk_tree_view_column_class_init (GtkTreeViewColumnClass *class) g_param_spec_enum ("sort_order", _("Sort order"), _("Sort direction the sort indicator should indicate"), - GTK_TYPE_TREE_SORT_ORDER, - GTK_TREE_SORT_ASCENDING, + GTK_TYPE_SORT_TYPE, + GTK_SORT_ASCENDING, G_PARAM_READABLE | G_PARAM_WRITABLE)); } @@ -283,43 +308,58 @@ gtk_tree_view_column_class_init (GtkTreeViewColumnClass *class) static void gtk_tree_view_column_init (GtkTreeViewColumn *tree_column) { - /* FIXME remove on port to GtkObject */ - gtk_object_ref (GTK_OBJECT (tree_column)); - gtk_object_sink (GTK_OBJECT (tree_column)); - tree_column->button = NULL; tree_column->xalign = 0.0; - tree_column->width = 1; + tree_column->width = 0; tree_column->requested_width = -1; tree_column->min_width = -1; tree_column->max_width = -1; - tree_column->cell = NULL; - tree_column->attributes = NULL; - tree_column->column_type = GTK_TREE_VIEW_COLUMN_AUTOSIZE; + 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->clickable = FALSE; tree_column->dirty = TRUE; - tree_column->sort_order = GTK_TREE_SORT_ASCENDING; + 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->clickable_signal = 0; tree_column->sort_column_id = -1; tree_column->reorderable = FALSE; tree_column->maybe_reordered = FALSE; + tree_column->use_resized_width = FALSE; } 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) + { + GtkDestroyNotify d = info->destroy; - if (tree_column->func_data && tree_column->destroy) - (tree_column->destroy) (tree_column->func_data); + 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_slist_free (tree_column->attributes); g_free (tree_column->title); + g_list_free (tree_column->cell_list); + + if (tree_column->child) + g_object_unref (G_OBJECT (tree_column->child)); + + G_OBJECT_CLASS (parent_class)->finalize (object); } static void @@ -334,25 +374,24 @@ gtk_tree_view_column_set_property (GObject *object, switch (prop_id) { - case PROP_CELL_RENDERER: - gtk_tree_view_column_set_cell_renderer (tree_column, - (GtkCellRenderer*) - g_value_get_object (value)); - break; - 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_WIDTH: - gtk_tree_view_column_set_width (tree_column, - g_value_get_int (value)); + case PROP_FIXED_WIDTH: + gtk_tree_view_column_set_fixed_width (tree_column, + g_value_get_int (value)); break; case PROP_MIN_WIDTH: @@ -385,6 +424,11 @@ gtk_tree_view_column_set_property (GObject *object, 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)); @@ -413,24 +457,29 @@ gtk_tree_view_column_get_property (GObject *object, switch (prop_id) { - case PROP_CELL_RENDERER: - g_value_set_object (value, - (GObject*) gtk_tree_view_column_get_cell_renderer (tree_column)); - break; - 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_SIZING: g_value_set_enum (value, gtk_tree_view_column_get_sizing (tree_column)); break; - case PROP_WIDTH: + case PROP_FIXED_WIDTH: g_value_set_int (value, - gtk_tree_view_column_get_width (tree_column)); + gtk_tree_view_column_get_fixed_width (tree_column)); break; case PROP_MIN_WIDTH: @@ -463,6 +512,11 @@ gtk_tree_view_column_get_property (GObject *object, 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)); @@ -493,32 +547,25 @@ gtk_tree_view_column_create_button (GtkTreeViewColumn *tree_column) tree_view = (GtkTreeView *) tree_column->tree_view; - g_return_if_fail (tree_view != NULL); 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)); - - gtk_signal_connect (GTK_OBJECT (tree_column->button), "realize", - (GtkSignalFunc) gtk_tree_view_column_button_realize, - NULL); - gtk_signal_connect (GTK_OBJECT (tree_column->button), "clicked", - (GtkSignalFunc) gtk_tree_view_column_button_clicked, - (gpointer) tree_column); - gtk_signal_connect (GTK_OBJECT (tree_column->button), "pressed", - (GtkSignalFunc) gtk_tree_view_column_button_pressed, - (gpointer) tree_column); - gtk_signal_connect (GTK_OBJECT (tree_column->button), "motion_notify_event", - (GtkSignalFunc) gtk_tree_view_column_button_motion_event, - (gpointer) tree_column); - gtk_signal_connect (GTK_OBJECT (tree_column->button), "released", - (GtkSignalFunc) gtk_tree_view_column_button_released, - (gpointer) tree_column); + + 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); @@ -533,6 +580,10 @@ gtk_tree_view_column_create_button (GtkTreeViewColumn *tree_column) 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 @@ -546,8 +597,6 @@ gtk_tree_view_column_create_button (GtkTreeViewColumn *tree_column) gtk_widget_show (hbox); gtk_widget_show (tree_column->alignment); gtk_tree_view_column_update_button (tree_column); - - gtk_tree_view_column_set_clickable_real (tree_column); } static void @@ -558,7 +607,6 @@ gtk_tree_view_column_update_button (GtkTreeViewColumn *tree_column) GtkWidget *arrow; GtkWidget *current_child; - /* Create a button if necessary */ if (tree_column->visible && tree_column->button == NULL && @@ -601,22 +649,22 @@ gtk_tree_view_column_update_button (GtkTreeViewColumn *tree_column) g_return_if_fail (GTK_IS_LABEL (current_child)); if (tree_column->title) - gtk_label_set_text (GTK_LABEL (current_child), - tree_column->title); + gtk_label_set_text_with_mnemonic (GTK_LABEL (current_child), + tree_column->title); else - gtk_label_set_text (GTK_LABEL (current_child), - ""); + gtk_label_set_text_with_mnemonic (GTK_LABEL (current_child), + ""); } switch (tree_column->sort_order) { - case GTK_TREE_SORT_ASCENDING: + case GTK_SORT_ASCENDING: gtk_arrow_set (GTK_ARROW (arrow), GTK_ARROW_DOWN, GTK_SHADOW_IN); break; - case GTK_TREE_SORT_DESCENDING: + case GTK_SORT_DESCENDING: gtk_arrow_set (GTK_ARROW (arrow), GTK_ARROW_UP, GTK_SHADOW_IN); @@ -627,11 +675,11 @@ gtk_tree_view_column_update_button (GtkTreeViewColumn *tree_column) break; } - /* Put arrow on the right if the text is left-or-center justified, - * and on the left otherwise; do this by packing boxes, so flipping - * text direction will reverse things - */ - gtk_widget_ref (arrow); + /* Put arrow on the right if the text is left-or-center justified, and on the + * left otherwise; do this by packing boxes, so flipping text direction will + * reverse things + */ + g_object_ref (arrow); gtk_container_remove (GTK_CONTAINER (hbox), arrow); if (tree_column->xalign <= 0.5) @@ -644,25 +692,25 @@ gtk_tree_view_column_update_button (GtkTreeViewColumn *tree_column) /* move it to the front */ gtk_box_reorder_child (GTK_BOX (hbox), arrow, 0); } - gtk_widget_unref (arrow); + g_object_unref (arrow); if (tree_column->show_sort_indicator) gtk_widget_show (arrow); else gtk_widget_hide (arrow); - /* It's always safe to hide the button. It isn't always safe to show it, as if you show it - * before it's realized, it'll get the wrong window. */ + /* It's always safe to hide the button. It isn't always safe to show it, as + * if you show it before it's realized, it'll get the wrong window. */ if (tree_column->button && tree_column->tree_view != NULL && GTK_WIDGET_REALIZED (tree_column->tree_view)) { if (tree_column->visible) { - gtk_widget_show (tree_column->button); + gtk_widget_show_now (tree_column->button); if (tree_column->window) { - if (tree_column->column_type == GTK_TREE_VIEW_COLUMN_RESIZEABLE) + if (tree_column->resizable) { gdk_window_show (tree_column->window); gdk_window_raise (tree_column->window); @@ -680,117 +728,126 @@ gtk_tree_view_column_update_button (GtkTreeViewColumn *tree_column) gdk_window_hide (tree_column->window); } } + + if (tree_column->reorderable || tree_column->clickable) + { + GTK_WIDGET_SET_FLAGS (tree_column->button, GTK_CAN_FOCUS); + } + else + { + GTK_WIDGET_UNSET_FLAGS (tree_column->button, GTK_CAN_FOCUS); + if (GTK_WIDGET_HAS_FOCUS (tree_column->button)) + { + GtkWidget *toplevel = gtk_widget_get_toplevel (tree_column->tree_view); + if (GTK_WIDGET_TOPLEVEL (toplevel)) + { + gtk_window_set_focus (GTK_WINDOW (toplevel), NULL); + } + } + } + /* Queue a resize on the assumption that we always want to catch all changes + * and columns don't change all that often. + */ + if (GTK_WIDGET_REALIZED (tree_column->tree_view)) + gtk_widget_queue_resize (tree_column->tree_view); - tree_column->dirty = TRUE; - gtk_widget_queue_resize (tree_column->tree_view); } /* Button signal handlers */ static gint -gtk_tree_view_column_button_passive_func (GtkWidget *widget, - GdkEvent *event, - gpointer data) +gtk_tree_view_column_button_event (GtkWidget *widget, + GdkEvent *event, + gpointer data) { + GtkTreeViewColumn *column = (GtkTreeViewColumn *) data; + g_return_val_if_fail (event != NULL, FALSE); - switch (event->type) + if (event->type == GDK_BUTTON_PRESS && + column->reorderable) { - case GDK_MOTION_NOTIFY: - case GDK_BUTTON_PRESS: - case GDK_2BUTTON_PRESS: - case GDK_3BUTTON_PRESS: - case GDK_BUTTON_RELEASE: - case GDK_ENTER_NOTIFY: - case GDK_LEAVE_NOTIFY: - return TRUE; - default: - break; + column->maybe_reordered = TRUE; + gdk_window_get_pointer (widget->window, + &column->drag_x, + &column->drag_y, + NULL); + gtk_widget_grab_focus (widget); } - return FALSE; -} - -static void -gtk_tree_view_column_button_realize (GtkWidget *widget, gpointer data) -{ - gdk_window_set_events (widget->window, gdk_window_get_events (widget->window) | GDK_POINTER_MOTION_MASK); -} - -static void -gtk_tree_view_column_button_pressed (GtkWidget *widget, gpointer data) -{ - GtkTreeViewColumn *tree_column = (GtkTreeViewColumn *) data; - if (! tree_column->reorderable) - return; + if (event->type == GDK_BUTTON_RELEASE && + column->maybe_reordered) + column->maybe_reordered = FALSE; - tree_column->maybe_reordered = TRUE; - gdk_window_get_pointer (widget->window, - &tree_column->drag_x, - &tree_column->drag_y, - NULL); + if (event->type == GDK_MOTION_NOTIFY && + (column->maybe_reordered) && + (gtk_drag_check_threshold (widget, + column->drag_x, + column->drag_y, + (gint) ((GdkEventMotion *)event)->x, + (gint) ((GdkEventMotion *)event)->y))) + { + column->maybe_reordered = FALSE; + /* this is to change our drag_x to be relative to + * tree_view->priv->bin_window, instead of our window. + */ + column->drag_x -= column->button->allocation.x; + _gtk_tree_view_column_start_drag (GTK_TREE_VIEW (column->tree_view), column); + return TRUE; + } + if (column->clickable == FALSE) + { + switch (event->type) + { + case GDK_BUTTON_PRESS: + case GDK_2BUTTON_PRESS: + case GDK_3BUTTON_PRESS: + case GDK_MOTION_NOTIFY: + case GDK_BUTTON_RELEASE: + case GDK_ENTER_NOTIFY: + case GDK_LEAVE_NOTIFY: + return TRUE; + default: + return FALSE; + } + } + return FALSE; } -static void -gtk_tree_view_column_button_released (GtkWidget *widget, gpointer data) -{ - GtkTreeViewColumn *tree_column = (GtkTreeViewColumn *) data; - - tree_column->maybe_reordered = FALSE; -} - static void gtk_tree_view_column_button_clicked (GtkWidget *widget, gpointer data) { - g_signal_emit_by_name (G_OBJECT (data), "clicked"); + g_signal_emit_by_name (data, "clicked"); } -static gint -gtk_tree_view_column_button_motion_event (GtkWidget *widget, - GdkEventMotion *event, - gpointer data) +static gboolean +gtk_tree_view_column_mnemonic_activate (GtkWidget *widget, + gboolean group_cycling, + gpointer data) { - GtkTreeViewColumn *tree_column = (GtkTreeViewColumn *) data; - - if ((tree_column->maybe_reordered) && - (gtk_drag_check_threshold (widget, - tree_column->drag_x, - tree_column->drag_y, - (gint) event->x, - (gint) event->y))) - { - tree_column->maybe_reordered = FALSE; - _gtk_tree_view_column_start_drag (GTK_TREE_VIEW (tree_column->tree_view), tree_column); - } + GtkTreeViewColumn *column = (GtkTreeViewColumn *)data; - return TRUE; -} + g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (column), FALSE); -static void -gtk_tree_view_model_property_changed (GtkTreeView *view, - guint n_pspecs, - GParamSpec **pspecs, - GtkTreeViewColumn *tree_column) -{ - gint i; + GTK_TREE_VIEW (column->tree_view)->priv->focus_column = column; + if (column->clickable) + gtk_button_clicked (GTK_BUTTON (column->button)); + else if (GTK_WIDGET_CAN_FOCUS (column->button)) + gtk_widget_grab_focus (column->button); + else + gtk_widget_grab_focus (column->tree_view); - for (i = 0; i < n_pspecs; i++) - { - if (! strcmp (pspecs[i]->name, "model")) - { - gtk_tree_view_column_setup_sort_column_id_callback (tree_column); - } - } + return TRUE; } static void gtk_tree_view_model_sort_column_changed (GtkTreeSortable *sortable, - GtkTreeViewColumn *column) + GtkTreeViewColumn *column) { gint sort_column_id; - GtkTreeSortOrder order; + GtkSortType order; if (gtk_tree_sortable_get_sort_column_id (sortable, &sort_column_id, @@ -806,45 +863,52 @@ gtk_tree_view_model_sort_column_changed (GtkTreeSortable *sortable, gtk_tree_view_column_set_sort_indicator (column, FALSE); } } + else + { + gtk_tree_view_column_set_sort_indicator (column, FALSE); + } } static void gtk_tree_view_column_sort (GtkTreeViewColumn *tree_column, gpointer data) { - GList *list; + gint sort_column_id; + GtkSortType order; + gboolean has_sort_column; + gboolean has_default_sort_func; g_return_if_fail (tree_column->tree_view != NULL); - if (tree_column->show_sort_indicator) + has_sort_column = + gtk_tree_sortable_get_sort_column_id (GTK_TREE_SORTABLE (GTK_TREE_VIEW (tree_column->tree_view)->priv->model), + &sort_column_id, + &order); + has_default_sort_func = + gtk_tree_sortable_has_default_sort_func (GTK_TREE_SORTABLE (GTK_TREE_VIEW (tree_column->tree_view)->priv->model)); + + if (has_sort_column && + sort_column_id == tree_column->sort_column_id) { - if (tree_column->sort_order == GTK_TREE_SORT_ASCENDING) - gtk_tree_view_column_set_sort_order (tree_column, GTK_TREE_SORT_DESCENDING); + if (order == GTK_SORT_ASCENDING) + gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (GTK_TREE_VIEW (tree_column->tree_view)->priv->model), + tree_column->sort_column_id, + GTK_SORT_DESCENDING); + else if (order == GTK_SORT_DESCENDING && has_default_sort_func) + gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (GTK_TREE_VIEW (tree_column->tree_view)->priv->model), + GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, + GTK_SORT_ASCENDING); else - gtk_tree_view_column_set_sort_order (tree_column, GTK_TREE_SORT_ASCENDING); + gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (GTK_TREE_VIEW (tree_column->tree_view)->priv->model), + tree_column->sort_column_id, + GTK_SORT_ASCENDING); } else { - gtk_tree_view_column_set_sort_order (tree_column, GTK_TREE_SORT_ASCENDING); - gtk_tree_view_column_set_sort_indicator (tree_column, TRUE); + gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (GTK_TREE_VIEW (tree_column->tree_view)->priv->model), + tree_column->sort_column_id, + GTK_SORT_ASCENDING); } - - list = (GTK_TREE_VIEW (tree_column->tree_view)->priv->columns); - g_assert (list); - while (list) - { - GtkTreeViewColumn *tmp_column; - - tmp_column = GTK_TREE_VIEW_COLUMN (list->data); - if (tmp_column->visible && tmp_column != tree_column) - gtk_tree_view_column_set_sort_indicator (tmp_column, FALSE); - - list = list->next; - } - - gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (GTK_TREE_VIEW (tree_column->tree_view)->priv->model), - tree_column->sort_column_id, - tree_column->sort_order); } @@ -859,27 +923,20 @@ gtk_tree_view_column_setup_sort_column_id_callback (GtkTreeViewColumn *tree_colu model = gtk_tree_view_get_model (GTK_TREE_VIEW (tree_column->tree_view)); if (model == NULL) - { - if (tree_column->sort_column_changed_signal) - { - g_signal_handler_disconnect (G_OBJECT (tree_column), tree_column->sort_column_changed_signal); - tree_column->sort_column_changed_signal = 0; - } - return; - } + return; if (GTK_IS_TREE_SORTABLE (model) && tree_column->sort_column_id != -1) { gint real_sort_column_id; - GtkTreeSortOrder real_order; + GtkSortType real_order; if (tree_column->sort_column_changed_signal == 0) - tree_column->sort_column_changed_signal = - g_signal_connectc (G_OBJECT (model), "sort_column_changed", - GTK_SIGNAL_FUNC (gtk_tree_view_model_sort_column_changed), - tree_column, FALSE); - + tree_column->sort_column_changed_signal = + g_signal_connect (model, "sort_column_changed", + G_CALLBACK (gtk_tree_view_model_sort_column_changed), + tree_column); + if (gtk_tree_sortable_get_sort_column_id (GTK_TREE_SORTABLE (model), &real_sort_column_id, &real_order) && @@ -907,7 +964,6 @@ _gtk_tree_view_column_realize_button (GtkTreeViewColumn *column) tree_view = (GtkTreeView *)column->tree_view; - g_return_if_fail (tree_view != NULL); g_return_if_fail (GTK_IS_TREE_VIEW (tree_view)); g_return_if_fail (GTK_WIDGET_REALIZED (tree_view)); g_return_if_fail (tree_view->priv->header_window != NULL); @@ -929,9 +985,8 @@ _gtk_tree_view_column_realize_button (GtkTreeViewColumn *column) GDK_POINTER_MOTION_HINT_MASK | GDK_KEY_PRESS_MASK); attributes_mask = GDK_WA_CURSOR | GDK_WA_X | GDK_WA_Y; - attr.cursor = gdk_cursor_new (GDK_SB_H_DOUBLE_ARROW); - tree_view->priv->cursor_drag = attr.cursor; - + attr.cursor = gdk_cursor_new_for_display (gdk_drawable_get_display (tree_view->priv->header_window), + GDK_SB_H_DOUBLE_ARROW); attr.y = 0; attr.width = TREE_VIEW_DRAG_WIDTH; attr.height = tree_view->priv->header_height; @@ -943,6 +998,8 @@ _gtk_tree_view_column_realize_button (GtkTreeViewColumn *column) gdk_window_set_user_data (column->window, tree_view); gtk_tree_view_column_update_button (column); + + gdk_cursor_unref (attr.cursor); } void @@ -956,6 +1013,18 @@ _gtk_tree_view_column_unrealize_button (GtkTreeViewColumn *column) column->window = NULL; } +void +_gtk_tree_view_column_unset_model (GtkTreeViewColumn *column, + GtkTreeModel *old_model) +{ + if (column->sort_column_changed_signal) + { + g_signal_handler_disconnect (old_model, + column->sort_column_changed_signal); + column->sort_column_changed_signal = 0; + } +} + void _gtk_tree_view_column_set_tree_view (GtkTreeViewColumn *column, GtkTreeView *tree_view) @@ -965,10 +1034,11 @@ _gtk_tree_view_column_set_tree_view (GtkTreeViewColumn *column, column->tree_view = GTK_WIDGET (tree_view); gtk_tree_view_column_create_button (column); - column->property_changed_signal = gtk_signal_connect (GTK_OBJECT (tree_view), - "properties_changed", - GTK_SIGNAL_FUNC (gtk_tree_view_model_property_changed), - column); + column->property_changed_signal = + g_signal_connect_swapped (tree_view, + "notify::model", + G_CALLBACK (gtk_tree_view_column_setup_sort_column_id_callback), + column); gtk_tree_view_column_setup_sort_column_id_callback (column); } @@ -982,13 +1052,14 @@ _gtk_tree_view_column_unset_tree_view (GtkTreeViewColumn *column) } if (column->property_changed_signal) { - g_signal_handler_disconnect (G_OBJECT (column->tree_view), column->property_changed_signal); + g_signal_handler_disconnect (column->tree_view, column->property_changed_signal); column->property_changed_signal = 0; } if (column->sort_column_changed_signal) { - g_signal_handler_disconnect (G_OBJECT (column), column->sort_column_changed_signal); + g_signal_handler_disconnect (gtk_tree_view_get_model (GTK_TREE_VIEW (column->tree_view)), + column->sort_column_changed_signal); column->sort_column_changed_signal = 0; } @@ -996,27 +1067,67 @@ _gtk_tree_view_column_unset_tree_view (GtkTreeViewColumn *column) column->button = NULL; } -void -_gtk_tree_view_column_set_width (GtkTreeViewColumn *tree_column, - gint width) -{ - if (tree_column->min_width != -1 && - width <= tree_column->min_width) - width = tree_column->min_width; - else if (tree_column->max_width != -1 && - width > tree_column->max_width) - width = tree_column->max_width; - - if (tree_column->width == width) - return; - - tree_column->width = width; +gboolean +_gtk_tree_view_column_has_editable_cell (GtkTreeViewColumn *column) +{ + GList *list; + + for (list = column->cell_list; list; list = list->next) + if (((GtkTreeViewColumnCellInfo *)list->data)->cell->mode == + GTK_CELL_RENDERER_MODE_EDITABLE) + return TRUE; + + return FALSE; +} + +/* gets cell being edited */ +GtkCellRenderer * +_gtk_tree_view_column_get_edited_cell (GtkTreeViewColumn *column) +{ + GList *list; + + for (list = column->cell_list; list; list = list->next) + if (((GtkTreeViewColumnCellInfo *)list->data)->in_editing_mode) + return ((GtkTreeViewColumnCellInfo *)list->data)->cell; + + return NULL; +} + +gint +_gtk_tree_view_column_count_special_cells (GtkTreeViewColumn *column) +{ + gint i = 0; + GList *list; - g_object_notify (G_OBJECT (tree_column), "width"); + for (list = column->cell_list; list; list = list->next) + { + GtkTreeViewColumnCellInfo *cellinfo = list->data; + + if (cellinfo->cell->mode == GTK_CELL_RENDERER_MODE_EDITABLE || + cellinfo->cell->mode == GTK_CELL_RENDERER_MODE_ACTIVATABLE) + i++; + } - if (tree_column->tree_view != NULL) - gtk_widget_queue_resize (tree_column->tree_view); + return i; +} +GtkCellRenderer * +_gtk_tree_view_column_get_cell_at_pos (GtkTreeViewColumn *column, + gint x) +{ + GList *list; + gint current_x = 0; + + list = gtk_tree_view_column_cell_first (column); + for (; list; list = gtk_tree_view_column_cell_next (column, list)) + { + GtkTreeViewColumnCellInfo *cellinfo = list->data; + if (current_x <= x && x <= current_x + cellinfo->real_width) + return cellinfo->cell; + current_x += cellinfo->real_width; + } + + return NULL; } /* Public Functions */ @@ -1034,7 +1145,7 @@ gtk_tree_view_column_new (void) { GtkTreeViewColumn *tree_column; - tree_column = GTK_TREE_VIEW_COLUMN (gtk_type_new (GTK_TYPE_TREE_VIEW_COLUMN)); + tree_column = g_object_new (GTK_TYPE_TREE_VIEW_COLUMN, NULL); return tree_column; } @@ -1043,12 +1154,28 @@ gtk_tree_view_column_new (void) * gtk_tree_view_column_new_with_attributes: * @title: The title to set the header to. * @cell: The #GtkCellRenderer. - * @Varargs: A NULL terminated list of attributes. + * @Varargs: A %NULL-terminated list of attributes. * * Creates a new #GtkTreeViewColumn with a number of default values. This is - * equivalent to calling @gtk_tree_view_column_set_title, - * @gtk_tree_view_column_set_cell_renderer, and - * @gtk_tree_view_column_set_attributes on the newly created #GtkTreeViewColumn. + * equivalent to calling gtk_tree_view_column_set_title(), + * gtk_tree_view_column_pack_start(), and + * gtk_tree_view_column_set_attributes() on the newly created #GtkTreeViewColumn. + * + * Here's a simple example: + * + * enum { TEXT_COLUMN, COLOR_COLUMN, N_COLUMNS }; + * ... + * { + * GtkTreeViewColumn *column; + * GtkCellRenderer *renderer = gtk_cell_renderer_text_new (); + * + * column = gtk_tree_view_column_new_with_attributes ("Title", + * renderer, + * "text", TEXT_COLUMN, + * "foreground", COLOR_COLUMN, + * NULL); + * } + * * * Return value: A newly created #GtkTreeViewColumn. **/ @@ -1063,117 +1190,197 @@ gtk_tree_view_column_new_with_attributes (const gchar *title, retval = gtk_tree_view_column_new (); gtk_tree_view_column_set_title (retval, title); - gtk_tree_view_column_set_cell_renderer (retval, cell); + gtk_tree_view_column_pack_start (retval, cell, TRUE); va_start (args, cell); - gtk_tree_view_column_set_attributesv (retval, args); + gtk_tree_view_column_set_attributesv (retval, cell, args); va_end (args); return retval; } +static GtkTreeViewColumnCellInfo * +gtk_tree_view_column_get_cell_info (GtkTreeViewColumn *tree_column, + GtkCellRenderer *cell_renderer) +{ + GList *list; + for (list = tree_column->cell_list; list; list = list->next) + if (((GtkTreeViewColumnCellInfo *)list->data)->cell == cell_renderer) + return (GtkTreeViewColumnCellInfo *) list->data; + return NULL; +} + + /** - * gtk_tree_view_column_set_cell_renderer: + * gtk_tree_view_column_pack_start: * @tree_column: A #GtkTreeViewColumn. - * @cell: The #GtkCellRenderer, or NULL. - * - * Sets the cell renderer of the @tree_column. If there is a cell - * renderer already set, then it is removed. If @cell is NULL, then - * the cell renderer is unset. + * @cell: The #GtkCellRenderer. + * @expand: %TRUE if @cell is to be given extra space allocated to box. + * + * Packs the @cell into the beginning of the column. If @expand is FALSE, then + * the @cell is allocated no more space than it needs. Any unused space is divided + * evenly between cells for which @expand is TRUE. **/ void -gtk_tree_view_column_set_cell_renderer (GtkTreeViewColumn *tree_column, - GtkCellRenderer *cell) +gtk_tree_view_column_pack_start (GtkTreeViewColumn *tree_column, + GtkCellRenderer *cell, + gboolean expand) { + GtkTreeViewColumnCellInfo *cell_info; + g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column)); + g_return_if_fail (GTK_IS_CELL_RENDERER (cell)); + g_return_if_fail (! gtk_tree_view_column_get_cell_info (tree_column, cell)); - if (cell) - g_return_if_fail (GTK_IS_CELL_RENDERER (cell)); + g_object_ref (cell); + gtk_object_sink (GTK_OBJECT (cell)); - if (cell) - g_object_ref (G_OBJECT (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; - if (tree_column->cell) - g_object_unref (G_OBJECT (tree_column->cell)); + tree_column->cell_list = g_list_append (tree_column->cell_list, cell_info); +} - tree_column->cell = cell; +/** + * gtk_tree_view_column_pack_end: + * @tree_column: A #GtkTreeViewColumn. + * @cell: The #GtkCellRenderer. + * @expand: %TRUE if @cell is to be given extra space allocated to box. + * + * Adds the @cell to end of the column. If @expand is FALSE, then the @cell + * is allocated no more space than it needs. Any unused space is divided + * evenly between cells for which @expand is TRUE. + **/ +void +gtk_tree_view_column_pack_end (GtkTreeViewColumn *tree_column, + GtkCellRenderer *cell, + gboolean expand) +{ + GtkTreeViewColumnCellInfo *cell_info; - if (tree_column->tree_view) + g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column)); + g_return_if_fail (GTK_IS_CELL_RENDERER (cell)); + g_return_if_fail (! gtk_tree_view_column_get_cell_info (tree_column, cell)); + + g_object_ref (cell); + gtk_object_sink (GTK_OBJECT (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; + + tree_column->cell_list = g_list_append (tree_column->cell_list, cell_info); +} + + +/** + * gtk_tree_view_column_clear: + * @tree_column: A #GtkTreeViewColumn + * + * Unsets all the mappings on all renderers on the @tree_column. + **/ +void +gtk_tree_view_column_clear (GtkTreeViewColumn *tree_column) +{ + GList *list; + g_return_if_fail (tree_column != NULL); + + for (list = tree_column->cell_list; list; list = list->next) { - tree_column->dirty = TRUE; - gtk_widget_queue_resize (tree_column->tree_view); + GtkTreeViewColumnCellInfo *info = (GtkTreeViewColumnCellInfo *)list->data; + + gtk_tree_view_column_clear_attributes (tree_column, info->cell); + g_object_unref (info->cell); + g_free (info); } - g_object_notify (G_OBJECT (tree_column), "cell_renderer"); + g_list_free (tree_column->cell_list); + tree_column->cell_list = NULL; } /** - * gtk_tree_view_column_get_cell_renderer: - * @tree_column: a #GtkTreeViewColumn + * gtk_tree_view_column_get_cell_renderers: + * @tree_column: A #GtkTreeViewColumn * - * Gets the value set with gtk_tree_view_column_set_cell_renderer(). + * Returns a newly-allocated #GList of all the cell renderers in the column, + * in no particular order. The list must be freed with g_list_free(). * - * Return value: cell renderer for the column, or %NULL if unset + * Return value: A list of #GtkCellRenderers **/ -GtkCellRenderer* -gtk_tree_view_column_get_cell_renderer (GtkTreeViewColumn *tree_column) +GList * +gtk_tree_view_column_get_cell_renderers (GtkTreeViewColumn *tree_column) { - g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column), NULL); - - return tree_column->cell; + GList *retval = NULL, *list; + + g_return_val_if_fail (tree_column != NULL, NULL); + + for (list = tree_column->cell_list; list; list = list->next) + { + GtkTreeViewColumnCellInfo *info = (GtkTreeViewColumnCellInfo *)list->data; + + retval = g_list_append (retval, info->cell); + } + + return retval; } /** * gtk_tree_view_column_add_attribute: * @tree_column: A #GtkTreeViewColumn. - * @attribute: An attribute on the columns cell + * @cell_renderer: the #GtkCellRenderer to set attributes on + * @attribute: An attribute on the renderer * @column: The column position on the model to get the attribute from. * * Adds an attribute mapping to the list in @tree_column. The @column is the - * column position on the model to get a value from, and the @attribute is the - * parameter on the @tree_column's cell renderer to set that value to. + * column of the model to get a value from, and the @attribute is the + * parameter on @cell_renderer 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 #GtkCellRendererText get its values from + * column 2. **/ void gtk_tree_view_column_add_attribute (GtkTreeViewColumn *tree_column, + GtkCellRenderer *cell_renderer, const gchar *attribute, gint column) { - g_return_if_fail (tree_column != NULL); + GtkTreeViewColumnCellInfo *info; + g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column)); + info = gtk_tree_view_column_get_cell_info (tree_column, cell_renderer); + g_return_if_fail (info != NULL); - tree_column->attributes = g_slist_prepend (tree_column->attributes, - GINT_TO_POINTER (column)); - tree_column->attributes = g_slist_prepend (tree_column->attributes, - g_strdup (attribute)); + 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) - { - tree_column->dirty = TRUE; - gtk_widget_queue_resize (tree_column->tree_view); - } + _gtk_tree_view_column_cell_set_dirty (tree_column, TRUE); } static void gtk_tree_view_column_set_attributesv (GtkTreeViewColumn *tree_column, + GtkCellRenderer *cell_renderer, va_list args) { gchar *attribute; gint column; - g_return_if_fail (tree_column != NULL); - g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column)); - attribute = va_arg (args, gchar *); - gtk_tree_view_column_clear_attributes (tree_column); + gtk_tree_view_column_clear_attributes (tree_column, cell_renderer); while (attribute != NULL) { column = va_arg (args, gint); - gtk_tree_view_column_add_attribute (tree_column, - attribute, - column); + gtk_tree_view_column_add_attribute (tree_column, cell_renderer, attribute, column); attribute = va_arg (args, gchar *); } } @@ -1181,26 +1388,27 @@ gtk_tree_view_column_set_attributesv (GtkTreeViewColumn *tree_column, /** * gtk_tree_view_column_set_attributes: * @tree_column: A #GtkTreeViewColumn. - * @Varargs: A NULL terminated listing of attributes. + * @cell_renderer: the #GtkCellRenderer we're setting the attributes of + * @Varargs: A %NULL-terminated list of attributes. * * Sets the attributes in the list as the attributes of @tree_column. * The attributes should be in attribute/column order, as in - * @gtk_tree_view_column_add_attribute. All existing attributes + * gtk_tree_view_column_add_attribute(). All existing attributes * are removed, and replaced with the new attributes. **/ void gtk_tree_view_column_set_attributes (GtkTreeViewColumn *tree_column, + GtkCellRenderer *cell_renderer, ...) { va_list args; - g_return_if_fail (tree_column != NULL); g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column)); + g_return_if_fail (GTK_IS_CELL_RENDERER (cell_renderer)); + g_return_if_fail (gtk_tree_view_column_get_cell_info (tree_column, cell_renderer)); - va_start (args, tree_column); - - gtk_tree_view_column_set_attributesv (tree_column, args); - + va_start (args, cell_renderer); + gtk_tree_view_column_set_attributesv (tree_column, cell_renderer, args); va_end (args); } @@ -1208,122 +1416,129 @@ gtk_tree_view_column_set_attributes (GtkTreeViewColumn *tree_column, /** * gtk_tree_view_column_set_cell_data_func: * @tree_column: A #GtkTreeViewColumn + * @cell_renderer: A #GtkCellRenderer * @func: The #GtkTreeViewColumnFunc to use. * @func_data: The user data for @func. * @destroy: The destroy notification for @func_data * - * Sets the #GtkTreeViewColumnFunc to use for the column. This function is used - * instead of the standard attributes mapping for setting the column value, and - * should set the value of @tree_column 's cell renderer as appropriate. @func - * may be NULL to remove an older one. + * Sets the #GtkTreeViewColumnFunc to use for the column. This + * function is used instead of the standard attributes mapping for + * setting the column value, and should set the value of @tree_column's + * cell renderer as appropriate. @func may be %NULL to remove an + * older one. **/ void -gtk_tree_view_column_set_cell_data_func (GtkTreeViewColumn *tree_column, - GtkCellDataFunc func, - gpointer func_data, - GtkDestroyNotify destroy) +gtk_tree_view_column_set_cell_data_func (GtkTreeViewColumn *tree_column, + GtkCellRenderer *cell_renderer, + GtkTreeCellDataFunc func, + gpointer func_data, + GtkDestroyNotify destroy) { - g_return_if_fail (tree_column != NULL); + GtkTreeViewColumnCellInfo *info; + g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column)); + g_return_if_fail (GTK_IS_CELL_RENDERER (cell_renderer)); + info = gtk_tree_view_column_get_cell_info (tree_column, cell_renderer); - if (func == tree_column->func && - func_data == tree_column->func_data && - destroy == tree_column->destroy) - return; + g_return_if_fail (info != NULL); + + if (info->destroy) + { + GtkDestroyNotify d = info->destroy; - if (tree_column->func_data && tree_column->destroy) - (tree_column->destroy) (tree_column->func_data); + info->destroy = NULL; + d (info->func_data); + } - tree_column->func = func; - tree_column->func_data = func_data; - tree_column->destroy = destroy; + info->func = func; + info->func_data = func_data; + info->destroy = destroy; if (tree_column->tree_view) - { - tree_column->dirty = TRUE; - gtk_widget_queue_resize (tree_column->tree_view); - } + _gtk_tree_view_column_cell_set_dirty (tree_column, TRUE); } /** * gtk_tree_view_column_clear_attributes: * @tree_column: a #GtkTreeViewColumn + * @cell_renderer: a #GtkCellRenderer to clear the attribute mapping on. * * Clears all existing attributes previously set with * gtk_tree_view_column_set_attributes(). **/ void -gtk_tree_view_column_clear_attributes (GtkTreeViewColumn *tree_column) +gtk_tree_view_column_clear_attributes (GtkTreeViewColumn *tree_column, + GtkCellRenderer *cell_renderer) { - GSList *list; - + GtkTreeViewColumnCellInfo *info; + g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column)); + g_return_if_fail (GTK_IS_CELL_RENDERER (cell_renderer)); + + info = gtk_tree_view_column_get_cell_info (tree_column, cell_renderer); + + gtk_tree_view_column_clear_attributes_by_info (tree_column, info); +} + +static void +gtk_tree_view_column_clear_attributes_by_info (GtkTreeViewColumn *tree_column, + GtkTreeViewColumnCellInfo *info) +{ + GSList *list; - list = tree_column->attributes; + list = info->attributes; while (list && list->next) { g_free (list->data); list = list->next->next; } - g_slist_free (tree_column->attributes); - tree_column->attributes = NULL; + g_slist_free (info->attributes); + info->attributes = NULL; if (tree_column->tree_view) - { - tree_column->dirty = TRUE; - gtk_widget_queue_resize (tree_column->tree_view); - } + _gtk_tree_view_column_cell_set_dirty (tree_column, TRUE); } + /** - * gtk_tree_view_column_set_cell_data: + * gtk_tree_view_column_set_spacing: * @tree_column: A #GtkTreeViewColumn. - * @tree_model: The #GtkTreeModel to to get the cell renderers attributes from. - * @iter: The #GtkTreeIter to to get the cell renderer's attributes from. + * @spacing: distance between cell renderers in pixels. * - * Sets the cell renderer based on the @tree_model and @tree_node. That is, for - * every attribute mapping in @tree_column, it will get a value from the set - * column on the @tree_node, and use that value to set the attribute on the cell - * renderer. + * Sets the spacing field of @tree_column, which is the number of pixels to + * place between cell renderers packed into it. **/ void -gtk_tree_view_column_set_cell_data (GtkTreeViewColumn *tree_column, - GtkTreeModel *tree_model, - GtkTreeIter *iter) +gtk_tree_view_column_set_spacing (GtkTreeViewColumn *tree_column, + gint spacing) { - GSList *list; - GValue value = { 0, }; - GObject *cell; - - g_return_if_fail (tree_column != NULL); g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column)); - g_return_if_fail (tree_column->cell != NULL); + g_return_if_fail (spacing >= 0); - if (tree_model == NULL) + if (tree_column->spacing == spacing) return; - cell = (GObject *) tree_column->cell; - list = tree_column->attributes; - - g_object_freeze_notify (cell); - - while (list && list->next) - { - gtk_tree_model_get_value (tree_model, iter, - GPOINTER_TO_INT (list->next->data), - &value); - g_object_set_property (cell, (gchar *) list->data, &value); - g_value_unset (&value); - list = list->next->next; - - } + tree_column->spacing = spacing; + if (tree_column->tree_view) + _gtk_tree_view_column_cell_set_dirty (tree_column, TRUE); +} - if (tree_column->func) - (* tree_column->func) (tree_column, tree_column->cell, tree_model, iter, tree_column->func_data); +/** + * gtk_tree_view_column_get_spacing: + * @tree_column: A #GtkTreeViewColumn. + * + * Returns the spacing of @tree_column. + * + * Return value: the spacing of @tree_column. + **/ +gint +gtk_tree_view_column_get_spacing (GtkTreeViewColumn *tree_column) +{ + g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column), 0); - g_object_thaw_notify (cell); + return tree_column->spacing; } /* Options for manipulating the columns */ @@ -1331,7 +1546,7 @@ gtk_tree_view_column_set_cell_data (GtkTreeViewColumn *tree_column, /** * gtk_tree_view_column_set_visible: * @tree_column: A #GtkTreeViewColumn. - * @visible: TRUE if the @tree_column is visible. + * @visible: %TRUE if the @tree_column is visible. * * Sets the visibility of @tree_column. **/ @@ -1339,7 +1554,6 @@ void gtk_tree_view_column_set_visible (GtkTreeViewColumn *tree_column, gboolean visible) { - g_return_if_fail (tree_column != NULL); g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column)); visible = !! visible; @@ -1349,6 +1563,9 @@ gtk_tree_view_column_set_visible (GtkTreeViewColumn *tree_column, tree_column->visible = visible; + if (tree_column->visible) + _gtk_tree_view_column_cell_set_dirty (tree_column, TRUE); + gtk_tree_view_column_update_button (tree_column); g_object_notify (G_OBJECT (tree_column), "visible"); } @@ -1357,7 +1574,7 @@ gtk_tree_view_column_set_visible (GtkTreeViewColumn *tree_column, * gtk_tree_view_column_get_visible: * @tree_column: A #GtkTreeViewColumn. * - * Returns TRUE if @tree_column is visible. + * Returns %TRUE if @tree_column is visible. * * Return value: whether the column is visible or not. If it is visible, then * the tree will show the column. @@ -1365,12 +1582,59 @@ gtk_tree_view_column_set_visible (GtkTreeViewColumn *tree_column, gboolean gtk_tree_view_column_get_visible (GtkTreeViewColumn *tree_column) { - g_return_val_if_fail (tree_column != NULL, FALSE); g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column), FALSE); return tree_column->visible; } +/** + * gtk_tree_view_column_set_resizable: + * @tree_column: A #GtkTreeViewColumn + * @resizable: %TRUE, if the column can be resized + * + * If @resizable is %TRUE, then the user can explicitly resize the column by + * grabbing the outer edge of the column button. If resizable is TRUE and + * sizing mode of the column is #GTK_TREE_VIEW_COLUMN_AUTOSIZE, then the sizing + * mode is changed to #GTK_TREE_VIEW_COLUMN_GROW_ONLY. + **/ +void +gtk_tree_view_column_set_resizable (GtkTreeViewColumn *tree_column, + gboolean resizable) +{ + g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column)); + + resizable = !! resizable; + + if (tree_column->resizable == resizable) + return; + + tree_column->resizable = resizable; + + if (resizable && tree_column->column_type == GTK_TREE_VIEW_COLUMN_AUTOSIZE) + gtk_tree_view_column_set_sizing (tree_column, GTK_TREE_VIEW_COLUMN_GROW_ONLY); + + gtk_tree_view_column_update_button (tree_column); + + g_object_notify (G_OBJECT (tree_column), "resizable"); +} + +/** + * gtk_tree_view_column_get_resizable: + * @tree_column: A #GtkTreeViewColumn + * + * Returns #TRUE if the @tree_column can be resized by the end user. + * + * Return value: #TRUE, if the @tree_column can be resized. + **/ +gboolean +gtk_tree_view_column_get_resizable (GtkTreeViewColumn *tree_column) +{ + g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column), FALSE); + + return tree_column->resizable; +} + + /** * gtk_tree_view_column_set_sizing: * @tree_column: A #GtkTreeViewColumn. @@ -1382,22 +1646,28 @@ void gtk_tree_view_column_set_sizing (GtkTreeViewColumn *tree_column, GtkTreeViewColumnSizing type) { - g_return_if_fail (tree_column != NULL); g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column)); if (type == tree_column->column_type) return; + if (type == GTK_TREE_VIEW_COLUMN_AUTOSIZE) + gtk_tree_view_column_set_resizable (tree_column, FALSE); + +#if 0 + /* I was clearly on crack when I wrote this. I'm not sure what's supposed to + * be below so I'll leave it until I figure it out. + */ if (tree_column->column_type == GTK_TREE_VIEW_COLUMN_AUTOSIZE && tree_column->requested_width != -1) { gtk_tree_view_column_set_sizing (tree_column, tree_column->requested_width); } +#endif tree_column->column_type = type; gtk_tree_view_column_update_button (tree_column); - if (type != GTK_TREE_VIEW_COLUMN_AUTOSIZE) g_object_notify (G_OBJECT (tree_column), "sizing"); } @@ -1409,71 +1679,75 @@ gtk_tree_view_column_set_sizing (GtkTreeViewColumn *tree_column, * * Return value: The type of @tree_column. **/ -gint +GtkTreeViewColumnSizing gtk_tree_view_column_get_sizing (GtkTreeViewColumn *tree_column) { - g_return_val_if_fail (tree_column != NULL, 0); g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column), 0); return tree_column->column_type; } /** - * gtk_tree_view_column_get_size: + * gtk_tree_view_column_get_width: * @tree_column: A #GtkTreeViewColumn. * - * Returns the current size of the @tree_column in pixels. + * Returns the current size of @tree_column in pixels. * - * Return value: The current size of the @tree_column. + * Return value: The current width of @tree_column. **/ gint -gtk_tree_view_column_get_size (GtkTreeViewColumn *tree_column) +gtk_tree_view_column_get_width (GtkTreeViewColumn *tree_column) { - g_return_val_if_fail (tree_column != NULL, 0); g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column), 0); return tree_column->width; } /** - * gtk_tree_view_column_set_width: + * gtk_tree_view_column_set_fixed_width: * @tree_column: A #GtkTreeViewColumn. - * @width: The size to set the @tree_column to. + * @fixed_width: The size to set @tree_column to. Must be greater than 0. * - * Sets the size of the column in pixels, unless the the column type is - * #GTK_TREE_VIEW_COLUMN_AUTOSIZE. In this case, the value is discarded as the - * size of the column is based on the calculated width of the column. The - * width is clamped to the min/max width for the column. + * Sets the size of the column in pixels. This is meaningful only if the sizing + * type is #GTK_TREE_VIEW_COLUMN_FIXED. The size of the column is clamped to + * the min/max width for the column. Please note that the min/max width of the + * column doesn't actually affect the "fixed_width" property of the widget, just + * the actual size when displayed. **/ void -gtk_tree_view_column_set_width (GtkTreeViewColumn *tree_column, - gint width) +gtk_tree_view_column_set_fixed_width (GtkTreeViewColumn *tree_column, + gint fixed_width) { - g_return_if_fail (tree_column != NULL); g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column)); - g_return_if_fail (width > 0); + g_return_if_fail (fixed_width > 0); - if (tree_column->column_type == GTK_TREE_VIEW_COLUMN_AUTOSIZE) - return; + tree_column->fixed_width = fixed_width; + + if (tree_column->tree_view && + GTK_WIDGET_REALIZED (tree_column->tree_view) && + tree_column->column_type == GTK_TREE_VIEW_COLUMN_FIXED) + { + gtk_widget_queue_resize (tree_column->tree_view); + } - tree_column->requested_width = width; - _gtk_tree_view_column_set_width (tree_column, width); + g_object_notify (G_OBJECT (tree_column), "fixed_width"); } /** - * gtk_tree_view_column_get_width: + * gtk_tree_view_column_get_fixed_width: * @tree_column: a #GtkTreeViewColumn * - * Gets the value set by gtk_tree_view_column_set_width(). + * Gets the fixed width of the column. This value is only meaning may not be + * the actual width of the column on the screen, just what is requested. * - * Return value: the width of the column + * Return value: the fixed width of the column **/ gint -gtk_tree_view_column_get_width (GtkTreeViewColumn *tree_column) +gtk_tree_view_column_get_fixed_width (GtkTreeViewColumn *tree_column) { g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column), 0); - return tree_column->width; + return tree_column->fixed_width; } /** @@ -1488,38 +1762,33 @@ void gtk_tree_view_column_set_min_width (GtkTreeViewColumn *tree_column, gint min_width) { - gint real_min_width; - - g_return_if_fail (tree_column != NULL); g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column)); g_return_if_fail (min_width >= -1); if (min_width == tree_column->min_width) return; - real_min_width = (tree_column->min_width == -1) ? - tree_column->button->requisition.width : tree_column->min_width; - - /* We want to queue a resize if the either the old min_size or the - * new min_size determined the size of the column */ - if (tree_column->tree_view && + if (tree_column->visible && + tree_column->tree_view != NULL && GTK_WIDGET_REALIZED (tree_column->tree_view)) { - if ((tree_column->min_width > tree_column->width) || - (tree_column->min_width == -1 && - tree_column->button->requisition.width > tree_column->width) || - (min_width > tree_column->width) || - (min_width == -1 && - tree_column->button->requisition.width > tree_column->width)) + if (min_width > tree_column->width) gtk_widget_queue_resize (tree_column->tree_view); } - if (tree_column->max_width != -1 && tree_column->max_width < real_min_width) - tree_column->max_width = real_min_width; - tree_column->min_width = min_width; - + g_object_freeze_notify (G_OBJECT (tree_column)); + if (tree_column->max_width != -1 && tree_column->max_width < min_width) + { + tree_column->max_width = min_width; + g_object_notify (G_OBJECT (tree_column), "max_width"); + } g_object_notify (G_OBJECT (tree_column), "min_width"); + g_object_thaw_notify (G_OBJECT (tree_column)); + + if (tree_column->column_type == GTK_TREE_VIEW_COLUMN_AUTOSIZE) + _gtk_tree_view_column_autosize (GTK_TREE_VIEW (tree_column->tree_view), + tree_column); } /** @@ -1534,7 +1803,6 @@ gtk_tree_view_column_set_min_width (GtkTreeViewColumn *tree_column, gint gtk_tree_view_column_get_min_width (GtkTreeViewColumn *tree_column) { - g_return_val_if_fail (tree_column != NULL, -1); g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column), -1); return tree_column->min_width; @@ -1546,36 +1814,41 @@ gtk_tree_view_column_get_min_width (GtkTreeViewColumn *tree_column) * @max_width: The maximum width of the column in pixels, or -1. * * Sets the maximum width of the @tree_column. If @max_width is -1, then the - * maximum width is unset. + * maximum width is unset. Note, the column can actually be wider than max + * width if it's the last column in a view. In this case, the column expands to + * fill any extra space. **/ void gtk_tree_view_column_set_max_width (GtkTreeViewColumn *tree_column, gint max_width) { - gint real_min_width; - - g_return_if_fail (tree_column != NULL); g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column)); g_return_if_fail (max_width >= -1); if (max_width == tree_column->max_width) return; - real_min_width = tree_column->min_width == -1 ? - tree_column->button->requisition.width : tree_column->min_width; - - if (tree_column->tree_view && - GTK_WIDGET_REALIZED (tree_column->tree_view) && - ((tree_column->max_width < tree_column->width) || - (max_width != -1 && max_width < tree_column->width))) - gtk_widget_queue_resize (tree_column->tree_view); + if (tree_column->visible && + tree_column->tree_view != NULL && + GTK_WIDGET_REALIZED (tree_column->tree_view)) + { + if (max_width != -1 && max_width < tree_column->width) + gtk_widget_queue_resize (tree_column->tree_view); + } tree_column->max_width = max_width; - - if (real_min_width > max_width) - tree_column->min_width = max_width; - + g_object_freeze_notify (G_OBJECT (tree_column)); + if (max_width != -1 && max_width < tree_column->min_width) + { + tree_column->min_width = max_width; + g_object_notify (G_OBJECT (tree_column), "min_width"); + } g_object_notify (G_OBJECT (tree_column), "max_width"); + g_object_thaw_notify (G_OBJECT (tree_column)); + + if (tree_column->column_type == GTK_TREE_VIEW_COLUMN_AUTOSIZE) + _gtk_tree_view_column_autosize (GTK_TREE_VIEW (tree_column->tree_view), + tree_column); } /** @@ -1590,7 +1863,6 @@ gtk_tree_view_column_set_max_width (GtkTreeViewColumn *tree_column, gint gtk_tree_view_column_get_max_width (GtkTreeViewColumn *tree_column) { - g_return_val_if_fail (tree_column != NULL, -1); g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column), -1); return tree_column->max_width; @@ -1601,7 +1873,7 @@ gtk_tree_view_column_get_max_width (GtkTreeViewColumn *tree_column) * @tree_column: a #GtkTreeViewColumn * * Emits the "clicked" signal on the column. This function will only work if - * the user could have conceivably clicked on the button. + * @tree_column is clickable. **/ void gtk_tree_view_column_clicked (GtkTreeViewColumn *tree_column) @@ -1626,7 +1898,6 @@ void gtk_tree_view_column_set_title (GtkTreeViewColumn *tree_column, const gchar *title) { - g_return_if_fail (tree_column != NULL); g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column)); g_free (tree_column->title); @@ -1636,7 +1907,6 @@ gtk_tree_view_column_set_title (GtkTreeViewColumn *tree_column, tree_column->title = NULL; gtk_tree_view_column_update_button (tree_column); - g_object_notify (G_OBJECT (tree_column), "title"); } @@ -1644,59 +1914,25 @@ gtk_tree_view_column_set_title (GtkTreeViewColumn *tree_column, * gtk_tree_view_column_get_title: * @tree_column: A #GtkTreeViewColumn. * - * Returns the title of the widget. This value should not be modified. + * Returns the title of the widget. * - * Return value: the title of the column. + * Return value: the title of the column. This string should not be + * modified or freed. **/ G_CONST_RETURN gchar * gtk_tree_view_column_get_title (GtkTreeViewColumn *tree_column) { - g_return_val_if_fail (tree_column != NULL, NULL); g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column), NULL); return tree_column->title; } - -static void -gtk_tree_view_column_set_clickable_real (GtkTreeViewColumn *tree_column) -{ - if (!tree_column->button) - return; - - if (tree_column->clickable) - { - if (tree_column->clickable_signal) - { - g_signal_handler_disconnect (G_OBJECT (tree_column->button), tree_column->clickable_signal); - tree_column->clickable_signal = 0; - } - - GTK_WIDGET_SET_FLAGS (tree_column->button, GTK_CAN_FOCUS); - if (GTK_WIDGET_VISIBLE (tree_column->tree_view)) - gtk_widget_queue_draw (tree_column->button); - } - else - { - tree_column->clickable_signal = - gtk_signal_connect (GTK_OBJECT (tree_column->button), - "event", - (GtkSignalFunc) gtk_tree_view_column_button_passive_func, - NULL); - - GTK_WIDGET_UNSET_FLAGS (tree_column->button, GTK_CAN_FOCUS); - if (GTK_WIDGET_VISIBLE (tree_column->tree_view)) - gtk_widget_queue_draw (tree_column->button); - } - -} - /** * gtk_tree_view_column_set_clickable: * @tree_column: A #GtkTreeViewColumn. - * @clickable: TRUE if the header is active. + * @clickable: %TRUE if the header is active. * - * Sets the header to be active if @active is TRUE. When the header is active, + * Sets the header to be active if @active is %TRUE. When the header is active, * then it can take keyboard focus, and can be clicked. **/ void @@ -1705,11 +1941,12 @@ gtk_tree_view_column_set_clickable (GtkTreeViewColumn *tree_column, { g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column)); - if (tree_column->clickable == (clickable?TRUE:FALSE)) + clickable = !! clickable; + if (tree_column->clickable == clickable) return; - tree_column->clickable = (clickable?TRUE:FALSE); - gtk_tree_view_column_set_clickable_real (tree_column); + tree_column->clickable = clickable; + gtk_tree_view_column_update_button (tree_column); g_object_notify (G_OBJECT (tree_column), "clickable"); } @@ -1719,7 +1956,7 @@ gtk_tree_view_column_set_clickable (GtkTreeViewColumn *tree_column, * * Returns %TRUE if the user can click on the header for the column. * - * Return value: whether the user can click the column header + * Return value: %TRUE if user can click the column header. **/ gboolean gtk_tree_view_column_get_clickable (GtkTreeViewColumn *tree_column) @@ -1732,9 +1969,9 @@ gtk_tree_view_column_get_clickable (GtkTreeViewColumn *tree_column) /** * gtk_tree_view_column_set_widget: * @tree_column: A #GtkTreeViewColumn. - * @widget: A child #GtkWidget, or NULL. + * @widget: A child #GtkWidget, or %NULL. * - * Sets the widget in the header to be @widget. If widget is NULL, then the + * Sets the widget in the header to be @widget. If widget is %NULL, then the * header button is set with a #GtkLabel set to the title of @tree_column. **/ void @@ -1746,12 +1983,12 @@ gtk_tree_view_column_set_widget (GtkTreeViewColumn *tree_column, if (widget) { - gtk_object_ref (GTK_OBJECT (widget)); + g_object_ref (widget); gtk_object_sink (GTK_OBJECT (widget)); } if (tree_column->child) - gtk_object_unref (GTK_OBJECT (tree_column->child)); + g_object_unref (tree_column->child); tree_column->child = widget; gtk_tree_view_column_update_button (tree_column); @@ -1762,16 +1999,14 @@ gtk_tree_view_column_set_widget (GtkTreeViewColumn *tree_column, * gtk_tree_view_column_get_widget: * @tree_column: A #GtkTreeViewColumn. * - * Returns the #GtkWidget in the button in the column header. If a custom - * widget has not been set, then this will be a #GtkAlignment with a #GtkLabel - * in it. + * Returns the #GtkWidget in the button on the column header. If a custom + * widget has not been set then %NULL is returned. * - * Return value: The #GtkWidget in the column header. + * Return value: The #GtkWidget in the column header, or %NULL **/ GtkWidget * gtk_tree_view_column_get_widget (GtkTreeViewColumn *tree_column) { - g_return_val_if_fail (tree_column != NULL, NULL); g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column), NULL); return tree_column->child; @@ -1780,17 +2015,20 @@ gtk_tree_view_column_get_widget (GtkTreeViewColumn *tree_column) /** * gtk_tree_view_column_set_alignment: * @tree_column: A #GtkTreeViewColumn. - * @xalign: alignment (0.0 for left, 0.5 for center, 1.0 for right) + * @xalign: The alignment, which is between [0.0 and 1.0] inclusive. * * Sets the alignment of the title or custom widget inside the column header. + * The alignment determines its location inside the button -- 0.0 for left, 0.5 + * for center, 1.0 for right. **/ void gtk_tree_view_column_set_alignment (GtkTreeViewColumn *tree_column, gfloat xalign) { - g_return_if_fail (tree_column != NULL); g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column)); + xalign = CLAMP (xalign, 0.0, 1.0); + if (tree_column->xalign == xalign) return; @@ -1799,6 +2037,15 @@ gtk_tree_view_column_set_alignment (GtkTreeViewColumn *tree_column, g_object_notify (G_OBJECT (tree_column), "alignment"); } +/** + * gtk_tree_view_column_get_alignment: + * @tree_column: A #GtkTreeViewColumn. + * + * Returns the current x alignment of @tree_column. This value can range + * between 0.0 and 1.0. + * + * Return value: The current alignent of @tree_column. + **/ gfloat gtk_tree_view_column_get_alignment (GtkTreeViewColumn *tree_column) { @@ -1807,12 +2054,23 @@ gtk_tree_view_column_get_alignment (GtkTreeViewColumn *tree_column) return tree_column->xalign; } +/** + * gtk_tree_view_column_set_reorderable: + * @tree_column: A #GtkTreeViewColumn + * @reorderable: #TRUE, if the column can be reordered. + * + * If @reorderable is #TRUE, then the column can be reordered by the end user + * dragging the header. + **/ void gtk_tree_view_column_set_reorderable (GtkTreeViewColumn *tree_column, gboolean reorderable) { g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column)); + /* if (reorderable) + gtk_tree_view_column_set_clickable (tree_column, TRUE);*/ + if (tree_column->reorderable == (reorderable?TRUE:FALSE)) return; @@ -1821,6 +2079,14 @@ gtk_tree_view_column_set_reorderable (GtkTreeViewColumn *tree_column, g_object_notify (G_OBJECT (tree_column), "reorderable"); } +/** + * gtk_tree_view_column_get_reorderable: + * @tree_column: A #GtkTreeViewColumn + * + * Returns #TRUE if the @tree_column can be reordered by the user. + * + * Return value: #TRUE if the @tree_column can be reordered by the user. + **/ gboolean gtk_tree_view_column_get_reorderable (GtkTreeViewColumn *tree_column) { @@ -1833,10 +2099,10 @@ gtk_tree_view_column_get_reorderable (GtkTreeViewColumn *tree_column) /** * gtk_tree_view_column_set_sort_column_id: * @tree_column: a #GtkTreeViewColumn - * @sort_column_id: The sort_column_id of the model to sort on. - * - * Sets the sort_column_id that the column sorts on. Doing so makes headers - * clickable. + * @sort_column_id: The @sort_column_id of the model to sort on. + * + * Sets the logical @sort_column_id that this column sorts on when this column + * is selected for sorting. Doing so makes the column header clickable. **/ void gtk_tree_view_column_set_sort_column_id (GtkTreeViewColumn *tree_column, @@ -1855,17 +2121,17 @@ gtk_tree_view_column_set_sort_column_id (GtkTreeViewColumn *tree_column, { if (tree_column->sort_clicked_signal) { - g_signal_handler_disconnect (G_OBJECT (tree_column), tree_column->sort_clicked_signal); + g_signal_handler_disconnect (tree_column, tree_column->sort_clicked_signal); tree_column->sort_clicked_signal = 0; } if (tree_column->sort_column_changed_signal) { - g_signal_handler_disconnect (G_OBJECT (tree_column), tree_column->sort_column_changed_signal); + g_signal_handler_disconnect (tree_column, tree_column->sort_column_changed_signal); tree_column->sort_column_changed_signal = 0; } - gtk_tree_view_column_set_sort_order (tree_column, GTK_TREE_SORT_ASCENDING); + gtk_tree_view_column_set_sort_order (tree_column, GTK_SORT_ASCENDING); gtk_tree_view_column_set_sort_indicator (tree_column, FALSE); return; } @@ -1873,14 +2139,33 @@ gtk_tree_view_column_set_sort_column_id (GtkTreeViewColumn *tree_column, gtk_tree_view_column_set_clickable (tree_column, TRUE); if (! tree_column->sort_clicked_signal) - tree_column->sort_clicked_signal = g_signal_connectc (G_OBJECT (tree_column), - "clicked", - G_CALLBACK (gtk_tree_view_column_sort), - NULL, FALSE); + tree_column->sort_clicked_signal = g_signal_connect (tree_column, + "clicked", + G_CALLBACK (gtk_tree_view_column_sort), + NULL); gtk_tree_view_column_setup_sort_column_id_callback (tree_column); } +/** + * gtk_tree_view_column_get_sort_column_id: + * @tree_column: a #GtkTreeViewColumn + * + * Gets the logical @sort_column_id that the model sorts on when this + * column is selected for sorting. + * See gtk_tree_view_column_set_sort_column_id(). + * + * Return value: the current @sort_column_id for this column, or -1 if + * this column can't be used for sorting. + **/ +gint +gtk_tree_view_column_get_sort_column_id (GtkTreeViewColumn *tree_column) +{ + g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column), 0); + + return tree_column->sort_column_id; +} + /** * gtk_tree_view_column_set_sort_indicator: * @tree_column: a #GtkTreeViewColumn @@ -1929,20 +2214,21 @@ gtk_tree_view_column_get_sort_indicator (GtkTreeViewColumn *tree_column) * @tree_column: a #GtkTreeViewColumn * @order: sort order that the sort indicator should indicate * - * Changes the appearance of the sort indicator. (This does - * not actually sort the model. Use + * Changes the appearance of the sort indicator. + * + * This does not actually sort the model. Use * gtk_tree_view_column_set_sort_column_id() if you want automatic sorting * support. This function is primarily for custom sorting behavior, and should - * be used in conjunction with #gtk_tree_sortable_set_sort_column() to do - * that. For custom models, the mechanism will vary. The sort indicator changes - * direction to indicate normal sort or reverse sort. Note that you must have - * the sort indicator enabled to see anything when calling this function; see - * gtk_tree_view_column_set_sort_indicator(). + * be used in conjunction with gtk_tree_sortable_set_sort_column() to do + * that. For custom models, the mechanism will vary. * + * The sort indicator changes direction to indicate normal sort or reverse sort. + * Note that you must have the sort indicator enabled to see anything when + * calling this function; see gtk_tree_view_column_set_sort_indicator(). **/ void gtk_tree_view_column_set_sort_order (GtkTreeViewColumn *tree_column, - GtkTreeSortOrder order) + GtkSortType order) { g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column)); @@ -1962,7 +2248,7 @@ gtk_tree_view_column_set_sort_order (GtkTreeViewColumn *tree_column, * * Return value: the sort order the sort indicator is indicating **/ -GtkTreeSortOrder +GtkSortType gtk_tree_view_column_get_sort_order (GtkTreeViewColumn *tree_column) { g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column), 0); @@ -1970,5 +2256,1048 @@ gtk_tree_view_column_get_sort_order (GtkTreeViewColumn *tree_column) return tree_column->sort_order; } +/** + * gtk_tree_view_column_cell_set_cell_data: + * @tree_column: A #GtkTreeViewColumn. + * @tree_model: The #GtkTreeModel to to get the cell renderers attributes from. + * @iter: The #GtkTreeIter to to get the cell renderer's attributes from. + * @is_expander: %TRUE, if the row has children + * @is_expanded: %TRUE, if the row has visible children + * + * Sets the cell renderer based on the @tree_model and @iter. That is, for + * every attribute mapping in @tree_column, it will get a value from the set + * column on the @iter, and use that value to set the attribute on the cell + * renderer. This is used primarily by the #GtkTreeView. + **/ +void +gtk_tree_view_column_cell_set_cell_data (GtkTreeViewColumn *tree_column, + GtkTreeModel *tree_model, + GtkTreeIter *iter, + gboolean is_expander, + gboolean is_expanded) +{ + GSList *list; + GValue value = { 0, }; + GList *cell_list; + + g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column)); + g_return_if_fail (tree_column->cell_list != NULL); + + if (tree_model == NULL) + return; + + for (cell_list = tree_column->cell_list; cell_list; cell_list = cell_list->next) + { + GtkTreeViewColumnCellInfo *info = (GtkTreeViewColumnCellInfo *) cell_list->data; + GObject *cell = (GObject *) info->cell; + + list = info->attributes; + + g_object_freeze_notify (cell); + g_object_set (cell, "is_expander", is_expander, "is_expanded", is_expanded, NULL); + + while (list && list->next) + { + gtk_tree_model_get_value (tree_model, iter, + GPOINTER_TO_INT (list->next->data), + &value); + g_object_set_property (cell, (gchar *) list->data, &value); + g_value_unset (&value); + list = list->next->next; + } + + if (info->func) + (* info->func) (tree_column, info->cell, tree_model, iter, info->func_data); + g_object_thaw_notify (G_OBJECT (info->cell)); + } + +} + +/** + * gtk_tree_view_column_cell_get_size: + * @tree_column: A #GtkTreeViewColumn. + * @cell_area: The area a cell in the column will be allocated, or %NULL + * @x_offset: location to return x offset of a cell relative to @cell_area, or %NULL + * @y_offset: location to return y offset of a cell relative to @cell_area, or %NULL + * @width: location to return width needed to render a cell, or %NULL + * @height: location to return height needed to render a cell, or %NULL + * + * Obtains the width and height needed to render the column. This is used + * primarily by the #GtkTreeView. + **/ +void +gtk_tree_view_column_cell_get_size (GtkTreeViewColumn *tree_column, + GdkRectangle *cell_area, + gint *x_offset, + gint *y_offset, + gint *width, + gint *height) +{ + GList *list; + gboolean first_cell = TRUE; + gint focus_line_width; + + g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column)); + + if (height) + * height = 0; + if (width) + * width = 0; + + gtk_widget_style_get (tree_column->tree_view, "focus-line-width", &focus_line_width, NULL); + + for (list = tree_column->cell_list; list; list = list->next) + { + GtkTreeViewColumnCellInfo *info = (GtkTreeViewColumnCellInfo *) list->data; + gboolean visible; + gint new_height = 0; + gint new_width = 0; + g_object_get (info->cell, "visible", &visible, NULL); + + if (visible == FALSE) + continue; + + if (first_cell == FALSE && *width) + *width += tree_column->spacing; + + gtk_cell_renderer_get_size (info->cell, + tree_column->tree_view, + cell_area, + x_offset, + y_offset, + &new_width, + &new_height); + + if (height) + * height = MAX (*height, new_height + focus_line_width * 2); + info->requested_width = MAX (info->requested_width, new_width + focus_line_width * 2); + if (width) + * width += info->requested_width; + first_cell = FALSE; + } +} + +/* both rendering and rendering focus are somewhat complicated, and a bit of + * code. Rather than duplicate them, we put them together to keep the code in + * one place + */ +enum { + CELL_ACTION_RENDER, + CELL_ACTION_FOCUS, + CELL_ACTION_EVENT +}; + +static gboolean +gtk_tree_view_column_cell_process_action (GtkTreeViewColumn *tree_column, + GdkWindow *window, + GdkRectangle *background_area, + GdkRectangle *cell_area, + guint flags, + gint action, + GdkRectangle *expose_area, /* RENDER */ + GdkRectangle *focus_rectangle, /* FOCUS */ + GtkCellEditable **editable_widget, /* EVENT */ + GdkEvent *event, /* EVENT */ + gchar *path_string) /* EVENT */ +{ + GList *list; + GdkRectangle real_cell_area; + GdkRectangle real_background_area; + gint expand_cell_count = 0; + gint full_requested_width = 0; + gint extra_space; + gint min_x, min_y, max_x, max_y; + gint focus_line_width; + gint dx; + gint special_cells; + + min_x = G_MAXINT; + min_y = G_MAXINT; + max_x = 0; + max_y = 0; + + special_cells = _gtk_tree_view_column_count_special_cells (tree_column); + + if (special_cells > 1 && action == CELL_ACTION_FOCUS) + { + GtkTreeViewColumnCellInfo *info = NULL; + gboolean found_has_focus = FALSE; + + /* one should have focus */ + for (list = tree_column->cell_list; list; list = list->next) + { + info = list->data; + if (info && info->has_focus) + { + found_has_focus = TRUE; + break; + } + } + + if (!found_has_focus) + { + /* give the first one focus */ + info = gtk_tree_view_column_cell_first (tree_column)->data; + info->has_focus = TRUE; + } + } + + gtk_widget_style_get (GTK_WIDGET (tree_column->tree_view), + "focus-line-width", &focus_line_width, + NULL); + + real_cell_area = *cell_area; + real_background_area = *background_area; + dx = real_cell_area.x - real_background_area.x - focus_line_width; + + real_cell_area.x += focus_line_width; + + /* Find out how many extra space we have to allocate */ + for (list = tree_column->cell_list; list; list = list->next) + { + GtkTreeViewColumnCellInfo *info = (GtkTreeViewColumnCellInfo *)list->data; + + if (! info->cell->visible) + continue; + + if (info->expand == TRUE) + expand_cell_count ++; + full_requested_width += info->requested_width; + } + + extra_space = background_area->width - full_requested_width; + if (extra_space < 0) + extra_space = 0; + else if (extra_space > 0 && expand_cell_count > 0) + extra_space /= expand_cell_count; + + /* iterate list for GTK_PACK_START cells */ + for (list = tree_column->cell_list; list; list = list->next) + { + GtkTreeViewColumnCellInfo *info = (GtkTreeViewColumnCellInfo *) list->data; + + if (info->pack == GTK_PACK_END) + continue; + + if (! info->cell->visible) + continue; + + real_background_area.width = info->requested_width + + (info->expand?extra_space:0); + info->real_width = real_background_area.width; + + real_cell_area.width = real_background_area.width; + real_cell_area.width -= 2 * focus_line_width; + + if (action == CELL_ACTION_RENDER) + { + gtk_cell_renderer_render (info->cell, + window, + tree_column->tree_view, + &real_background_area, + &real_cell_area, + expose_area, + flags); + } + else if (action == CELL_ACTION_FOCUS) + { + gint x_offset, y_offset, width, height; + + gtk_cell_renderer_get_size (info->cell, + tree_column->tree_view, + &real_cell_area, + &x_offset, &y_offset, + &width, &height); + if (special_cells > 1) + { + if (info->has_focus) + { + min_x = real_cell_area.x + x_offset; + max_x = min_x + width; + min_y = real_cell_area.y + y_offset; + max_y = min_y + height; + } + } + else + { + if (min_x > (real_cell_area.x + x_offset)) + min_x = real_cell_area.x + x_offset; + if (max_x < real_cell_area.x + x_offset + width) + max_x = real_cell_area.x + x_offset + width; + if (min_y > (real_cell_area.y + y_offset)) + min_y = real_cell_area.y + y_offset; + if (max_y < real_cell_area.y + y_offset + height) + max_y = real_cell_area.y + y_offset + height; + } + } + else if (action == CELL_ACTION_EVENT) + { + gboolean try_event = FALSE; + if (event) + { + if (special_cells == 1) + { + /* only 1 activatable cell -> whole column can activate */ + if (cell_area->x <= ((GdkEventButton *)event)->x && + cell_area->x + cell_area->width > ((GdkEventButton *)event)->x) + try_event = TRUE; + } + else if (real_cell_area.x <= ((GdkEventButton *)event)->x && + real_cell_area.x + real_cell_area.width > ((GdkEventButton *)event)->x) + /* only activate cell if the user clicked on an individual + * cell + */ + try_event = TRUE; + } + else if (special_cells > 1 && info->has_focus) + try_event = TRUE; + else if (special_cells == 1) + try_event = TRUE; + + if (try_event) + { + gboolean visible, mode; + + g_object_get (G_OBJECT (info->cell), + "visible", &visible, + "mode", &mode, + NULL); + if (visible && mode == GTK_CELL_RENDERER_MODE_ACTIVATABLE) + { + if (gtk_cell_renderer_activate (info->cell, + event, + tree_column->tree_view, + path_string, + background_area, + cell_area, + flags)) + return TRUE; + } + else if (visible && mode == GTK_CELL_RENDERER_MODE_EDITABLE) + { + *editable_widget = + gtk_cell_renderer_start_editing (info->cell, + event, + tree_column->tree_view, + path_string, + background_area, + cell_area, + flags); + + if (*editable_widget != NULL) + { + g_return_val_if_fail (GTK_IS_CELL_EDITABLE (*editable_widget), FALSE); + info->in_editing_mode = TRUE; + gtk_tree_view_column_focus_cell (tree_column, info->cell); + + return TRUE; + } + } + } + } + + real_cell_area.x += (info->real_width + tree_column->spacing); + real_background_area.x += (info->real_width + tree_column->spacing); + } + + /* iterate list for PACK_END cells */ + for (list = g_list_last (tree_column->cell_list); list; list = list->prev) + { + GtkTreeViewColumnCellInfo *info = (GtkTreeViewColumnCellInfo *) list->data; + + if (info->pack == GTK_PACK_START) + continue; + + if (! info->cell->visible) + continue; + + real_background_area.width = info->requested_width + + (info->expand?extra_space:0); + info->real_width = real_background_area.width; + + real_cell_area.width = real_background_area.width; + real_cell_area.width -= 2 * focus_line_width; + + if (action == CELL_ACTION_RENDER) + { + gtk_cell_renderer_render (info->cell, + window, + tree_column->tree_view, + &real_background_area, + &real_cell_area, + expose_area, + flags); + } + else if (action == CELL_ACTION_FOCUS) + { + gint x_offset, y_offset, width, height; + + gtk_cell_renderer_get_size (info->cell, + tree_column->tree_view, + &real_cell_area, + &x_offset, &y_offset, + &width, &height); + + if (special_cells > 1) + { + if (info->has_focus) + { + min_x = real_cell_area.x + x_offset; + max_x = min_x + width; + min_y = real_cell_area.y + y_offset; + max_y = min_y + height; + } + } + else + { + if (min_x > (real_cell_area.x + x_offset)) + min_x = real_cell_area.x + x_offset; + if (max_x < real_cell_area.x + x_offset + width) + max_x = real_cell_area.x + x_offset + width; + if (min_y > (real_cell_area.y + y_offset)) + min_y = real_cell_area.y + y_offset; + if (max_y < real_cell_area.y + y_offset + height) + max_y = real_cell_area.y + y_offset + height; + } + } + else if (action == CELL_ACTION_EVENT) + { + gboolean try_event = FALSE; + + if (event) + { + if (special_cells == 1) + { + /* only 1 activatable cell -> whole column can activate */ + if (cell_area->x <= ((GdkEventButton *)event)->x && + cell_area->x + cell_area->width > ((GdkEventButton *)event)->x) + try_event = TRUE; + } + else if (real_cell_area.x <= ((GdkEventButton *)event)->x && + real_cell_area.x + real_cell_area.width > ((GdkEventButton *)event)->x) + /* only activate cell if the user clicked on an individual + * cell + */ + try_event = TRUE; + } + else if (special_cells > 1 && info->has_focus) + try_event = TRUE; + else if (special_cells == 1) + try_event = TRUE; + + if (try_event) + { + gboolean visible, mode; + + g_object_get (G_OBJECT (info->cell), + "visible", &visible, + "mode", &mode, + NULL); + if (visible && mode == GTK_CELL_RENDERER_MODE_ACTIVATABLE) + { + if (gtk_cell_renderer_activate (info->cell, + event, + tree_column->tree_view, + path_string, + background_area, + cell_area, + flags)) + return TRUE; + } + else if (visible && mode == GTK_CELL_RENDERER_MODE_EDITABLE) + { + *editable_widget = + gtk_cell_renderer_start_editing (info->cell, + event, + tree_column->tree_view, + path_string, + background_area, + cell_area, + flags); + + if (*editable_widget != NULL) + { + g_return_val_if_fail (GTK_IS_CELL_EDITABLE (*editable_widget), FALSE); + info->in_editing_mode = TRUE; + gtk_tree_view_column_focus_cell (tree_column, info->cell); + + return TRUE; + } + } + } + } + + real_cell_area.x += (info->real_width + tree_column->spacing); + real_background_area.x += (info->real_width + tree_column->spacing); + } + + /* fill focus_rectangle when required */ + if (action == CELL_ACTION_FOCUS) + { + if (min_x >= max_x || min_y >= max_y) + { + *focus_rectangle = *cell_area; + /* don't change the focus_rectangle, just draw it nicely inside + * the cell area */ + } + else + { + focus_rectangle->x = min_x - focus_line_width; + focus_rectangle->y = min_y - focus_line_width; + focus_rectangle->width = (max_x - min_x) + 2 * focus_line_width; + focus_rectangle->height = (max_y - min_y) + 2 * focus_line_width; + } + } + + return FALSE; +} + +/** + * gtk_tree_view_column_cell_render: + * @tree_column: A #GtkTreeViewColumn. + * @window: a #GdkDrawable to draw to + * @background_area: entire cell area (including tree expanders and maybe padding on the sides) + * @cell_area: area normally rendered by a cell renderer + * @expose_area: area that actually needs updating + * @flags: flags that affect rendering + * + * Renders the cell contained by #tree_column. This is used primarily by the + * #GtkTreeView. + **/ +void +_gtk_tree_view_column_cell_render (GtkTreeViewColumn *tree_column, + GdkWindow *window, + GdkRectangle *background_area, + GdkRectangle *cell_area, + GdkRectangle *expose_area, + guint flags) +{ + g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column)); + g_return_if_fail (background_area != NULL); + g_return_if_fail (cell_area != NULL); + g_return_if_fail (expose_area != NULL); + + gtk_tree_view_column_cell_process_action (tree_column, + window, + background_area, + cell_area, + flags, + CELL_ACTION_RENDER, + expose_area, + NULL, NULL, NULL, NULL); +} + +gboolean +_gtk_tree_view_column_cell_event (GtkTreeViewColumn *tree_column, + GtkCellEditable **editable_widget, + GdkEvent *event, + gchar *path_string, + GdkRectangle *background_area, + GdkRectangle *cell_area, + guint flags) +{ + g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column), FALSE); + + return gtk_tree_view_column_cell_process_action (tree_column, + NULL, + background_area, + cell_area, + flags, + CELL_ACTION_EVENT, + NULL, NULL, + editable_widget, + event, + path_string); +} + +/* cell list manipulation */ +static GList * +gtk_tree_view_column_cell_first (GtkTreeViewColumn *tree_column) +{ + GList *list = tree_column->cell_list; + + /* first GTK_PACK_START cell we find */ + for ( ; list; list = list->next) + { + GtkTreeViewColumnCellInfo *info = list->data; + if (info->pack == GTK_PACK_START) + return list; + } + + /* hmm, else the *last* GTK_PACK_END cell */ + list = g_list_last (tree_column->cell_list); + + for ( ; list; list = list->prev) + { + GtkTreeViewColumnCellInfo *info = list->data; + if (info->pack == GTK_PACK_END) + return list; + } + + return NULL; +} + +static GList * +gtk_tree_view_column_cell_last (GtkTreeViewColumn *tree_column) +{ + GList *list = tree_column->cell_list; + + /* *first* GTK_PACK_END cell we find */ + for ( ; list ; list = list->next) + { + GtkTreeViewColumnCellInfo *info = list->data; + if (info->pack == GTK_PACK_END) + return list; + } + + /* hmm, else the last GTK_PACK_START cell */ + list = g_list_last (tree_column->cell_list); + + for ( ; list; list = list->prev) + { + GtkTreeViewColumnCellInfo *info = list->data; + if (info->pack == GTK_PACK_START) + return list; + } + + return NULL; +} + +static GList * +gtk_tree_view_column_cell_next (GtkTreeViewColumn *tree_column, + GList *current) +{ + GList *list; + GtkTreeViewColumnCellInfo *info = current->data; + + if (info->pack == GTK_PACK_START) + { + for (list = current->next; list; list = list->next) + { + GtkTreeViewColumnCellInfo *inf = list->data; + if (inf->pack == GTK_PACK_START) + return list; + } + + /* out of GTK_PACK_START cells, get *last* GTK_PACK_END one */ + list = g_list_last (tree_column->cell_list); + for (; list; list = list->prev) + { + GtkTreeViewColumnCellInfo *inf = list->data; + if (inf->pack == GTK_PACK_END) + return list; + } + } + + for (list = current->prev; list; list = list->prev) + { + GtkTreeViewColumnCellInfo *inf = list->data; + if (inf->pack == GTK_PACK_END) + return list; + } + + return NULL; +} + +static GList * +gtk_tree_view_column_cell_prev (GtkTreeViewColumn *tree_column, + GList *current) +{ + GList *list; + GtkTreeViewColumnCellInfo *info = current->data; + + if (info->pack == GTK_PACK_END) + { + for (list = current->next; list; list = list->next) + { + GtkTreeViewColumnCellInfo *inf = list->data; + if (inf->pack == GTK_PACK_END) + return list; + } + + /* out of GTK_PACK_END, get last GTK_PACK_START one */ + list = g_list_last (tree_column->cell_list); + for ( ; list; list = list->prev) + { + GtkTreeViewColumnCellInfo *inf = list->data; + if (inf->pack == GTK_PACK_START) + return list; + } + } + + for (list = current->prev; list; list = list->prev) + { + GtkTreeViewColumnCellInfo *inf = list->data; + if (inf->pack == GTK_PACK_START) + return list; + } + + return NULL; +} + +gboolean +_gtk_tree_view_column_cell_focus (GtkTreeViewColumn *tree_column, + gint direction, + gboolean left, + gboolean right) +{ + gint count; + + count = _gtk_tree_view_column_count_special_cells (tree_column); + + /* if we are the current focus column and have multiple editable cells, + * try to select the next one, else move the focus to the next column + */ + if (GTK_TREE_VIEW (tree_column->tree_view)->priv->focus_column == tree_column) + { + if (count > 1) + { + GList *next, *prev; + GList *list = tree_column->cell_list; + GtkTreeViewColumnCellInfo *info = NULL; + + /* find current focussed cell */ + for ( ; list; list = list->next) + { + info = list->data; + if (info->has_focus) + break; + } + + /* not a focussed cell in the focus column? */ + if (!list || !info || !info->has_focus) + return FALSE; + + next = gtk_tree_view_column_cell_next (tree_column, list); + prev = gtk_tree_view_column_cell_prev (tree_column, list); + + info->has_focus = FALSE; + if (direction > 0 && next) + { + info = next->data; + info->has_focus = TRUE; + return TRUE; + } + else if (direction > 0 && !next && !right) + { + /* keep focus on latest cell */ + info = gtk_tree_view_column_cell_last (tree_column)->data; + info->has_focus = TRUE; + return TRUE; + } + else if (direction < 0 && prev) + { + info = prev->data; + info->has_focus = TRUE; + return TRUE; + } + else if (direction < 0 && !prev && !left) + { + /* keep focus on first cell */ + info = gtk_tree_view_column_cell_first (tree_column)->data; + info->has_focus = TRUE; + return TRUE; + } + } + return FALSE; + } + + /* we get focus, if we have multiple editable cells, give the correct one + * focus + */ + if (count > 1) + { + GList *list = tree_column->cell_list; + + /* clear focus first */ + for ( ; list ; list = list->next) + { + GtkTreeViewColumnCellInfo *info = list->data; + if (info->has_focus) + info->has_focus = FALSE; + } + + if (direction > 0) + ((GtkTreeViewColumnCellInfo *)gtk_tree_view_column_cell_first (tree_column)->data)->has_focus = TRUE; + else if (direction < 0) + ((GtkTreeViewColumnCellInfo *)gtk_tree_view_column_cell_last (tree_column)->data)->has_focus = TRUE; + } + return TRUE; +} + +void +_gtk_tree_view_column_cell_draw_focus (GtkTreeViewColumn *tree_column, + GdkWindow *window, + GdkRectangle *background_area, + GdkRectangle *cell_area, + GdkRectangle *expose_area, + guint flags) +{ + gint focus_line_width; + GtkStateType cell_state; + + g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column)); + gtk_widget_style_get (GTK_WIDGET (tree_column->tree_view), + "focus-line-width", &focus_line_width, NULL); + if (tree_column->editable_widget) + { + /* This function is only called on the editable row when editing. + */ +#if 0 + gtk_paint_focus (tree_column->tree_view->style, + window, + GTK_WIDGET_STATE (tree_column->tree_view), + NULL, + tree_column->tree_view, + "treeview", + cell_area->x - focus_line_width, + cell_area->y - focus_line_width, + cell_area->width + 2 * focus_line_width, + cell_area->height + 2 * focus_line_width); +#endif + } + else + { + GdkRectangle focus_rectangle; + gtk_tree_view_column_cell_process_action (tree_column, + window, + background_area, + cell_area, + flags, + CELL_ACTION_FOCUS, + expose_area, + &focus_rectangle, + NULL, NULL, NULL); + + cell_state = flags & GTK_CELL_RENDERER_SELECTED ? GTK_STATE_SELECTED : + (flags & GTK_CELL_RENDERER_PRELIT ? GTK_STATE_PRELIGHT : + (flags & GTK_CELL_RENDERER_INSENSITIVE ? GTK_STATE_INSENSITIVE : GTK_STATE_NORMAL)); + gtk_paint_focus (tree_column->tree_view->style, + window, + cell_state, + NULL, + tree_column->tree_view, + "treeview", + focus_rectangle.x, + focus_rectangle.y, + focus_rectangle.width, + focus_rectangle.height); + } +} + +/** + * gtk_tree_view_column_cell_is_visible: + * @tree_column: A #GtkTreeViewColumn + * + * Returns #TRUE if any of the cells packed into the @tree_column are visible. + * For this to be meaningful, you must first initialize the cells with + * gtk_tree_view_column_cell_set_cell_data() + * + * Return value: #TRUE, if any of the cells packed into the @tree_column are currently visible + **/ +gboolean +gtk_tree_view_column_cell_is_visible (GtkTreeViewColumn *tree_column) +{ + GList *list; + + g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column), FALSE); + + for (list = tree_column->cell_list; list; list = list->next) + { + GtkTreeViewColumnCellInfo *info = (GtkTreeViewColumnCellInfo *) list->data; + + if (info->cell->visible) + return TRUE; + } + + return FALSE; +} + +/** + * gtk_tree_view_column_focus_cell: + * @tree_column: A #GtkTreeViewColumn + * @cell: A #GtkCellRenderer + * + * Sets the current keyboard focus to be at @cell, if the column contains + * 2 or more editable and activatable cells. + **/ +void +gtk_tree_view_column_focus_cell (GtkTreeViewColumn *tree_column, + GtkCellRenderer *cell) +{ + GList *list; + gboolean found_cell = FALSE; + + g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column)); + g_return_if_fail (GTK_IS_CELL_RENDERER (cell)); + + if (_gtk_tree_view_column_count_special_cells (tree_column) < 2) + return; + + for (list = tree_column->cell_list; list; list = list->next) + { + GtkTreeViewColumnCellInfo *info = list->data; + + if (info->cell == cell) + { + info->has_focus = TRUE; + found_cell = TRUE; + break; + } + } + + if (found_cell) + { + for (list = tree_column->cell_list; list; list = list->next) + { + GtkTreeViewColumnCellInfo *info = list->data; + + if (info->cell != cell) + info->has_focus = FALSE; + } + + /* FIXME: redraw? */ + } +} + +void +_gtk_tree_view_column_cell_set_dirty (GtkTreeViewColumn *tree_column, + gboolean install_handler) +{ + GList *list; + + for (list = tree_column->cell_list; list; list = list->next) + { + GtkTreeViewColumnCellInfo *info = (GtkTreeViewColumnCellInfo *) list->data; + + info->requested_width = 0; + } + tree_column->dirty = TRUE; + tree_column->resized_width = MAX (tree_column->requested_width, tree_column->button_request); + tree_column->requested_width = -1; + tree_column->width = 0; + + if (tree_column->tree_view && + GTK_WIDGET_REALIZED (tree_column->tree_view)) + { + if (install_handler) + _gtk_tree_view_install_mark_rows_col_dirty (GTK_TREE_VIEW (tree_column->tree_view)); + else + GTK_TREE_VIEW (tree_column->tree_view)->priv->mark_rows_col_dirty = TRUE; + gtk_widget_queue_resize (tree_column->tree_view); + } +} + +void +_gtk_tree_view_column_start_editing (GtkTreeViewColumn *tree_column, + GtkCellEditable *cell_editable) +{ + g_return_if_fail (tree_column->editable_widget == NULL); + + tree_column->editable_widget = cell_editable; +} + +void +_gtk_tree_view_column_stop_editing (GtkTreeViewColumn *tree_column) +{ + GList *list; + + g_return_if_fail (tree_column->editable_widget != NULL); + + tree_column->editable_widget = NULL; + for (list = tree_column->cell_list; list; list = list->next) + ((GtkTreeViewColumnCellInfo *)list->data)->in_editing_mode = FALSE; +} + +void +_gtk_tree_view_column_get_neighbor_sizes (GtkTreeViewColumn *column, + GtkCellRenderer *cell, + gint *left, + gint *right) +{ + GList *list; + + if (left) + { + *left = 0; + list = gtk_tree_view_column_cell_first (column); + + for (; list; list = gtk_tree_view_column_cell_next (column, list)) + { + GtkTreeViewColumnCellInfo *info = + (GtkTreeViewColumnCellInfo *)list->data; + + if (info->cell == cell) + break; + + *left += info->real_width; + } + } + + if (right) + { + GList *next; + + *right = 0; + list = gtk_tree_view_column_cell_first (column); + + for (; list; list = gtk_tree_view_column_cell_next (column, list)) + { + GtkTreeViewColumnCellInfo *info = + (GtkTreeViewColumnCellInfo *)list->data; + + if (info->cell == cell) + break; + } + + /* skip cell */ + next = gtk_tree_view_column_cell_next (column, list); + if (list && next) + { + list = next; + for ( ; list; list = gtk_tree_view_column_cell_next (column, list)) + { + GtkTreeViewColumnCellInfo *info = + (GtkTreeViewColumnCellInfo *)list->data; + + *right += info->real_width; + } + } + } +} + +gboolean +gtk_tree_view_column_cell_get_position (GtkTreeViewColumn *tree_column, + GtkCellRenderer *cell_renderer, + gint *start_pos, + gint *width) +{ + GList *list; + gint current_x = 0; + gboolean found_cell = FALSE; + GtkTreeViewColumnCellInfo *cellinfo; + + list = gtk_tree_view_column_cell_first (tree_column); + for (; list; list = gtk_tree_view_column_cell_next (tree_column, list)) + { + cellinfo = list->data; + if (cellinfo->cell == cell_renderer) + { + found_cell = TRUE; + break; + } + current_x += cellinfo->real_width; + } + + if (found_cell) + { + if (start_pos) + *start_pos = current_x; + if (width) + *width = cellinfo->real_width; + } + + return found_cell; +}