[glade3/signal-tree-model] glade-signal-editor: Adapt to tristan's UI wishes
- From: Johannes Schmid <jhs src gnome org>
- To: commits-list gnome org
- Cc:
- Subject: [glade3/signal-tree-model] glade-signal-editor: Adapt to tristan's UI wishes
- Date: Fri, 7 Jan 2011 11:56:37 +0000 (UTC)
commit 097de9b14d0de293620049ab1863b62be0b2bdff
Author: Johannes Schmid <jhs gnome org>
Date: Fri Jan 7 12:56:06 2011 +0100
glade-signal-editor: Adapt to tristan's UI wishes
gladeui/glade-signal-editor.c | 16 +-
gladeui/glade-signal-model.c | 779 +++++++++++++++++++++--------------------
gladeui/glade-signal-model.h | 2 +-
3 files changed, 405 insertions(+), 392 deletions(-)
---
diff --git a/gladeui/glade-signal-editor.c b/gladeui/glade-signal-editor.c
index f5ba90f..98f3c8f 100644
--- a/gladeui/glade-signal-editor.c
+++ b/gladeui/glade-signal-editor.c
@@ -99,6 +99,8 @@ on_handler_edited (GtkCellRendererText* renderer,
GladeSignal* old_signal;
GladeSignal* new_signal;
+ g_message ("Changing handler!");
+
gtk_tree_model_get (self->priv->model,
&iter,
GLADE_SIGNAL_COLUMN_SIGNAL,
@@ -129,13 +131,13 @@ on_handler_edited (GtkCellRendererText* renderer,
}
else
{
- GtkTreeIter parent;
GladeSignal* signal;
gchar* name;
+ g_message ("Adding handler!");
+
/* Get the signal name */
- gtk_tree_model_iter_parent (self->priv->model, &parent, &iter);
- gtk_tree_model_get (self->priv->model, &parent,
+ gtk_tree_model_get (self->priv->model, &iter,
GLADE_SIGNAL_COLUMN_NAME, &name,
-1);
@@ -373,13 +375,13 @@ name_cell_data_func (GtkTreeViewColumn* column,
{
gchar* name;
gboolean bold;
- gboolean handler;
PangoWeight weight = PANGO_WEIGHT_NORMAL;
+ gboolean visible;
gtk_tree_model_get (model, iter,
GLADE_SIGNAL_COLUMN_NAME, &name,
- GLADE_SIGNAL_COLUMN_HAS_HANDLERS, &bold,
- GLADE_SIGNAL_COLUMN_IS_HANDLER, &handler,
+ GLADE_SIGNAL_COLUMN_NOT_DUMMY, &bold,
+ GLADE_SIGNAL_COLUMN_SHOW_NAME, &visible,
-1);
if (bold)
@@ -388,7 +390,7 @@ name_cell_data_func (GtkTreeViewColumn* column,
g_object_set (renderer,
"text", name,
"weight", weight,
- "visible", !handler,
+ "visible", visible,
NULL);
g_free (name);
diff --git a/gladeui/glade-signal-model.c b/gladeui/glade-signal-model.c
index f3b1f9c..de69939 100644
--- a/gladeui/glade-signal-model.c
+++ b/gladeui/glade-signal-model.c
@@ -1,12 +1,12 @@
/*
* glade3
* Copyright (C) Johannes Schmid 2010 <jhs gnome org>
- *
+ *
* glade3 is free software: you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation, either version 2 of the License, or
* (at your option) any later version.
- *
+ *
* glade3 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.
@@ -55,14 +55,26 @@ static void
on_glade_signal_model_removed (GladeWidget* widget, const GladeSignal* signal,
GladeSignalModel* model);
static void
-on_glade_signal_model_changed (GladeWidget* widget, const GladeSignal* old_signal,
- const GladeSignal* new_signal, GladeSignalModel* model);
+on_glade_signal_model_changed (GladeWidget* widget, const GladeSignal* signal,
+ GladeSignalModel* model);
G_DEFINE_TYPE_WITH_CODE (GladeSignalModel, glade_signal_model, G_TYPE_OBJECT,
G_IMPLEMENT_INTERFACE (GTK_TYPE_TREE_MODEL,
- gtk_tree_model_iface_init);
+ gtk_tree_model_iface_init);
G_IMPLEMENT_INTERFACE (GTK_TYPE_TREE_DRAG_SOURCE,
- gtk_tree_drag_source_iface_init))
+ gtk_tree_drag_source_iface_init))
+
+static gint
+g_ptr_array_find (GPtrArray* array, gpointer data)
+{
+ gint i;
+ for (i = 0; i < array->len; i++)
+ {
+ if (array->pdata[i] == data)
+ return i;
+ }
+ return -1;
+}
static void
glade_signal_model_init (GladeSignalModel *object)
@@ -80,12 +92,12 @@ glade_signal_model_create_widget_list (GladeSignalModel* sig_model)
GladeWidget *widget = sig_model->priv->widget;
GladeWidgetAdaptor *adaptor = glade_widget_get_adaptor (widget);
- for (list = glade_widget_adaptor_get_signals (adaptor);
+ for (list = glade_widget_adaptor_get_signals (adaptor);
list != NULL; list = g_list_next (list))
{
GladeSignalClass *signal = (GladeSignalClass *) list->data;
- if (!g_list_find_custom (sig_model->priv->widgets, (gpointer) glade_signal_class_get_type (signal), (GCompareFunc) strcmp))
+ if (!g_list_find_custom (sig_model->priv->widgets, (gpointer) glade_signal_class_get_type (signal), (GCompareFunc) strcmp))
{
sig_model->priv->widgets = g_list_prepend (sig_model->priv->widgets, (gpointer) glade_signal_class_get_type (signal));
}
@@ -98,7 +110,7 @@ glade_signal_model_finalize (GObject *object)
{
GladeSignalModel* sig_model = GLADE_SIGNAL_MODEL (object);
- g_list_free (sig_model->priv->widgets);
+ g_list_free (sig_model->priv->widgets);
g_hash_table_destroy (sig_model->priv->dummy_signals);
G_OBJECT_CLASS (glade_signal_model_parent_class)->finalize (object);
}
@@ -108,31 +120,31 @@ glade_signal_model_set_property (GObject *object, guint prop_id, const GValue *v
{
GladeSignalModel* sig_model;
- g_return_if_fail (GLADE_IS_SIGNAL_MODEL (object));
+ g_return_if_fail (GLADE_IS_SIGNAL_MODEL (object));
- sig_model = GLADE_SIGNAL_MODEL (object);
+ sig_model = GLADE_SIGNAL_MODEL (object);
switch (prop_id)
{
- case PROP_WIDGET:
- sig_model->priv->widget = g_value_get_object (value);
- glade_signal_model_create_widget_list (sig_model);
- g_signal_connect (sig_model->priv->widget,
- "add-signal-handler",
- G_CALLBACK (on_glade_signal_model_added), sig_model);
- g_signal_connect (sig_model->priv->widget,
- "remove-signal-handler",
- G_CALLBACK (on_glade_signal_model_removed), sig_model);
- g_signal_connect (sig_model->priv->widget,
- "change-signal-handler",
- G_CALLBACK (on_glade_signal_model_changed), sig_model);
- break;
- case PROP_SIGNALS:
- sig_model->priv->signals = g_value_get_pointer (value);
- break;
- default:
- G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
- break;
+ case PROP_WIDGET:
+ sig_model->priv->widget = g_value_get_object (value);
+ glade_signal_model_create_widget_list (sig_model);
+ g_signal_connect (sig_model->priv->widget,
+ "add-signal-handler",
+ G_CALLBACK (on_glade_signal_model_added), sig_model);
+ g_signal_connect (sig_model->priv->widget,
+ "remove-signal-handler",
+ G_CALLBACK (on_glade_signal_model_removed), sig_model);
+ g_signal_connect (sig_model->priv->widget,
+ "change-signal-handler",
+ G_CALLBACK (on_glade_signal_model_changed), sig_model);
+ break;
+ case PROP_SIGNALS:
+ sig_model->priv->signals = g_value_get_pointer (value);
+ break;
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+ break;
}
}
@@ -141,21 +153,21 @@ glade_signal_model_get_property (GObject *object, guint prop_id, GValue *value,
{
GladeSignalModel* sig_model;
- g_return_if_fail (GLADE_IS_SIGNAL_MODEL (object));
+ g_return_if_fail (GLADE_IS_SIGNAL_MODEL (object));
- sig_model = GLADE_SIGNAL_MODEL (object);
+ sig_model = GLADE_SIGNAL_MODEL (object);
switch (prop_id)
{
- case PROP_WIDGET:
- g_value_set_object (value, sig_model->priv->widget);
- break;
- case PROP_SIGNALS:
- g_value_set_pointer (value, sig_model->priv->signals);
- break;
- default:
- G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
- break;
+ case PROP_WIDGET:
+ g_value_set_object (value, sig_model->priv->widget);
+ break;
+ case PROP_SIGNALS:
+ g_value_set_pointer (value, sig_model->priv->signals);
+ break;
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+ break;
}
}
@@ -165,7 +177,7 @@ glade_signal_model_class_init (GladeSignalModelClass *klass)
GObjectClass* object_class = G_OBJECT_CLASS (klass);
g_type_class_add_private (klass, sizeof (GladeSignalModelPrivate));
-
+
object_class->finalize = glade_signal_model_finalize;
object_class->set_property = glade_signal_model_set_property;
object_class->get_property = glade_signal_model_get_property;
@@ -180,9 +192,9 @@ glade_signal_model_class_init (GladeSignalModelClass *klass)
g_object_class_install_property (object_class,
PROP_SIGNALS,
g_param_spec_pointer ("signals",
- "A GHashTable containing the widget signals",
- "Use to query signals",
- G_PARAM_CONSTRUCT_ONLY | G_PARAM_WRITABLE));
+ "A GHashTable containing the widget signals",
+ "Use to query signals",
+ G_PARAM_CONSTRUCT_ONLY | G_PARAM_WRITABLE));
}
/*
@@ -224,6 +236,8 @@ glade_signal_model_get_column_type (GtkTreeModel* model,
{
case GLADE_SIGNAL_COLUMN_NAME:
return G_TYPE_STRING;
+ case GLADE_SIGNAL_COLUMN_SHOW_NAME:
+ return G_TYPE_BOOLEAN;
case GLADE_SIGNAL_COLUMN_HANDLER:
return G_TYPE_STRING;
case GLADE_SIGNAL_COLUMN_OBJECT:
@@ -236,8 +250,6 @@ glade_signal_model_get_column_type (GtkTreeModel* model,
return G_TYPE_BOOLEAN;
case GLADE_SIGNAL_COLUMN_NOT_DUMMY:
return G_TYPE_BOOLEAN;
- case GLADE_SIGNAL_COLUMN_HAS_HANDLERS:
- return G_TYPE_BOOLEAN;
case GLADE_SIGNAL_COLUMN_VERSION_WARNING:
return G_TYPE_BOOLEAN;
case GLADE_SIGNAL_COLUMN_TOOLTIP:
@@ -254,7 +266,6 @@ enum
{
ITER_WIDGET = 0,
ITER_SIGNAL = 1,
- ITER_HANDLER = 2
};
static GladeSignal*
@@ -289,7 +300,7 @@ glade_signal_model_not_dummy_handler (GladeSignalModel* model,
if (widget && sig_class && handler)
return handler != glade_signal_model_get_dummy_handler (model,
- sig_class);
+ sig_class);
return FALSE;
}
@@ -305,27 +316,17 @@ glade_signal_model_create_widget_iter (GladeSignalModel* sig_model,
}
static void
-glade_signal_model_create_handler_iter (GladeSignalModel* sig_model,
- const gchar* widget,
- GladeSignalClass* signal_class,
- GladeSignal* signal,
- GtkTreeIter* iter)
-{
- glade_signal_model_create_widget_iter (sig_model, widget, iter);
- iter->user_data2 = signal_class;
- iter->user_data3 = signal;
- /* Check the version warning here */
- glade_project_verify_signal (sig_model->priv->widget, signal);
-}
-
-static void
glade_signal_model_create_signal_iter (GladeSignalModel* sig_model,
const gchar* widget,
- GladeSignalClass* signal_class,
+ const GladeSignalClass* signal_class,
+ const GladeSignal* signal,
GtkTreeIter* iter)
{
glade_signal_model_create_widget_iter (sig_model, widget, iter);
- iter->user_data2 = signal_class;
+ iter->user_data2 = (GladeSignalClass*) signal_class;
+ iter->user_data3 = (GladeSignal*) signal;
+ /* Check the version warning here */
+ glade_project_verify_signal (sig_model->priv->widget, (GladeSignal*) signal);
}
static GList* glade_signal_model_create_signal_list (GladeSignalModel* sig_model,
@@ -336,7 +337,7 @@ static GList* glade_signal_model_create_signal_list (GladeSignalModel* sig_model
GladeWidget *widget = sig_model->priv->widget;
GladeWidgetAdaptor *adaptor = glade_widget_get_adaptor (widget);
- for (signals = glade_widget_adaptor_get_signals (adaptor);
+ for (signals = glade_widget_adaptor_get_signals (adaptor);
signals != NULL;
signals = g_list_next (signals))
{
@@ -349,109 +350,100 @@ static GList* glade_signal_model_create_signal_list (GladeSignalModel* sig_model
return widget_signals;
}
-static gboolean
-glade_signal_model_has_handlers (GladeSignalModel* model, GtkTreeIter* iter)
+/* Be sure to update the parent columns when signals are added/removed
+ * as that might affect the appearance */
+static void
+glade_signal_model_update_class (GladeSignalModel* model,
+ GtkTreeIter* iter)
{
const gchar* widget = iter->user_data;
- GladeSignalClass* sig_class = iter->user_data2;
- GladeSignal* signal = iter->user_data3;
+ GladeSignalClass* class = iter->user_data2;
+ GtkTreeIter class_dummy;
- if (signal)
- return FALSE;
+ glade_signal_model_create_signal_iter (model,
+ widget,
+ class,
+ glade_signal_model_get_dummy_handler (model,
+ class),
+ &class_dummy);
- if (sig_class)
+ do
{
- GPtrArray* handlers = g_hash_table_lookup (model->priv->signals,
- glade_signal_class_get_name (sig_class));
- if (handlers && handlers->len > 0)
- return TRUE;
- }
- else if (widget)
- {
- GList* signals = glade_signal_model_create_signal_list (model, widget);
- GList* class_iter;
+ GtkTreePath* path = gtk_tree_model_get_path (GTK_TREE_MODEL (model),
+ &class_dummy);
- for (class_iter = signals; class_iter != NULL; class_iter = g_list_next (class_iter))
- {
- GPtrArray* handlers;
-
- sig_class = class_iter->data;
- handlers = g_hash_table_lookup (model->priv->signals,
- glade_signal_class_get_name (sig_class));
- if (handlers && handlers->len > 0)
- {
- g_list_free (signals);
- return TRUE;
- }
- }
- g_list_free (signals);
+ gtk_tree_model_row_changed (GTK_TREE_MODEL (model), path, &class_dummy);
+ gtk_tree_path_free (path);
}
- return FALSE;
+ while (gtk_tree_model_iter_previous (GTK_TREE_MODEL (model), &class_dummy) &&
+ class == class_dummy.user_data2);
}
-static gboolean
-glade_signal_model_iter_for_signal (GladeSignalModel* model, const GladeSignal* signal, GtkTreeIter* iter)
+static GladeSignalClass*
+glade_signal_model_find_signal_class (GladeSignalModel* model,
+ const GladeSignal* handler)
{
- const GList* list;
- GladeWidget *widget = model->priv->widget;
- GladeWidgetAdaptor *adaptor = glade_widget_get_adaptor (widget);
-
- for (list = glade_widget_adaptor_get_signals (adaptor);
- list != NULL; list = g_list_next (list))
+ GladeSignalClass* class = NULL;
+ GList* widgets = model->priv->widgets;
+ GList* widget;
+ for (widget = widgets; widget != NULL; widget = g_list_next (widget))
{
- GladeSignalClass *sig_class = (GladeSignalClass *) list->data;
- if (g_str_equal (glade_signal_get_name (signal),
- glade_signal_class_get_name (sig_class)))
+ GList* signals = glade_signal_model_create_signal_list (model,
+ widget->data);
+ GList* signal;
+ for (signal = signals; signal != NULL; signal = g_list_next (signal))
{
- glade_signal_model_create_handler_iter (model,
- glade_signal_class_get_type (sig_class),
- sig_class,
- (GladeSignal*) signal,
- iter);
- return TRUE;
- }
+ GPtrArray* handlers =
+ g_hash_table_lookup (model->priv->signals,
+ glade_signal_class_get_name (GLADE_SIGNAL_CLASS(signal->data)));
+ if (handlers && g_ptr_array_find (handlers, (gpointer) handler) != -1)
+ {
+ class = signal->data;
+ break;
+ }
+ }
+ g_list_free (signals);
+ if (class)
+ break;
}
- return FALSE;
+ return class;
}
-/* Be sure to update the parent columns when signals are added/removed
- * as that might affect the appearance */
static void
-glade_signal_model_update_parents (GladeSignalModel* model,
- GtkTreeIter* iter)
+glade_signal_model_iter_for_signal (GladeSignalModel* model,
+ const GladeSignalClass* sig_class,
+ const GladeSignal* handler,
+ GtkTreeIter* iter)
{
- GtkTreeIter sig_class_iter;
- GtkTreeIter widget_iter;
- GtkTreePath* sig_class_path;
- GtkTreePath* widget_path;
-
- gtk_tree_model_iter_parent (GTK_TREE_MODEL (model), &sig_class_iter, iter);
- gtk_tree_model_iter_parent (GTK_TREE_MODEL (model), &widget_iter, &sig_class_iter);
-
- sig_class_path = gtk_tree_model_get_path (GTK_TREE_MODEL (model), &sig_class_iter);
- widget_path = gtk_tree_model_get_path (GTK_TREE_MODEL (model), &widget_iter);
-
- gtk_tree_model_row_changed (GTK_TREE_MODEL (model), sig_class_path, &sig_class_iter);
- gtk_tree_model_row_changed (GTK_TREE_MODEL (model), widget_path, &widget_iter);
-
- gtk_tree_path_free (sig_class_path);
- gtk_tree_path_free (widget_path);
+ glade_signal_model_create_signal_iter (model,
+ glade_signal_class_get_type (sig_class),
+ sig_class,
+ handler,
+ iter);
}
static void
on_glade_signal_model_added (GladeWidget* widget, const GladeSignal* signal,
GladeSignalModel* model)
{
- GtkTreeIter iter;
-
- if (glade_signal_model_iter_for_signal (model, signal, &iter))
+ GtkTreeIter iter;
+ GladeSignalClass* sig_class =
+ glade_signal_model_find_signal_class (model,
+ signal);
+ if (sig_class)
{
- GtkTreePath* path = gtk_tree_model_get_path (GTK_TREE_MODEL (model),
+ GtkTreePath* path;
+ glade_signal_model_iter_for_signal (model,
+ sig_class,
+ signal,
+ &iter);
+ path = gtk_tree_model_get_path (GTK_TREE_MODEL (model),
&iter);
+
gtk_tree_model_row_inserted (GTK_TREE_MODEL (model),
path,
&iter);
- glade_signal_model_update_parents (model, &iter);
+ glade_signal_model_update_class (model, &iter);
gtk_tree_path_free (path);
model->priv->stamp++;
}
@@ -462,34 +454,49 @@ on_glade_signal_model_removed (GladeWidget* widget, const GladeSignal* signal,
GladeSignalModel* model)
{
GtkTreeIter iter;
+ GladeSignalClass* sig_class =
+ glade_signal_model_find_signal_class (model,
+ signal);
- if (glade_signal_model_iter_for_signal (model, signal, &iter))
+ if (sig_class)
{
- GtkTreePath* path = gtk_tree_model_get_path (GTK_TREE_MODEL (model),
+ GtkTreePath* path;
+ glade_signal_model_iter_for_signal (model,
+ sig_class,
+ signal,
+ &iter);
+ path = gtk_tree_model_get_path (GTK_TREE_MODEL (model),
&iter);
gtk_tree_model_row_deleted (GTK_TREE_MODEL (model),
- gtk_tree_model_get_path (GTK_TREE_MODEL (model),
- &iter));
- glade_signal_model_update_parents (model, &iter);
+ path);
+ glade_signal_model_update_class (model, &iter);
gtk_tree_path_free (path);
model->priv->stamp++;
}
}
static void
-on_glade_signal_model_changed (GladeWidget* widget, const GladeSignal* old_signal,
- const GladeSignal* new_signal, GladeSignalModel* model)
+on_glade_signal_model_changed (GladeWidget* widget, const GladeSignal* signal,
+ GladeSignalModel* model)
{
GtkTreeIter iter;
+ GladeSignalClass* sig_class =
+ glade_signal_model_find_signal_class (model,
+ signal);
- if (glade_signal_model_iter_for_signal (model, new_signal, &iter))
+ if (sig_class)
{
- GtkTreePath* path = gtk_tree_model_get_path (GTK_TREE_MODEL (model),
+ GtkTreePath* path;
+ glade_signal_model_iter_for_signal (model,
+ sig_class,
+ signal,
+ &iter);
+ path = gtk_tree_model_get_path (GTK_TREE_MODEL (model),
&iter);
gtk_tree_model_row_changed (GTK_TREE_MODEL (model),
- gtk_tree_model_get_path (GTK_TREE_MODEL (model),
- &iter),
- &iter);
+ path,
+ &iter);
+ glade_signal_model_update_class (model, &iter);
gtk_tree_path_free (path);
model->priv->stamp++;
}
@@ -503,11 +510,11 @@ glade_signal_model_get_iter (GtkTreeModel* model,
gint* indices;
gint depth;
GladeSignalModel* sig_model;
-
+
g_return_val_if_fail (path != NULL, FALSE);
g_return_val_if_fail (iter != NULL, FALSE);
g_return_val_if_fail (GLADE_IS_SIGNAL_MODEL(model), FALSE);
-
+
indices = gtk_tree_path_get_indices(path);
depth = gtk_tree_path_get_depth (path);
sig_model = GLADE_SIGNAL_MODEL (model);
@@ -515,7 +522,7 @@ glade_signal_model_get_iter (GtkTreeModel* model,
switch (depth)
{
case 1:
- /* Widget */
+ /* Widget */
{
glade_signal_model_create_widget_iter (sig_model,
g_list_nth_data (sig_model->priv->widgets,
@@ -524,72 +531,25 @@ glade_signal_model_get_iter (GtkTreeModel* model,
return TRUE;
}
case 2:
- /* Signal */
- {
- const gchar* widget = g_list_nth_data (sig_model->priv->widgets,
- indices[ITER_WIDGET]);
- GList* signals = glade_signal_model_create_signal_list (sig_model,
- widget);
- if (signals)
- {
- glade_signal_model_create_signal_iter (sig_model, widget,
- g_list_nth_data (signals, indices[ITER_SIGNAL]),
- iter);
- g_list_free (signals);
- return TRUE;
- }
- return FALSE;
- }
- case 3:
- /* Handler */
+ /* Signal */
{
- GPtrArray* handlers;
- const gchar* widget = g_list_nth_data (sig_model->priv->widgets,
- indices[ITER_WIDGET]);
- GList* signals = glade_signal_model_create_signal_list (sig_model,
- widget);
- if (signals)
- {
- GladeSignalClass* signal = g_list_nth_data (signals, indices[ITER_SIGNAL]);
- handlers = g_hash_table_lookup (sig_model->priv->signals,
- glade_signal_class_get_name (signal));
- if (handlers && indices[ITER_HANDLER] < handlers->len)
- {
- GladeSignal* handler =
- (GladeSignal*) g_ptr_array_index (handlers, indices[ITER_HANDLER]);
- glade_signal_model_create_handler_iter (sig_model, widget,
- signal,
- handler, iter);
- return TRUE;
- }
- else if ((!handlers && indices[ITER_HANDLER] == 0) || indices[ITER_HANDLER] == handlers->len)
- {
- GladeSignal *handler =
- glade_signal_model_get_dummy_handler (sig_model, signal);
- glade_signal_model_create_handler_iter (sig_model, widget,
- signal,
- handler, iter);
- return TRUE;
- }
- }
- return FALSE;
+ gboolean retval;
+ GtkTreePath* path =
+ gtk_tree_path_new_from_indices (indices[ITER_WIDGET], -1);
+ GtkTreeIter widget_iter;
+
+ gtk_tree_model_get_iter (model, &widget_iter, path);
+ retval = gtk_tree_model_iter_nth_child (model,
+ iter,
+ &widget_iter,
+ indices[ITER_SIGNAL]);
+ gtk_tree_path_free (path);
+ return retval;
}
}
return FALSE;
}
-static gint
-g_ptr_array_find (GPtrArray* array, gpointer data)
-{
- gint i;
- for (i = 0; i < array->len; i++)
- {
- if (array->pdata[i] == data)
- return i;
- }
- return -1;
-}
-
static GtkTreePath*
glade_signal_model_get_path (GtkTreeModel* model,
GtkTreeIter* iter)
@@ -600,55 +560,52 @@ glade_signal_model_get_path (GtkTreeModel* model,
GladeSignalModel* sig_model;
- g_return_val_if_fail (iter != NULL, NULL);
+ g_return_val_if_fail (iter != NULL, NULL);
g_return_val_if_fail (GLADE_IS_SIGNAL_MODEL(model), NULL);
- widget = iter->user_data;
- sig_class = iter->user_data2;
- handler = iter->user_data3;
- sig_model = GLADE_SIGNAL_MODEL (model);
-
- if (handler)
+ widget = iter->user_data;
+ sig_class = iter->user_data2;
+ handler = iter->user_data3;
+ sig_model = GLADE_SIGNAL_MODEL (model);
+
+ if (handler && sig_class)
{
- /* Handler */
- GPtrArray* handlers;
- gint index0, index1, index2;
+ /* Signal */
+ gint index0, index1 = 0;
+ GList* signal;
GList* signals = glade_signal_model_create_signal_list (sig_model,
widget);
index0 = g_list_index (sig_model->priv->widgets,
widget);
- index1 = g_list_index (signals, sig_class);
+
+ for (signal = signals; signal != NULL; signal = g_list_next (signal))
+ {
- handlers = g_hash_table_lookup (sig_model->priv->signals,
- glade_signal_class_get_name (sig_class));
+ GPtrArray* handlers = g_hash_table_lookup (sig_model->priv->signals,
+ glade_signal_class_get_name (signal->data));
- if (handler == glade_signal_model_get_dummy_handler (sig_model,
- sig_class))
- {
- if (handlers)
- index2 = handlers->len;
+ if (signal->data != sig_class)
+ {
+ if (handlers)
+ index1 += handlers->len;
+ index1++; /* dummy_handler */
+ }
else
- index2 = 0;
+ {
+ if (handlers)
+ {
+ gint handler_index = g_ptr_array_find (handlers, handler);
+ if (handler_index == -1) /* dummy handler */
+ {
+ index1 += handlers->len;
+ }
+ else
+ index1 += handler_index;
+ }
+ break;
+ }
}
- else if (handlers)
- index2 = g_ptr_array_find (handlers, handler);
- else
- g_assert_not_reached();
-
- g_list_free (signals);
- return gtk_tree_path_new_from_indices (index0, index1, index2, -1);
- }
- else if (sig_class)
- {
- /* Signal */
- GList* signals = glade_signal_model_create_signal_list (sig_model,
- widget);
- gint index0 = g_list_index (sig_model->priv->widgets,
- widget);
- gint index1 = g_list_index (signals, sig_class);
- g_list_free (signals);
-
return gtk_tree_path_new_from_indices (index0, index1, -1);
}
else if (widget)
@@ -672,30 +629,46 @@ glade_signal_model_get_value (GtkTreeModel* model,
GladeSignalModel* sig_model;
- g_return_if_fail (iter != NULL);
+ g_return_if_fail (iter != NULL);
g_return_if_fail (GLADE_IS_SIGNAL_MODEL(model));
- widget = iter->user_data;
- sig_class = iter->user_data2;
- handler = iter->user_data3;
- sig_model = GLADE_SIGNAL_MODEL (model);
-
+ widget = iter->user_data;
+ sig_class = iter->user_data2;
+ handler = iter->user_data3;
+ sig_model = GLADE_SIGNAL_MODEL (model);
+
value = g_value_init (value,
glade_signal_model_get_column_type (model, column));
-
+
switch (column)
{
case GLADE_SIGNAL_COLUMN_NAME:
if (widget && sig_class && handler)
- g_value_set_static_string (value,
- "");
- else if (widget && sig_class)
+ {
g_value_set_static_string (value,
glade_signal_class_get_name (sig_class));
+
+ }
else if (widget)
g_value_set_static_string (value,
widget);
break;
+ case GLADE_SIGNAL_COLUMN_SHOW_NAME:
+ if (widget && sig_class && handler)
+ {
+ GPtrArray* handlers = g_hash_table_lookup (sig_model->priv->signals,
+ glade_signal_class_get_name (sig_class));
+ if (!handlers || !handlers->len || g_ptr_array_find (handlers, handler) == 0)
+ g_value_set_boolean (value,
+ TRUE);
+ else
+ g_value_set_boolean (value,
+ FALSE);
+ }
+ else if (widget)
+ g_value_set_boolean (value,
+ TRUE);
+ break;
case GLADE_SIGNAL_COLUMN_HANDLER:
if (widget && sig_class && handler)
g_value_set_static_string (value,
@@ -706,15 +679,15 @@ glade_signal_model_get_value (GtkTreeModel* model,
break;
case GLADE_SIGNAL_COLUMN_OBJECT:
if (widget && sig_class && handler)
- {
- const gchar* userdata = glade_signal_get_userdata (handler);
- if (userdata && strlen (userdata))
- g_value_set_static_string (value,
- userdata);
- else
- g_value_set_static_string (value,
- USERDATA_DEFAULT);
- }
+ {
+ const gchar* userdata = glade_signal_get_userdata (handler);
+ if (userdata && strlen (userdata))
+ g_value_set_static_string (value,
+ userdata);
+ else
+ g_value_set_static_string (value,
+ USERDATA_DEFAULT);
+ }
else
g_value_set_static_string (value,
"");
@@ -741,31 +714,26 @@ glade_signal_model_get_value (GtkTreeModel* model,
break;
case GLADE_SIGNAL_COLUMN_NOT_DUMMY:
g_value_set_boolean (value,
- glade_signal_model_not_dummy_handler (sig_model,
- iter));
- break;
- case GLADE_SIGNAL_COLUMN_HAS_HANDLERS:
- g_value_set_boolean (value,
- glade_signal_model_has_handlers (sig_model,
- iter));
+ glade_signal_model_not_dummy_handler (sig_model,
+ iter));
break;
case GLADE_SIGNAL_COLUMN_VERSION_WARNING:
- {
- gboolean warn = FALSE;
- if (handler)
- {
- const gchar* warning = glade_signal_get_support_warning (handler);
- warn = warning && strlen (warning);
- }
- g_value_set_boolean (value, warn);
- }
+ {
+ gboolean warn = FALSE;
+ if (handler)
+ {
+ const gchar* warning = glade_signal_get_support_warning (handler);
+ warn = warning && strlen (warning);
+ }
+ g_value_set_boolean (value, warn);
+ }
break;
case GLADE_SIGNAL_COLUMN_TOOLTIP:
if (handler)
g_value_set_string (value,
- glade_signal_get_support_warning (handler));
- else
- g_value_set_static_string (value, NULL);
+ glade_signal_get_support_warning (handler));
+ else
+ g_value_set_static_string (value, NULL);
break;
case GLADE_SIGNAL_COLUMN_SIGNAL:
g_value_set_pointer (value, handler);
@@ -776,70 +744,116 @@ glade_signal_model_get_value (GtkTreeModel* model,
}
static gboolean
+glade_signal_model_iter_next_signal (GladeSignalModel* sig_model,
+ const gchar* widget,
+ GtkTreeIter* iter,
+ GList* signal)
+{
+ if (signal->next)
+ {
+ signal = signal->next;
+ GladeSignal* next_handler;
+ GPtrArray* next_handlers =
+ g_hash_table_lookup (sig_model->priv->signals,
+ glade_signal_class_get_name (signal->data));
+ if (next_handlers && next_handlers->len)
+ {
+ next_handler = g_ptr_array_index (next_handlers, 0);
+ }
+ else
+ {
+ next_handler =
+ glade_signal_model_get_dummy_handler (sig_model,
+ signal->data);
+ }
+ glade_signal_model_create_signal_iter (sig_model, widget,
+ signal->data, next_handler,
+ iter);
+ g_list_free (signal);
+ return TRUE;
+ }
+ else
+ {
+ g_list_free (signal);
+ return FALSE;
+ }
+}
+
+
+static gboolean
glade_signal_model_iter_next (GtkTreeModel* model,
GtkTreeIter* iter)
{
const gchar* widget;
GladeSignalClass* sig_class;
GladeSignal* handler;
- GtkTreeIter parent;
+ GtkTreeIter parent;
GladeSignalModel* sig_model;
- g_return_val_if_fail (iter != NULL, FALSE);
+ g_return_val_if_fail (iter != NULL, FALSE);
g_return_val_if_fail (GLADE_IS_SIGNAL_MODEL(model), FALSE);
- widget = iter->user_data;
- sig_class = iter->user_data2;
- handler = iter->user_data3;
+ widget = iter->user_data;
+ sig_class = iter->user_data2;
+ handler = iter->user_data3;
- sig_model = GLADE_SIGNAL_MODEL (model);
+ sig_model = GLADE_SIGNAL_MODEL (model);
gtk_tree_model_iter_parent (model, &parent, iter);
- if (handler)
+ if (handler && sig_class)
{
+ GList* signals = glade_signal_model_create_signal_list (sig_model,
+ widget);
+ GList* signal = g_list_find (signals, sig_class);
GPtrArray* handlers = g_hash_table_lookup (sig_model->priv->signals,
glade_signal_class_get_name (sig_class));
GladeSignal* dummy = glade_signal_model_get_dummy_handler (sig_model,
sig_class);
if (handler == dummy)
{
- return FALSE;
+ return glade_signal_model_iter_next_signal (sig_model, widget, iter, signal);
}
else if (handlers)
{
gint new_index = g_ptr_array_find (handlers, handler) + 1;
- if (new_index > 0)
+ if (new_index < handlers->len)
+ {
+ glade_signal_model_create_signal_iter (sig_model, widget,
+ sig_class,
+ g_ptr_array_index (handlers, new_index),
+ iter);
+ g_list_free (signals);
+ return TRUE;
+ }
+ else if (new_index == handlers->len)
{
- gtk_tree_model_iter_nth_child (model, iter, &parent, new_index);
+ glade_signal_model_create_signal_iter (sig_model, widget,
+ sig_class,
+ glade_signal_model_get_dummy_handler (sig_model,
+ sig_class),
+ iter);
+ g_list_free (signals);
return TRUE;
}
+ else
+ {
+ return glade_signal_model_iter_next_signal (sig_model, widget, iter, signal);
+ }
}
else
{
- glade_signal_model_create_handler_iter (sig_model,
- widget,
- sig_class,
- dummy,
- iter);
- return TRUE;
+ g_list_free (signals);
+ return FALSE;
}
}
- else if (sig_class)
- {
- GList* signals = glade_signal_model_create_signal_list (sig_model,
- widget);
-
- gint new_index = g_list_index (signals, sig_class) + 1;
- return gtk_tree_model_iter_nth_child (model, iter, &parent, new_index);
- }
else if (widget)
{
gint new_index = g_list_index (sig_model->priv->widgets,
widget) + 1;
-
+
return gtk_tree_model_iter_nth_child (model, iter, NULL, new_index);
}
iter->user_data = NULL;
@@ -861,31 +875,32 @@ glade_signal_model_iter_n_children (GtkTreeModel* model,
g_return_val_if_fail (iter != NULL, 0);
g_return_val_if_fail (GLADE_IS_SIGNAL_MODEL(model), 0);
- handler = iter->user_data3;
- sig_model = GLADE_SIGNAL_MODEL (model);
- sig_class = iter->user_data2;
- widget = iter->user_data;
-
- if (handler)
+ handler = iter->user_data3;
+ sig_model = GLADE_SIGNAL_MODEL (model);
+ sig_class = iter->user_data2;
+ widget = iter->user_data;
+
+ if (handler && sig_class)
{
return 0;
}
- else if (sig_class)
- {
- gint children = 0;
- GPtrArray* handlers = g_hash_table_lookup (sig_model->priv->signals,
- glade_signal_class_get_name (sig_class));
- if (handlers)
- children = handlers->len;
- return children + 1;
- }
else if (widget)
{
GList* signals = glade_signal_model_create_signal_list (sig_model,
widget);
- gint retval = g_list_length (signals);
-
+ GList* signal;
+ gint retval = 0;
+
+ for (signal = signals; signal != NULL; signal = g_list_next (signal))
+ {
+ GPtrArray* handlers = g_hash_table_lookup (sig_model->priv->signals,
+ glade_signal_class_get_name (signal->data));
+ if (handlers)
+ retval += handlers->len;
+ retval++;
+ }
g_list_free (signals);
+
return retval;
}
g_assert_not_reached ();
@@ -897,7 +912,7 @@ glade_signal_model_iter_has_child (GtkTreeModel* model,
{
g_return_val_if_fail (iter != NULL, FALSE);
g_return_val_if_fail (GLADE_IS_SIGNAL_MODEL(model), FALSE);
-
+
return (glade_signal_model_iter_n_children (model, iter) != 0);
}
@@ -915,55 +930,56 @@ glade_signal_model_iter_nth_child (GtkTreeModel* model,
g_return_val_if_fail (iter != NULL, 0);
g_return_val_if_fail (GLADE_IS_SIGNAL_MODEL(model), 0);
- handler = parent ? parent->user_data3 : NULL;
- sig_model = GLADE_SIGNAL_MODEL (model);
- sig_class = parent ? parent->user_data2 : NULL;
- widget =parent ? parent->user_data : NULL;
-
+ handler = parent ? parent->user_data3 : NULL;
+ sig_model = GLADE_SIGNAL_MODEL (model);
+ sig_class = parent ? parent->user_data2 : NULL;
+ widget = parent ? parent->user_data : NULL;
+
if (handler)
{
return FALSE;
}
- else if (sig_class)
+ else if (widget)
{
- GPtrArray* handlers = g_hash_table_lookup (sig_model->priv->signals,
- glade_signal_class_get_name (sig_class));
-
- if (handlers)
+ GList* signals = glade_signal_model_create_signal_list (sig_model,
+ widget);
+ GList* signal;
+ for (signal = signals; signal != NULL; signal = g_list_next (signal))
{
- if (n < handlers->len)
+ GPtrArray* handlers = g_hash_table_lookup (sig_model->priv->signals,
+ glade_signal_class_get_name (signal->data));
+ if (handlers)
{
- glade_signal_model_create_handler_iter (sig_model, widget, sig_class,
- g_ptr_array_index (handlers, n),
- iter);
+ if (n >= handlers->len)
+ n -= handlers->len;
+ else
+ {
+ glade_signal_model_create_signal_iter (sig_model,
+ widget,
+ signal->data,
+ g_ptr_array_index (handlers, n),
+ iter);
+ g_list_free (signals);
+ return TRUE;
+ }
+ }
+ if (n == 0)
+ {
+ GladeSignal* handler =
+ glade_signal_model_get_dummy_handler (sig_model,
+ signal->data);
+ glade_signal_model_create_signal_iter (sig_model,
+ widget,
+ signal->data,
+ handler,
+ iter);
+ g_list_free (signals);
return TRUE;
}
- }
- if (!handlers || handlers->len == n)
- {
- glade_signal_model_create_handler_iter (sig_model, widget, sig_class,
- glade_signal_model_get_dummy_handler (sig_model,
- sig_class),
- iter);
- return TRUE;
+ n--;
}
return FALSE;
}
- else if (widget)
- {
- GList* signals = glade_signal_model_create_signal_list (sig_model,
- widget);
- gboolean retval = FALSE;
- if (g_list_length (signals) > n)
- {
- glade_signal_model_create_signal_iter (sig_model, widget,
- g_list_nth_data (signals, n),
- iter);
- retval = TRUE;
- }
- g_list_free (signals);
- return retval;
- }
else
{
if (g_list_length (sig_model->priv->widgets) > n)
@@ -995,21 +1011,16 @@ glade_signal_model_iter_parent (GtkTreeModel* model,
GladeSignalClass* sig_class;
const gchar* widget;
- g_return_val_if_fail (iter != NULL, FALSE);
+ g_return_val_if_fail (iter != NULL, FALSE);
g_return_val_if_fail (child != NULL, FALSE);
g_return_val_if_fail (GLADE_IS_SIGNAL_MODEL(model), FALSE);
- sig_model = GLADE_SIGNAL_MODEL (model);
- handler = child->user_data3;
- sig_class = child->user_data2;
- widget = child->user_data;
-
- if (handler)
- {
- glade_signal_model_create_signal_iter (sig_model, widget, sig_class, iter);
- return TRUE;
- }
- else if (sig_class)
+ sig_model = GLADE_SIGNAL_MODEL (model);
+ handler = child->user_data3;
+ sig_class = child->user_data2;
+ widget = child->user_data;
+
+ if (handler && sig_class)
{
glade_signal_model_create_widget_iter (sig_model, widget, iter);
return TRUE;
@@ -1047,7 +1058,7 @@ glade_signal_model_row_draggable (GtkTreeDragSource* model,
GLADE_SIGNAL_COLUMN_IS_HANDLER, &is_handler,
GLADE_SIGNAL_COLUMN_NOT_DUMMY, ¬_dummy,
-1);
-
+
return (is_handler && not_dummy);
}
diff --git a/gladeui/glade-signal-model.h b/gladeui/glade-signal-model.h
index 19f63dc..5207244 100644
--- a/gladeui/glade-signal-model.h
+++ b/gladeui/glade-signal-model.h
@@ -38,13 +38,13 @@ typedef struct _GladeSignalModelPrivate GladeSignalModelPrivate;
typedef enum
{
GLADE_SIGNAL_COLUMN_NAME,
+ GLADE_SIGNAL_COLUMN_SHOW_NAME,
GLADE_SIGNAL_COLUMN_HANDLER,
GLADE_SIGNAL_COLUMN_OBJECT,
GLADE_SIGNAL_COLUMN_SWAP,
GLADE_SIGNAL_COLUMN_AFTER,
GLADE_SIGNAL_COLUMN_IS_HANDLER,
GLADE_SIGNAL_COLUMN_NOT_DUMMY,
- GLADE_SIGNAL_COLUMN_HAS_HANDLERS,
GLADE_SIGNAL_COLUMN_VERSION_WARNING,
GLADE_SIGNAL_COLUMN_TOOLTIP,
GLADE_SIGNAL_COLUMN_SIGNAL,
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
