* Copyright (C) 1998 Lars Hamann and Stefan Jeske
*
* This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Library General Public
+ * modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Library General Public License for more details.
+ * Lesser General Public License for more details.
*
- * You should have received a copy of the GNU Library General Public
+ * You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
+/*
+ * Modified by the GTK+ Team and others 1997-2000. See the AUTHORS
+ * file for a list of people on the GTK+ Team. See the ChangeLog
+ * files for a list of changes. These files are distributed with
+ * GTK+ at ftp://ftp.gtk.org/pub/gtk/.
+ */
+
#include <stdlib.h>
#include "gtkctree.h"
#include "gtkbindings.h"
#include "gtkmain.h"
#include "gtkdnd.h"
-#include <gdk/gdkx.h>
#include <gdk/gdkkeysyms.h>
#define PM_SIZE 8
#define TAB_SIZE (PM_SIZE + 6)
#define CELL_SPACING 1
-#define CLIST_OPTIMUM_SIZE 512
+#define CLIST_OPTIMUM_SIZE 64
#define COLUMN_INSET 3
#define DRAG_WIDTH 6
return -1;
}
-#define GTK_CLIST_CLASS_FW(_widget_) GTK_CLIST_CLASS (((GtkObject*) (_widget_))->klass)
#define CLIST_UNFROZEN(clist) (((GtkCList*) (clist))->freeze_count == 0)
#define CLIST_REFRESH(clist) G_STMT_START { \
if (CLIST_UNFROZEN (clist)) \
- GTK_CLIST_CLASS_FW (clist)->refresh ((GtkCList*) (clist)); \
+ GTK_CLIST_GET_CLASS (clist)->refresh ((GtkCList*) (clist)); \
} G_STMT_END
};
-static void gtk_ctree_class_init (GtkCTreeClass *klass);
-static void gtk_ctree_init (GtkCTree *ctree);
+static void gtk_ctree_class_init (GtkCTreeClass *klass);
+static void gtk_ctree_init (GtkCTree *ctree);
+static GObject* gtk_ctree_constructor (GType type,
+ guint n_construct_properties,
+ GObjectConstructParam *construct_params);
static void gtk_ctree_set_arg (GtkObject *object,
GtkArg *arg,
guint arg_id);
guint info,
guint32 time);
static void remove_grab (GtkCList *clist);
+static void drag_dest_cell (GtkCList *clist,
+ gint x,
+ gint y,
+ GtkCListDestInfo *dest_info);
enum
static void
gtk_ctree_class_init (GtkCTreeClass *klass)
{
+ GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
GtkObjectClass *object_class;
GtkWidgetClass *widget_class;
GtkCListClass *clist_class;
+ GtkBindingSet *binding_set;
+
+ gobject_class->constructor = gtk_ctree_constructor;
object_class = (GtkObjectClass *) klass;
widget_class = (GtkWidgetClass *) klass;
parent_class = gtk_type_class (GTK_TYPE_CLIST);
container_class = gtk_type_class (GTK_TYPE_CONTAINER);
- gtk_object_add_arg_type ("GtkCTree::n_columns",
+ object_class->set_arg = gtk_ctree_set_arg;
+ object_class->get_arg = gtk_ctree_get_arg;
+
+ widget_class->realize = gtk_ctree_realize;
+ widget_class->unrealize = gtk_ctree_unrealize;
+ widget_class->button_press_event = gtk_ctree_button_press;
+
+ widget_class->drag_begin = gtk_ctree_drag_begin;
+ widget_class->drag_motion = gtk_ctree_drag_motion;
+ widget_class->drag_data_received = gtk_ctree_drag_data_received;
+
+ clist_class->select_row = real_select_row;
+ clist_class->unselect_row = real_unselect_row;
+ clist_class->row_move = real_row_move;
+ clist_class->undo_selection = real_undo_selection;
+ clist_class->resync_selection = resync_selection;
+ clist_class->selection_find = selection_find;
+ clist_class->click_column = NULL;
+ clist_class->draw_row = draw_row;
+ clist_class->draw_drag_highlight = draw_drag_highlight;
+ clist_class->clear = real_clear;
+ clist_class->select_all = real_select_all;
+ clist_class->unselect_all = real_unselect_all;
+ clist_class->fake_unselect_all = fake_unselect_all;
+ clist_class->insert_row = real_insert_row;
+ clist_class->remove_row = real_remove_row;
+ clist_class->sort_list = real_sort_list;
+ clist_class->set_cell_contents = set_cell_contents;
+ clist_class->cell_size_request = cell_size_request;
+
+ klass->tree_select_row = real_tree_select;
+ klass->tree_unselect_row = real_tree_unselect;
+ klass->tree_expand = real_tree_expand;
+ klass->tree_collapse = real_tree_collapse;
+ klass->tree_move = real_tree_move;
+ klass->change_focus_row_expansion = change_focus_row_expansion;
+
+ gtk_object_add_arg_type ("GtkCTree::n_columns", /* overrides GtkCList::n_columns!! */
GTK_TYPE_UINT,
GTK_ARG_READWRITE | GTK_ARG_CONSTRUCT_ONLY,
ARG_N_COLUMNS);
GTK_TYPE_CTREE_EXPANDER_STYLE,
GTK_ARG_READWRITE,
ARG_EXPANDER_STYLE);
- object_class->set_arg = gtk_ctree_set_arg;
- object_class->get_arg = gtk_ctree_get_arg;
ctree_signals[TREE_SELECT_ROW] =
gtk_signal_new ("tree_select_row",
GTK_RUN_FIRST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkCTreeClass, tree_select_row),
- gtk_marshal_NONE__POINTER_INT,
- GTK_TYPE_NONE, 2, GTK_TYPE_CTREE_NODE, GTK_TYPE_INT);
+ gtk_marshal_VOID__BOXED_INT,
+ GTK_TYPE_NONE, 2,
+ GTK_TYPE_CTREE_NODE | G_SIGNAL_TYPE_STATIC_SCOPE,
+ GTK_TYPE_INT);
ctree_signals[TREE_UNSELECT_ROW] =
gtk_signal_new ("tree_unselect_row",
GTK_RUN_FIRST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkCTreeClass, tree_unselect_row),
- gtk_marshal_NONE__POINTER_INT,
- GTK_TYPE_NONE, 2, GTK_TYPE_CTREE_NODE, GTK_TYPE_INT);
+ gtk_marshal_VOID__BOXED_INT,
+ GTK_TYPE_NONE, 2,
+ GTK_TYPE_CTREE_NODE | G_SIGNAL_TYPE_STATIC_SCOPE,
+ GTK_TYPE_INT);
ctree_signals[TREE_EXPAND] =
gtk_signal_new ("tree_expand",
GTK_RUN_LAST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkCTreeClass, tree_expand),
- gtk_marshal_NONE__POINTER,
- GTK_TYPE_NONE, 1, GTK_TYPE_CTREE_NODE);
+ gtk_marshal_VOID__BOXED,
+ GTK_TYPE_NONE, 1,
+ GTK_TYPE_CTREE_NODE | G_SIGNAL_TYPE_STATIC_SCOPE);
ctree_signals[TREE_COLLAPSE] =
gtk_signal_new ("tree_collapse",
GTK_RUN_LAST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkCTreeClass, tree_collapse),
- gtk_marshal_NONE__POINTER,
- GTK_TYPE_NONE, 1, GTK_TYPE_POINTER);
+ gtk_marshal_VOID__BOXED,
+ GTK_TYPE_NONE, 1,
+ GTK_TYPE_CTREE_NODE | G_SIGNAL_TYPE_STATIC_SCOPE);
ctree_signals[TREE_MOVE] =
gtk_signal_new ("tree_move",
GTK_RUN_LAST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkCTreeClass, tree_move),
- gtk_marshal_NONE__POINTER_POINTER_POINTER,
- GTK_TYPE_NONE, 3, GTK_TYPE_CTREE_NODE,
- GTK_TYPE_CTREE_NODE, GTK_TYPE_CTREE_NODE);
+ gtk_marshal_VOID__BOXED_BOXED_BOXED,
+ GTK_TYPE_NONE, 3,
+ GTK_TYPE_CTREE_NODE | G_SIGNAL_TYPE_STATIC_SCOPE,
+ GTK_TYPE_CTREE_NODE | G_SIGNAL_TYPE_STATIC_SCOPE,
+ GTK_TYPE_CTREE_NODE | G_SIGNAL_TYPE_STATIC_SCOPE);
ctree_signals[CHANGE_FOCUS_ROW_EXPANSION] =
gtk_signal_new ("change_focus_row_expansion",
GTK_RUN_LAST | GTK_RUN_ACTION,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkCTreeClass,
change_focus_row_expansion),
- gtk_marshal_NONE__ENUM,
+ gtk_marshal_VOID__ENUM,
GTK_TYPE_NONE, 1, GTK_TYPE_CTREE_EXPANSION_TYPE);
- gtk_object_class_add_signals (object_class, ctree_signals, LAST_SIGNAL);
-
- widget_class->realize = gtk_ctree_realize;
- widget_class->unrealize = gtk_ctree_unrealize;
- widget_class->button_press_event = gtk_ctree_button_press;
-
- widget_class->drag_begin = gtk_ctree_drag_begin;
- widget_class->drag_motion = gtk_ctree_drag_motion;
- widget_class->drag_data_received = gtk_ctree_drag_data_received;
-
- clist_class->select_row = real_select_row;
- clist_class->unselect_row = real_unselect_row;
- clist_class->row_move = real_row_move;
- clist_class->undo_selection = real_undo_selection;
- clist_class->resync_selection = resync_selection;
- clist_class->selection_find = selection_find;
- clist_class->click_column = NULL;
- clist_class->draw_row = draw_row;
- clist_class->draw_drag_highlight = draw_drag_highlight;
- clist_class->clear = real_clear;
- clist_class->select_all = real_select_all;
- clist_class->unselect_all = real_unselect_all;
- clist_class->fake_unselect_all = fake_unselect_all;
- clist_class->insert_row = real_insert_row;
- clist_class->remove_row = real_remove_row;
- clist_class->sort_list = real_sort_list;
- clist_class->set_cell_contents = set_cell_contents;
- clist_class->cell_size_request = cell_size_request;
-
- klass->tree_select_row = real_tree_select;
- klass->tree_unselect_row = real_tree_unselect;
- klass->tree_expand = real_tree_expand;
- klass->tree_collapse = real_tree_collapse;
- klass->tree_move = real_tree_move;
- klass->change_focus_row_expansion = change_focus_row_expansion;
-
- {
- GtkBindingSet *binding_set;
-
- binding_set = gtk_binding_set_by_class (klass);
- gtk_binding_entry_add_signal (binding_set,
- '+', GDK_SHIFT_MASK,
- "change_focus_row_expansion", 1,
- GTK_TYPE_ENUM, GTK_CTREE_EXPANSION_EXPAND);
- gtk_binding_entry_add_signal (binding_set,
- GDK_KP_Add, 0,
- "change_focus_row_expansion", 1,
- GTK_TYPE_ENUM, GTK_CTREE_EXPANSION_EXPAND);
- gtk_binding_entry_add_signal (binding_set,
- GDK_KP_Add, GDK_CONTROL_MASK,
- "change_focus_row_expansion", 1,
- GTK_TYPE_ENUM,
- GTK_CTREE_EXPANSION_EXPAND_RECURSIVE);
- gtk_binding_entry_add_signal (binding_set,
- '-', 0,
- "change_focus_row_expansion", 1,
- GTK_TYPE_ENUM, GTK_CTREE_EXPANSION_COLLAPSE);
- gtk_binding_entry_add_signal (binding_set,
- GDK_KP_Subtract, 0,
- "change_focus_row_expansion", 1,
- GTK_TYPE_ENUM, GTK_CTREE_EXPANSION_COLLAPSE);
- gtk_binding_entry_add_signal (binding_set,
- GDK_KP_Subtract, GDK_CONTROL_MASK,
- "change_focus_row_expansion", 1,
- GTK_TYPE_ENUM,
- GTK_CTREE_EXPANSION_COLLAPSE_RECURSIVE);
- gtk_binding_entry_add_signal (binding_set,
- '=', 0,
- "change_focus_row_expansion", 1,
- GTK_TYPE_ENUM, GTK_CTREE_EXPANSION_TOGGLE);
- gtk_binding_entry_add_signal (binding_set,
- GDK_KP_Multiply, 0,
- "change_focus_row_expansion", 1,
- GTK_TYPE_ENUM, GTK_CTREE_EXPANSION_TOGGLE);
- gtk_binding_entry_add_signal (binding_set,
- GDK_KP_Multiply, GDK_CONTROL_MASK,
- "change_focus_row_expansion", 1,
- GTK_TYPE_ENUM,
- GTK_CTREE_EXPANSION_TOGGLE_RECURSIVE);
- }
+ binding_set = gtk_binding_set_by_class (klass);
+ gtk_binding_entry_add_signal (binding_set,
+ GDK_plus, GDK_SHIFT_MASK,
+ "change_focus_row_expansion", 1,
+ GTK_TYPE_ENUM, GTK_CTREE_EXPANSION_EXPAND);
+ gtk_binding_entry_add_signal (binding_set,
+ GDK_plus, 0,
+ "change_focus_row_expansion", 1,
+ GTK_TYPE_ENUM, GTK_CTREE_EXPANSION_EXPAND);
+ gtk_binding_entry_add_signal (binding_set,
+ GDK_plus, GDK_CONTROL_MASK | GDK_SHIFT_MASK,
+ "change_focus_row_expansion", 1,
+ GTK_TYPE_ENUM, GTK_CTREE_EXPANSION_EXPAND_RECURSIVE);
+ gtk_binding_entry_add_signal (binding_set,
+ GDK_plus, GDK_CONTROL_MASK,
+ "change_focus_row_expansion", 1,
+ GTK_TYPE_ENUM, GTK_CTREE_EXPANSION_EXPAND_RECURSIVE);
+
+ gtk_binding_entry_add_signal (binding_set,
+ GDK_KP_Add, GDK_SHIFT_MASK,
+ "change_focus_row_expansion", 1,
+ GTK_TYPE_ENUM, GTK_CTREE_EXPANSION_EXPAND);
+ gtk_binding_entry_add_signal (binding_set,
+ GDK_KP_Add, 0,
+ "change_focus_row_expansion", 1,
+ GTK_TYPE_ENUM, GTK_CTREE_EXPANSION_EXPAND);
+ gtk_binding_entry_add_signal (binding_set,
+ GDK_KP_Add, GDK_CONTROL_MASK | GDK_SHIFT_MASK,
+ "change_focus_row_expansion", 1,
+ GTK_TYPE_ENUM, GTK_CTREE_EXPANSION_EXPAND_RECURSIVE);
+ gtk_binding_entry_add_signal (binding_set,
+ GDK_KP_Add, GDK_CONTROL_MASK,
+ "change_focus_row_expansion", 1,
+ GTK_TYPE_ENUM, GTK_CTREE_EXPANSION_EXPAND_RECURSIVE);
+
+ gtk_binding_entry_add_signal (binding_set,
+ GDK_minus, 0,
+ "change_focus_row_expansion", 1,
+ GTK_TYPE_ENUM, GTK_CTREE_EXPANSION_COLLAPSE);
+ gtk_binding_entry_add_signal (binding_set,
+ GDK_minus, GDK_CONTROL_MASK,
+ "change_focus_row_expansion", 1,
+ GTK_TYPE_ENUM,
+ GTK_CTREE_EXPANSION_COLLAPSE_RECURSIVE);
+ gtk_binding_entry_add_signal (binding_set,
+ GDK_KP_Subtract, 0,
+ "change_focus_row_expansion", 1,
+ GTK_TYPE_ENUM, GTK_CTREE_EXPANSION_COLLAPSE);
+ gtk_binding_entry_add_signal (binding_set,
+ GDK_KP_Subtract, GDK_CONTROL_MASK,
+ "change_focus_row_expansion", 1,
+ GTK_TYPE_ENUM,
+ GTK_CTREE_EXPANSION_COLLAPSE_RECURSIVE);
+ gtk_binding_entry_add_signal (binding_set,
+ GDK_equal, 0,
+ "change_focus_row_expansion", 1,
+ GTK_TYPE_ENUM, GTK_CTREE_EXPANSION_TOGGLE);
+ gtk_binding_entry_add_signal (binding_set,
+ GDK_KP_Equal, 0,
+ "change_focus_row_expansion", 1,
+ GTK_TYPE_ENUM, GTK_CTREE_EXPANSION_TOGGLE);
+ gtk_binding_entry_add_signal (binding_set,
+ GDK_equal, GDK_SHIFT_MASK,
+ "change_focus_row_expansion", 1,
+ GTK_TYPE_ENUM, GTK_CTREE_EXPANSION_TOGGLE);
+ gtk_binding_entry_add_signal (binding_set,
+ GDK_KP_Equal, GDK_SHIFT_MASK,
+ "change_focus_row_expansion", 1,
+ GTK_TYPE_ENUM, GTK_CTREE_EXPANSION_TOGGLE);
+ gtk_binding_entry_add_signal (binding_set,
+ GDK_KP_Multiply, 0,
+ "change_focus_row_expansion", 1,
+ GTK_TYPE_ENUM, GTK_CTREE_EXPANSION_TOGGLE);
+ gtk_binding_entry_add_signal (binding_set,
+ GDK_asterisk, 0,
+ "change_focus_row_expansion", 1,
+ GTK_TYPE_ENUM, GTK_CTREE_EXPANSION_TOGGLE);
+ gtk_binding_entry_add_signal (binding_set,
+ GDK_KP_Multiply, GDK_CONTROL_MASK,
+ "change_focus_row_expansion", 1,
+ GTK_TYPE_ENUM,
+ GTK_CTREE_EXPANSION_TOGGLE_RECURSIVE);
+ gtk_binding_entry_add_signal (binding_set,
+ GDK_asterisk, GDK_CONTROL_MASK,
+ "change_focus_row_expansion", 1,
+ GTK_TYPE_ENUM,
+ GTK_CTREE_EXPANSION_TOGGLE_RECURSIVE);
}
static void
guint arg_id)
{
GtkCTree *ctree;
+ GtkCList *clist;
ctree = GTK_CTREE (object);
+ clist = GTK_CLIST (ctree);
switch (arg_id)
{
- case ARG_N_COLUMNS: /* construct-only arg, only set when !GTK_CONSTRUCTED */
- if (ctree->tree_column)
- gtk_ctree_construct (ctree,
- MAX (1, GTK_VALUE_UINT (*arg)),
- ctree->tree_column, NULL);
- else
- GTK_CLIST (ctree)->columns = MAX (1, GTK_VALUE_UINT (*arg));
+ case ARG_N_COLUMNS: /* construct-only arg, only set at construction time */
+ g_return_if_fail (clist->row_mem_chunk == NULL);
+ clist->columns = MAX (1, GTK_VALUE_UINT (*arg));
+ clist->row_mem_chunk = g_mem_chunk_new ("ctree row mem chunk",
+ sizeof (GtkCTreeRow),
+ sizeof (GtkCTreeRow)
+ * CLIST_OPTIMUM_SIZE,
+ G_ALLOC_AND_FREE);
+ clist->cell_mem_chunk = g_mem_chunk_new ("ctree cell mem chunk",
+ sizeof (GtkCell) * clist->columns,
+ sizeof (GtkCell) * clist->columns
+ * CLIST_OPTIMUM_SIZE,
+ G_ALLOC_AND_FREE);
+ ctree->tree_column = CLAMP (ctree->tree_column, 0, clist->columns);
break;
- case ARG_TREE_COLUMN: /* construct-only arg, only set when !GTK_CONSTRUCTED */
- if (GTK_CLIST (ctree)->columns)
- gtk_ctree_construct (ctree,
- GTK_CLIST (ctree)->columns,
- MAX (1, GTK_VALUE_UINT (*arg)),
- NULL);
- else
- ctree->tree_column = MAX (1, GTK_VALUE_UINT (*arg));
+ case ARG_TREE_COLUMN: /* construct-only arg, only set at construction time */
+ ctree->tree_column = GTK_VALUE_UINT (*arg);
+ if (clist->row_mem_chunk)
+ ctree->tree_column = CLAMP (ctree->tree_column, 0, clist->columns);
break;
case ARG_INDENT:
gtk_ctree_set_indent (ctree, GTK_VALUE_UINT (*arg));
GtkCTreeNode *child;
gint i;
- g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_CTREE (widget));
GTK_WIDGET_CLASS (parent_class)->realize (widget);
if (ctree->line_style == GTK_CTREE_LINES_DOTTED)
{
gdk_gc_set_line_attributes (ctree->lines_gc, 1,
- GDK_LINE_ON_OFF_DASH, None, None);
+ GDK_LINE_ON_OFF_DASH, GDK_CAP_BUTT, GDK_JOIN_MITER);
gdk_gc_set_dashes (ctree->lines_gc, 0, "\1\1", 2);
}
}
GtkCTree *ctree;
GtkCList *clist;
- g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_CTREE (widget));
GTK_WIDGET_CLASS (parent_class)->unrealize (widget);
GtkCList *clist;
gint button_actions;
- g_return_val_if_fail (widget != NULL, FALSE);
g_return_val_if_fail (GTK_IS_CTREE (widget), FALSE);
g_return_val_if_fail (event != NULL, FALSE);
else
gtk_ctree_expand (ctree, work);
- return FALSE;
+ return TRUE;
}
}
+
return GTK_WIDGET_CLASS (parent_class)->button_press_event (widget, event);
}
gint i;
gint y = 0;
- g_return_if_fail (clist != NULL);
g_return_if_fail (GTK_IS_CTREE (clist));
ctree = GTK_CTREE (clist);
if (width > 0 && height > 0)
gdk_draw_pixmap (window, fg_gc, pixmap, xsrc, ysrc, x, y, width, height);
-
- gdk_gc_set_clip_origin (fg_gc, 0, 0);
+
+ if (mask)
+ {
+ gdk_gc_set_clip_rectangle (fg_gc, NULL);
+ gdk_gc_set_clip_origin (fg_gc, 0, 0);
+ }
return x + MAX (width, 0);
}
GdkRectangle cell_rectangle;
GdkRectangle clip_rectangle;
GdkRectangle intersect_rectangle;
+ gint last_column;
gint column_left = 0;
gint column_right = 0;
gint offset = 0;
cell_rectangle.width = row_rectangle.width;
cell_rectangle.height = CELL_SPACING;
- /* rectangle used to clip drawing operations, it's y and height
+ /* rectangle used to clip drawing operations, its y and height
* positions only need to be set once, so we set them once here.
* the x and width are set withing the drawing loop below once per
* column */
if (gdk_rectangle_intersect (area, &cell_rectangle, crect))
gdk_draw_rectangle (clist->clist_window,
- widget->style->base_gc[GTK_STATE_ACTIVE], TRUE,
+ widget->style->base_gc[GTK_STATE_NORMAL], TRUE,
crect->x, crect->y, crect->width, crect->height);
}
else
crect = &cell_rectangle;
gdk_draw_rectangle (clist->clist_window,
- widget->style->base_gc[GTK_STATE_ACTIVE], TRUE,
+ widget->style->base_gc[GTK_STATE_NORMAL], TRUE,
crect->x, crect->y, crect->width, crect->height);
}
}
}
- /* the last row has to clear it's bottom cell spacing too */
+ /* the last row has to clear its bottom cell spacing too */
if (clist_row == clist->row_list_end->data)
{
cell_rectangle.y += clist->row_height + CELL_SPACING;
if (!area || gdk_rectangle_intersect (area, &cell_rectangle, crect))
{
gdk_draw_rectangle (clist->clist_window,
- widget->style->base_gc[GTK_STATE_ACTIVE], TRUE,
+ widget->style->base_gc[GTK_STATE_NORMAL], TRUE,
crect->x, crect->y, crect->width, crect->height);
/* horizontal black lines */
}
}
+ for (last_column = clist->columns - 1;
+ last_column >= 0 && !clist->column[last_column].visible; last_column--)
+ ;
+
/* iterate and draw all the columns (row cells) and draw their contents */
for (i = 0; i < clist->columns; i++)
{
GtkStyle *style;
GdkGC *fg_gc;
GdkGC *bg_gc;
+ PangoLayout *layout = NULL;
+ PangoRectangle logical_rect;
gint width;
gint height;
gint pixmap_width;
gint string_width;
gint old_offset;
- gint row_center_offset;
if (!clist->column[i].visible)
continue;
cell_rectangle.x = clip_rectangle.x - COLUMN_INSET - CELL_SPACING;
cell_rectangle.width = (clip_rectangle.width + 2 * COLUMN_INSET +
- (1 + (i + 1 == clist->columns)) * CELL_SPACING);
+ (1 + (i == last_column)) * CELL_SPACING);
cell_rectangle.y = clip_rectangle.y;
cell_rectangle.height = clip_rectangle.height;
gdk_draw_rectangle (clist->clist_window, bg_gc, TRUE,
crect->x, crect->y, crect->width, crect->height);
- /* calculate real width for column justification */
+
+ layout = _gtk_clist_create_cell_layout (clist, clist_row, i);
+ if (layout)
+ {
+ pango_layout_get_pixel_extents (layout, NULL, &logical_rect);
+ width = logical_rect.width;
+ }
+ else
+ width = 0;
+
switch (clist_row->cell[i].type)
{
- case GTK_CELL_TEXT:
- width = gdk_string_width
- (style->font, GTK_CELL_TEXT (clist_row->cell[i])->text);
- break;
case GTK_CELL_PIXMAP:
gdk_window_get_size
(GTK_CELL_PIXMAP (clist_row->cell[i])->pixmap, &pixmap_width,
&height);
- width = pixmap_width;
+ width += pixmap_width;
break;
case GTK_CELL_PIXTEXT:
if (GTK_CELL_PIXTEXT (clist_row->cell[i])->pixmap)
- gdk_window_get_size
- (GTK_CELL_PIXTEXT (clist_row->cell[i])->pixmap,
- &pixmap_width, &height);
-
- width = pixmap_width;
-
- if (GTK_CELL_PIXTEXT (clist_row->cell[i])->text)
{
- string_width = gdk_string_width
- (style->font, GTK_CELL_PIXTEXT (clist_row->cell[i])->text);
- width += string_width;
+ gdk_window_get_size
+ (GTK_CELL_PIXTEXT (clist_row->cell[i])->pixmap,
+ &pixmap_width, &height);
+ width += pixmap_width;
}
if (GTK_CELL_PIXTEXT (clist_row->cell[i])->text &&
((GtkCTreeRow *)clist_row)->level);
break;
default:
- continue;
break;
}
(clip_rectangle.height - height) / 2,
pixmap_width, height);
offset += GTK_CELL_PIXTEXT (clist_row->cell[i])->spacing;
- case GTK_CELL_TEXT:
- if (style != GTK_WIDGET (clist)->style)
- row_center_offset = (((clist->row_height -
- style->font->ascent -
- style->font->descent - 1) / 2) +
- 1.5 + style->font->ascent);
- else
- row_center_offset = clist->row_center_offset;
- gdk_gc_set_clip_rectangle (fg_gc, &clip_rectangle);
- gdk_draw_string
- (clist->clist_window, style->font, fg_gc,
- offset,
- row_rectangle.y + row_center_offset +
- clist_row->cell[i].vertical,
- (clist_row->cell[i].type == GTK_CELL_PIXTEXT) ?
- GTK_CELL_PIXTEXT (clist_row->cell[i])->text :
- GTK_CELL_TEXT (clist_row->cell[i])->text);
- gdk_gc_set_clip_rectangle (fg_gc, NULL);
+ /* Fall through */
+ case GTK_CELL_TEXT:
+ if (layout)
+ {
+ gint row_center_offset = 1.5 + (clist->row_height - logical_rect.height - 1) / 2;
+
+ gdk_gc_set_clip_rectangle (fg_gc, &clip_rectangle);
+ gdk_draw_layout (clist->clist_window, fg_gc,
+ offset,
+ row_rectangle.y + row_center_offset + clist_row->cell[i].vertical,
+ layout);
+ gdk_gc_set_clip_rectangle (fg_gc, NULL);
+ g_object_unref (G_OBJECT (layout));
+ }
break;
default:
break;
if (area && !gdk_rectangle_intersect (area, &cell_rectangle,
&intersect_rectangle))
- continue;
+ {
+ if (layout)
+ g_object_unref (G_OBJECT (layout));
+ continue;
+ }
/* draw lines */
offset = gtk_ctree_draw_lines (ctree, (GtkCTreeRow *)clist_row, row, i,
+ (clip_rectangle.height - height) / 2,
pixmap_width, height);
- if (string_width)
- {
+ if (layout)
+ {
+ gint row_center_offset = 1.5 + (clist->row_height - logical_rect.height - 1) / 2;
+
if (clist->column[i].justification == GTK_JUSTIFY_RIGHT)
{
offset = (old_offset - string_width);
if (GTK_CELL_PIXTEXT (clist_row->cell[i])->pixmap)
offset += GTK_CELL_PIXTEXT (clist_row->cell[i])->spacing;
}
-
- if (style != GTK_WIDGET (clist)->style)
- row_center_offset = (((clist->row_height - style->font->ascent -
- style->font->descent - 1) / 2) +
- 1.5 + style->font->ascent);
- else
- row_center_offset = clist->row_center_offset;
gdk_gc_set_clip_rectangle (fg_gc, &clip_rectangle);
- gdk_draw_string (clist->clist_window, style->font, fg_gc, offset,
- row_rectangle.y + row_center_offset +
- clist_row->cell[i].vertical,
- GTK_CELL_PIXTEXT (clist_row->cell[i])->text);
+ gdk_draw_layout (clist->clist_window, fg_gc,
+ offset,
+ row_rectangle.y + row_center_offset + clist_row->cell[i].vertical,
+ layout);
+
+ g_object_unref (G_OBJECT (layout));
}
gdk_gc_set_clip_rectangle (fg_gc, NULL);
}
/* draw focus rectangle */
- if (clist->focus_row == row && GTK_WIDGET_HAS_FOCUS (widget))
+ if (clist->focus_row == row &&
+ GTK_WIDGET_CAN_FOCUS (widget) && GTK_WIDGET_HAS_FOCUS (widget))
{
if (!area)
gdk_draw_rectangle (clist->clist_window, clist->xor_gc, FALSE,
num++;
}
if (work && gtk_clist_row_is_visible (clist, num) != GTK_VISIBILITY_NONE)
- GTK_CLIST_CLASS_FW (clist)->draw_row
+ GTK_CLIST_GET_CLASS (clist)->draw_row
(clist, NULL, num, GTK_CLIST_ROW ((GList *) node));
}
}
clist = GTK_CLIST (ctree);
- if (update_focus_row && clist->selection_mode == GTK_SELECTION_EXTENDED)
+ if (update_focus_row && clist->selection_mode == GTK_SELECTION_MULTIPLE)
{
- if (clist->anchor != -1)
- GTK_CLIST_CLASS_FW (clist)->resync_selection (clist, NULL);
+ GTK_CLIST_GET_CLASS (clist)->resync_selection (clist, NULL);
g_list_free (clist->undo_selection);
g_list_free (clist->undo_unselection);
GtkCTreeNode *parent;
GList *list;
- g_return_if_fail (ctree != NULL);
g_return_if_fail (GTK_IS_CTREE (ctree));
g_return_if_fail (node != NULL);
clist = GTK_CLIST (ctree);
- if (update_focus_row && clist->selection_mode == GTK_SELECTION_EXTENDED)
+ if (update_focus_row && clist->selection_mode == GTK_SELECTION_MULTIPLE)
{
- if (clist->anchor != -1)
- GTK_CLIST_CLASS_FW (clist)->resync_selection (clist, NULL);
+ GTK_CLIST_GET_CLASS (clist)->resync_selection (clist, NULL);
g_list_free (clist->undo_selection);
g_list_free (clist->undo_unselection);
GtkCTree *ctree;
GtkCTreeNode *node;
- g_return_if_fail (clist != NULL);
g_return_if_fail (GTK_IS_CTREE (clist));
if (GTK_CLIST_AUTO_SORT (clist))
visible = gtk_ctree_is_viewable (ctree, node);
- if (clist->selection_mode == GTK_SELECTION_EXTENDED)
+ if (clist->selection_mode == GTK_SELECTION_MULTIPLE)
{
- if (clist->anchor != -1)
- GTK_CLIST_CLASS_FW (clist)->resync_selection (clist, NULL);
+ GTK_CLIST_GET_CLASS (clist)->resync_selection (clist, NULL);
g_list_free (clist->undo_selection);
g_list_free (clist->undo_unselection);
gtk_clist_freeze (clist);
work = NULL;
- if (gtk_ctree_is_viewable (ctree, node) ||
- gtk_ctree_is_viewable (ctree, new_sibling))
+ if (gtk_ctree_is_viewable (ctree, node))
work = GTK_CTREE_NODE (g_list_nth (clist->row_list, clist->focus_row));
gtk_ctree_unlink (ctree, node, FALSE);
GtkCList *clist;
GtkCTreeNode *node;
- g_return_if_fail (ctree != NULL);
g_return_if_fail (GTK_IS_CTREE (ctree));
clist = GTK_CLIST (ctree);
gboolean visible;
gint level;
- g_return_if_fail (ctree != NULL);
g_return_if_fail (GTK_IS_CTREE (ctree));
if (!node || GTK_CTREE_ROW (node)->expanded || GTK_CTREE_ROW (node)->is_leaf)
clist = GTK_CLIST (ctree);
- if (clist->selection_mode == GTK_SELECTION_EXTENDED && clist->anchor >= 0)
- GTK_CLIST_CLASS_FW (clist)->resync_selection (clist, NULL);
+ GTK_CLIST_GET_CLASS (clist)->resync_selection (clist, NULL);
GTK_CTREE_ROW (node)->expanded = TRUE;
level = GTK_CTREE_ROW (node)->level;
/* get cell width if tree_column is auto resized */
if (visible && clist->column[ctree->tree_column].auto_resize &&
!GTK_CLIST_AUTO_RESIZE_BLOCKED (clist))
- GTK_CLIST_CLASS_FW (clist)->cell_size_request
+ GTK_CLIST_GET_CLASS (clist)->cell_size_request
(clist, >K_CTREE_ROW (node)->row, ctree->tree_column, &requisition);
/* unref/unset closed pixmap */
for (i = 0; i < clist->columns; i++)
if (clist->column[i].auto_resize)
{
- GTK_CLIST_CLASS_FW (clist)->cell_size_request
+ GTK_CLIST_GET_CLASS (clist)->cell_size_request
(clist, >K_CTREE_ROW (work)->row, i, &requisition);
cell_width[i] = MAX (requisition.width, cell_width[i]);
}
gboolean visible;
gint level;
- g_return_if_fail (ctree != NULL);
g_return_if_fail (GTK_IS_CTREE (ctree));
if (!node || !GTK_CTREE_ROW (node)->expanded ||
clist = GTK_CLIST (ctree);
- if (clist->selection_mode == GTK_SELECTION_EXTENDED && clist->anchor >= 0)
- GTK_CLIST_CLASS_FW (clist)->resync_selection (clist, NULL);
+ GTK_CLIST_GET_CLASS (clist)->resync_selection (clist, NULL);
GTK_CTREE_ROW (node)->expanded = FALSE;
level = GTK_CTREE_ROW (node)->level;
/* get cell width if tree_column is auto resized */
if (visible && clist->column[ctree->tree_column].auto_resize &&
!GTK_CLIST_AUTO_RESIZE_BLOCKED (clist))
- GTK_CLIST_CLASS_FW (clist)->cell_size_request
+ GTK_CLIST_GET_CLASS (clist)->cell_size_request
(clist, >K_CTREE_ROW (node)->row, ctree->tree_column, &requisition);
/* unref/unset opened pixmap */
return;
if (clist_row)
- GTK_CLIST_CLASS_FW (clist)->cell_size_request (clist, clist_row,
+ GTK_CLIST_GET_CLASS (clist)->cell_size_request (clist, clist_row,
column, &requisition);
else
requisition.width = 0;
for (list = clist->row_list; list; list = list->next)
{
- GTK_CLIST_CLASS_FW (clist)->cell_size_request
+ GTK_CLIST_GET_CLASS (clist)->cell_size_request
(clist, GTK_CLIST_ROW (list), column, &requisition);
new_width = MAX (new_width, requisition.width);
if (new_width == clist->column[column].width)
GtkRequisition *requisition)
{
GtkCTree *ctree;
- GtkStyle *style;
gint width;
gint height;
+ PangoLayout *layout;
+ PangoRectangle logical_rect;
- g_return_if_fail (clist != NULL);
g_return_if_fail (GTK_IS_CTREE (clist));
g_return_if_fail (requisition != NULL);
ctree = GTK_CTREE (clist);
- get_cell_style (clist, clist_row, GTK_STATE_NORMAL, column, &style,
- NULL, NULL);
+ layout = _gtk_clist_create_cell_layout (clist, clist_row, column);
+ if (layout)
+ {
+ pango_layout_get_pixel_extents (layout, NULL, &logical_rect);
+
+ requisition->width = logical_rect.width;
+ requisition->height = logical_rect.height;
+
+ g_object_unref (G_OBJECT (layout));
+ }
+ else
+ {
+ requisition->width = 0;
+ requisition->height = 0;
+ }
switch (clist_row->cell[column].type)
{
- case GTK_CELL_TEXT:
- requisition->width =
- gdk_string_width (style->font,
- GTK_CELL_TEXT (clist_row->cell[column])->text);
- requisition->height = style->font->ascent + style->font->descent;
- break;
case GTK_CELL_PIXTEXT:
if (GTK_CELL_PIXTEXT (clist_row->cell[column])->pixmap)
{
else
width = height = 0;
- requisition->width = width +
- gdk_string_width (style->font,
- GTK_CELL_TEXT (clist_row->cell[column])->text);
-
- requisition->height = MAX (style->font->ascent + style->font->descent,
- height);
+ requisition->width += width;
+ requisition->height = MAX (requisition->height, height);
+
if (column == ctree->tree_column)
{
requisition->width += (ctree->tree_spacing + ctree->tree_indent *
case GTK_CELL_PIXMAP:
gdk_window_get_size (GTK_CELL_PIXMAP (clist_row->cell[column])->pixmap,
&width, &height);
- requisition->width = width;
- requisition->height = height;
+ requisition->width += width;
+ requisition->height = MAX (requisition->height, height);
break;
default:
requisition->width = 0;
gboolean visible = FALSE;
GtkCTree *ctree;
GtkRequisition requisition;
+ gchar *old_text = NULL;
+ GdkPixmap *old_pixmap = NULL;
+ GdkBitmap *old_mask = NULL;
- g_return_if_fail (clist != NULL);
g_return_if_fail (GTK_IS_CTREE (clist));
g_return_if_fail (clist_row != NULL);
gtk_ctree_is_viewable (ctree, parent)))
{
visible = TRUE;
- GTK_CLIST_CLASS_FW (clist)->cell_size_request (clist, clist_row,
+ GTK_CLIST_GET_CLASS (clist)->cell_size_request (clist, clist_row,
column, &requisition);
}
}
{
case GTK_CELL_EMPTY:
break;
-
case GTK_CELL_TEXT:
- g_free (GTK_CELL_TEXT (clist_row->cell[column])->text);
+ old_text = GTK_CELL_TEXT (clist_row->cell[column])->text;
break;
case GTK_CELL_PIXMAP:
- gdk_pixmap_unref (GTK_CELL_PIXMAP (clist_row->cell[column])->pixmap);
- if (GTK_CELL_PIXMAP (clist_row->cell[column])->mask)
- gdk_bitmap_unref (GTK_CELL_PIXMAP (clist_row->cell[column])->mask);
+ old_pixmap = GTK_CELL_PIXMAP (clist_row->cell[column])->pixmap;
+ old_mask = GTK_CELL_PIXMAP (clist_row->cell[column])->mask;
break;
case GTK_CELL_PIXTEXT:
- if (GTK_CELL_PIXTEXT (clist_row->cell[column])->text)
- g_free (GTK_CELL_PIXTEXT (clist_row->cell[column])->text);
- if (GTK_CELL_PIXTEXT (clist_row->cell[column])->pixmap)
- {
- gdk_pixmap_unref
- (GTK_CELL_PIXTEXT (clist_row->cell[column])->pixmap);
- if (GTK_CELL_PIXTEXT (clist_row->cell[column])->mask)
- gdk_bitmap_unref
- (GTK_CELL_PIXTEXT (clist_row->cell[column])->mask);
- }
+ old_text = GTK_CELL_PIXTEXT (clist_row->cell[column])->text;
+ old_pixmap = GTK_CELL_PIXTEXT (clist_row->cell[column])->pixmap;
+ old_mask = GTK_CELL_PIXTEXT (clist_row->cell[column])->mask;
break;
case GTK_CELL_WIDGET:
/* unimplimented */
if (column == ctree->tree_column && type != GTK_CELL_EMPTY)
type = GTK_CELL_PIXTEXT;
+ /* Note that pixmap and mask were already ref'ed by the caller
+ */
switch (type)
{
case GTK_CELL_TEXT:
if (visible && clist->column[column].auto_resize &&
!GTK_CLIST_AUTO_RESIZE_BLOCKED (clist))
column_auto_resize (clist, clist_row, column, requisition.width);
+
+ if (old_text)
+ g_free (old_text);
+ if (old_pixmap)
+ gdk_pixmap_unref (old_pixmap);
+ if (old_mask)
+ gdk_pixmap_unref (old_mask);
}
static void
GtkCTreeNode *node,
gpointer data)
{
- GtkCList *clist;
-
- clist = GTK_CLIST (ctree);
-
- if (GTK_CTREE_ROW (node)->row.state == GTK_STATE_SELECTED)
- {
- GList *work;
-
- work = g_list_find (clist->selection, node);
- if (work)
- {
- if (clist->selection_end && clist->selection_end == work)
- clist->selection_end = clist->selection_end->prev;
- clist->selection = g_list_remove_link (clist->selection, work);
- g_list_free_1 (work);
- }
- }
-
+ tree_unselect (ctree, node, NULL);
row_delete (ctree, GTK_CTREE_ROW (node));
g_list_free_1 ((GList *)node);
}
for (i = 0; i < clist->columns; i++)
{
- GTK_CLIST_CLASS_FW (clist)->set_cell_contents
+ GTK_CLIST_GET_CLASS (clist)->set_cell_contents
(clist, &(ctree_row->row), i, GTK_CELL_EMPTY, NULL, 0, NULL, NULL);
if (ctree_row->row.cell[i].style)
{
if (GTK_WIDGET_REALIZED (ctree))
gtk_style_detach (ctree_row->row.cell[i].style);
- gtk_style_unref (ctree_row->row.cell[i].style);
+ g_object_unref (ctree_row->row.cell[i].style);
}
}
{
if (GTK_WIDGET_REALIZED (ctree))
gtk_style_detach (ctree_row->row.style);
- gtk_style_unref (ctree_row->row.style);
+ g_object_unref (ctree_row->row.style);
}
if (ctree_row->pixmap_closed)
}
if (ctree_row->row.destroy)
- ctree_row->row.destroy (ctree_row->row.data);
+ {
+ GtkDestroyNotify dnotify = ctree_row->row.destroy;
+ gpointer ddata = ctree_row->row.data;
+
+ ctree_row->row.destroy = NULL;
+ ctree_row->row.data = NULL;
+
+ dnotify (ddata);
+ }
g_mem_chunk_free (clist->cell_mem_chunk, ctree_row->row.cell);
g_mem_chunk_free (clist->row_mem_chunk, ctree_row);
{
GList *node;
- g_return_if_fail (clist != NULL);
g_return_if_fail (GTK_IS_CTREE (clist));
if ((node = g_list_nth (clist->row_list, row)) &&
{
GList *node;
- g_return_if_fail (clist != NULL);
g_return_if_fail (GTK_IS_CTREE (clist));
if ((node = g_list_nth (clist->row_list, row)))
GtkCTreeNode *sel_row;
gboolean node_selected;
- g_return_if_fail (ctree != NULL);
g_return_if_fail (GTK_IS_CTREE (ctree));
if (!node || GTK_CTREE_ROW (node)->row.state == GTK_STATE_SELECTED ||
{
GtkCList *clist;
- g_return_if_fail (ctree != NULL);
g_return_if_fail (GTK_IS_CTREE (ctree));
if (!node || GTK_CTREE_ROW (node)->row.state != GTK_STATE_SELECTED)
GtkCTree *ctree;
GtkCTreeNode *node;
- g_return_if_fail (clist != NULL);
g_return_if_fail (GTK_IS_CTREE (clist));
ctree = GTK_CTREE (clist);
case GTK_SELECTION_BROWSE:
return;
- case GTK_SELECTION_EXTENDED:
+ case GTK_SELECTION_MULTIPLE:
gtk_clist_freeze (clist);
gtk_clist_thaw (clist);
break;
- case GTK_SELECTION_MULTIPLE:
- gtk_ctree_select_recursive (ctree, NULL);
- break;
-
default:
/* do nothing */
break;
GtkCTreeNode *node;
GList *list;
- g_return_if_fail (clist != NULL);
g_return_if_fail (GTK_IS_CTREE (clist));
ctree = GTK_CTREE (clist);
}
break;
- case GTK_SELECTION_EXTENDED:
+ case GTK_SELECTION_MULTIPLE:
g_list_free (clist->undo_selection);
g_list_free (clist->undo_unselection);
clist->undo_selection = NULL;
gint xl;
gint yu;
- g_return_val_if_fail (ctree != NULL, FALSE);
g_return_val_if_fail (GTK_IS_CTREE (ctree), FALSE);
g_return_val_if_fail (node != NULL, FALSE);
tree_row = GTK_CTREE_ROW (node);
- cell = GTK_CELL_PIXTEXT(tree_row->row.cell[ctree->tree_column]);
+ cell = GTK_CELL_PIXTEXT (tree_row->row.cell[ctree->tree_column]);
yu = (ROW_TOP_YPIXEL (clist, row) + (clist->row_height - PM_SIZE) / 2 -
(clist->row_height - 1) % 2);
* Creation, insertion, deletion *
***********************************************************/
-void
-gtk_ctree_construct (GtkCTree *ctree,
- gint columns,
- gint tree_column,
- gchar *titles[])
+static GObject*
+gtk_ctree_constructor (GType type,
+ guint n_construct_properties,
+ GObjectConstructParam *construct_properties)
{
- GtkCList *clist;
-
- g_return_if_fail (ctree != NULL);
- g_return_if_fail (GTK_IS_CTREE (ctree));
- g_return_if_fail (GTK_OBJECT_CONSTRUCTED (ctree) == FALSE);
+ GObject *object = G_OBJECT_CLASS (parent_class)->constructor (type,
+ n_construct_properties,
+ construct_properties);
- clist = GTK_CLIST (ctree);
-
- clist->row_mem_chunk = g_mem_chunk_new ("ctree row mem chunk",
- sizeof (GtkCTreeRow),
- sizeof (GtkCTreeRow)
- * CLIST_OPTIMUM_SIZE,
- G_ALLOC_AND_FREE);
-
- clist->cell_mem_chunk = g_mem_chunk_new ("ctree cell mem chunk",
- sizeof (GtkCell) * columns,
- sizeof (GtkCell) * columns
- * CLIST_OPTIMUM_SIZE,
- G_ALLOC_AND_FREE);
-
- ctree->tree_column = tree_column;
-
- gtk_clist_construct (clist, columns, titles);
+ return object;
}
-GtkWidget *
+GtkWidget*
gtk_ctree_new_with_titles (gint columns,
gint tree_column,
gchar *titles[])
g_return_val_if_fail (columns > 0, NULL);
g_return_val_if_fail (tree_column >= 0 && tree_column < columns, NULL);
- widget = gtk_type_new (GTK_TYPE_CTREE);
- gtk_ctree_construct (GTK_CTREE (widget), columns, tree_column, titles);
+ widget = gtk_widget_new (GTK_TYPE_CTREE,
+ "n_columns", columns,
+ "tree_column", tree_column,
+ NULL);
+ if (titles)
+ {
+ GtkCList *clist = GTK_CLIST (widget);
+ guint i;
+
+ for (i = 0; i < columns; i++)
+ gtk_clist_set_column_title (clist, i, titles[i]);
+ gtk_clist_column_titles_show (clist);
+ }
return widget;
}
GtkCTreeNode *sibling;
GtkCTreeNode *node;
- g_return_val_if_fail (clist != NULL, -1);
g_return_val_if_fail (GTK_IS_CTREE (clist), -1);
sibling = GTK_CTREE_NODE (g_list_nth (clist->row_list, row));
GList *list;
gint i;
- g_return_val_if_fail (ctree != NULL, NULL);
g_return_val_if_fail (GTK_IS_CTREE (ctree), NULL);
if (sibling)
g_return_val_if_fail (GTK_CTREE_ROW (sibling)->parent == parent, NULL);
if (text)
for (i = 0; i < clist->columns; i++)
if (text[i] && i != ctree->tree_column)
- GTK_CLIST_CLASS_FW (clist)->set_cell_contents
+ GTK_CLIST_GET_CLASS (clist)->set_cell_contents
(clist, &(new_row->row), i, GTK_CELL_TEXT, text[i], 0, NULL, NULL);
set_node_info (ctree, node, text ?
GNode *work;
guint depth = 1;
- g_return_val_if_fail (ctree != NULL, NULL);
g_return_val_if_fail (GTK_IS_CTREE (ctree), NULL);
g_return_val_if_fail (gnode != NULL, NULL);
g_return_val_if_fail (func != NULL, NULL);
if (!func (ctree, depth, gnode, cnode, data))
{
tree_delete_row (ctree, cnode, NULL);
+ gtk_clist_thaw (clist);
return NULL;
}
GNode *gnode;
gint depth;
- g_return_val_if_fail (ctree != NULL, NULL);
g_return_val_if_fail (GTK_IS_CTREE (ctree), NULL);
g_return_val_if_fail (node != NULL, NULL);
g_return_val_if_fail (func != NULL, NULL);
{
GtkCTreeNode *node;
- g_return_if_fail (clist != NULL);
g_return_if_fail (GTK_IS_CTREE (clist));
node = GTK_CTREE_NODE (g_list_nth (clist->row_list, row));
{
GtkCList *clist;
- g_return_if_fail (ctree != NULL);
g_return_if_fail (GTK_IS_CTREE (ctree));
clist = GTK_CLIST (ctree);
gtk_ctree_unlink (ctree, node, TRUE);
gtk_ctree_post_recursive (ctree, node, GTK_CTREE_FUNC (tree_delete),
NULL);
- if ((clist->selection_mode == GTK_SELECTION_BROWSE ||
- clist->selection_mode == GTK_SELECTION_EXTENDED) &&
- !clist->selection && clist->focus_row >= 0)
+ if (clist->selection_mode == GTK_SELECTION_BROWSE && !clist->selection &&
+ clist->focus_row >= 0)
gtk_clist_select_row (clist, clist->focus_row, -1);
auto_resize_columns (clist);
GtkCTreeNode *work;
GtkCTreeNode *ptr;
- g_return_if_fail (clist != NULL);
g_return_if_fail (GTK_IS_CTREE (clist));
ctree = GTK_CTREE (clist);
GtkCTreeNode *work;
GtkCTreeNode *tmp;
- g_return_if_fail (ctree != NULL);
g_return_if_fail (GTK_IS_CTREE (ctree));
g_return_if_fail (func != NULL);
GtkCTreeNode *work;
GtkCTreeNode *tmp;
- g_return_if_fail (ctree != NULL);
g_return_if_fail (GTK_IS_CTREE (ctree));
g_return_if_fail (func != NULL);
GtkCTreeNode *work;
GtkCTreeNode *tmp;
- g_return_if_fail (ctree != NULL);
g_return_if_fail (GTK_IS_CTREE (ctree));
g_return_if_fail (func != NULL);
GtkCTreeNode *work;
GtkCTreeNode *tmp;
- g_return_if_fail (ctree != NULL);
g_return_if_fail (GTK_IS_CTREE (ctree));
g_return_if_fail (func != NULL);
{
GtkCTreeRow *work;
- g_return_val_if_fail (ctree != NULL, FALSE);
g_return_val_if_fail (GTK_IS_CTREE (ctree), FALSE);
g_return_val_if_fail (node != NULL, FALSE);
gtk_ctree_last (GtkCTree *ctree,
GtkCTreeNode *node)
{
- g_return_val_if_fail (ctree != NULL, NULL);
g_return_val_if_fail (GTK_IS_CTREE (ctree), NULL);
if (!node)
{
GtkCTreeNode *node;
- g_return_val_if_fail (ctree != NULL, FALSE);
g_return_val_if_fail (GTK_IS_CTREE (ctree), FALSE);
g_return_val_if_fail (ctree_row != NULL, FALSE);
if (ctree_row->parent)
- node = GTK_CTREE_ROW(ctree_row->parent)->children;
+ node = GTK_CTREE_ROW (ctree_row->parent)->children;
else
node = GTK_CTREE_NODE (GTK_CLIST (ctree)->row_list);
gtk_ctree_node_nth (GtkCTree *ctree,
guint row)
{
- g_return_val_if_fail (ctree != NULL, NULL);
g_return_val_if_fail (GTK_IS_CTREE (ctree), NULL);
if ((row < 0) || (row >= GTK_CLIST(ctree)->rows))
GtkCTreeNode *node,
GtkCTreeNode *child)
{
+ g_return_val_if_fail (GTK_IS_CTREE (ctree), FALSE);
g_return_val_if_fail (node != NULL, FALSE);
- return gtk_ctree_find (ctree, GTK_CTREE_ROW (node)->children, child);
+ if (GTK_CTREE_ROW (node)->children)
+ return gtk_ctree_find (ctree, GTK_CTREE_ROW (node)->children, child);
+
+ return FALSE;
}
GtkCTreeNode *
{
GList *list = NULL;
- g_return_val_if_fail (ctree != NULL, NULL);
g_return_val_if_fail (GTK_IS_CTREE (ctree), NULL);
/* if node == NULL then look in the whole tree */
{
GList *list = NULL;
- g_return_val_if_fail (ctree != NULL, NULL);
g_return_val_if_fail (GTK_IS_CTREE (ctree), NULL);
g_return_val_if_fail (func != NULL, NULL);
gint column;
gint row;
- g_return_val_if_fail (ctree != NULL, FALSE);
g_return_val_if_fail (GTK_IS_CTREE (ctree), FALSE);
if (gtk_clist_get_selection_info (GTK_CLIST (ctree), x, y, &row, &column))
GtkCTreeNode *new_parent,
GtkCTreeNode *new_sibling)
{
- g_return_if_fail (ctree != NULL);
g_return_if_fail (GTK_IS_CTREE (ctree));
g_return_if_fail (node != NULL);
gtk_ctree_expand (GtkCTree *ctree,
GtkCTreeNode *node)
{
- g_return_if_fail (ctree != NULL);
g_return_if_fail (GTK_IS_CTREE (ctree));
g_return_if_fail (node != NULL);
GtkCList *clist;
gboolean thaw = FALSE;
- g_return_if_fail (ctree != NULL);
g_return_if_fail (GTK_IS_CTREE (ctree));
clist = GTK_CLIST (ctree);
GtkCList *clist;
gboolean thaw = FALSE;
- g_return_if_fail (ctree != NULL);
g_return_if_fail (GTK_IS_CTREE (ctree));
clist = GTK_CLIST (ctree);
gtk_ctree_collapse (GtkCTree *ctree,
GtkCTreeNode *node)
{
- g_return_if_fail (ctree != NULL);
g_return_if_fail (GTK_IS_CTREE (ctree));
g_return_if_fail (node != NULL);
gboolean thaw = FALSE;
gint i;
- g_return_if_fail (ctree != NULL);
g_return_if_fail (GTK_IS_CTREE (ctree));
if (node && GTK_CTREE_ROW (node)->is_leaf)
gboolean thaw = FALSE;
gint i;
- g_return_if_fail (ctree != NULL);
g_return_if_fail (GTK_IS_CTREE (ctree));
if (node && GTK_CTREE_ROW (node)->is_leaf)
gtk_ctree_toggle_expansion (GtkCTree *ctree,
GtkCTreeNode *node)
{
- g_return_if_fail (ctree != NULL);
g_return_if_fail (GTK_IS_CTREE (ctree));
g_return_if_fail (node != NULL);
GtkCList *clist;
gboolean thaw = FALSE;
- g_return_if_fail (ctree != NULL);
g_return_if_fail (GTK_IS_CTREE (ctree));
if (node && GTK_CTREE_ROW (node)->is_leaf)
gtk_ctree_select (GtkCTree *ctree,
GtkCTreeNode *node)
{
- g_return_if_fail (ctree != NULL);
g_return_if_fail (GTK_IS_CTREE (ctree));
g_return_if_fail (node != NULL);
gtk_ctree_unselect (GtkCTree *ctree,
GtkCTreeNode *node)
{
- g_return_if_fail (ctree != NULL);
g_return_if_fail (GTK_IS_CTREE (ctree));
g_return_if_fail (node != NULL);
GtkCList *clist;
gboolean thaw = FALSE;
- g_return_if_fail (ctree != NULL);
g_return_if_fail (GTK_IS_CTREE (ctree));
clist = GTK_CLIST (ctree);
thaw = TRUE;
}
- if (clist->selection_mode == GTK_SELECTION_EXTENDED)
+ if (clist->selection_mode == GTK_SELECTION_MULTIPLE)
{
- if (clist->anchor != -1)
- GTK_CLIST_CLASS_FW (clist)->resync_selection (clist, NULL);
+ GTK_CLIST_GET_CLASS (clist)->resync_selection (clist, NULL);
g_list_free (clist->undo_selection);
g_list_free (clist->undo_unselection);
{
GtkCList *clist;
- g_return_if_fail (ctree != NULL);
g_return_if_fail (GTK_IS_CTREE (ctree));
g_return_if_fail (node != NULL);
clist = GTK_CLIST (ctree);
- GTK_CLIST_CLASS_FW (clist)->set_cell_contents
- (clist, &(GTK_CTREE_ROW(node)->row), column, GTK_CELL_TEXT,
+ GTK_CLIST_GET_CLASS (clist)->set_cell_contents
+ (clist, &(GTK_CTREE_ROW (node)->row), column, GTK_CELL_TEXT,
text, 0, NULL, NULL);
tree_draw_node (ctree, node);
{
GtkCList *clist;
- g_return_if_fail (ctree != NULL);
g_return_if_fail (GTK_IS_CTREE (ctree));
g_return_if_fail (node != NULL);
g_return_if_fail (pixmap != NULL);
clist = GTK_CLIST (ctree);
- GTK_CLIST_CLASS_FW (clist)->set_cell_contents
+ GTK_CLIST_GET_CLASS (clist)->set_cell_contents
(clist, &(GTK_CTREE_ROW (node)->row), column, GTK_CELL_PIXMAP,
NULL, 0, pixmap, mask);
{
GtkCList *clist;
- g_return_if_fail (ctree != NULL);
g_return_if_fail (GTK_IS_CTREE (ctree));
g_return_if_fail (node != NULL);
if (column != ctree->tree_column)
gdk_pixmap_ref (mask);
}
- GTK_CLIST_CLASS_FW (clist)->set_cell_contents
+ GTK_CLIST_GET_CLASS (clist)->set_cell_contents
(clist, &(GTK_CTREE_ROW (node)->row), column, GTK_CELL_PIXTEXT,
text, spacing, pixmap, mask);
gboolean old_leaf;
gboolean old_expanded;
- g_return_if_fail (ctree != NULL);
g_return_if_fail (GTK_IS_CTREE (ctree));
g_return_if_fail (node != NULL);
while (work)
{
ptr = work;
- work = GTK_CTREE_ROW(work)->sibling;
+ work = GTK_CTREE_ROW (work)->sibling;
gtk_ctree_remove_node (ctree, ptr);
}
}
GtkRequisition requisition;
gboolean visible = FALSE;
- g_return_if_fail (ctree != NULL);
g_return_if_fail (GTK_IS_CTREE (ctree));
g_return_if_fail (node != NULL);
{
visible = gtk_ctree_is_viewable (ctree, node);
if (visible)
- GTK_CLIST_CLASS_FW (clist)->cell_size_request
+ GTK_CLIST_GET_CLASS (clist)->cell_size_request
(clist, >K_CTREE_ROW (node)->row, column, &requisition);
}
GtkCTreeNode *node,
gboolean selectable)
{
- g_return_if_fail (ctree != NULL);
g_return_if_fail (GTK_IS_CTREE (ctree));
g_return_if_fail (node != NULL);
clist = GTK_CLIST (ctree);
if (clist->anchor >= 0 &&
- clist->selection_mode == GTK_SELECTION_EXTENDED)
+ clist->selection_mode == GTK_SELECTION_MULTIPLE)
{
clist->drag_button = 0;
remove_grab (clist);
- GTK_CLIST_CLASS_FW (clist)->resync_selection (clist, NULL);
+ GTK_CLIST_GET_CLASS (clist)->resync_selection (clist, NULL);
}
gtk_ctree_unselect (ctree, node);
}
GtkCTreeNode *node,
gint column)
{
- g_return_val_if_fail (ctree != NULL, -1);
g_return_val_if_fail (GTK_IS_CTREE (ctree), -1);
g_return_val_if_fail (node != NULL, -1);
return GTK_CTREE_ROW (node)->row.cell[column].type;
}
-gint
+gboolean
gtk_ctree_node_get_text (GtkCTree *ctree,
GtkCTreeNode *node,
gint column,
gchar **text)
{
- g_return_val_if_fail (ctree != NULL, 0);
- g_return_val_if_fail (GTK_IS_CTREE (ctree), 0);
- g_return_val_if_fail (node != NULL, 0);
+ g_return_val_if_fail (GTK_IS_CTREE (ctree), FALSE);
+ g_return_val_if_fail (node != NULL, FALSE);
if (column < 0 || column >= GTK_CLIST (ctree)->columns)
- return 0;
+ return FALSE;
if (GTK_CTREE_ROW (node)->row.cell[column].type != GTK_CELL_TEXT)
- return 0;
+ return FALSE;
if (text)
*text = GTK_CELL_TEXT (GTK_CTREE_ROW (node)->row.cell[column])->text;
- return 1;
+ return TRUE;
}
-gint
+gboolean
gtk_ctree_node_get_pixmap (GtkCTree *ctree,
GtkCTreeNode *node,
gint column,
GdkPixmap **pixmap,
GdkBitmap **mask)
{
- g_return_val_if_fail (ctree != NULL, 0);
- g_return_val_if_fail (GTK_IS_CTREE (ctree), 0);
- g_return_val_if_fail (node != NULL, 0);
+ g_return_val_if_fail (GTK_IS_CTREE (ctree), FALSE);
+ g_return_val_if_fail (node != NULL, FALSE);
if (column < 0 || column >= GTK_CLIST (ctree)->columns)
- return 0;
+ return FALSE;
if (GTK_CTREE_ROW (node)->row.cell[column].type != GTK_CELL_PIXMAP)
- return 0;
+ return FALSE;
if (pixmap)
- *pixmap = GTK_CELL_PIXMAP (GTK_CTREE_ROW(node)->row.cell[column])->pixmap;
+ *pixmap = GTK_CELL_PIXMAP (GTK_CTREE_ROW (node)->row.cell[column])->pixmap;
if (mask)
*mask = GTK_CELL_PIXMAP (GTK_CTREE_ROW (node)->row.cell[column])->mask;
- return 1;
+ return TRUE;
}
-gint
+gboolean
gtk_ctree_node_get_pixtext (GtkCTree *ctree,
GtkCTreeNode *node,
gint column,
GdkPixmap **pixmap,
GdkBitmap **mask)
{
- g_return_val_if_fail (ctree != NULL, 0);
- g_return_val_if_fail (GTK_IS_CTREE (ctree), 0);
- g_return_val_if_fail (node != NULL, 0);
+ g_return_val_if_fail (GTK_IS_CTREE (ctree), FALSE);
+ g_return_val_if_fail (node != NULL, FALSE);
if (column < 0 || column >= GTK_CLIST (ctree)->columns)
- return 0;
+ return FALSE;
if (GTK_CTREE_ROW (node)->row.cell[column].type != GTK_CELL_PIXTEXT)
- return 0;
+ return FALSE;
if (text)
*text = GTK_CELL_PIXTEXT (GTK_CTREE_ROW (node)->row.cell[column])->text;
if (mask)
*mask = GTK_CELL_PIXTEXT (GTK_CTREE_ROW (node)->row.cell[column])->mask;
- return 1;
+ return TRUE;
}
-gint
+gboolean
gtk_ctree_get_node_info (GtkCTree *ctree,
GtkCTreeNode *node,
gchar **text,
gboolean *is_leaf,
gboolean *expanded)
{
- g_return_val_if_fail (ctree != NULL, 0);
- g_return_val_if_fail (GTK_IS_CTREE (ctree), 0);
- g_return_val_if_fail (node != NULL, 0);
+ g_return_val_if_fail (GTK_IS_CTREE (ctree), FALSE);
+ g_return_val_if_fail (node != NULL, FALSE);
if (text)
*text = GTK_CELL_PIXTEXT
if (expanded)
*expanded = GTK_CTREE_ROW (node)->expanded;
- return 1;
+ return TRUE;
}
void
GtkRequisition requisition;
gboolean visible = FALSE;
- g_return_if_fail (ctree != NULL);
g_return_if_fail (GTK_IS_CTREE (ctree));
g_return_if_fail (node != NULL);
{
visible = gtk_ctree_is_viewable (ctree, node);
if (visible)
- GTK_CLIST_CLASS_FW (clist)->cell_size_request
+ GTK_CLIST_GET_CLASS (clist)->cell_size_request
(clist, >K_CTREE_ROW (node)->row, column, &requisition);
}
{
if (GTK_WIDGET_REALIZED (ctree))
gtk_style_detach (GTK_CTREE_ROW (node)->row.cell[column].style);
- gtk_style_unref (GTK_CTREE_ROW (node)->row.cell[column].style);
+ g_object_unref (GTK_CTREE_ROW (node)->row.cell[column].style);
}
GTK_CTREE_ROW (node)->row.cell[column].style = style;
if (GTK_CTREE_ROW (node)->row.cell[column].style)
{
- gtk_style_ref (GTK_CTREE_ROW (node)->row.cell[column].style);
+ g_object_ref (GTK_CTREE_ROW (node)->row.cell[column].style);
if (GTK_WIDGET_REALIZED (ctree))
GTK_CTREE_ROW (node)->row.cell[column].style =
GtkCTreeNode *node,
gint column)
{
- g_return_val_if_fail (ctree != NULL, NULL);
g_return_val_if_fail (GTK_IS_CTREE (ctree), NULL);
g_return_val_if_fail (node != NULL, NULL);
gint *old_width = NULL;
gint i;
- g_return_if_fail (ctree != NULL);
g_return_if_fail (GTK_IS_CTREE (ctree));
g_return_if_fail (node != NULL);
for (i = 0; i < clist->columns; i++)
if (clist->column[i].auto_resize)
{
- GTK_CLIST_CLASS_FW (clist)->cell_size_request
+ GTK_CLIST_GET_CLASS (clist)->cell_size_request
(clist, >K_CTREE_ROW (node)->row, i, &requisition);
old_width[i] = requisition.width;
}
{
if (GTK_WIDGET_REALIZED (ctree))
gtk_style_detach (GTK_CTREE_ROW (node)->row.style);
- gtk_style_unref (GTK_CTREE_ROW (node)->row.style);
+ g_object_unref (GTK_CTREE_ROW (node)->row.style);
}
GTK_CTREE_ROW (node)->row.style = style;
if (GTK_CTREE_ROW (node)->row.style)
{
- gtk_style_ref (GTK_CTREE_ROW (node)->row.style);
+ g_object_ref (GTK_CTREE_ROW (node)->row.style);
if (GTK_WIDGET_REALIZED (ctree))
GTK_CTREE_ROW (node)->row.style =
gtk_ctree_node_get_row_style (GtkCTree *ctree,
GtkCTreeNode *node)
{
- g_return_val_if_fail (ctree != NULL, NULL);
g_return_val_if_fail (GTK_IS_CTREE (ctree), NULL);
g_return_val_if_fail (node != NULL, NULL);
GtkCTreeNode *node,
GdkColor *color)
{
- g_return_if_fail (ctree != NULL);
g_return_if_fail (GTK_IS_CTREE (ctree));
g_return_if_fail (node != NULL);
GtkCTreeNode *node,
GdkColor *color)
{
- g_return_if_fail (ctree != NULL);
g_return_if_fail (GTK_IS_CTREE (ctree));
g_return_if_fail (node != NULL);
gpointer data,
GtkDestroyNotify destroy)
{
- g_return_if_fail (ctree != NULL);
+ GtkDestroyNotify dnotify;
+ gpointer ddata;
+
g_return_if_fail (GTK_IS_CTREE (ctree));
g_return_if_fail (node != NULL);
+ dnotify = GTK_CTREE_ROW (node)->row.destroy;
+ ddata = GTK_CTREE_ROW (node)->row.data;
+
GTK_CTREE_ROW (node)->row.data = data;
GTK_CTREE_ROW (node)->row.destroy = destroy;
+
+ if (dnotify)
+ dnotify (ddata);
}
gpointer
gtk_ctree_node_get_row_data (GtkCTree *ctree,
GtkCTreeNode *node)
{
- g_return_val_if_fail (ctree != NULL, NULL);
g_return_val_if_fail (GTK_IS_CTREE (ctree), NULL);
return node ? GTK_CTREE_ROW (node)->row.data : NULL;
gint row = -1;
GtkCList *clist;
- g_return_if_fail (ctree != NULL);
g_return_if_fail (GTK_IS_CTREE (ctree));
clist = GTK_CLIST (ctree);
{
GtkCList *clist;
- g_return_if_fail (ctree != NULL);
g_return_if_fail (GTK_IS_CTREE (ctree));
g_return_if_fail (indent >= 0);
GtkCList *clist;
gint old_spacing;
- g_return_if_fail (ctree != NULL);
g_return_if_fail (GTK_IS_CTREE (ctree));
g_return_if_fail (spacing >= 0);
gtk_ctree_set_show_stub (GtkCTree *ctree,
gboolean show_stub)
{
- g_return_if_fail (ctree != NULL);
g_return_if_fail (GTK_IS_CTREE (ctree));
show_stub = show_stub != FALSE;
if (CLIST_UNFROZEN (clist) && clist->rows &&
gtk_clist_row_is_visible (clist, 0) != GTK_VISIBILITY_NONE)
- GTK_CLIST_CLASS_FW (clist)->draw_row
+ GTK_CLIST_GET_CLASS (clist)->draw_row
(clist, NULL, 0, GTK_CLIST_ROW (clist->row_list));
}
}
GtkCList *clist;
GtkCTreeLineStyle old_style;
- g_return_if_fail (ctree != NULL);
g_return_if_fail (GTK_IS_CTREE (ctree));
if (line_style == ctree->line_style)
case GTK_CTREE_LINES_SOLID:
if (GTK_WIDGET_REALIZED (ctree))
gdk_gc_set_line_attributes (ctree->lines_gc, 1, GDK_LINE_SOLID,
- None, None);
+ GDK_CAP_BUTT, GDK_JOIN_MITER);
break;
case GTK_CTREE_LINES_DOTTED:
if (GTK_WIDGET_REALIZED (ctree))
gdk_gc_set_line_attributes (ctree->lines_gc, 1,
- GDK_LINE_ON_OFF_DASH, None, None);
+ GDK_LINE_ON_OFF_DASH, GDK_CAP_BUTT, GDK_JOIN_MITER);
gdk_gc_set_dashes (ctree->lines_gc, 0, "\1\1", 2);
break;
case GTK_CTREE_LINES_TABBED:
if (GTK_WIDGET_REALIZED (ctree))
gdk_gc_set_line_attributes (ctree->lines_gc, 1, GDK_LINE_SOLID,
- None, None);
+ GDK_CAP_BUTT, GDK_JOIN_MITER);
break;
case GTK_CTREE_LINES_NONE:
break;
GtkCList *clist;
GtkCTreeExpanderStyle old_style;
- g_return_if_fail (ctree != NULL);
g_return_if_fail (GTK_IS_CTREE (ctree));
if (expander_style == ctree->expander_style)
GtkCList *clist;
GtkCTreeNode *focus_node = NULL;
- g_return_if_fail (ctree != NULL);
g_return_if_fail (GTK_IS_CTREE (ctree));
clist = GTK_CLIST (ctree);
gtk_clist_freeze (clist);
- if (clist->selection_mode == GTK_SELECTION_EXTENDED)
+ if (clist->selection_mode == GTK_SELECTION_MULTIPLE)
{
- if (clist->anchor != -1)
- GTK_CLIST_CLASS_FW (clist)->resync_selection (clist, NULL);
+ GTK_CLIST_GET_CLASS (clist)->resync_selection (clist, NULL);
g_list_free (clist->undo_selection);
g_list_free (clist->undo_unselection);
GtkCList *clist;
GtkCTreeNode *focus_node = NULL;
- g_return_if_fail (ctree != NULL);
g_return_if_fail (GTK_IS_CTREE (ctree));
clist = GTK_CLIST (ctree);
gtk_clist_freeze (clist);
- if (clist->selection_mode == GTK_SELECTION_EXTENDED)
+ if (clist->selection_mode == GTK_SELECTION_MULTIPLE)
{
- if (clist->anchor != -1)
- GTK_CLIST_CLASS_FW (clist)->resync_selection (clist, NULL);
+ GTK_CLIST_GET_CLASS (clist)->resync_selection (clist, NULL);
g_list_free (clist->undo_selection);
g_list_free (clist->undo_unselection);
if (CLIST_UNFROZEN (clist) &&
gtk_clist_row_is_visible (clist, row) != GTK_VISIBILITY_NONE)
- GTK_CLIST_CLASS_FW (clist)->draw_row (clist, NULL, row,
+ GTK_CLIST_GET_CLASS (clist)->draw_row (clist, NULL, row,
GTK_CLIST_ROW (focus_node));
}
}
gint row;
gboolean unselect;
- g_return_if_fail (clist != NULL);
g_return_if_fail (GTK_IS_CTREE (clist));
- if (clist->anchor < 0)
+ if (clist->selection_mode != GTK_SELECTION_MULTIPLE)
+ return;
+
+ if (clist->anchor < 0 || clist->drag_pos < 0)
return;
ctree = GTK_CTREE (clist);
}
}
- for (list = g_list_reverse (clist->undo_unselection); list;
- list = list->next)
+ clist->undo_unselection = g_list_reverse (clist->undo_unselection);
+ for (list = clist->undo_unselection; list; list = list->next)
gtk_ctree_select (ctree, list->data);
clist->anchor = -1;
GtkCTree *ctree;
GList *work;
- g_return_if_fail (clist != NULL);
g_return_if_fail (GTK_IS_CTREE (clist));
- if (clist->selection_mode != GTK_SELECTION_EXTENDED)
+ if (clist->selection_mode != GTK_SELECTION_MULTIPLE)
return;
if (!(clist->undo_selection || clist->undo_unselection))
if (GTK_WIDGET_HAS_FOCUS (clist) && clist->focus_row != clist->undo_anchor)
{
- gtk_widget_draw_focus (GTK_WIDGET (clist));
clist->focus_row = clist->undo_anchor;
- gtk_widget_draw_focus (GTK_WIDGET (clist));
+ gtk_widget_queue_draw (GTK_WIDGET (clist));
}
else
clist->focus_row = clist->undo_anchor;
gtk_ctree_set_drag_compare_func (GtkCTree *ctree,
GtkCTreeCompareDragFunc cmp_func)
{
- g_return_if_fail (ctree != NULL);
g_return_if_fail (GTK_IS_CTREE (ctree));
ctree->drag_compare = cmp_func;
GtkCTreeNode *drag_target,
GtkCListDragPos insert_pos)
{
- g_return_val_if_fail (ctree != NULL, FALSE);
g_return_val_if_fail (GTK_IS_CTREE (ctree), FALSE);
if (drag_source && drag_source != drag_target &&
ctree->drag_compare (ctree,
drag_source,
GTK_CTREE_ROW (drag_target)->parent,
- GTK_CTREE_ROW(drag_target)->sibling));
+ GTK_CTREE_ROW (drag_target)->sibling));
break;
case GTK_CLIST_DRAG_BEFORE:
if (GTK_CTREE_ROW (drag_source)->sibling != drag_target)
g_free (info);
}
+static void
+drag_dest_cell (GtkCList *clist,
+ gint x,
+ gint y,
+ GtkCListDestInfo *dest_info)
+{
+ GtkWidget *widget;
+
+ widget = GTK_WIDGET (clist);
+
+ dest_info->insert_pos = GTK_CLIST_DRAG_NONE;
+
+ y -= (GTK_CONTAINER (widget)->border_width +
+ widget->style->ythickness + clist->column_title_area.height);
+ dest_info->cell.row = ROW_FROM_YPIXEL (clist, y);
+
+ if (dest_info->cell.row >= clist->rows)
+ {
+ dest_info->cell.row = clist->rows - 1;
+ y = ROW_TOP_YPIXEL (clist, dest_info->cell.row) + clist->row_height;
+ }
+ if (dest_info->cell.row < -1)
+ dest_info->cell.row = -1;
+
+ x -= GTK_CONTAINER (widget)->border_width + widget->style->xthickness;
+
+ dest_info->cell.column = COLUMN_FROM_XPIXEL (clist, x);
+
+ if (dest_info->cell.row >= 0)
+ {
+ gint y_delta;
+ gint h = 0;
+
+ y_delta = y - ROW_TOP_YPIXEL (clist, dest_info->cell.row);
+
+ if (GTK_CLIST_DRAW_DRAG_RECT(clist) &&
+ !GTK_CTREE_ROW (g_list_nth (clist->row_list,
+ dest_info->cell.row))->is_leaf)
+ {
+ dest_info->insert_pos = GTK_CLIST_DRAG_INTO;
+ h = clist->row_height / 4;
+ }
+ else if (GTK_CLIST_DRAW_DRAG_LINE(clist))
+ {
+ dest_info->insert_pos = GTK_CLIST_DRAG_BEFORE;
+ h = clist->row_height / 2;
+ }
+
+ if (GTK_CLIST_DRAW_DRAG_LINE(clist))
+ {
+ if (y_delta < h)
+ dest_info->insert_pos = GTK_CLIST_DRAG_BEFORE;
+ else if (clist->row_height - y_delta < h)
+ dest_info->insert_pos = GTK_CLIST_DRAG_AFTER;
+ }
+ }
+}
+
static void
gtk_ctree_drag_begin (GtkWidget *widget,
GdkDragContext *context)
GtkCTree *ctree;
gboolean use_icons;
- g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_CTREE (widget));
g_return_if_fail (context != NULL);
{
GtkCList *clist;
GtkCTree *ctree;
- gint row, column;
+ GtkCListDestInfo new_info;
GtkCListDestInfo *dest_info;
- gint h = 0;
- gint insert_pos = GTK_CLIST_DRAG_NONE;
- gint y_delta;
- g_return_val_if_fail (widget != NULL, FALSE);
g_return_val_if_fail (GTK_IS_CTREE (widget), FALSE);
clist = GTK_CLIST (widget);
ctree = GTK_CTREE (widget);
- y -= (GTK_CONTAINER (widget)->border_width +
- widget->style->klass->ythickness + clist->column_title_area.height);
- row = ROW_FROM_YPIXEL (clist, y);
-
- if (row >= clist->rows)
- {
- row = clist->rows - 1;
- y = ROW_TOP_YPIXEL (clist, row) + clist->row_height;
- }
- if (row < -1)
- row = -1;
-
- x -= GTK_CONTAINER (widget)->border_width + widget->style->klass->xthickness;
- column = COLUMN_FROM_XPIXEL (clist, x);
-
- if (row >= 0)
- {
- y_delta = y - ROW_TOP_YPIXEL (clist, row);
-
- if (GTK_CLIST_DRAW_DRAG_RECT(clist))
- {
- insert_pos = GTK_CLIST_DRAG_INTO;
- h = clist->row_height / 4;
- }
- else if (GTK_CLIST_DRAW_DRAG_LINE(clist))
- {
- insert_pos = GTK_CLIST_DRAG_BEFORE;
- h = clist->row_height / 2;
- }
-
- if (GTK_CLIST_DRAW_DRAG_LINE(clist))
- {
- if (y_delta < h)
- insert_pos = GTK_CLIST_DRAG_BEFORE;
- else if (clist->row_height - y_delta < h)
- insert_pos = GTK_CLIST_DRAG_AFTER;
- }
- }
-
dest_info = g_dataset_get_data (context, "gtk-clist-drag-dest");
if (!dest_info)
drag_dest_info_destroy);
}
+ drag_dest_cell (clist, x, y, &new_info);
+
if (GTK_CLIST_REORDERABLE (clist))
{
GList *list;
drag_source = GTK_CTREE_NODE (g_list_nth (clist->row_list,
clist->click_cell.row));
- drag_target = GTK_CTREE_NODE (g_list_nth (clist->row_list, row));
+ drag_target = GTK_CTREE_NODE (g_list_nth (clist->row_list,
+ new_info.cell.row));
if (gtk_drag_get_source_widget (context) != widget ||
- !check_drag (ctree, drag_source, drag_target, insert_pos))
+ !check_drag (ctree, drag_source, drag_target,
+ new_info.insert_pos))
{
if (dest_info->cell.row < 0)
{
return TRUE;
}
- if (row != dest_info->cell.row ||
- (row == dest_info->cell.row &&
- dest_info->insert_pos != insert_pos))
+ if (new_info.cell.row != dest_info->cell.row ||
+ (new_info.cell.row == dest_info->cell.row &&
+ dest_info->insert_pos != new_info.insert_pos))
{
if (dest_info->cell.row >= 0)
- GTK_CLIST_CLASS_FW (clist)->draw_drag_highlight
+ GTK_CLIST_GET_CLASS (clist)->draw_drag_highlight
(clist,
g_list_nth (clist->row_list, dest_info->cell.row)->data,
dest_info->cell.row, dest_info->insert_pos);
- dest_info->insert_pos = insert_pos;
- dest_info->cell.row = row;
- dest_info->cell.column = column;
+ dest_info->insert_pos = new_info.insert_pos;
+ dest_info->cell.row = new_info.cell.row;
+ dest_info->cell.column = new_info.cell.column;
- GTK_CLIST_CLASS_FW (clist)->draw_drag_highlight
+ GTK_CLIST_GET_CLASS (clist)->draw_drag_highlight
(clist,
g_list_nth (clist->row_list, dest_info->cell.row)->data,
dest_info->cell.row, dest_info->insert_pos);
+ clist->drag_highlight_row = dest_info->cell.row;
+ clist->drag_highlight_pos = dest_info->insert_pos;
+
gdk_drag_status (context, context->suggested_action, time);
}
return TRUE;
}
}
- dest_info->insert_pos = insert_pos;
- dest_info->cell.row = row;
- dest_info->cell.column = column;
+ dest_info->insert_pos = new_info.insert_pos;
+ dest_info->cell.row = new_info.cell.row;
+ dest_info->cell.column = new_info.cell.column;
return TRUE;
}
GtkCTree *ctree;
GtkCList *clist;
- g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_CTREE (widget));
g_return_if_fail (context != NULL);
g_return_if_fail (selection_data != NULL);
selection_data->length == sizeof (GtkCListCellInfo))
{
GtkCListCellInfo *source_info;
- GtkCListDestInfo *dest_info;
source_info = (GtkCListCellInfo *)(selection_data->data);
- dest_info = g_dataset_get_data (context, "gtk-clist-drag-dest");
-
- if (dest_info && source_info)
+ if (source_info)
{
+ GtkCListDestInfo dest_info;
GtkCTreeNode *source_node;
GtkCTreeNode *dest_node;
+
+ drag_dest_cell (clist, x, y, &dest_info);
source_node = GTK_CTREE_NODE (g_list_nth (clist->row_list,
source_info->row));
dest_node = GTK_CTREE_NODE (g_list_nth (clist->row_list,
- dest_info->cell.row));
+ dest_info.cell.row));
- if (!source_info || !dest_info)
+ if (!source_node || !dest_node)
return;
- switch (dest_info->insert_pos)
+ switch (dest_info.insert_pos)
{
case GTK_CLIST_DRAG_NONE:
break;
case GTK_CLIST_DRAG_INTO:
if (check_drag (ctree, source_node, dest_node,
- dest_info->insert_pos))
+ dest_info.insert_pos))
gtk_ctree_move (ctree, source_node, dest_node,
GTK_CTREE_ROW (dest_node)->children);
g_dataset_remove_data (context, "gtk-clist-drag-dest");
break;
case GTK_CLIST_DRAG_BEFORE:
if (check_drag (ctree, source_node, dest_node,
- dest_info->insert_pos))
+ dest_info.insert_pos))
gtk_ctree_move (ctree, source_node,
GTK_CTREE_ROW (dest_node)->parent, dest_node);
g_dataset_remove_data (context, "gtk-clist-drag-dest");
break;
case GTK_CLIST_DRAG_AFTER:
if (check_drag (ctree, source_node, dest_node,
- dest_info->insert_pos))
+ dest_info.insert_pos))
gtk_ctree_move (ctree, source_node,
GTK_CTREE_ROW (dest_node)->parent,
GTK_CTREE_ROW (dest_node)->sibling);
}
}
}
+
+/* dummy boxed type definition, used so that the GtkCTreeNode signal
+ * arguments have a reasonable type.
+ */
+gpointer
+ctree_node_copy (gpointer boxed)
+{
+ return boxed;
+}
+
+void
+ctree_node_free (gpointer boxed)
+{
+ /* nothing */
+}
+
+GType
+gtk_ctree_node_get_type (void)
+{
+ static GType our_type = 0;
+
+ if (our_type == 0)
+ our_type = g_boxed_type_register_static ("GtkCTreeNode",
+ (GBoxedCopyFunc)ctree_node_copy,
+ (GBoxedFreeFunc)ctree_node_free);
+
+ return our_type;
+}