+Mon Sep 17 17:39:52 2001 Jonathan Blandford <jrb@redhat.com>
+
+ * gtk/gtkcelleditable.[ch]: Add editable interface. This should
+ be the last big GtkTreeView API change.
+
+ * gtk/gtkcellrenderer.[ch]: Get rid of the "event" vfunc, and
+ replace with "activate" and "start_editing". Also, added a
+ "can_activate" and "can_edit" property.
+
+ * gtk/gtktreeviewcolumn.c: modify to use above.
+
2001-09-16 Alexander Larsson <alla@lysator.liu.se>
- * gtk/gtkoptionmenu.c:
- Handle scroll wheel events.
+ * gtk/gtkoptionmenu.c: Handle scroll wheel events.
Fri Sep 14 22:31:25 2001 Matthias Clasen <matthiasc@poet.de>
+Mon Sep 17 17:39:52 2001 Jonathan Blandford <jrb@redhat.com>
+
+ * gtk/gtkcelleditable.[ch]: Add editable interface. This should
+ be the last big GtkTreeView API change.
+
+ * gtk/gtkcellrenderer.[ch]: Get rid of the "event" vfunc, and
+ replace with "activate" and "start_editing". Also, added a
+ "can_activate" and "can_edit" property.
+
+ * gtk/gtktreeviewcolumn.c: modify to use above.
+
2001-09-16 Alexander Larsson <alla@lysator.liu.se>
- * gtk/gtkoptionmenu.c:
- Handle scroll wheel events.
+ * gtk/gtkoptionmenu.c: Handle scroll wheel events.
Fri Sep 14 22:31:25 2001 Matthias Clasen <matthiasc@poet.de>
+Mon Sep 17 17:39:52 2001 Jonathan Blandford <jrb@redhat.com>
+
+ * gtk/gtkcelleditable.[ch]: Add editable interface. This should
+ be the last big GtkTreeView API change.
+
+ * gtk/gtkcellrenderer.[ch]: Get rid of the "event" vfunc, and
+ replace with "activate" and "start_editing". Also, added a
+ "can_activate" and "can_edit" property.
+
+ * gtk/gtktreeviewcolumn.c: modify to use above.
+
2001-09-16 Alexander Larsson <alla@lysator.liu.se>
- * gtk/gtkoptionmenu.c:
- Handle scroll wheel events.
+ * gtk/gtkoptionmenu.c: Handle scroll wheel events.
Fri Sep 14 22:31:25 2001 Matthias Clasen <matthiasc@poet.de>
+Mon Sep 17 17:39:52 2001 Jonathan Blandford <jrb@redhat.com>
+
+ * gtk/gtkcelleditable.[ch]: Add editable interface. This should
+ be the last big GtkTreeView API change.
+
+ * gtk/gtkcellrenderer.[ch]: Get rid of the "event" vfunc, and
+ replace with "activate" and "start_editing". Also, added a
+ "can_activate" and "can_edit" property.
+
+ * gtk/gtktreeviewcolumn.c: modify to use above.
+
2001-09-16 Alexander Larsson <alla@lysator.liu.se>
- * gtk/gtkoptionmenu.c:
- Handle scroll wheel events.
+ * gtk/gtkoptionmenu.c: Handle scroll wheel events.
Fri Sep 14 22:31:25 2001 Matthias Clasen <matthiasc@poet.de>
+Mon Sep 17 17:39:52 2001 Jonathan Blandford <jrb@redhat.com>
+
+ * gtk/gtkcelleditable.[ch]: Add editable interface. This should
+ be the last big GtkTreeView API change.
+
+ * gtk/gtkcellrenderer.[ch]: Get rid of the "event" vfunc, and
+ replace with "activate" and "start_editing". Also, added a
+ "can_activate" and "can_edit" property.
+
+ * gtk/gtktreeviewcolumn.c: modify to use above.
+
2001-09-16 Alexander Larsson <alla@lysator.liu.se>
- * gtk/gtkoptionmenu.c:
- Handle scroll wheel events.
+ * gtk/gtkoptionmenu.c: Handle scroll wheel events.
Fri Sep 14 22:31:25 2001 Matthias Clasen <matthiasc@poet.de>
+Mon Sep 17 17:39:52 2001 Jonathan Blandford <jrb@redhat.com>
+
+ * gtk/gtkcelleditable.[ch]: Add editable interface. This should
+ be the last big GtkTreeView API change.
+
+ * gtk/gtkcellrenderer.[ch]: Get rid of the "event" vfunc, and
+ replace with "activate" and "start_editing". Also, added a
+ "can_activate" and "can_edit" property.
+
+ * gtk/gtktreeviewcolumn.c: modify to use above.
+
2001-09-16 Alexander Larsson <alla@lysator.liu.se>
- * gtk/gtkoptionmenu.c:
- Handle scroll wheel events.
+ * gtk/gtkoptionmenu.c: Handle scroll wheel events.
Fri Sep 14 22:31:25 2001 Matthias Clasen <matthiasc@poet.de>
+Mon Sep 17 17:39:52 2001 Jonathan Blandford <jrb@redhat.com>
+
+ * gtk/gtkcelleditable.[ch]: Add editable interface. This should
+ be the last big GtkTreeView API change.
+
+ * gtk/gtkcellrenderer.[ch]: Get rid of the "event" vfunc, and
+ replace with "activate" and "start_editing". Also, added a
+ "can_activate" and "can_edit" property.
+
+ * gtk/gtktreeviewcolumn.c: modify to use above.
+
2001-09-16 Alexander Larsson <alla@lysator.liu.se>
- * gtk/gtkoptionmenu.c:
- Handle scroll wheel events.
+ * gtk/gtkoptionmenu.c: Handle scroll wheel events.
Fri Sep 14 22:31:25 2001 Matthias Clasen <matthiasc@poet.de>
@accel_group:
@Returns:
+<!-- ##### FUNCTION gtk_cell_renderer_event ##### -->
+<para>
+
+</para>
+
+@cell:
+@event:
+@widget:
+@path:
+@background_area:
+@cell_area:
+@flags:
+@Returns:
+
<!-- ##### FUNCTION gtk_cell_renderer_text_pixbuf_new ##### -->
<para>
@xpad:
@ypad:
@can_activate:
+@can_edit:
@visible:
@is_expander:
@is_expanded:
@flags:
-<!-- ##### FUNCTION gtk_cell_renderer_event ##### -->
-<para>
-
-</para>
-
-@cell:
-@event:
-@widget:
-@path:
-@background_area:
-@cell_area:
-@flags:
-@Returns:
-
-
gtkctree.h \
gtkcurve.h \
gtkcellrenderer.h \
+ gtkcelleditable.h \
gtkcellrenderertext.h \
gtkcellrenderertoggle.h \
gtkcellrendererpixbuf.h \
gtkbutton.c \
gtkcalendar.c \
gtkcellrenderer.c \
+ gtkcelleditable.c \
gtkcellrenderertext.c \
gtkcellrenderertoggle.c \
gtkcellrendererpixbuf.c \
--- /dev/null
+/* gtkcelleditable.c
+ * Copyright (C) 2000 Red Hat, Inc., Jonathan Blandford <jrb@redhat.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+
+#include "gtkcelleditable.h"
+#include "gtksignal.h"
+
+static void gtk_cell_editable_base_init (gpointer g_class);
+
+GtkType
+gtk_cell_editable_get_type (void)
+{
+ static GtkType cell_editable_type = 0;
+
+ if (! cell_editable_type)
+ {
+ static const GTypeInfo cell_editable_info =
+ {
+ sizeof (GtkCellEditableIface), /* class_size */
+ gtk_cell_editable_base_init, /* base_init */
+ NULL, /* base_finalize */
+ NULL,
+ NULL, /* class_finalize */
+ NULL, /* class_data */
+ 0,
+ 0,
+ NULL
+ };
+ cell_editable_type = g_type_register_static (G_TYPE_INTERFACE, "GtkCellEditable", &cell_editable_info, 0);
+ g_type_interface_add_prerequisite (cell_editable_type, GTK_TYPE_WIDGET);
+ }
+
+ return cell_editable_type;
+}
+
+static void
+gtk_cell_editable_base_init (gpointer g_class)
+{
+ static gboolean initialized = FALSE;
+
+ if (! initialized)
+ {
+ g_signal_new ("editing_done",
+ GTK_TYPE_CELL_EDITABLE,
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (GtkCellEditableIface, editing_done),
+ NULL, NULL,
+ gtk_marshal_VOID__VOID,
+ G_TYPE_NONE, 0);
+ g_signal_new ("remove_widget",
+ GTK_TYPE_CELL_EDITABLE,
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (GtkCellEditableIface, remove_widget),
+ NULL, NULL,
+ gtk_marshal_VOID__VOID,
+ G_TYPE_NONE, 0);
+ initialized = TRUE;
+ }
+}
+
+void
+gtk_cell_editable_start_editing (GtkCellEditable *cell_editable,
+ GdkEvent *event)
+{
+}
+
+void
+gtk_cell_editable_stop_editing (GtkCellEditable *cell_editable)
+{
+}
+
+
+void
+gtk_cell_editable_editing_done (GtkCellEditable *cell_editable)
+{
+}
+
+void
+gtk_cell_editable_remove_widget (GtkCellEditable *cell_editable)
+{
+
+}
--- /dev/null
+/* gtkcelleditable.h
+ * Copyright (C) 2001 Red Hat, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#ifndef __GTK_CELL_EDITABLE_H__
+#define __GTK_CELL_EDITABLE_H__
+
+#include <gtk/gtkwidget.h>
+
+G_BEGIN_DECLS
+
+#define GTK_TYPE_CELL_EDITABLE (gtk_cell_editable_get_type ())
+#define GTK_CELL_EDITABLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_CELL_EDITABLE, GtkCellEditable))
+#define GTK_CELL_EDITABLE_CLASS(obj) (G_TYPE_CHECK_CLASS_CAST ((obj), GTK_TYPE_CELL_EDITABLE, GtkCellEditableIface))
+#define GTK_IS_CELL_EDITABLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_CELL_EDITABLE))
+#define GTK_CELL_EDITABLE_GET_IFACE(obj) ((GtkCellEditableIface *)g_type_interface_peek (((GTypeInstance *) GTK_CELL_EDITABLE (obj))->g_class, GTK_TYPE_CELL_EDITABLE))
+
+typedef struct _GtkCellEditable GtkCellEditable; /* Dummy typedef */
+typedef struct _GtkCellEditableIface GtkCellEditableIface;
+
+struct _GtkCellEditableIface
+{
+ GTypeInterface g_iface;
+
+ /* signals */
+ void (* editing_done) (GtkCellEditable *cell_editable);
+ void (* remove_widget) (GtkCellEditable *cell_editable);
+
+ /* virtual table */
+ void (* start_editing) (GtkCellEditable *cell_editable,
+ GdkEvent *event);
+ void (* stop_editing) (GtkCellEditable *cell_editable);
+};
+
+
+GType gtk_cell_editable_get_type (void) G_GNUC_CONST;
+
+void gtk_cell_editable_start_editing (GtkCellEditable *cell_editable,
+ GdkEvent *event);
+void gtk_cell_editable_stop_editing (GtkCellEditable *cell_editable);
+void gtk_cell_editable_editing_done (GtkCellEditable *cell_editable);
+void gtk_cell_editable_remove_widget (GtkCellEditable *cell_editable);
+
+
+G_END_DECLS
+
+#endif /* __GTK_CELL_EDITABLE_H__ */
enum {
PROP_ZERO,
PROP_CAN_ACTIVATE,
+ PROP_CAN_EDIT,
PROP_VISIBLE,
PROP_XALIGN,
PROP_YALIGN,
gtk_cell_renderer_init (GtkCellRenderer *cell)
{
cell->can_activate = FALSE;
+ cell->can_edit = FALSE;
cell->visible = TRUE;
cell->width = -1;
cell->height = -1;
G_PARAM_READABLE |
G_PARAM_WRITABLE));
+ g_object_class_install_property (object_class,
+ PROP_CAN_EDIT,
+ g_param_spec_boolean ("can_edit",
+ _("can_edit"),
+ _("Cell supports CellEditable interface."),
+ FALSE,
+ G_PARAM_READABLE |
+ G_PARAM_WRITABLE));
+
g_object_class_install_property (object_class,
PROP_VISIBLE,
g_param_spec_boolean ("visible",
case PROP_CAN_ACTIVATE:
g_value_set_boolean (value, cell->can_activate);
break;
+ case PROP_CAN_EDIT:
+ g_value_set_boolean (value, cell->can_edit);
+ break;
case PROP_VISIBLE:
g_value_set_boolean (value, cell->visible);
break;
case PROP_CAN_ACTIVATE:
cell->can_activate = g_value_get_boolean (value);
g_object_notify (object, "can_activate");
+ /* can_activate and can_edit are mutually exclusive */
+ if (cell->can_activate && cell->can_edit)
+ {
+ cell->can_edit = FALSE;
+ g_object_notify (object, "can_edit");
+ }
+ break;
+ case PROP_CAN_EDIT:
+ cell->can_edit = g_value_get_boolean (value);
+ g_object_notify (object, "can_edit");
+ /* can_activate and can_edit are mutually exclusive */
+ if (cell->can_activate && cell->can_edit)
+ {
+ cell->can_activate = FALSE;
+ g_object_notify (object, "can_activate");
+ }
break;
case PROP_VISIBLE:
cell->visible = g_value_get_boolean (value);
}
/**
- * gtk_cell_renderer_event:
+ * gtk_cell_renderer_activate:
* @cell: a #GtkCellRenderer
* @event: a #GdkEvent
* @widget: widget that received the event
* @cell_area: cell area as passed to gtk_cell_renderer_render()
* @flags: render flags
*
- * Passes an event to the cell renderer for possible processing. Some
- * cell renderers may use events; for example, #GtkCellRendererToggle
- * toggles when it gets a mouse click.
+ * Passes an activate event to the cell renderer for possible processing. Some
+ * cell renderers may use events; for example, #GtkCellRendererToggle toggles
+ * when it gets a mouse click.
*
* Return value: %TRUE if the event was consumed/handled
**/
gboolean
-gtk_cell_renderer_event (GtkCellRenderer *cell,
- GdkEvent *event,
- GtkWidget *widget,
- gchar *path,
- GdkRectangle *background_area,
- GdkRectangle *cell_area,
- GtkCellRendererState flags)
+gtk_cell_renderer_activate (GtkCellRenderer *cell,
+ GdkEvent *event,
+ GtkWidget *widget,
+ gchar *path,
+ GdkRectangle *background_area,
+ GdkRectangle *cell_area,
+ GtkCellRendererState flags)
{
- /* It's actually okay to pass in a NULL cell, as we run into that
- * a lot
- */
- if (cell == NULL)
- return FALSE;
g_return_val_if_fail (GTK_IS_CELL_RENDERER (cell), FALSE);
- if (GTK_CELL_RENDERER_GET_CLASS (cell)->event == NULL)
+
+ if (! cell->can_activate)
return FALSE;
- return GTK_CELL_RENDERER_GET_CLASS (cell)->event (cell,
- event,
- widget,
- path,
- background_area,
- cell_area,
- flags);
+ if (GTK_CELL_RENDERER_GET_CLASS (cell)->activate == NULL)
+ return FALSE;
+
+ return GTK_CELL_RENDERER_GET_CLASS (cell)->activate (cell,
+ event,
+ widget,
+ path,
+ background_area,
+ cell_area,
+ flags);
+}
+
+
+/**
+ * gtk_cell_renderer_start_editing:
+ * @cell: a #GtkCellRenderer
+ * @event: a #GdkEvent
+ * @widget: widget that received the event
+ * @path: widget-dependent string representation of the event location; e.g. for #GtkTreeView, a string representation of #GtkTreePath
+ * @background_area: background area as passed to gtk_cell_renderer_render()
+ * @cell_area: cell area as passed to gtk_cell_renderer_render()
+ * @flags: render flags
+ *
+ * Passes an activate event to the cell renderer for possible processing.
+ *
+ * Return value: A new #GtkCellEditable, or %NULL
+ **/
+GtkCellEditable *
+gtk_cell_renderer_start_editing (GtkCellRenderer *cell,
+ GdkEvent *event,
+ GtkWidget *widget,
+ gchar *path,
+ GdkRectangle *background_area,
+ GdkRectangle *cell_area,
+ GtkCellRendererState flags)
+
+{
+ g_return_val_if_fail (GTK_IS_CELL_RENDERER (cell), NULL);
+
+ if (! cell->can_edit)
+ return NULL;
+
+ if (GTK_CELL_RENDERER_GET_CLASS (cell)->start_editing == NULL)
+ return NULL;
+
+
+ return GTK_CELL_RENDERER_GET_CLASS (cell)->start_editing (cell,
+ event,
+ widget,
+ path,
+ background_area,
+ cell_area,
+ flags);
}
/**
#include <gtk/gtkobject.h>
#include <gtk/gtkwidget.h>
+#include <gtk/gtkcelleditable.h>
-#ifdef __cplusplus
-extern "C" {
-
-#endif /* __cplusplus */
+G_BEGIN_DECLS
typedef enum
{
guint16 ypad;
guint can_activate : 1;
+ guint can_edit : 1;
guint visible : 1;
guint is_expander : 1;
guint is_expanded : 1;
GtkObjectClass parent_class;
/* vtable - not signals */
- void (* get_size) (GtkCellRenderer *cell,
- GtkWidget *widget,
- GdkRectangle *cell_area,
- gint *x_offset,
- gint *y_offset,
- gint *width,
- gint *height);
-
- void (* render) (GtkCellRenderer *cell,
- GdkWindow *window,
- GtkWidget *widget,
- GdkRectangle *background_area,
- GdkRectangle *cell_area,
- GdkRectangle *expose_area,
- GtkCellRendererState flags);
-
- gboolean (* event) (GtkCellRenderer *cell,
- GdkEvent *event,
- GtkWidget *widget,
- gchar *path,
- GdkRectangle *background_area,
- GdkRectangle *cell_area,
- GtkCellRendererState flags);
+ void (* get_size) (GtkCellRenderer *cell,
+ GtkWidget *widget,
+ GdkRectangle *cell_area,
+ gint *x_offset,
+ gint *y_offset,
+ gint *width,
+ gint *height);
+ void (* render) (GtkCellRenderer *cell,
+ GdkWindow *window,
+ GtkWidget *widget,
+ GdkRectangle *background_area,
+ GdkRectangle *cell_area,
+ GdkRectangle *expose_area,
+ GtkCellRendererState flags);
+ gboolean (* activate) (GtkCellRenderer *cell,
+ GdkEvent *event,
+ GtkWidget *widget,
+ gchar *path,
+ GdkRectangle *background_area,
+ GdkRectangle *cell_area,
+ GtkCellRendererState flags);
+ GtkCellEditable *(* start_editing) (GtkCellRenderer *cell,
+ GdkEvent *event,
+ GtkWidget *widget,
+ gchar *path,
+ GdkRectangle *background_area,
+ GdkRectangle *cell_area,
+ GtkCellRendererState flags);
};
-GtkType gtk_cell_renderer_get_type (void);
-void gtk_cell_renderer_get_size (GtkCellRenderer *cell,
- GtkWidget *widget,
- GdkRectangle *cell_area,
- gint *x_offset,
- gint *y_offset,
- gint *width,
- gint *height);
-void gtk_cell_renderer_render (GtkCellRenderer *cell,
- GdkWindow *window,
- GtkWidget *widget,
- GdkRectangle *background_area,
- GdkRectangle *cell_area,
- GdkRectangle *expose_area,
- GtkCellRendererState flags);
-gboolean gtk_cell_renderer_event (GtkCellRenderer *cell,
- GdkEvent *event,
- GtkWidget *widget,
- gchar *path,
- GdkRectangle *background_area,
- GdkRectangle *cell_area,
- GtkCellRendererState flags);
-void gtk_cell_renderer_set_fixed_size (GtkCellRenderer *cell,
- gint width,
- gint height);
-void gtk_cell_renderer_get_fixed_size (GtkCellRenderer *cell,
- gint *width,
- gint *height);
-
-
-#ifdef __cplusplus
-}
-#endif /* __cplusplus */
-
+GType gtk_cell_renderer_get_type (void) G_GNUC_CONST;
+
+void gtk_cell_renderer_get_size (GtkCellRenderer *cell,
+ GtkWidget *widget,
+ GdkRectangle *cell_area,
+ gint *x_offset,
+ gint *y_offset,
+ gint *width,
+ gint *height);
+void gtk_cell_renderer_render (GtkCellRenderer *cell,
+ GdkWindow *window,
+ GtkWidget *widget,
+ GdkRectangle *background_area,
+ GdkRectangle *cell_area,
+ GdkRectangle *expose_area,
+ GtkCellRendererState flags);
+gboolean gtk_cell_renderer_activate (GtkCellRenderer *cell,
+ GdkEvent *event,
+ GtkWidget *widget,
+ gchar *path,
+ GdkRectangle *background_area,
+ GdkRectangle *cell_area,
+ GtkCellRendererState flags);
+GtkCellEditable *gtk_cell_renderer_start_editing (GtkCellRenderer *cell,
+ GdkEvent *event,
+ GtkWidget *widget,
+ gchar *path,
+ GdkRectangle *background_area,
+ GdkRectangle *cell_area,
+ GtkCellRendererState flags);
+void gtk_cell_renderer_set_fixed_size (GtkCellRenderer *cell,
+ gint width,
+ gint height);
+void gtk_cell_renderer_get_fixed_size (GtkCellRenderer *cell,
+ gint *width,
+ gint *height);
+
+
+
+G_END_DECLS
#endif /* __GTK_CELL_RENDERER_H__ */
GdkRectangle *cell_area,
GdkRectangle *expose_area,
guint flags);
-static gboolean gtk_cell_renderer_toggle_event (GtkCellRenderer *cell,
- GdkEvent *event,
- GtkWidget *widget,
- gchar *path,
- GdkRectangle *background_area,
- GdkRectangle *cell_area,
- guint flags);
+static gboolean gtk_cell_renderer_toggle_activate (GtkCellRenderer *cell,
+ GdkEvent *event,
+ GtkWidget *widget,
+ gchar *path,
+ GdkRectangle *background_area,
+ GdkRectangle *cell_area,
+ guint flags);
enum {
cell_class->get_size = gtk_cell_renderer_toggle_get_size;
cell_class->render = gtk_cell_renderer_toggle_render;
- cell_class->event = gtk_cell_renderer_toggle_event;
+ cell_class->activate = gtk_cell_renderer_toggle_activate;
g_object_class_install_property (object_class,
PROP_ACTIVE,
}
static gint
-gtk_cell_renderer_toggle_event (GtkCellRenderer *cell,
- GdkEvent *event,
- GtkWidget *widget,
- gchar *path,
- GdkRectangle *background_area,
- GdkRectangle *cell_area,
- guint flags)
+gtk_cell_renderer_toggle_activate (GtkCellRenderer *cell,
+ GdkEvent *event,
+ GtkWidget *widget,
+ gchar *path,
+ GdkRectangle *background_area,
+ GdkRectangle *cell_area,
+ guint flags)
{
GtkCellRendererToggle *celltoggle;
gboolean retval = FALSE;
static GdkColor gtk_default_prelight_bg = { 0, 0xea60, 0xea60, 0xea60 };
static GdkColor gtk_default_selected_bg = { 0, 0, 0, 0x9c40 };
static GdkColor gtk_default_insensitive_bg = { 0, 0xd6d6, 0xd6d6, 0xd6d6 };
+static GdkColor gtk_default_selected_base = { 0, 0xa4a4, 0xdfdf, 0xffff };
+static GdkColor gtk_default_active_base = { 0, 0xbcbc, 0xd2d2, 0xeeee };
static gpointer parent_class = NULL;
static GdkFont *static_default_font = NULL;
style->base[i] = style->white;
}
- style->base[GTK_STATE_SELECTED] = gtk_default_selected_bg;
+ style->base[GTK_STATE_SELECTED] = gtk_default_selected_base;
+ style->text[GTK_STATE_SELECTED] = style->black;
+ style->base[GTK_STATE_ACTIVE] = gtk_default_active_base;
+ style->text[GTK_STATE_ACTIVE] = style->black;
style->base[GTK_STATE_INSENSITIVE] = gtk_default_prelight_bg;
style->text[GTK_STATE_INSENSITIVE] = gtk_default_insensitive_fg;
!strncmp ("cell_odd", detail, strlen ("cell_odd")))
{
/* This has to be really broken; alex made me do it. -jrb */
- /* Red rum!!! REd RUM!!! */
if (GTK_WIDGET_HAS_FOCUS (widget))
- gc1 = style->bg_gc[state_type];
+ gc1 = style->base_gc[state_type];
else
- gc1 = style->bg_gc[GTK_STATE_ACTIVE];
-
+ gc1 = style->base_gc[GTK_STATE_ACTIVE];
}
else
{
NULL
};
tree_sortable_type = g_type_register_static (G_TYPE_INTERFACE, "GtkTreeSortable", &tree_sortable_info, 0);
- g_type_interface_add_prerequisite (tree_sortable_type, G_TYPE_OBJECT);
+ g_type_interface_add_prerequisite (tree_sortable_type, GTK_TYPE_TREE_MODEL);
}
return tree_sortable_type;
GdkEventButton *event);
static void gtk_tree_view_set_focus_child (GtkContainer *container,
GtkWidget *child);
-static void gtk_tree_view_draw_focus (GtkWidget *widget);
static gint gtk_tree_view_focus_in (GtkWidget *widget,
GdkEventFocus *event);
static gint gtk_tree_view_focus_out (GtkWidget *widget,
static void gtk_tree_view_real_set_cursor (GtkTreeView *tree_view,
GtkTreePath *path,
gboolean clear_and_select);
+static void gtk_tree_view_ensure_focus_column (GtkTreeView *tree_view);
/* interactive search */
g_assert (tree_view->priv->prelight_node == NULL);
}
+static void
+gtk_tree_view_ensure_focus_column (GtkTreeView *tree_view)
+{
+ GList *list;
+ if (tree_view->priv->focus_column != NULL &&
+ tree_view->priv->focus_column->visible)
+ return;
+
+ if (tree_view->priv->focus_column)
+ gtk_tree_view_column_cell_focus (tree_view->priv->focus_column, 0, TRUE);
+
+ for (list = tree_view->priv->columns; list; list = list->next)
+ {
+ GtkTreeViewColumn *column = list->data;
+
+ if (column->visible)
+ {
+ gtk_tree_view_column_cell_focus (column, 1, FALSE);
+ return;
+ }
+ }
+}
+
/* Our motion arrow is either a box (in the case of the original spot)
return FALSE;
}
-/* Draws the focus rectangle around the cursor row */
-static void
-gtk_tree_view_draw_focus (GtkWidget *widget)
-{
- GtkTreeView *tree_view;
- GtkTreePath *cursor_path;
- GtkRBTree *tree = NULL;
- GtkRBNode *node = NULL;
- gint x, y;
- gint width, height;
- gint vertical_separator;
-
- g_return_if_fail (GTK_IS_TREE_VIEW (widget));
-
- tree_view = GTK_TREE_VIEW (widget);
-
- gtk_widget_style_get (widget, "vertical_separator", &vertical_separator, NULL);
-
- if (! GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_DRAW_KEYFOCUS))
- return;
-
- if (! gtk_tree_row_reference_valid (tree_view->priv->cursor))
- return;
-
- cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
-
- _gtk_tree_view_find_node (tree_view, cursor_path, &tree, &node);
-
- if (tree == NULL)
- {
- gtk_tree_path_free (cursor_path);
- return;
- }
-
- gdk_drawable_get_size (tree_view->priv->bin_window,
- &width, NULL);
-
-
- x = 0;
- y = BACKGROUND_FIRST_PIXEL (tree_view, tree, node);
- gdk_drawable_get_size (tree_view->priv->bin_window,
- &width, NULL);
- width = width - 1;
- height = BACKGROUND_HEIGHT (node) - 1;
- if (tree_view->priv->focus_column != NULL)
- {
- GtkTreeIter iter;
-
- gtk_tree_model_get_iter (tree_view->priv->model, &iter, cursor_path);
- gtk_tree_view_column_cell_set_cell_data (tree_view->priv->focus_column,
- tree_view->priv->model,
- &iter,
- GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT),
- node->children?TRUE:FALSE);
-
- if (gtk_tree_view_column_cell_can_focus (tree_view->priv->focus_column))
- {
- GdkRectangle cell_area;
- gint x_offset;
- gint y_offset;
-
- cell_area.x = tree_view->priv->focus_column->button->allocation.x;
- cell_area.y = y;
- cell_area.width = tree_view->priv->focus_column->width;
- cell_area.height = CELL_HEIGHT (node, vertical_separator);
-
- gtk_tree_view_column_cell_get_size (tree_view->priv->focus_column,
- &cell_area, &x_offset, &y_offset, &width, &height);
-
- width += 2;
- height += 2;
-
- x = cell_area.x + x_offset - 1;
- y = cell_area.y + y_offset - 1 + vertical_separator/2;
- }
- }
-
- gtk_paint_focus (widget->style,
- tree_view->priv->bin_window,
- NULL,
- widget,
- "treeview",
- x, y, width, height);
-
- gtk_tree_path_free (cursor_path);
-}
-
/* Warning: Very scary function.
* Modify at your own risk
*/
return TRUE;
gtk_tree_view_check_dirty_and_clean (GTK_TREE_VIEW (widget));
- /* we want to account for a potential HEADER offset.
- * That is, if the header exists, we want to offset our event by its
- * height to find the right node.
+ gtk_tree_view_ensure_focus_column (GTK_TREE_VIEW (widget));
+ /* we want to account for a potential HEADER offset. That is, if the header
+ * exists, we want to offset our event by its height to find the right node.
*/
new_y = (event->area.y<TREE_VIEW_HEADER_HEIGHT (tree_view))?TREE_VIEW_HEADER_HEIGHT (tree_view):event->area.y;
-
- /* y_offset is the */
-
y_offset = -_gtk_rbtree_find_offset (tree_view->priv->tree,
TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, new_y),
&tree,
else
state = GTK_STATE_NORMAL;
- /* Draw background */
+ /* Draw background */
gtk_paint_flat_box (widget->style,
event->window,
state,
&event->area,
flags);
}
+ if (node == cursor &&
+ GTK_WIDGET_HAS_FOCUS (widget) &&
+ column == tree_view->priv->focus_column)
+ {
+ gtk_tree_view_column_cell_draw_focus (column,
+ event->window,
+ &background_area,
+ &cell_area,
+ &event->area,
+ flags);
+ }
cell_offset += column->width;
}
- if (node == cursor && GTK_WIDGET_HAS_FOCUS (widget))
- gtk_tree_view_draw_focus (widget);
if (node == drag_highlight)
{
&iter,
GTK_RBNODE_FLAG_SET (cursor_node, GTK_RBNODE_IS_PARENT),
cursor_node->children?TRUE:FALSE);
- if (gtk_tree_view_column_cell_can_focus (column))
+ if (gtk_tree_view_column_cell_focus (column, count, FALSE))
{
- if (gtk_tree_view_column_cell_focus (column, count, FALSE))
- {
- tree_view->priv->focus_column = column;
- found_column = TRUE;
- break;
- }
+ tree_view->priv->focus_column = column;
+ found_column = TRUE;
+ break;
}
loop_end:
if (count == 1)
va_list args);
static GtkTreeViewColumnCellInfo *gtk_tree_view_column_get_cell_info (GtkTreeViewColumn *tree_column,
GtkCellRenderer *cell_renderer);
-static void gtk_tree_view_column_cell_foreach (GtkTreeViewColumn *tree_column,
- gboolean direction,
- GFunc function,
- gpointer data);
}
}
-#if 0
+
/**
* gtk_tree_view_column_cell_get_size:
* @tree_column: A #GtkTreeViewColumn.
* primarily by the GtkTreeView.
**/
void
-gtk_tree_view_column_cell_get_size (GtkTreeViewColumn *tree_column,
- GdkRectangle *cell_area,
- gint *x_offset,
- gint *y_offset,
- gint *width,
- gint *height)
-{
- g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column));
-
- gtk_cell_renderer_get_size (((GtkTreeViewColumnCellInfo *) tree_column->cell_list->data)->cell,
- tree_column->tree_view,
- cell_area,
- x_offset,
- y_offset,
- width,
- height);
-
-}
-#endif
-void
gtk_tree_view_column_cell_get_size (GtkTreeViewColumn *tree_column,
GdkRectangle *cell_area,
gint *x_offset,
NULL);
if (visible && can_activate)
{
- if (gtk_cell_renderer_event (((GtkTreeViewColumnCellInfo *) tree_column->cell_list->data)->cell,
- event,
- tree_column->tree_view,
- path_string,
- background_area,
- cell_area,
- flags))
+ if (gtk_cell_renderer_activate (((GtkTreeViewColumnCellInfo *) tree_column->cell_list->data)->cell,
+ event,
+ tree_column->tree_view,
+ path_string,
+ background_area,
+ cell_area,
+ flags))
return TRUE;
}
gint direction,
gboolean unfocus)
{
- GList *list;
- gboolean visible;
- gboolean can_activate;
-
+ if (unfocus)
+ GTK_TREE_VIEW (tree_column->tree_view)->priv->focus_column = NULL;
+ else
+ GTK_TREE_VIEW (tree_column->tree_view)->priv->focus_column = tree_column;
+ return TRUE;
}
-gboolean
-gtk_tree_view_column_cell_can_focus (GtkTreeViewColumn *tree_column)
-{
- GList *list;
- gboolean visible;
- gboolean can_activate;
-
- for (list = tree_column->cell_list; list; list = list->next)
- {
- GtkTreeViewColumnCellInfo *info = (GtkTreeViewColumnCellInfo *) list->data;
- g_object_get (G_OBJECT (info->cell),
- "can_activate", &can_activate,
- "visible", &visible,
- NULL);
- if (can_activate && visible)
- return TRUE;
- }
-
- return FALSE;
+void
+gtk_tree_view_column_cell_draw_focus (GtkTreeViewColumn *tree_column,
+ GdkWindow *window,
+ GdkRectangle *background_area,
+ GdkRectangle *cell_area,
+ GdkRectangle *expose_area,
+ guint flags)
+{
+ gtk_paint_focus (tree_column->tree_view->style,
+ window,
+ NULL,
+ tree_column->tree_view,
+ "treeview",
+ cell_area->x,
+ cell_area->y,
+ cell_area->width-1,
+ cell_area->height);
}
-
gboolean
gtk_tree_view_column_cell_is_visible (GtkTreeViewColumn *tree_column)
{
gboolean gtk_tree_view_column_cell_focus (GtkTreeViewColumn *tree_column,
gint direction,
gboolean unfocus);
-gboolean gtk_tree_view_column_cell_can_focus (GtkTreeViewColumn *tree_column);
+void gtk_tree_view_column_cell_draw_focus (GtkTreeViewColumn *tree_column,
+ GdkWindow *window,
+ GdkRectangle *background_area,
+ GdkRectangle *cell_area,
+ GdkRectangle *expose_area,
+ guint flags);
gboolean gtk_tree_view_column_cell_is_visible (GtkTreeViewColumn *tree_column);
void gtk_tree_view_column_cell_set_dirty (GtkTreeViewColumn *tree_column);
projects / ~andy / gtk / commitdiff