* 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/.
+ */
+
+#undef GDK_DISABLE_DEPRECATED
+#undef GTK_DISABLE_DEPRECATED
+
+#include <config.h>
#include <stdlib.h>
#include "gtkctree.h"
#include "gtkbindings.h"
#include "gtkmain.h"
-#include <gdk/gdkx.h>
+#include "gtkmarshalers.h"
+#include "gtkdnd.h"
+#include "gtkintl.h"
#include <gdk/gdkkeysyms.h>
+#include "gtkalias.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
+ (clist)->hoffset)
#define COLUMN_LEFT(clist, column) ((clist)->column[(column)].area.x)
-#define GTK_CLIST_CLASS_FW(_widget_) GTK_CLIST_CLASS (GTK_OBJECT (_widget_)->klass)
+static inline gint
+COLUMN_FROM_XPIXEL (GtkCList * clist,
+ gint x)
+{
+ gint i, cx;
+
+ for (i = 0; i < clist->columns; i++)
+ if (clist->column[i].visible)
+ {
+ cx = clist->column[i].area.x + clist->hoffset;
+
+ if (x >= (cx - (COLUMN_INSET + CELL_SPACING)) &&
+ x <= (cx + clist->column[i].area.width + COLUMN_INSET))
+ return i;
+ }
+
+ /* no match */
+ return -1;
+}
+#define CLIST_UNFROZEN(clist) (((GtkCList*) (clist))->freeze_count == 0)
+#define CLIST_REFRESH(clist) G_STMT_START { \
+ if (CLIST_UNFROZEN (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);
+
+enum {
+ ARG_0,
+ ARG_N_COLUMNS,
+ ARG_TREE_COLUMN,
+ ARG_INDENT,
+ ARG_SPACING,
+ ARG_SHOW_STUB,
+ ARG_LINE_STYLE,
+ ARG_EXPANDER_STYLE
+};
+
+
+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);
+static void gtk_ctree_get_arg (GtkObject *object,
+ GtkArg *arg,
+ guint arg_id);
static void gtk_ctree_realize (GtkWidget *widget);
static void gtk_ctree_unrealize (GtkWidget *widget);
static gint gtk_ctree_button_press (GtkWidget *widget,
GdkEventButton *event);
-static gint gtk_ctree_button_release (GtkWidget *widget,
- GdkEventButton *event);
-static gint gtk_ctree_button_motion (GtkWidget *widget,
- GdkEventMotion *event);
static void ctree_attach_styles (GtkCTree *ctree,
GtkCTreeNode *node,
gpointer data);
static void draw_row (GtkCList *clist,
GdkRectangle *area,
gint row,
- GtkCListRow *clist_row);
-static void draw_xor_line (GtkCTree *ctree);
-static void draw_xor_rect (GtkCTree *ctree);
-static void create_drag_icon (GtkCTree *ctree,
- GtkCTreeRow *row);
+ GtkCListRow *clist_row);
+static void draw_drag_highlight (GtkCList *clist,
+ GtkCListRow *dest_row,
+ gint dest_row_number,
+ GtkCListDragPos drag_pos);
static void tree_draw_node (GtkCTree *ctree,
GtkCTreeNode *node);
static void set_cell_contents (GtkCList *clist,
static void real_tree_unselect (GtkCTree *ctree,
GtkCTreeNode *node,
gint column);
-static void tree_toggle_selection (GtkCTree *ctree,
- GtkCTreeNode *node,
- gint column);
static void real_tree_expand (GtkCTree *ctree,
GtkCTreeNode *node);
static void real_tree_collapse (GtkCTree *ctree,
GtkCTreeNode *node,
GtkCTreeNode *new_parent,
GtkCTreeNode *new_sibling);
+static void real_row_move (GtkCList *clist,
+ gint source_row,
+ gint dest_row);
static void gtk_ctree_link (GtkCTree *ctree,
GtkCTreeNode *node,
GtkCTreeNode *parent,
static void real_remove_row (GtkCList *clist,
gint row);
static void real_sort_list (GtkCList *clist);
-static void set_mouse_cursor (GtkCTree *ctree,
- gboolean enable);
-static void check_cursor (GtkCTree *ctree);
static void cell_size_request (GtkCList *clist,
GtkCListRow *clist_row,
gint column,
gint old_width);
static void auto_resize_columns (GtkCList *clist);
+
+static gboolean check_drag (GtkCTree *ctree,
+ GtkCTreeNode *drag_source,
+ GtkCTreeNode *drag_target,
+ GtkCListDragPos insert_pos);
+static void gtk_ctree_drag_begin (GtkWidget *widget,
+ GdkDragContext *context);
+static gint gtk_ctree_drag_motion (GtkWidget *widget,
+ GdkDragContext *context,
+ gint x,
+ gint y,
+ guint time);
+static void gtk_ctree_drag_data_received (GtkWidget *widget,
+ GdkDragContext *context,
+ gint x,
+ gint y,
+ GtkSelectionData *selection_data,
+ 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
{
TREE_SELECT_ROW,
LAST_SIGNAL
};
-typedef void (*GtkCTreeSignal1) (GtkObject *object,
- GtkCTreeNode *arg1,
- gint arg2,
- gpointer data);
-
-typedef void (*GtkCTreeSignal2) (GtkObject *object,
- GtkCTreeNode *arg1,
- GtkCTreeNode *arg2,
- GtkCTreeNode *arg3,
- gpointer data);
-
-typedef void (*GtkCTreeSignal3) (GtkObject *object,
- GtkCTreeNode *arg1,
- gpointer data);
-
-typedef void (*GtkCTreeSignal4) (GtkObject *object,
- GtkCTreeExpansionType arg1,
- gpointer data);
-
-
static GtkCListClass *parent_class = NULL;
static GtkContainerClass *container_class = NULL;
static guint ctree_signals[LAST_SIGNAL] = {0};
if (!ctree_type)
{
- GtkTypeInfo ctree_info =
+ static const GtkTypeInfo ctree_info =
{
"GtkCTree",
sizeof (GtkCTree),
(GtkClassInitFunc) NULL,
};
+ I_("GtkCTree");
ctree_type = gtk_type_unique (GTK_TYPE_CLIST, &ctree_info);
}
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);
- ctree_signals[TREE_SELECT_ROW] =
- gtk_signal_new ("tree_select_row",
- GTK_RUN_FIRST,
- object_class->type,
- GTK_SIGNAL_OFFSET (GtkCTreeClass, tree_select_row),
- gtk_marshal_NONE__POINTER_INT,
- GTK_TYPE_NONE, 2, GTK_TYPE_POINTER, GTK_TYPE_INT);
- ctree_signals[TREE_UNSELECT_ROW] =
- gtk_signal_new ("tree_unselect_row",
- GTK_RUN_FIRST,
- object_class->type,
- GTK_SIGNAL_OFFSET (GtkCTreeClass, tree_unselect_row),
- gtk_marshal_NONE__POINTER_INT,
- GTK_TYPE_NONE, 2, GTK_TYPE_POINTER, GTK_TYPE_INT);
- ctree_signals[TREE_EXPAND] =
- gtk_signal_new ("tree_expand",
- GTK_RUN_LAST,
- object_class->type,
- GTK_SIGNAL_OFFSET (GtkCTreeClass, tree_expand),
- gtk_marshal_NONE__POINTER,
- GTK_TYPE_NONE, 1, GTK_TYPE_POINTER);
- ctree_signals[TREE_COLLAPSE] =
- gtk_signal_new ("tree_collapse",
- GTK_RUN_LAST,
- object_class->type,
- GTK_SIGNAL_OFFSET (GtkCTreeClass, tree_collapse),
- gtk_marshal_NONE__POINTER,
- GTK_TYPE_NONE, 1, GTK_TYPE_POINTER);
- ctree_signals[TREE_MOVE] =
- gtk_signal_new ("tree_move",
- GTK_RUN_LAST,
- object_class->type,
- GTK_SIGNAL_OFFSET (GtkCTreeClass, tree_move),
- gtk_marshal_NONE__POINTER_POINTER_POINTER,
- GTK_TYPE_NONE, 3, GTK_TYPE_POINTER, GTK_TYPE_POINTER,
- GTK_TYPE_POINTER);
- ctree_signals[CHANGE_FOCUS_ROW_EXPANSION] =
- gtk_signal_new ("change_focus_row_expansion",
- GTK_RUN_LAST | GTK_RUN_ACTION,
- object_class->type,
- GTK_SIGNAL_OFFSET (GtkCTreeClass,
- change_focus_row_expansion),
- gtk_marshal_NONE__ENUM,
- GTK_TYPE_NONE, 1, GTK_TYPE_C_TREE_EXPANSION_TYPE);
-
- gtk_object_class_add_signals (object_class, ctree_signals, LAST_SIGNAL);
+ 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->button_release_event = gtk_ctree_button_release;
- widget_class->motion_notify_event = gtk_ctree_button_motion;
+
+ 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;
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);
- }
+ gtk_object_add_arg_type ("GtkCTree::n-columns", /* overrides GtkCList::n_columns!! */
+ GTK_TYPE_UINT,
+ GTK_ARG_READWRITE | GTK_ARG_CONSTRUCT_ONLY | G_PARAM_STATIC_NAME,
+ ARG_N_COLUMNS);
+ gtk_object_add_arg_type ("GtkCTree::tree-column",
+ GTK_TYPE_UINT,
+ GTK_ARG_READWRITE | GTK_ARG_CONSTRUCT_ONLY | G_PARAM_STATIC_NAME,
+ ARG_TREE_COLUMN);
+ gtk_object_add_arg_type ("GtkCTree::indent",
+ GTK_TYPE_UINT,
+ GTK_ARG_READWRITE | G_PARAM_STATIC_NAME,
+ ARG_INDENT);
+ gtk_object_add_arg_type ("GtkCTree::spacing",
+ GTK_TYPE_UINT,
+ GTK_ARG_READWRITE | G_PARAM_STATIC_NAME,
+ ARG_SPACING);
+ gtk_object_add_arg_type ("GtkCTree::show-stub",
+ GTK_TYPE_BOOL,
+ GTK_ARG_READWRITE | G_PARAM_STATIC_NAME,
+ ARG_SHOW_STUB);
+ gtk_object_add_arg_type ("GtkCTree::line-style",
+ GTK_TYPE_CTREE_LINE_STYLE,
+ GTK_ARG_READWRITE | G_PARAM_STATIC_NAME,
+ ARG_LINE_STYLE);
+ gtk_object_add_arg_type ("GtkCTree::expander-style",
+ GTK_TYPE_CTREE_EXPANDER_STYLE,
+ GTK_ARG_READWRITE | G_PARAM_STATIC_NAME,
+ ARG_EXPANDER_STYLE);
+
+ ctree_signals[TREE_SELECT_ROW] =
+ gtk_signal_new (I_("tree_select_row"),
+ GTK_RUN_FIRST,
+ GTK_CLASS_TYPE (object_class),
+ GTK_SIGNAL_OFFSET (GtkCTreeClass, tree_select_row),
+ _gtk_marshal_VOID__POINTER_INT,
+ GTK_TYPE_NONE, 2,
+ GTK_TYPE_CTREE_NODE,
+ GTK_TYPE_INT);
+ ctree_signals[TREE_UNSELECT_ROW] =
+ gtk_signal_new (I_("tree_unselect_row"),
+ GTK_RUN_FIRST,
+ GTK_CLASS_TYPE (object_class),
+ GTK_SIGNAL_OFFSET (GtkCTreeClass, tree_unselect_row),
+ _gtk_marshal_VOID__POINTER_INT,
+ GTK_TYPE_NONE, 2,
+ GTK_TYPE_CTREE_NODE,
+ GTK_TYPE_INT);
+ ctree_signals[TREE_EXPAND] =
+ gtk_signal_new (I_("tree_expand"),
+ GTK_RUN_LAST,
+ GTK_CLASS_TYPE (object_class),
+ GTK_SIGNAL_OFFSET (GtkCTreeClass, tree_expand),
+ _gtk_marshal_VOID__POINTER,
+ GTK_TYPE_NONE, 1,
+ GTK_TYPE_CTREE_NODE);
+ ctree_signals[TREE_COLLAPSE] =
+ gtk_signal_new (I_("tree_collapse"),
+ GTK_RUN_LAST,
+ GTK_CLASS_TYPE (object_class),
+ GTK_SIGNAL_OFFSET (GtkCTreeClass, tree_collapse),
+ _gtk_marshal_VOID__POINTER,
+ GTK_TYPE_NONE, 1,
+ GTK_TYPE_CTREE_NODE);
+ ctree_signals[TREE_MOVE] =
+ gtk_signal_new (I_("tree_move"),
+ GTK_RUN_LAST,
+ GTK_CLASS_TYPE (object_class),
+ GTK_SIGNAL_OFFSET (GtkCTreeClass, tree_move),
+ _gtk_marshal_VOID__POINTER_POINTER_POINTER,
+ GTK_TYPE_NONE, 3,
+ GTK_TYPE_CTREE_NODE,
+ GTK_TYPE_CTREE_NODE,
+ GTK_TYPE_CTREE_NODE);
+ ctree_signals[CHANGE_FOCUS_ROW_EXPANSION] =
+ gtk_signal_new (I_("change_focus_row_expansion"),
+ GTK_RUN_LAST | GTK_RUN_ACTION,
+ GTK_CLASS_TYPE (object_class),
+ GTK_SIGNAL_OFFSET (GtkCTreeClass,
+ change_focus_row_expansion),
+ _gtk_marshal_VOID__ENUM,
+ GTK_TYPE_NONE, 1, GTK_TYPE_CTREE_EXPANSION_TYPE);
+
+ binding_set = gtk_binding_set_by_class (klass);
+ 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,
+ "change_focus_row_expansion", 1,
+ GTK_TYPE_ENUM, GTK_CTREE_EXPANSION_EXPAND_RECURSIVE);
+
+ 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,
+ 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_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
+gtk_ctree_set_arg (GtkObject *object,
+ GtkArg *arg,
+ 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 at construction time */
+ clist->columns = MAX (1, GTK_VALUE_UINT (*arg));
+ ctree->tree_column = CLAMP (ctree->tree_column, 0, clist->columns);
+ break;
+ case ARG_TREE_COLUMN: /* construct-only arg, only set at construction time */
+ ctree->tree_column = GTK_VALUE_UINT (*arg);
+ ctree->tree_column = CLAMP (ctree->tree_column, 0, clist->columns);
+ break;
+ case ARG_INDENT:
+ gtk_ctree_set_indent (ctree, GTK_VALUE_UINT (*arg));
+ break;
+ case ARG_SPACING:
+ gtk_ctree_set_spacing (ctree, GTK_VALUE_UINT (*arg));
+ break;
+ case ARG_SHOW_STUB:
+ gtk_ctree_set_show_stub (ctree, GTK_VALUE_BOOL (*arg));
+ break;
+ case ARG_LINE_STYLE:
+ gtk_ctree_set_line_style (ctree, GTK_VALUE_ENUM (*arg));
+ break;
+ case ARG_EXPANDER_STYLE:
+ gtk_ctree_set_expander_style (ctree, GTK_VALUE_ENUM (*arg));
+ break;
+ default:
+ break;
+ }
+}
+
+static void
+gtk_ctree_get_arg (GtkObject *object,
+ GtkArg *arg,
+ guint arg_id)
+{
+ GtkCTree *ctree;
+
+ ctree = GTK_CTREE (object);
+ switch (arg_id)
+ {
+ case ARG_N_COLUMNS:
+ GTK_VALUE_UINT (*arg) = GTK_CLIST (ctree)->columns;
+ break;
+ case ARG_TREE_COLUMN:
+ GTK_VALUE_UINT (*arg) = ctree->tree_column;
+ break;
+ case ARG_INDENT:
+ GTK_VALUE_UINT (*arg) = ctree->tree_indent;
+ break;
+ case ARG_SPACING:
+ GTK_VALUE_UINT (*arg) = ctree->tree_spacing;
+ break;
+ case ARG_SHOW_STUB:
+ GTK_VALUE_BOOL (*arg) = ctree->show_stub;
+ break;
+ case ARG_LINE_STYLE:
+ GTK_VALUE_ENUM (*arg) = ctree->line_style;
+ break;
+ case ARG_EXPANDER_STYLE:
+ GTK_VALUE_ENUM (*arg) = ctree->expander_style;
+ break;
+ default:
+ arg->type = GTK_TYPE_INVALID;
+ break;
+ }
}
static void
gtk_ctree_init (GtkCTree *ctree)
{
- ctree->drag_icon = NULL;
+ GtkCList *clist;
+
+ GTK_CLIST_SET_FLAG (ctree, CLIST_DRAW_DRAG_RECT);
+ GTK_CLIST_SET_FLAG (ctree, CLIST_DRAW_DRAG_LINE);
+
+ clist = GTK_CLIST (ctree);
+
ctree->tree_indent = 20;
ctree->tree_spacing = 5;
ctree->tree_column = 0;
- ctree->drag_row = -1;
- ctree->drag_source = NULL;
- ctree->drag_target = NULL;
- ctree->insert_pos = GTK_CTREE_POS_AS_CHILD;
- ctree->reorderable = FALSE;
- ctree->use_icons = TRUE;
- ctree->in_drag = FALSE;
- ctree->drag_rect = FALSE;
ctree->line_style = GTK_CTREE_LINES_SOLID;
ctree->expander_style = GTK_CTREE_EXPANDER_SQUARE;
ctree->drag_compare = NULL;
ctree->show_stub = TRUE;
+
+ clist->button_actions[0] |= GTK_BUTTON_EXPANDS;
}
static void
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);
+ GTK_WIDGET_CLASS (parent_class)->realize (widget);
ctree = GTK_CTREE (widget);
clist = GTK_CLIST (widget);
}
values.foreground = widget->style->fg[GTK_STATE_NORMAL];
- values.background = widget->style->bg[GTK_STATE_NORMAL];
+ values.background = widget->style->base[GTK_STATE_NORMAL];
values.subwindow_mode = GDK_INCLUDE_INFERIORS;
values.line_style = GDK_LINE_SOLID;
ctree->lines_gc = gdk_gc_new_with_values (GTK_CLIST(widget)->clist_window,
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);
+ GTK_WIDGET_CLASS (parent_class)->unrealize (widget);
ctree = GTK_CTREE (widget);
clist = GTK_CLIST (widget);
{
GtkCTree *ctree;
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);
ctree = GTK_CTREE (widget);
clist = GTK_CLIST (widget);
+ button_actions = clist->button_actions[event->button - 1];
+
+ if (button_actions == GTK_BUTTON_IGNORED)
+ return FALSE;
+
if (event->window == clist->clist_window)
{
- gboolean collapse_expand = FALSE;
GtkCTreeNode *work;
gint x;
gint y;
if (!gtk_clist_get_selection_info (clist, x, y, &row, &column))
return FALSE;
- if (event->button == 2)
- ctree->drag_row = - 1 - ROW_FROM_YPIXEL (clist, y);
-
work = GTK_CTREE_NODE (g_list_nth (clist->row_list, row));
- if (ctree->reorderable && event->button == 2 && !ctree->in_drag &&
- clist->anchor == -1)
- {
- gdk_pointer_grab (event->window, FALSE,
- GDK_POINTER_MOTION_HINT_MASK |
- GDK_BUTTON2_MOTION_MASK | GDK_BUTTON_RELEASE_MASK,
- NULL, NULL, event->time);
- gtk_grab_add (widget);
- ctree->in_drag = TRUE;
- ctree->drag_source = work;
- ctree->drag_target = NULL;
- gdk_gc_set_line_attributes (clist->xor_gc, 1, GDK_LINE_ON_OFF_DASH,
- None, None);
- gdk_gc_set_dashes (clist->xor_gc, 0, "\2\2", 2);
- return FALSE;
- }
- else if (event->button == 1 &&
- (GTK_CTREE_ROW (work)->children &&
- (event->type == GDK_2BUTTON_PRESS ||
- ctree_is_hot_spot (ctree, work, row, x, y))))
+ if (button_actions & GTK_BUTTON_EXPANDS &&
+ (GTK_CTREE_ROW (work)->children && !GTK_CTREE_ROW (work)->is_leaf &&
+ (event->type == GDK_2BUTTON_PRESS ||
+ ctree_is_hot_spot (ctree, work, row, x, y))))
{
if (GTK_CTREE_ROW (work)->expanded)
gtk_ctree_collapse (ctree, work);
else
gtk_ctree_expand (ctree, work);
- collapse_expand = TRUE;
- }
- if (event->button == 1)
- {
- gint old_row = clist->focus_row;
- gboolean no_focus_row = FALSE;
-
- switch (clist->selection_mode)
- {
- case GTK_SELECTION_MULTIPLE:
- case GTK_SELECTION_SINGLE:
- if (!collapse_expand)
- break;
-
- if (clist->focus_row == -1)
- {
- old_row = row;
- no_focus_row = TRUE;
- }
-
- GTK_CLIST_SET_FLAG (clist, CLIST_DRAG_SELECTION);
- gdk_pointer_grab (clist->clist_window, FALSE,
- GDK_POINTER_MOTION_HINT_MASK |
- GDK_BUTTON1_MOTION_MASK |
- GDK_BUTTON_RELEASE_MASK,
- NULL, NULL, event->time);
- gtk_grab_add (widget);
-
- if (GTK_CLIST_ADD_MODE (clist))
- {
- GTK_CLIST_UNSET_FLAG (clist, CLIST_ADD_MODE);
- if (GTK_WIDGET_HAS_FOCUS (widget))
- {
- gtk_widget_draw_focus (widget);
- gdk_gc_set_line_attributes (clist->xor_gc, 1,
- GDK_LINE_SOLID, 0, 0);
- clist->focus_row = row;
- gtk_widget_draw_focus (widget);
- }
- else
- {
- gdk_gc_set_line_attributes (clist->xor_gc, 1,
- GDK_LINE_SOLID, 0, 0);
- clist->focus_row = row;
- }
- }
- else if (row != clist->focus_row)
- {
- if (GTK_WIDGET_HAS_FOCUS (widget))
- {
- gtk_widget_draw_focus (widget);
- clist->focus_row = row;
- gtk_widget_draw_focus (widget);
- }
- else
- clist->focus_row = row;
- }
-
- if (!GTK_WIDGET_HAS_FOCUS (widget))
- gtk_widget_grab_focus (widget);
-
- return FALSE;
-
- default:
- break;
- }
+ return TRUE;
}
}
+
return GTK_WIDGET_CLASS (parent_class)->button_press_event (widget, event);
}
-static gint
-gtk_ctree_button_motion (GtkWidget *widget,
- GdkEventMotion *event)
-{
- GtkCTree *ctree;
- GtkCList *clist;
- gint x;
- gint y;
- gint row;
- gint insert_pos = GTK_CTREE_POS_AS_CHILD;
-
- 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);
-
- ctree = GTK_CTREE (widget);
- clist = GTK_CLIST (widget);
-
- if (GTK_CLIST_IN_DRAG (clist))
- return GTK_WIDGET_CLASS (parent_class)->motion_notify_event
- (widget, event);
-
- if (event->window == clist->clist_window &&
- ctree->in_drag && ctree->reorderable)
- {
- GdkModifierType modmask;
- gint root_x;
- gint root_y;
-
- x = event->x;
- y = event->y;
- if (event->is_hint)
- gdk_window_get_pointer (event->window, &x, &y, NULL);
-
- /* delayed drag start */
- if (!ctree->drag_target &&
- y >= ROW_TOP_YPIXEL (clist, -ctree->drag_row-1) &&
- y <= ROW_TOP_YPIXEL (clist, -ctree->drag_row-1) + clist->row_height)
- return
- GTK_WIDGET_CLASS (parent_class)->motion_notify_event (widget, event);
-
- if (ctree->use_icons)
- {
- if (!ctree->drag_icon)
- create_drag_icon (ctree, GTK_CTREE_ROW (ctree->drag_source));
- else
- {
- gdk_window_get_pointer (NULL, &root_x, &root_y, &modmask);
- gdk_window_move (ctree->drag_icon, root_x - ctree->icon_width /2,
- root_y - ctree->icon_height);
- }
- }
-
- /* out of bounds check */
- if (x < 0 || y < -3 || x > clist->clist_window_width ||
- y > clist->clist_window_height + 3 ||
- y > ROW_TOP_YPIXEL (clist, clist->rows-1) + clist->row_height + 3)
- {
- if (ctree->drag_row >= 0)
- {
- if (ctree->drag_rect)
- {
- draw_xor_rect (ctree);
- ctree->drag_rect = FALSE;
- }
- else
- draw_xor_line (ctree);
- ctree->drag_row = -1;
- }
- return
- (* GTK_WIDGET_CLASS (parent_class)->motion_notify_event)
- (widget, event);
- }
-
- row = ROW_FROM_YPIXEL (clist, y);
-
- /* re-calculate target (mouse left the window) */
- if (ctree->drag_target && ctree->drag_row == -1)
- ctree->drag_target = GTK_CTREE_NODE (g_list_nth (clist->row_list,row));
-
- if (y < 0 || y > clist->clist_window_height ||
- ROW_TOP_YPIXEL (clist, row + 1) > clist->clist_window_height
- || row >= clist->rows)
- return GTK_WIDGET_CLASS (parent_class)->motion_notify_event
- (widget, event);
-
- if (y - ROW_TOP_YPIXEL (clist, row) < clist->row_height / 4)
- insert_pos = GTK_CTREE_POS_BEFORE;
- else if (ROW_TOP_YPIXEL (clist, row) + clist->row_height - y
- < clist->row_height / 4)
- insert_pos = GTK_CTREE_POS_AFTER;
-
- if (row != ctree->drag_row ||
- (row == ctree->drag_row && ctree->insert_pos != insert_pos))
- {
- if (insert_pos != GTK_CTREE_POS_AS_CHILD)
- {
- if (ctree->drag_row >= 0)
- {
- if (ctree->drag_rect)
- {
- draw_xor_rect (ctree);
- ctree->drag_rect = FALSE;
- }
- else
- draw_xor_line (ctree);
- }
- ctree->insert_pos = insert_pos;
- ctree->drag_target =
- GTK_CTREE_NODE (g_list_nth (clist->row_list, row));
- ctree->drag_row = row;
- draw_xor_line (ctree);
- check_cursor(ctree);
- }
- else if (ctree->drag_target &&
- !GTK_CTREE_ROW (ctree->drag_target)->is_leaf)
- {
- if (ctree->drag_row >= 0)
- {
- if (ctree->drag_rect)
- draw_xor_rect (ctree);
- else
- draw_xor_line (ctree);
- }
- ctree->drag_rect = TRUE;
- ctree->insert_pos = insert_pos;
- ctree->drag_target =
- GTK_CTREE_NODE (g_list_nth (clist->row_list, row));
- ctree->drag_row = row;
- draw_xor_rect (ctree);
- check_cursor(ctree);
- }
- }
- }
- return GTK_WIDGET_CLASS (parent_class)->motion_notify_event (widget, event);
-}
-
-static gint
-gtk_ctree_button_release (GtkWidget *widget,
- GdkEventButton *event)
-{
- GtkCTree *ctree;
- GtkCList *clist;
-
- 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);
-
- ctree = GTK_CTREE (widget);
- clist = GTK_CLIST (widget);
-
- if (event->button == 2 && clist->anchor == -1)
- {
- gtk_grab_remove (widget);
- gdk_pointer_ungrab (event->time);
-
- ctree->in_drag = FALSE;
-
- set_mouse_cursor(ctree, TRUE);
-
- if (ctree->use_icons && ctree->drag_icon)
- {
- gdk_window_destroy (ctree->drag_icon);
- ctree->drag_icon = NULL;
- }
-
- if (ctree->drag_row >= 0)
- {
- if (ctree->drag_rect)
- {
- draw_xor_rect (ctree);
- ctree->drag_rect = FALSE;
- }
- else
- draw_xor_line (ctree);
- ctree->drag_row = -1;
- }
-
- if (GTK_CLIST_ADD_MODE (clist))
- gdk_gc_set_dashes (clist->xor_gc, 0, "\4\4", 2);
- else
- gdk_gc_set_line_attributes (clist->xor_gc, 1,
- GDK_LINE_SOLID, 0, 0);
-
- /* nop if out of bounds / source == target */
- if (event->x < 0 || event->y < -3 ||
- event->x > clist->clist_window_width ||
- event->y > clist->clist_window_height + 3 ||
- ctree->drag_target == ctree->drag_source ||
- !ctree->drag_target)
- return GTK_WIDGET_CLASS (parent_class)->button_release_event
- (widget, event);
-
- if (!GTK_CTREE_ROW (ctree->drag_source)->children ||
- !gtk_ctree_is_ancestor (ctree, ctree->drag_source,
- ctree->drag_target))
- {
- if (ctree->insert_pos == GTK_CTREE_POS_AFTER)
- {
- if (GTK_CTREE_ROW (ctree->drag_target)->sibling !=
- ctree->drag_source)
- if (!ctree->drag_compare ||
- ctree->drag_compare (ctree,
- ctree->drag_source,
- GTK_CTREE_ROW (ctree->drag_target)->parent,
- GTK_CTREE_ROW (ctree->drag_target)->sibling))
- gtk_signal_emit (GTK_OBJECT (ctree),
- ctree_signals[TREE_MOVE],
- ctree->drag_source,
- GTK_CTREE_ROW (ctree->drag_target)->parent,
- GTK_CTREE_ROW (ctree->drag_target)->sibling);
- }
- else if (ctree->insert_pos == GTK_CTREE_POS_BEFORE)
- {
- if (GTK_CTREE_ROW (ctree->drag_source)->sibling !=
- ctree->drag_target)
- if (!ctree->drag_compare ||
- ctree->drag_compare (ctree,
- ctree->drag_source,
- GTK_CTREE_ROW (ctree->drag_target)->parent,
- ctree->drag_target))
- gtk_signal_emit (GTK_OBJECT (ctree),
- ctree_signals[TREE_MOVE],
- ctree->drag_source,
- GTK_CTREE_ROW (ctree->drag_target)->parent,
- ctree->drag_target);
- }
- else if (!GTK_CTREE_ROW (ctree->drag_target)->is_leaf)
- {
- if (GTK_CTREE_ROW (ctree->drag_target)->children !=
- ctree->drag_source)
- if (!ctree->drag_compare ||
- ctree->drag_compare (ctree,
- ctree->drag_source,
- ctree->drag_target,
- GTK_CTREE_ROW (ctree->drag_target)->children))
- gtk_signal_emit (GTK_OBJECT (ctree),
- ctree_signals[TREE_MOVE],
- ctree->drag_source,
- ctree->drag_target,
- GTK_CTREE_ROW (ctree->drag_target)->children);
- }
- }
- ctree->drag_source = NULL;
- ctree->drag_target = NULL;
- }
- else if (event->button == 1 && GTK_CLIST_DRAG_SELECTION (clist) &&
- (clist->selection_mode == GTK_SELECTION_SINGLE ||
- clist->selection_mode == GTK_SELECTION_MULTIPLE))
- {
- gint row;
- gint column;
- GtkCTreeNode *work;
-
- if (gtk_clist_get_selection_info
- (clist, event->x, event->y, &row, &column))
- {
- if (clist->anchor == clist->focus_row &&
- (work = GTK_CTREE_NODE (g_list_nth (clist->row_list, row))))
- tree_toggle_selection (ctree, work, column);
- }
- clist->anchor = -1;
- }
- return GTK_WIDGET_CLASS (parent_class)->button_release_event (widget, event);
-}
-
-static void
-create_drag_icon (GtkCTree *ctree,
- GtkCTreeRow *row)
-{
- GtkCList *clist;
- GtkWidget *widget;
- GdkWindow *window = NULL;
- GdkWindowAttr attributes;
- gint attributes_mask;
- GdkPixmap *pixmap;
- GdkBitmap *mask;
- GdkModifierType modmask;
- gint root_x;
- gint root_y;
-
- clist = GTK_CLIST (ctree);
- widget = GTK_WIDGET (ctree);
-
- if (!(pixmap = GTK_CELL_PIXTEXT (row->row.cell[ctree->tree_column])->pixmap))
- return;
- mask = GTK_CELL_PIXTEXT (row->row.cell[ctree->tree_column])->mask;
-
- gdk_window_get_pointer (NULL, &root_x, &root_y, &modmask);
- gdk_window_get_size (pixmap, &ctree->icon_width, &ctree->icon_height);
-
- attributes.window_type = GDK_WINDOW_TEMP;
- attributes.x = root_x - ctree->icon_width / 2;
- attributes.y = root_y - ctree->icon_height;
- attributes.width = ctree->icon_width;
- attributes.height = ctree->icon_height;
- attributes.wclass = GDK_INPUT_OUTPUT;
- attributes.visual = gtk_widget_get_visual (widget);
- attributes.colormap = gtk_widget_get_colormap (widget);
- attributes.event_mask = gtk_widget_get_events (widget);
-
- attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
-
- window = gdk_window_new (widget->window, &attributes, attributes_mask);
- gdk_window_set_back_pixmap (window, pixmap, FALSE);
- if (mask)
- gdk_window_shape_combine_mask (window, mask, 0, 0);
- gdk_window_show (window);
-
- ctree->drag_icon = window;
-}
-
static void
-draw_xor_line (GtkCTree *ctree)
+draw_drag_highlight (GtkCList *clist,
+ GtkCListRow *dest_row,
+ gint dest_row_number,
+ GtkCListDragPos drag_pos)
{
- GtkCList *clist;
+ GtkCTree *ctree;
+ GdkPoint points[4];
gint level;
+ gint i;
gint y = 0;
- clist = GTK_CLIST (ctree);
+ g_return_if_fail (GTK_IS_CTREE (clist));
- level = GTK_CTREE_ROW (ctree->drag_target)->level;
+ ctree = GTK_CTREE (clist);
- if (ctree->insert_pos == GTK_CTREE_POS_AFTER)
- y = ROW_TOP_YPIXEL (clist, ctree->drag_row) + clist->row_height;
- else
- y = ROW_TOP_YPIXEL (clist, ctree->drag_row) - 1;
+ level = ((GtkCTreeRow *)(dest_row))->level;
- if (clist->column[ctree->tree_column].visible)
- switch (clist->column[ctree->tree_column].justification)
- {
- case GTK_JUSTIFY_CENTER:
- case GTK_JUSTIFY_FILL:
- case GTK_JUSTIFY_LEFT:
- if (ctree->tree_column > 0)
- gdk_draw_line (clist->clist_window, clist->xor_gc,
- COLUMN_LEFT_XPIXEL(clist, 0), y,
- COLUMN_LEFT_XPIXEL(clist, ctree->tree_column - 1) +
- clist->column[ctree->tree_column - 1].area.width, y);
+ y = ROW_TOP_YPIXEL (clist, dest_row_number) - 1;
+
+ switch (drag_pos)
+ {
+ case GTK_CLIST_DRAG_NONE:
+ break;
+ case GTK_CLIST_DRAG_AFTER:
+ y += clist->row_height + 1;
+ case GTK_CLIST_DRAG_BEFORE:
- gdk_draw_line (clist->clist_window, clist->xor_gc,
- COLUMN_LEFT_XPIXEL(clist, ctree->tree_column) +
- ctree->tree_indent * level -
- (ctree->tree_indent - PM_SIZE) / 2, y,
- GTK_WIDGET (ctree)->allocation.width, y);
- break;
- case GTK_JUSTIFY_RIGHT:
- if (ctree->tree_column < clist->columns - 1)
- gdk_draw_line (clist->clist_window, clist->xor_gc,
- COLUMN_LEFT_XPIXEL(clist, ctree->tree_column + 1), y,
- COLUMN_LEFT_XPIXEL(clist, clist->columns - 1) +
- clist->column[clist->columns - 1].area.width, y);
+ if (clist->column[ctree->tree_column].visible)
+ switch (clist->column[ctree->tree_column].justification)
+ {
+ case GTK_JUSTIFY_CENTER:
+ case GTK_JUSTIFY_FILL:
+ case GTK_JUSTIFY_LEFT:
+ if (ctree->tree_column > 0)
+ gdk_draw_line (clist->clist_window, clist->xor_gc,
+ COLUMN_LEFT_XPIXEL(clist, 0), y,
+ COLUMN_LEFT_XPIXEL(clist, ctree->tree_column - 1)+
+ clist->column[ctree->tree_column - 1].area.width,
+ y);
+
+ gdk_draw_line (clist->clist_window, clist->xor_gc,
+ COLUMN_LEFT_XPIXEL(clist, ctree->tree_column) +
+ ctree->tree_indent * level -
+ (ctree->tree_indent - PM_SIZE) / 2, y,
+ GTK_WIDGET (ctree)->allocation.width, y);
+ break;
+ case GTK_JUSTIFY_RIGHT:
+ if (ctree->tree_column < clist->columns - 1)
+ gdk_draw_line (clist->clist_window, clist->xor_gc,
+ COLUMN_LEFT_XPIXEL(clist, ctree->tree_column + 1),
+ y,
+ COLUMN_LEFT_XPIXEL(clist, clist->columns - 1) +
+ clist->column[clist->columns - 1].area.width, y);
+ gdk_draw_line (clist->clist_window, clist->xor_gc,
+ 0, y, COLUMN_LEFT_XPIXEL(clist, ctree->tree_column)
+ + clist->column[ctree->tree_column].area.width -
+ ctree->tree_indent * level +
+ (ctree->tree_indent - PM_SIZE) / 2, y);
+ break;
+ }
+ else
gdk_draw_line (clist->clist_window, clist->xor_gc,
- 0, y, COLUMN_LEFT_XPIXEL(clist, ctree->tree_column)
- + clist->column[ctree->tree_column].area.width -
- ctree->tree_indent * level +
- (ctree->tree_indent - PM_SIZE) / 2, y);
- break;
- }
- else
- gdk_draw_line (clist->clist_window, clist->xor_gc,
- 0, y, clist->clist_window_width, y);
-}
-
-static void
-draw_xor_rect (GtkCTree *ctree)
-{
- GtkCList *clist;
- GdkPoint points[4];
- guint level;
- gint i;
- gint y;
-
- clist = GTK_CLIST (ctree);
-
- level = GTK_CTREE_ROW (ctree->drag_target)->level;
-
- y = ROW_TOP_YPIXEL (clist, ctree->drag_row) + clist->row_height;
+ 0, y, clist->clist_window_width, y);
+ break;
+ case GTK_CLIST_DRAG_INTO:
+ y = ROW_TOP_YPIXEL (clist, dest_row_number) + clist->row_height;
- if (clist->column[ctree->tree_column].visible)
- switch (clist->column[ctree->tree_column].justification)
- {
- case GTK_JUSTIFY_CENTER:
- case GTK_JUSTIFY_FILL:
- case GTK_JUSTIFY_LEFT:
- points[0].x = COLUMN_LEFT_XPIXEL(clist, ctree->tree_column) +
- ctree->tree_indent * level - (ctree->tree_indent - PM_SIZE) / 2;
- points[0].y = y;
- points[3].x = points[0].x;
- points[3].y = y - clist->row_height - 1;
- points[1].x = clist->clist_window_width - 1;
- points[1].y = points[0].y;
- points[2].x = points[1].x;
- points[2].y = points[3].y;
-
- for (i = 0; i < 3; i++)
- gdk_draw_line (clist->clist_window, clist->xor_gc,
- points[i].x, points[i].y,
- points[i+1].x, points[i+1].y);
-
- if (ctree->tree_column > 0)
+ if (clist->column[ctree->tree_column].visible)
+ switch (clist->column[ctree->tree_column].justification)
{
- points[0].x = COLUMN_LEFT_XPIXEL(clist, ctree->tree_column - 1) +
- clist->column[ctree->tree_column - 1].area.width ;
+ case GTK_JUSTIFY_CENTER:
+ case GTK_JUSTIFY_FILL:
+ case GTK_JUSTIFY_LEFT:
+ points[0].x = COLUMN_LEFT_XPIXEL(clist, ctree->tree_column) +
+ ctree->tree_indent * level - (ctree->tree_indent - PM_SIZE) / 2;
points[0].y = y;
points[3].x = points[0].x;
points[3].y = y - clist->row_height - 1;
- points[1].x = 0;
+ points[1].x = clist->clist_window_width - 1;
points[1].y = points[0].y;
- points[2].x = 0;
+ points[2].x = points[1].x;
points[2].y = points[3].y;
for (i = 0; i < 3; i++)
gdk_draw_line (clist->clist_window, clist->xor_gc,
- points[i].x, points[i].y, points[i+1].x,
- points[i+1].y);
- }
- break;
- case GTK_JUSTIFY_RIGHT:
- points[0].x = COLUMN_LEFT_XPIXEL(clist, ctree->tree_column) -
- ctree->tree_indent * level + (ctree->tree_indent - PM_SIZE) / 2 +
- clist->column[ctree->tree_column].area.width;
- points[0].y = y;
- points[3].x = points[0].x;
- points[3].y = y - clist->row_height - 1;
- points[1].x = 0;
- points[1].y = points[0].y;
- points[2].x = 0;
- points[2].y = points[3].y;
-
- for (i = 0; i < 3; i++)
- gdk_draw_line (clist->clist_window, clist->xor_gc,
- points[i].x, points[i].y,
- points[i+1].x, points[i+1].y);
-
- if (ctree->tree_column < clist->columns - 1)
- {
- points[0].x = COLUMN_LEFT_XPIXEL(clist, ctree->tree_column + 1);
+ points[i].x, points[i].y,
+ points[i+1].x, points[i+1].y);
+
+ if (ctree->tree_column > 0)
+ {
+ points[0].x = COLUMN_LEFT_XPIXEL(clist,
+ ctree->tree_column - 1) +
+ clist->column[ctree->tree_column - 1].area.width ;
+ points[0].y = y;
+ points[3].x = points[0].x;
+ points[3].y = y - clist->row_height - 1;
+ points[1].x = 0;
+ points[1].y = points[0].y;
+ points[2].x = 0;
+ points[2].y = points[3].y;
+
+ for (i = 0; i < 3; i++)
+ gdk_draw_line (clist->clist_window, clist->xor_gc,
+ points[i].x, points[i].y, points[i+1].x,
+ points[i+1].y);
+ }
+ break;
+ case GTK_JUSTIFY_RIGHT:
+ points[0].x = COLUMN_LEFT_XPIXEL(clist, ctree->tree_column) -
+ ctree->tree_indent * level + (ctree->tree_indent - PM_SIZE) / 2 +
+ clist->column[ctree->tree_column].area.width;
points[0].y = y;
points[3].x = points[0].x;
points[3].y = y - clist->row_height - 1;
- points[1].x = clist->clist_window_width - 1;
+ points[1].x = 0;
points[1].y = points[0].y;
- points[2].x = points[1].x;
+ points[2].x = 0;
points[2].y = points[3].y;
for (i = 0; i < 3; i++)
gdk_draw_line (clist->clist_window, clist->xor_gc,
points[i].x, points[i].y,
points[i+1].x, points[i+1].y);
+
+ if (ctree->tree_column < clist->columns - 1)
+ {
+ points[0].x = COLUMN_LEFT_XPIXEL(clist, ctree->tree_column +1);
+ points[0].y = y;
+ points[3].x = points[0].x;
+ points[3].y = y - clist->row_height - 1;
+ points[1].x = clist->clist_window_width - 1;
+ points[1].y = points[0].y;
+ points[2].x = points[1].x;
+ points[2].y = points[3].y;
+
+ for (i = 0; i < 3; i++)
+ gdk_draw_line (clist->clist_window, clist->xor_gc,
+ points[i].x, points[i].y,
+ points[i+1].x, points[i+1].y);
+ }
+ break;
}
- break;
- }
- else
- gdk_draw_rectangle (clist->clist_window, clist->xor_gc, FALSE,
- 0, y - clist->row_height,
- clist->clist_window_width - 1, clist->row_height);
+ else
+ gdk_draw_rectangle (clist->clist_window, clist->xor_gc, FALSE,
+ 0, y - clist->row_height,
+ clist->clist_window_width - 1, clist->row_height);
+ break;
+ }
}
static gint
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);
}
GdkGC **fg_gc,
GdkGC **bg_gc)
{
+ gint fg_state;
+
+ if ((state == GTK_STATE_NORMAL) &&
+ (GTK_WIDGET (clist)->state == GTK_STATE_INSENSITIVE))
+ fg_state = GTK_STATE_INSENSITIVE;
+ else
+ fg_state = state;
+
if (clist_row->cell[column].style)
{
if (style)
*style = clist_row->cell[column].style;
if (fg_gc)
- *fg_gc = clist_row->cell[column].style->fg_gc[state];
- if (bg_gc)
- *bg_gc = clist_row->cell[column].style->bg_gc[state];
+ *fg_gc = clist_row->cell[column].style->fg_gc[fg_state];
+ if (bg_gc) {
+ if (state == GTK_STATE_SELECTED)
+ *bg_gc = clist_row->cell[column].style->bg_gc[state];
+ else
+ *bg_gc = clist_row->cell[column].style->base_gc[state];
+ }
}
else if (clist_row->style)
{
if (style)
*style = clist_row->style;
if (fg_gc)
- *fg_gc = clist_row->style->fg_gc[state];
- if (bg_gc)
- *bg_gc = clist_row->style->bg_gc[state];
+ *fg_gc = clist_row->style->fg_gc[fg_state];
+ if (bg_gc) {
+ if (state == GTK_STATE_SELECTED)
+ *bg_gc = clist_row->style->bg_gc[state];
+ else
+ *bg_gc = clist_row->style->base_gc[state];
+ }
}
else
{
if (style)
*style = GTK_WIDGET (clist)->style;
if (fg_gc)
- *fg_gc = GTK_WIDGET (clist)->style->fg_gc[state];
- if (bg_gc)
- *bg_gc = GTK_WIDGET (clist)->style->bg_gc[state];
+ *fg_gc = GTK_WIDGET (clist)->style->fg_gc[fg_state];
+ if (bg_gc) {
+ if (state == GTK_STATE_SELECTED)
+ *bg_gc = GTK_WIDGET (clist)->style->bg_gc[state];
+ else
+ *bg_gc = GTK_WIDGET (clist)->style->base_gc[state];
+ }
if (state != GTK_STATE_SELECTED)
{
>K_CTREE_ROW (parent)->row.background);
}
else if (state == GTK_STATE_SELECTED)
- bg_gc = style->bg_gc[state];
+ bg_gc = style->base_gc[state];
else
- bg_gc = GTK_WIDGET (clist)->style->bg_gc[state];
+ bg_gc = GTK_WIDGET (clist)->style->base_gc[state];
if (!area)
gdk_draw_rectangle (clist->clist_window, bg_gc, TRUE,
if (!area)
gdk_draw_rectangle (clist->clist_window,
GTK_WIDGET
- (ctree)->style->bg_gc[GTK_STATE_PRELIGHT],
+ (ctree)->style->base_gc[GTK_STATE_NORMAL],
TRUE,
tree_rectangle.x,
tree_rectangle.y,
&tc_rectangle))
gdk_draw_rectangle (clist->clist_window,
GTK_WIDGET
- (ctree)->style->bg_gc[GTK_STATE_PRELIGHT],
+ (ctree)->style->base_gc[GTK_STATE_NORMAL],
TRUE,
tc_rectangle.x,
tc_rectangle.y,
{
GtkWidget *widget;
GtkCTree *ctree;
- GdkRectangle *rect;
GdkRectangle *crect;
GdkRectangle row_rectangle;
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 (clist_row->state == GTK_STATE_NORMAL)
{
- state = GTK_STATE_PRELIGHT;
if (clist_row->fg_set)
gdk_gc_set_foreground (clist->fg_gc, &clist_row->foreground);
if (clist_row->bg_set)
gdk_gc_set_foreground (clist->bg_gc, &clist_row->background);
}
- else
- state = clist_row->state;
+
+ state = clist_row->state;
gdk_gc_set_foreground (ctree->lines_gc,
&widget->style->fg[clist_row->state]);
/* draw the cell borders */
if (area)
{
- rect = &intersect_rectangle;
crect = &intersect_rectangle;
if (gdk_rectangle_intersect (area, &cell_rectangle, crect))
}
else
{
- rect = &clip_rectangle;
crect = &cell_rectangle;
gdk_draw_rectangle (clist->clist_window,
}
}
- /* 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;
}
}
+ 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 +
- GTK_CELL_PIXTEXT (clist_row->cell[i])->spacing);
-
- 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 &&
+ GTK_CELL_PIXTEXT (clist_row->cell[i])->pixmap)
+ width += GTK_CELL_PIXTEXT (clist_row->cell[i])->spacing;
+
if (i == ctree->tree_column)
width += (ctree->tree_indent *
((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 = (clist->row_height - logical_rect.height) / 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 = (clist->row_height - logical_rect.height) / 2;
+
if (clist->column[i].justification == GTK_JUSTIFY_RIGHT)
- offset = (old_offset - string_width -
- GTK_CELL_PIXTEXT (clist_row->cell[i])->spacing);
- else
- 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);
+ {
+ offset = (old_offset - string_width);
+ if (GTK_CELL_PIXTEXT (clist_row->cell[i])->pixmap)
+ offset -= GTK_CELL_PIXTEXT (clist_row->cell[i])->spacing;
+ }
else
- row_center_offset = clist->row_center_offset;
+ {
+ if (GTK_CELL_PIXTEXT (clist_row->cell[i])->pixmap)
+ offset += GTK_CELL_PIXTEXT (clist_row->cell[i])->spacing;
+ }
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,
clist = GTK_CLIST (ctree);
- if (!GTK_CLIST_FROZEN (clist) && gtk_ctree_is_viewable (ctree, node))
+ if (CLIST_UNFROZEN (clist) && gtk_ctree_is_viewable (ctree, node))
{
GtkCTreeNode *work;
gint num = 0;
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);
}
}
+static void
+real_row_move (GtkCList *clist,
+ gint source_row,
+ gint dest_row)
+{
+ GtkCTree *ctree;
+ GtkCTreeNode *node;
+
+ g_return_if_fail (GTK_IS_CTREE (clist));
+
+ if (GTK_CLIST_AUTO_SORT (clist))
+ return;
+
+ if (source_row < 0 || source_row >= clist->rows ||
+ dest_row < 0 || dest_row >= clist->rows ||
+ source_row == dest_row)
+ return;
+
+ ctree = GTK_CTREE (clist);
+ node = GTK_CTREE_NODE (g_list_nth (clist->row_list, source_row));
+
+ if (source_row < dest_row)
+ {
+ GtkCTreeNode *work;
+
+ dest_row++;
+ work = GTK_CTREE_ROW (node)->children;
+
+ while (work && GTK_CTREE_ROW (work)->level > GTK_CTREE_ROW (node)->level)
+ {
+ work = GTK_CTREE_NODE_NEXT (work);
+ dest_row++;
+ }
+
+ if (dest_row > clist->rows)
+ dest_row = clist->rows;
+ }
+
+ if (dest_row < clist->rows)
+ {
+ GtkCTreeNode *sibling;
+
+ sibling = GTK_CTREE_NODE (g_list_nth (clist->row_list, dest_row));
+ gtk_ctree_move (ctree, node, GTK_CTREE_ROW (sibling)->parent, sibling);
+ }
+ else
+ gtk_ctree_move (ctree, node, NULL, NULL);
+}
+
static void
real_tree_move (GtkCTree *ctree,
GtkCTreeNode *node,
{
GtkCList *clist;
GtkCTreeNode *work;
- gboolean thaw = FALSE;
gboolean visible = FALSE;
g_return_if_fail (ctree != NULL);
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);
new_sibling == GTK_CTREE_ROW (node)->sibling)
return;
- if (!GTK_CLIST_FROZEN (clist))
- {
- gtk_clist_freeze (clist);
- thaw = TRUE;
- }
+ 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);
(clist, ctree->tree_column,
gtk_clist_optimal_column_width (clist, ctree->tree_column));
- if (thaw)
- gtk_clist_thaw (clist);
+ gtk_clist_thaw (clist);
}
static void
GtkCList *clist;
GtkCTreeNode *node;
- g_return_if_fail (ctree != NULL);
g_return_if_fail (GTK_IS_CTREE (ctree));
clist = GTK_CLIST (ctree);
- if (gdk_pointer_is_grabbed () && GTK_WIDGET_HAS_GRAB (ctree))
+ if (gdk_display_pointer_is_grabbed (gtk_widget_get_display (GTK_WIDGET (ctree))) &&
+ GTK_WIDGET_HAS_GRAB (ctree))
return;
if (!(node =
GtkCTreeNode *work;
GtkRequisition requisition;
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;
visible = gtk_ctree_is_viewable (ctree, node);
/* 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 */
work = GTK_CTREE_ROW (node)->children;
if (work)
{
- GList *list;
+ GList *list = (GList *)work;
gint *cell_width = NULL;
gint tmp = 0;
gint row;
cell_width = g_new0 (gint, clist->columns);
if (clist->column[ctree->tree_column].auto_resize)
cell_width[ctree->tree_column] = requisition.width;
- }
- while (GTK_CTREE_NODE_NEXT (work))
- {
- if (visible && !GTK_CLIST_AUTO_RESIZE_BLOCKED (clist))
+ while (work)
{
/* search maximum cell widths of auto_resize columns */
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]);
}
- }
- work = GTK_CTREE_NODE_NEXT (work);
- tmp++;
+ list = (GList *)work;
+ work = GTK_CTREE_NODE_NEXT (work);
+ tmp++;
+ }
}
+ else
+ while (work)
+ {
+ list = (GList *)work;
+ work = GTK_CTREE_NODE_NEXT (work);
+ tmp++;
+ }
- list = (GList *)work;
list->next = (GList *)GTK_CTREE_NODE_NEXT (node);
if (GTK_CTREE_NODE_NEXT (node))
{
- list = (GList *)GTK_CTREE_NODE_NEXT (node);
- list->prev = (GList *)work;
+ GList *tmp_list;
+
+ tmp_list = (GList *)GTK_CTREE_NODE_NEXT (node);
+ tmp_list->prev = list;
}
else
- clist->row_list_end = (GList *)work;
+ clist->row_list_end = list;
list = (GList *)node;
list->next = (GList *)(GTK_CTREE_ROW (node)->children);
-
+
if (visible)
{
/* resize auto_resize columns if needed */
/* update focus_row position */
row = g_list_position (clist->row_list, (GList *)node);
if (row < clist->focus_row)
- clist->focus_row += tmp + 1;
+ clist->focus_row += tmp;
- clist->rows += tmp + 1;
- if (!GTK_CLIST_FROZEN (ctree))
- gtk_clist_thaw (clist);
+ clist->rows += tmp;
+ CLIST_REFRESH (clist);
}
}
else if (visible && clist->column[ctree->tree_column].auto_resize)
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 */
if (row < clist->focus_row)
clist->focus_row -= tmp;
clist->rows -= tmp;
- if (!GTK_CLIST_FROZEN (ctree))
- gtk_clist_thaw (clist);
+ CLIST_REFRESH (clist);
}
}
else if (visible && clist->column[ctree->tree_column].auto_resize &&
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_PRELIGHT, 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;
- requisition->height = 0;
break;
}
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 */
+ /* unimplemented */
break;
default:
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:
break;
}
- if (visible)
+ if (visible && clist->column[column].auto_resize &&
+ !GTK_CLIST_AUTO_RESIZE_BLOCKED (clist))
column_auto_resize (clist, clist_row, column, requisition.width);
+
+ 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 (clist->selection, node);
- }
- }
-
+ tree_unselect (ctree, node, NULL);
row_delete (ctree, GTK_CTREE_ROW (node));
g_list_free_1 ((GList *)node);
}
int i;
clist = GTK_CLIST (ctree);
- ctree_row = g_chunk_new (GtkCTreeRow, clist->row_mem_chunk);
- ctree_row->row.cell = g_chunk_new (GtkCell, clist->cell_mem_chunk);
+ ctree_row = g_slice_new (GtkCTreeRow);
+ ctree_row->row.cell = g_slice_alloc (sizeof (GtkCell) * clist->columns);
for (i = 0; i < clist->columns; i++)
{
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);
+ g_slice_free1 (sizeof (GtkCell) * clist->columns, ctree_row->row.cell);
+ g_slice_free (GtkCTreeRow, ctree_row);
}
static void
{
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)
tree_draw_node (ctree, node);
}
-static void
-tree_toggle_selection (GtkCTree *ctree,
- GtkCTreeNode *node,
- gint column)
-{
- GtkCList *clist;
-
- g_return_if_fail (ctree != NULL);
- g_return_if_fail (GTK_IS_CTREE (ctree));
-
- clist = GTK_CLIST (ctree);
-
- switch (clist->selection_mode)
- {
- case GTK_SELECTION_SINGLE:
- case GTK_SELECTION_MULTIPLE:
- if (node && GTK_CTREE_ROW (node)->row.state == GTK_STATE_SELECTED)
- gtk_signal_emit (GTK_OBJECT (ctree), ctree_signals[TREE_UNSELECT_ROW],
- node, column);
- else if (node && GTK_CTREE_ROW (node)->row.selectable)
- gtk_signal_emit (GTK_OBJECT (ctree), ctree_signals[TREE_SELECT_ROW],
- node, column);
- break;
-
- case GTK_SELECTION_BROWSE:
- if (node && GTK_CTREE_ROW (node)->row.state == GTK_STATE_NORMAL &&
- GTK_CTREE_ROW (node)->row.selectable)
- gtk_signal_emit (GTK_OBJECT (ctree), ctree_signals[TREE_SELECT_ROW],
- node, column);
- break;
-
- case GTK_SELECTION_EXTENDED:
- break;
- }
-}
-
static void
select_row_recursive (GtkCTree *ctree,
GtkCTreeNode *node,
{
GtkCTree *ctree;
GtkCTreeNode *node;
- gboolean thaw = FALSE;
- 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:
- if (!GTK_CLIST_FROZEN (clist))
- {
- gtk_clist_freeze (clist);
- thaw = TRUE;
- }
+ gtk_clist_freeze (clist);
g_list_free (clist->undo_selection);
g_list_free (clist->undo_unselection);
node = GTK_CTREE_NODE_NEXT (node))
gtk_ctree_pre_recursive (ctree, node, select_row_recursive, NULL);
- if (thaw)
- gtk_clist_thaw (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;
{
GtkCTreeRow *tree_row;
GtkCList *clist;
- GtkCellPixText *cell;
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]);
-
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_CLIST_CONSTRUCTED (ctree) == FALSE);
-
- 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);
+ GObject *object = G_OBJECT_CLASS (parent_class)->constructor (type,
+ n_construct_properties,
+ construct_properties);
- ctree->tree_column = tree_column;
-
- gtk_clist_construct (clist, columns, titles);
+ return object;
}
-GtkWidget *
-gtk_ctree_new_with_titles (gint columns,
- gint tree_column,
- gchar *titles[])
+GtkWidget*
+gtk_ctree_new_with_titles (gint columns,
+ gint tree_column,
+ gchar *titles[])
{
GtkWidget *widget;
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 ?
column_auto_resize (clist, &(new_row->row), i, 0);
}
- if (!GTK_CLIST_FROZEN (clist))
- gtk_clist_thaw (clist);
+ if (clist->rows == 1)
+ {
+ clist->focus_row = 0;
+ if (clist->selection_mode == GTK_SELECTION_BROWSE)
+ gtk_ctree_select (ctree, node);
+ }
+
+
+ CLIST_REFRESH (clist);
return node;
}
GtkCTreeNode *child = NULL;
GtkCTreeNode *new_child;
GList *list;
- gboolean thaw;
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);
list->data = row_new (ctree);
cnode = GTK_CTREE_NODE (list);
- thaw = !GTK_CLIST_FROZEN (clist);
- if (thaw)
- gtk_clist_freeze (clist);
+ gtk_clist_freeze (clist);
set_node_info (ctree, cnode, "", 0, NULL, NULL, NULL, NULL, TRUE, FALSE);
if (!func (ctree, depth, gnode, cnode, data))
{
tree_delete_row (ctree, cnode, NULL);
+ gtk_clist_thaw (clist);
return NULL;
}
child = new_child;
}
- if (thaw)
- gtk_clist_thaw (clist);
+ gtk_clist_thaw (clist);
return cnode;
}
{
GtkCTreeNode *work;
GNode *gnode;
- GNode *new_sibling;
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);
if (parent)
g_node_insert_before (parent, sibling, gnode);
- for (work = GTK_CTREE_ROW (node)->children, new_sibling = NULL; work;
- work = GTK_CTREE_NODE_NEXT (work))
+ if (!GTK_CTREE_ROW (node)->is_leaf)
{
- sibling = gtk_ctree_export_to_gnode (ctree, gnode, new_sibling,
- work, func, data);
- if (sibling)
- new_sibling = sibling;
+ GNode *new_sibling = NULL;
+
+ for (work = GTK_CTREE_ROW (node)->children; work;
+ work = GTK_CTREE_ROW (work)->sibling)
+ new_sibling = gtk_ctree_export_to_gnode (ctree, gnode, new_sibling,
+ work, func, data);
+
+ g_node_reverse_children (gnode);
}
- g_node_reverse_children (gnode);
return gnode;
}
{
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));
GtkCTreeNode *node)
{
GtkCList *clist;
- gboolean thaw = FALSE;
- g_return_if_fail (ctree != NULL);
g_return_if_fail (GTK_IS_CTREE (ctree));
clist = GTK_CLIST (ctree);
- if (!GTK_CLIST_FROZEN (clist))
- {
- gtk_clist_freeze (clist);
- thaw = TRUE;
- }
+ gtk_clist_freeze (clist);
if (node)
{
- gboolean visible;
-
- visible = gtk_ctree_is_viewable (ctree, node);
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);
else
gtk_clist_clear (clist);
- if (thaw)
- gtk_clist_thaw (clist);
+ gtk_clist_thaw (clist);
}
static void
GtkCTreeNode *work;
GtkCTreeNode *ptr;
- g_return_if_fail (clist != NULL);
g_return_if_fail (GTK_IS_CTREE (clist));
ctree = GTK_CTREE (clist);
- ctree->drag_row = -1;
- ctree->drag_rect = FALSE;
- ctree->in_drag = FALSE;
- ctree->drag_source = NULL;
- ctree->drag_target = NULL;
- ctree->drag_icon = NULL;
-
/* remove all rows */
work = GTK_CTREE_NODE (clist->row_list);
clist->row_list = NULL;
}
GTK_CLIST_UNSET_FLAG (clist, CLIST_AUTO_RESIZE_BLOCKED);
- (parent_class->clear) (clist);
+ parent_class->clear (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);
+ g_return_val_if_fail (GTK_IS_CTREE (ctree), NULL);
+ g_return_val_if_fail (ctree_row != NULL, NULL);
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);
return node;
}
+GtkCTreeNode *
+gtk_ctree_node_nth (GtkCTree *ctree,
+ guint row)
+{
+ g_return_val_if_fail (GTK_IS_CTREE (ctree), NULL);
+
+ if ((row >= GTK_CLIST(ctree)->rows))
+ return NULL;
+
+ return GTK_CTREE_NODE (g_list_nth (GTK_CLIST (ctree)->row_list, row));
+}
+
gboolean
gtk_ctree_find (GtkCTree *ctree,
GtkCTreeNode *node,
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);
if (node && GTK_CTREE_ROW (node)->is_leaf)
return;
- if (((node && gtk_ctree_is_viewable (ctree, node)) || !node) &&
- !GTK_CLIST_FROZEN (clist))
+ if (CLIST_UNFROZEN (clist) && (!node || gtk_ctree_is_viewable (ctree, node)))
{
gtk_clist_freeze (clist);
thaw = TRUE;
GtkCList *clist;
gboolean thaw = FALSE;
- g_return_if_fail (ctree != NULL);
g_return_if_fail (GTK_IS_CTREE (ctree));
clist = GTK_CLIST (ctree);
if (node && GTK_CTREE_ROW (node)->is_leaf)
return;
- if (((node && gtk_ctree_is_viewable (ctree, node)) || !node) &&
- !GTK_CLIST_FROZEN (clist))
+ if (CLIST_UNFROZEN (clist) && (!node || gtk_ctree_is_viewable (ctree, node)))
{
gtk_clist_freeze (clist);
thaw = TRUE;
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)
clist = GTK_CLIST (ctree);
- if (((node && gtk_ctree_is_viewable (ctree, node)) || !node) &&
- !GTK_CLIST_FROZEN (clist))
+ if (CLIST_UNFROZEN (clist) && (!node || gtk_ctree_is_viewable (ctree, node)))
{
gtk_clist_freeze (clist);
thaw = TRUE;
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)
clist = GTK_CLIST (ctree);
- if (((node && gtk_ctree_is_viewable (ctree, node)) || !node) &&
- !GTK_CLIST_FROZEN (clist))
+ if (CLIST_UNFROZEN (clist) && (!node || gtk_ctree_is_viewable (ctree, node)))
{
gtk_clist_freeze (clist);
thaw = TRUE;
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)
clist = GTK_CLIST (ctree);
- if (((node && gtk_ctree_is_viewable (ctree, node)) || !node) &&
- !GTK_CLIST_FROZEN (clist))
+ if (CLIST_UNFROZEN (clist) && (!node || gtk_ctree_is_viewable (ctree, node)))
{
gtk_clist_freeze (clist);
thaw = TRUE;
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);
(!state && clist->selection_mode == GTK_SELECTION_BROWSE))
return;
- if (((node && gtk_ctree_is_viewable (ctree, node)) || !node) &&
- !GTK_CLIST_FROZEN (clist))
+ if (CLIST_UNFROZEN (clist) && (!node || gtk_ctree_is_viewable (ctree, node)))
{
gtk_clist_freeze (clist);
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);
}
column_auto_resize (clist, >K_CTREE_ROW (node)->row,
column, requisition.width);
- tree_draw_node (ctree, node);
+ tree_draw_node (ctree, node);
+}
+
+static void
+remove_grab (GtkCList *clist)
+{
+ if (gdk_display_pointer_is_grabbed (gtk_widget_get_display (GTK_WIDGET (clist))) &&
+ GTK_WIDGET_HAS_GRAB (clist))
+ {
+ gtk_grab_remove (GTK_WIDGET (clist));
+ gdk_display_pointer_ungrab (gtk_widget_get_display (GTK_WIDGET (clist)),
+ GDK_CURRENT_TIME);
+ }
+
+ if (clist->htimer)
+ {
+ g_source_remove (clist->htimer);
+ clist->htimer = 0;
+ }
+
+ if (clist->vtimer)
+ {
+ g_source_remove (clist->vtimer);
+ clist->vtimer = 0;
+ }
}
void
gtk_ctree_node_set_selectable (GtkCTree *ctree,
GtkCTreeNode *node,
- gboolean selectable)
+ 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)
{
- if ((gdk_pointer_is_grabbed () && GTK_WIDGET_HAS_FOCUS (clist)))
- {
- GTK_CLIST_UNSET_FLAG (clist, CLIST_DRAG_SELECTION);
- gtk_grab_remove (GTK_WIDGET (clist));
- gdk_pointer_ungrab (GDK_CURRENT_TIME);
- if (clist->htimer)
- {
- gtk_timeout_remove (clist->htimer);
- clist->htimer = 0;
- }
- if (clist->vtimer)
- {
- gtk_timeout_remove (clist->vtimer);
- clist->vtimer = 0;
- }
- }
- GTK_CLIST_CLASS_FW (clist)->resync_selection (clist, NULL);
+ clist->drag_button = 0;
+ remove_grab (clist);
+
+ 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);
}
void
-gtk_ctree_node_set_foreground (GtkCTree *ctree,
- GtkCTreeNode *node,
- GdkColor *color)
+gtk_ctree_node_set_foreground (GtkCTree *ctree,
+ GtkCTreeNode *node,
+ const GdkColor *color)
{
- g_return_if_fail (ctree != NULL);
g_return_if_fail (GTK_IS_CTREE (ctree));
g_return_if_fail (node != NULL);
}
void
-gtk_ctree_node_set_background (GtkCTree *ctree,
- GtkCTreeNode *node,
- GdkColor *color)
+gtk_ctree_node_set_background (GtkCTree *ctree,
+ GtkCTreeNode *node,
+ const 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);
gtk_clist_moveto (clist, row, column, row_align, col_align);
}
-GtkVisibility gtk_ctree_node_is_visible (GtkCTree *ctree,
- GtkCTreeNode *node)
+GtkVisibility
+gtk_ctree_node_is_visible (GtkCTree *ctree,
+ GtkCTreeNode *node)
{
gint row;
{
GtkCList *clist;
- g_return_if_fail (ctree != NULL);
g_return_if_fail (GTK_IS_CTREE (ctree));
g_return_if_fail (indent >= 0);
gtk_clist_set_column_width
(clist, ctree->tree_column,
gtk_clist_optimal_column_width (clist, ctree->tree_column));
- else if (!GTK_CLIST_FROZEN (ctree))
- gtk_clist_thaw (GTK_CLIST (ctree));
+ else
+ CLIST_REFRESH (ctree);
}
void
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_clist_set_column_width (clist, ctree->tree_column,
clist->column[ctree->tree_column].width +
spacing - old_spacing);
- else if (!GTK_CLIST_FROZEN (ctree))
- gtk_clist_thaw (GTK_CLIST (ctree));
+ else
+ CLIST_REFRESH (ctree);
}
void
-gtk_ctree_show_stub (GtkCTree *ctree,
- gboolean show_stub)
+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;
clist = GTK_CLIST (ctree);
ctree->show_stub = show_stub;
- if (!GTK_CLIST_FROZEN (clist) && clist->rows &&
+ 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));
}
}
-void
-gtk_ctree_set_reorderable (GtkCTree *ctree,
- gboolean reorderable)
-{
- g_return_if_fail (ctree != NULL);
- g_return_if_fail (GTK_IS_CTREE (ctree));
-
- ctree->reorderable = reorderable;
-}
-
-void
-gtk_ctree_set_use_drag_icons (GtkCTree *ctree,
- gboolean use_icons)
-{
- g_return_if_fail (ctree != NULL);
- g_return_if_fail (GTK_IS_CTREE (ctree));
-
- if (ctree->use_icons == (use_icons != 0))
- return;
-
- ctree->use_icons = (use_icons != 0);
-}
-
void
gtk_ctree_set_line_style (GtkCTree *ctree,
GtkCTreeLineStyle line_style)
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;
default:
return;
}
- if (!GTK_CLIST_FROZEN (ctree))
- gtk_clist_thaw (GTK_CLIST (ctree));
+ CLIST_REFRESH (ctree);
}
}
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)
gtk_clist_set_column_width (clist, ctree->tree_column, new_width);
}
- if (!GTK_CLIST_FROZEN (ctree) && GTK_WIDGET_DRAWABLE (clist))
- gtk_clist_thaw (GTK_CLIST (ctree));
+ if (GTK_WIDGET_DRAWABLE (clist))
+ CLIST_REFRESH (clist);
}
{
GtkCList *clist;
GtkCTreeNode *focus_node = NULL;
- gboolean thaw = FALSE;
- g_return_if_fail (ctree != NULL);
g_return_if_fail (GTK_IS_CTREE (ctree));
clist = GTK_CLIST (ctree);
- if (!GTK_CLIST_FROZEN (clist))
- {
- gtk_clist_freeze (clist);
- thaw = TRUE;
- }
+ 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);
clist->undo_anchor = clist->focus_row;
}
- if (thaw)
- gtk_clist_thaw (clist);
+ gtk_clist_thaw (clist);
}
static void
{
GtkCList *clist;
GtkCTreeNode *focus_node = NULL;
- gboolean thaw = FALSE;
- g_return_if_fail (ctree != NULL);
g_return_if_fail (GTK_IS_CTREE (ctree));
clist = GTK_CLIST (ctree);
- if (!GTK_CLIST_FROZEN (clist))
- {
- gtk_clist_freeze (clist);
- thaw = TRUE;
- }
+ 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);
clist->undo_anchor = clist->focus_row;
}
- if (thaw)
- gtk_clist_thaw (clist);
+ gtk_clist_thaw (clist);
}
/************************************************************************/
{
GTK_CTREE_ROW (focus_node)->row.state = GTK_STATE_SELECTED;
- if (!GTK_CLIST_FROZEN (clist) &&
+ 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 i;
gint e;
gint row;
- gboolean thaw = FALSE;
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);
- if (!GTK_CLIST_FROZEN (clist))
- {
- GTK_CLIST_SET_FLAG (clist, CLIST_FROZEN);
- thaw = TRUE;
- }
+ clist->freeze_count++;
i = MIN (clist->anchor, clist->drag_pos);
e = MAX (clist->anchor, clist->drag_pos);
}
}
-
- for (node = GTK_CTREE_NODE (g_list_nth (clist->row_list, i)); i <= e;
- i++, node = GTK_CTREE_NODE_NEXT (node))
- if (GTK_CTREE_ROW (node)->row.selectable)
- {
- if (g_list_find (clist->selection, node))
+ if (clist->anchor < clist->drag_pos)
+ {
+ for (node = GTK_CTREE_NODE (g_list_nth (clist->row_list, i)); i <= e;
+ i++, node = GTK_CTREE_NODE_NEXT (node))
+ if (GTK_CTREE_ROW (node)->row.selectable)
{
- if (GTK_CTREE_ROW (node)->row.state == GTK_STATE_NORMAL)
+ if (g_list_find (clist->selection, node))
+ {
+ if (GTK_CTREE_ROW (node)->row.state == GTK_STATE_NORMAL)
+ {
+ GTK_CTREE_ROW (node)->row.state = GTK_STATE_SELECTED;
+ gtk_ctree_unselect (ctree, node);
+ clist->undo_selection =
+ g_list_prepend (clist->undo_selection, node);
+ }
+ }
+ else if (GTK_CTREE_ROW (node)->row.state == GTK_STATE_SELECTED)
{
- GTK_CTREE_ROW (node)->row.state = GTK_STATE_SELECTED;
- gtk_ctree_unselect (ctree, node);
- clist->undo_selection = g_list_prepend (clist->undo_selection,
- node);
+ GTK_CTREE_ROW (node)->row.state = GTK_STATE_NORMAL;
+ clist->undo_unselection =
+ g_list_prepend (clist->undo_unselection, node);
}
}
- else if (GTK_CTREE_ROW (node)->row.state == GTK_STATE_SELECTED)
+ }
+ else
+ {
+ for (node = GTK_CTREE_NODE (g_list_nth (clist->row_list, e)); i <= e;
+ e--, node = GTK_CTREE_NODE_PREV (node))
+ if (GTK_CTREE_ROW (node)->row.selectable)
{
- GTK_CTREE_ROW (node)->row.state = GTK_STATE_NORMAL;
- clist->undo_unselection = g_list_prepend (clist->undo_unselection,
- node);
+ if (g_list_find (clist->selection, node))
+ {
+ if (GTK_CTREE_ROW (node)->row.state == GTK_STATE_NORMAL)
+ {
+ GTK_CTREE_ROW (node)->row.state = GTK_STATE_SELECTED;
+ gtk_ctree_unselect (ctree, node);
+ clist->undo_selection =
+ g_list_prepend (clist->undo_selection, node);
+ }
+ }
+ else if (GTK_CTREE_ROW (node)->row.state == GTK_STATE_SELECTED)
+ {
+ GTK_CTREE_ROW (node)->row.state = GTK_STATE_NORMAL;
+ clist->undo_unselection =
+ g_list_prepend (clist->undo_unselection, node);
+ }
}
- }
+ }
+ 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;
clist->drag_pos = -1;
- if (thaw)
- GTK_CLIST_UNSET_FLAG (clist, CLIST_FROZEN);
+ if (!CLIST_UNFROZEN (clist))
+ clist->freeze_count--;
}
static void
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;
}
+static gboolean
+check_drag (GtkCTree *ctree,
+ GtkCTreeNode *drag_source,
+ GtkCTreeNode *drag_target,
+ GtkCListDragPos insert_pos)
+{
+ g_return_val_if_fail (GTK_IS_CTREE (ctree), FALSE);
+
+ if (drag_source && drag_source != drag_target &&
+ (!GTK_CTREE_ROW (drag_source)->children ||
+ !gtk_ctree_is_ancestor (ctree, drag_source, drag_target)))
+ {
+ switch (insert_pos)
+ {
+ case GTK_CLIST_DRAG_NONE:
+ return FALSE;
+ case GTK_CLIST_DRAG_AFTER:
+ if (GTK_CTREE_ROW (drag_target)->sibling != drag_source)
+ return (!ctree->drag_compare ||
+ ctree->drag_compare (ctree,
+ drag_source,
+ GTK_CTREE_ROW (drag_target)->parent,
+ GTK_CTREE_ROW (drag_target)->sibling));
+ break;
+ case GTK_CLIST_DRAG_BEFORE:
+ if (GTK_CTREE_ROW (drag_source)->sibling != drag_target)
+ return (!ctree->drag_compare ||
+ ctree->drag_compare (ctree,
+ drag_source,
+ GTK_CTREE_ROW (drag_target)->parent,
+ drag_target));
+ break;
+ case GTK_CLIST_DRAG_INTO:
+ if (!GTK_CTREE_ROW (drag_target)->is_leaf &&
+ GTK_CTREE_ROW (drag_target)->children != drag_source)
+ return (!ctree->drag_compare ||
+ ctree->drag_compare (ctree,
+ drag_source,
+ drag_target,
+ GTK_CTREE_ROW (drag_target)->children));
+ break;
+ }
+ }
+ return FALSE;
+}
+
+
+
+/************************************/
static void
-set_mouse_cursor (GtkCTree *ctree,
- gboolean enable)
+drag_dest_info_destroy (gpointer data)
{
- GdkCursor *cursor;
+ GtkCListDestInfo *info = data;
- g_return_if_fail (ctree != NULL);
- g_return_if_fail (GTK_IS_CTREE (ctree));
+ g_free (info);
+}
- if (enable)
- cursor = gdk_cursor_new (GDK_LEFT_PTR);
- else
- cursor = gdk_cursor_new (GDK_CIRCLE);
+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;
+ }
- gdk_window_set_cursor (GTK_CLIST (ctree)->clist_window, cursor);
- gdk_cursor_destroy (cursor);
+ 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
-check_cursor (GtkCTree *ctree)
+gtk_ctree_drag_begin (GtkWidget *widget,
+ GdkDragContext *context)
{
- g_return_if_fail (ctree != NULL);
- g_return_if_fail (GTK_IS_CTREE (ctree));
+ GtkCList *clist;
+ GtkCTree *ctree;
+ gboolean use_icons;
+
+ g_return_if_fail (GTK_IS_CTREE (widget));
+ g_return_if_fail (context != NULL);
+
+ clist = GTK_CLIST (widget);
+ ctree = GTK_CTREE (widget);
+
+ use_icons = GTK_CLIST_USE_DRAG_ICONS (clist);
+ GTK_CLIST_UNSET_FLAG (clist, CLIST_USE_DRAG_ICONS);
+ GTK_WIDGET_CLASS (parent_class)->drag_begin (widget, context);
+
+ if (use_icons)
+ {
+ GtkCTreeNode *node;
+
+ GTK_CLIST_SET_FLAG (clist, CLIST_USE_DRAG_ICONS);
+ node = GTK_CTREE_NODE (g_list_nth (clist->row_list,
+ clist->click_cell.row));
+ if (node)
+ {
+ if (GTK_CELL_PIXTEXT
+ (GTK_CTREE_ROW (node)->row.cell[ctree->tree_column])->pixmap)
+ {
+ gtk_drag_set_icon_pixmap
+ (context,
+ gtk_widget_get_colormap (widget),
+ GTK_CELL_PIXTEXT
+ (GTK_CTREE_ROW (node)->row.cell[ctree->tree_column])->pixmap,
+ GTK_CELL_PIXTEXT
+ (GTK_CTREE_ROW (node)->row.cell[ctree->tree_column])->mask,
+ -2, -2);
+ return;
+ }
+ }
+ gtk_drag_set_icon_default (context);
+ }
+}
+
+static gint
+gtk_ctree_drag_motion (GtkWidget *widget,
+ GdkDragContext *context,
+ gint x,
+ gint y,
+ guint time)
+{
+ GtkCList *clist;
+ GtkCTree *ctree;
+ GtkCListDestInfo new_info;
+ GtkCListDestInfo *dest_info;
- if (!GTK_CTREE_ROW (ctree->drag_source)->children ||
- !gtk_ctree_is_ancestor (ctree, ctree->drag_source, ctree->drag_target))
+ g_return_val_if_fail (GTK_IS_CTREE (widget), FALSE);
+
+ clist = GTK_CLIST (widget);
+ ctree = GTK_CTREE (widget);
+
+ dest_info = g_dataset_get_data (context, "gtk-clist-drag-dest");
+
+ if (!dest_info)
+ {
+ dest_info = g_new (GtkCListDestInfo, 1);
+
+ dest_info->cell.row = -1;
+ dest_info->cell.column = -1;
+ dest_info->insert_pos = GTK_CLIST_DRAG_NONE;
+
+ g_dataset_set_data_full (context, "gtk-clist-drag-dest", dest_info,
+ drag_dest_info_destroy);
+ }
+
+ drag_dest_cell (clist, x, y, &new_info);
+
+ if (GTK_CLIST_REORDERABLE (clist))
{
- if (ctree->insert_pos == GTK_CTREE_POS_AFTER)
+ GList *list;
+ GdkAtom atom = gdk_atom_intern_static_string ("gtk-clist-drag-reorder");
+
+ list = context->targets;
+ while (list)
{
- if (GTK_CTREE_ROW (ctree->drag_target)->sibling !=
- ctree->drag_source)
- set_mouse_cursor
- (ctree,
- (!ctree->drag_compare ||
- ctree->drag_compare
- (ctree,
- ctree->drag_source,
- GTK_CTREE_ROW (ctree->drag_target)->parent,
- GTK_CTREE_ROW (ctree->drag_target)->sibling)));
+ if (atom == GDK_POINTER_TO_ATOM (list->data))
+ break;
+ list = list->next;
}
- else if (ctree->insert_pos == GTK_CTREE_POS_BEFORE)
+
+ if (list)
{
- if (GTK_CTREE_ROW (ctree->drag_source)->sibling !=
- ctree->drag_target)
- set_mouse_cursor
- (ctree,
- (!ctree->drag_compare ||
- ctree->drag_compare
- (ctree,
- ctree->drag_source,
- GTK_CTREE_ROW (ctree->drag_target)->parent,
- ctree->drag_target)));
+ GtkCTreeNode *drag_source;
+ GtkCTreeNode *drag_target;
+
+ 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,
+ new_info.cell.row));
+
+ if (gtk_drag_get_source_widget (context) != widget ||
+ !check_drag (ctree, drag_source, drag_target,
+ new_info.insert_pos))
+ {
+ if (dest_info->cell.row < 0)
+ {
+ gdk_drag_status (context, GDK_ACTION_DEFAULT, time);
+ return FALSE;
+ }
+ return TRUE;
+ }
+
+ 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_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 = new_info.insert_pos;
+ dest_info->cell.row = new_info.cell.row;
+ dest_info->cell.column = new_info.cell.column;
+
+ 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;
}
- else if (!GTK_CTREE_ROW (ctree->drag_target)->is_leaf)
+ }
+
+ 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;
+}
+
+static void
+gtk_ctree_drag_data_received (GtkWidget *widget,
+ GdkDragContext *context,
+ gint x,
+ gint y,
+ GtkSelectionData *selection_data,
+ guint info,
+ guint32 time)
+{
+ GtkCTree *ctree;
+ GtkCList *clist;
+
+ g_return_if_fail (GTK_IS_CTREE (widget));
+ g_return_if_fail (context != NULL);
+ g_return_if_fail (selection_data != NULL);
+
+ ctree = GTK_CTREE (widget);
+ clist = GTK_CLIST (widget);
+
+ if (GTK_CLIST_REORDERABLE (clist) &&
+ gtk_drag_get_source_widget (context) == widget &&
+ selection_data->target ==
+ gdk_atom_intern_static_string ("gtk-clist-drag-reorder") &&
+ selection_data->format == 8 &&
+ selection_data->length == sizeof (GtkCListCellInfo))
+ {
+ GtkCListCellInfo *source_info;
+
+ source_info = (GtkCListCellInfo *)(selection_data->data);
+ if (source_info)
{
- if (GTK_CTREE_ROW (ctree->drag_target)->children !=
- ctree->drag_source)
- set_mouse_cursor
- (ctree,
- (!ctree->drag_compare ||
- ctree->drag_compare
- (ctree,
- ctree->drag_source,
- ctree->drag_target,
- GTK_CTREE_ROW (ctree->drag_target)->children)));
+ 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));
+
+ if (!source_node || !dest_node)
+ return;
+
+ 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))
+ 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))
+ 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))
+ gtk_ctree_move (ctree, source_node,
+ GTK_CTREE_ROW (dest_node)->parent,
+ GTK_CTREE_ROW (dest_node)->sibling);
+ g_dataset_remove_data (context, "gtk-clist-drag-dest");
+ break;
+ }
}
}
- else
- set_mouse_cursor(ctree, FALSE);
}
+
+GType
+gtk_ctree_node_get_type (void)
+{
+ static GType our_type = 0;
+
+ if (our_type == 0)
+ our_type = g_pointer_type_register_static ("GtkCTreeNode");
+
+ return our_type;
+}
+
+#define __GTK_CTREE_C__
+#include "gtkaliasdef.c"
projects / ~andy / gtk / blobdiff