/*
* glade-signal-model.c
* Copyright (C) Johannes Schmid 2010 <jhs@gnome.org>
*
* This library is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 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
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include "glade-signal-model.h"
#include "glade-project.h"
#include <glib/gi18n-lib.h>
#include <string.h>
#define DETAIL_DEFAULT _("<Type here>")
#define HANDLER_DEFAULT _("<Type here>")
#define USERDATA_DEFAULT _("<Click here>")
struct _GladeSignalModelPrivate
{
GladeWidget *widget;
GList *widgets; /* names of the widgets that this widgets derives from and that have signals */
gint stamp;
GHashTable *dummy_signals;
GHashTable *signals; /* signals of the widget */
};
enum
{
PROP_0,
PROP_WIDGET,
PROP_SIGNALS
};
static void gtk_tree_model_iface_init (GtkTreeModelIface *iface);
static void gtk_tree_drag_source_iface_init (GtkTreeDragSourceIface *iface);
static void on_glade_signal_model_added (GladeWidget *widget, const GladeSignal *signal,
GladeSignalModel *model);
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 *signal,
GladeSignalModel *model);
static void on_glade_widget_support_changed (GladeWidget *widget, GladeSignalModel *model);
G_DEFINE_TYPE_WITH_CODE (GladeSignalModel, glade_signal_model, G_TYPE_OBJECT,
G_ADD_PRIVATE (GladeSignalModel)
G_IMPLEMENT_INTERFACE (GTK_TYPE_TREE_MODEL,
gtk_tree_model_iface_init);
G_IMPLEMENT_INTERFACE (GTK_TYPE_TREE_DRAG_SOURCE,
gtk_tree_drag_source_iface_init))
static void
glade_signal_model_init (GladeSignalModel *object)
{
object->priv = glade_signal_model_get_instance_private (object);
object->priv->dummy_signals =
g_hash_table_new_full (g_str_hash, g_str_equal, NULL, (GDestroyNotify) g_object_unref);
}
static void
glade_signal_model_create_widget_list (GladeSignalModel *sig_model)
{
const GList *list;
GladeWidget *widget = sig_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 *signal = (GladeSignalClass *) list->data;
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));
}
}
sig_model->priv->widgets = g_list_reverse (sig_model->priv->widgets);
}
static void
glade_signal_model_finalize (GObject *object)
{
GladeSignalModel *sig_model = GLADE_SIGNAL_MODEL (object);
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);
}
static void
glade_signal_model_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
GladeSignalModel *sig_model;
g_return_if_fail (GLADE_IS_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);
g_signal_connect (sig_model->priv->widget, "support-changed",
G_CALLBACK (on_glade_widget_support_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;
}
}
static void
glade_signal_model_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
GladeSignalModel *sig_model;
g_return_if_fail (GLADE_IS_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;
}
}
static void
glade_signal_model_class_init (GladeSignalModelClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
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;
g_object_class_install_property (object_class,
PROP_WIDGET,
g_param_spec_object ("widget",
"A GladeWidget",
"The GladeWidget used to query the signals",
GLADE_TYPE_WIDGET,
G_PARAM_CONSTRUCT_ONLY | G_PARAM_WRITABLE));
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));
}
/*
* glade_signal_model_new:
* @widget: The GladeWidget the signals belong to
* @signals: The signals of the #GladeWidget
*
* Creates a new GladeSignalModel object to show and edit the
* signals of a widgets in a GtkTreeView
*/
GtkTreeModel *
glade_signal_model_new (GladeWidget *widget, GHashTable *signals)
{
GObject *object = g_object_new (GLADE_TYPE_SIGNAL_MODEL,
"widget", widget,
"signals", signals, NULL);
return GTK_TREE_MODEL (object);
}
static GtkTreeModelFlags
glade_signal_model_get_flags (GtkTreeModel *model)
{
return 0;
}
static gint
glade_signal_model_get_n_columns (GtkTreeModel *model)
{
return GLADE_SIGNAL_N_COLUMNS;
}
static GType
glade_signal_model_get_column_type (GtkTreeModel *model, gint column)
{
switch (column)
{
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:
return G_TYPE_STRING;
case GLADE_SIGNAL_COLUMN_SWAP:
return G_TYPE_BOOLEAN;
case GLADE_SIGNAL_COLUMN_AFTER:
return G_TYPE_BOOLEAN;
case GLADE_SIGNAL_COLUMN_TOOLTIP:
return G_TYPE_STRING;
case GLADE_SIGNAL_COLUMN_SIGNAL:
return G_TYPE_OBJECT;
case GLADE_SIGNAL_COLUMN_DETAIL:
return G_TYPE_STRING;
default:
g_assert_not_reached();
return G_TYPE_NONE;
}
}
enum
{
ITER_WIDGET = 0,
ITER_SIGNAL = 1,
};
static inline gboolean
glade_signal_model_is_dummy_handler (GladeSignalModel *model,
GladeSignal *signal)
{
return glade_signal_get_handler (signal) == NULL;
}
static GladeSignal *
glade_signal_model_get_dummy_handler (GladeSignalModel *model,
const GladeSignalClass *sig_class)
{
GladeSignal *signal;
signal = g_hash_table_lookup (model->priv->dummy_signals,
glade_signal_class_get_name (sig_class));
if (!signal)
{
signal = glade_signal_new (sig_class,
NULL,
NULL,
FALSE,
FALSE);
g_hash_table_insert (model->priv->dummy_signals,
(gpointer) glade_signal_class_get_name (sig_class),
signal);
glade_project_verify_signal (model->priv->widget, signal);
}
return signal;
}
static void
glade_signal_model_create_widget_iter (GladeSignalModel *sig_model,
const gchar *widget,
GtkTreeIter *iter)
{
iter->stamp = sig_model->priv->stamp;
iter->user_data = (gpointer) widget;
iter->user_data2 = NULL;
iter->user_data3 = NULL;
}
static void
glade_signal_model_create_signal_iter (GladeSignalModel *sig_model,
const gchar *widget,
const GladeSignal *signal,
GtkTreeIter *iter)
{
glade_signal_model_create_widget_iter (sig_model, widget, iter);
iter->user_data2 = GLADE_SIGNAL (signal);
}
static GList *
glade_signal_model_create_signal_list (GladeSignalModel *sig_model,
const gchar *widget_type)
{
GList *widget_signals = NULL;
const GList *signals;
GladeWidget *widget = sig_model->priv->widget;
GladeWidgetAdaptor *adaptor = glade_widget_get_adaptor (widget);
for (signals = glade_widget_adaptor_get_signals (adaptor);
signals != NULL;
signals = g_list_next (signals))
{
GladeSignalClass *sig_class = signals->data;
if (g_str_equal (glade_signal_class_get_type (sig_class), widget_type))
{
widget_signals = g_list_append (widget_signals, sig_class);
}
}
return widget_signals;
}
static void
on_glade_signal_model_added (GladeWidget *widget,
const GladeSignal *signal,
GladeSignalModel* model)
{
GtkTreeIter iter;
GtkTreePath *path;
const GladeSignalClass *sig_class = glade_signal_get_class (signal);
glade_signal_model_create_signal_iter (model,
glade_signal_class_get_type (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);
gtk_tree_path_free (path);
model->priv->stamp++;
}
static void
on_glade_signal_model_removed (GladeWidget *widget,
const GladeSignal *signal,
GladeSignalModel *model)
{
GtkTreeIter iter;
GtkTreePath *path;
const GladeSignalClass *sig_class = glade_signal_get_class (signal);
glade_signal_model_create_signal_iter (model,
glade_signal_class_get_type (sig_class),
signal,
&iter);
path = gtk_tree_model_get_path (GTK_TREE_MODEL (model), &iter);
gtk_tree_model_row_deleted (GTK_TREE_MODEL (model), path);
gtk_tree_path_free (path);
model->priv->stamp++;
}
static void
on_glade_signal_model_changed (GladeWidget *widget,
const GladeSignal *signal,
GladeSignalModel *model)
{
GtkTreeIter iter;
GtkTreePath *path;
const GladeSignalClass *sig_class = glade_signal_get_class (signal);
glade_signal_model_create_signal_iter (model,
glade_signal_class_get_type (sig_class),
signal,
&iter);
path = gtk_tree_model_get_path (GTK_TREE_MODEL (model), &iter);
gtk_tree_model_row_changed (GTK_TREE_MODEL (model), path, &iter);
gtk_tree_path_free (path);
model->priv->stamp++;
}
static void
verify_dummies (const gchar *signal_name,
GladeSignal *signal,
GladeSignalModel *model)
{
glade_project_verify_signal (model->priv->widget, signal);
on_glade_signal_model_changed (model->priv->widget, signal, model);
}
static void
emit_changed (const gchar *signal_name,
GPtrArray *signals,
GladeSignalModel *model)
{
gint i;
GladeSignal *signal;
for (i = 0; i < signals->len; i++)
{
signal = (GladeSignal *)signals->pdata[i];
on_glade_signal_model_changed (model->priv->widget, signal, model);
}
}
static void
on_glade_widget_support_changed (GladeWidget *widget, GladeSignalModel *model)
{
/* Update support warning on dummy signals */
g_hash_table_foreach (model->priv->dummy_signals, (GHFunc)verify_dummies, model);
/* row changed on every row */
g_hash_table_foreach (model->priv->signals, (GHFunc)emit_changed, model);
}
static gboolean
glade_signal_model_get_iter (GtkTreeModel *model,
GtkTreeIter *iter,
GtkTreePath *path)
{
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);
switch (depth)
{
case 1:
/* Widget */
{
glade_signal_model_create_widget_iter (sig_model,
g_list_nth_data (sig_model->priv->widgets,
indices[ITER_WIDGET]),
iter);
return TRUE;
}
case 2:
/* Signal */
{
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 GtkTreePath*
glade_signal_model_get_path (GtkTreeModel *model, GtkTreeIter *iter)
{
const gchar *widget;
GladeSignal *handler;
GladeSignalModel *sig_model;
g_return_val_if_fail (iter != NULL, NULL);
g_return_val_if_fail (GLADE_IS_SIGNAL_MODEL(model), NULL);
widget = iter->user_data;
handler = iter->user_data2;
sig_model = GLADE_SIGNAL_MODEL (model);
if (handler)
{
/* Signal */
const GladeSignalClass *sig_class = glade_signal_get_class (handler);
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);
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 (signal->data != sig_class)
{
if (handlers)
index1 += handlers->len;
index1++; /* dummy_handler */
}
else
{
if (handlers)
{
guint handler_index;
if (g_ptr_array_find (handlers, handler, &handler_index))
index1 += handler_index;
else
index1 += handlers->len;
}
break;
}
}
return gtk_tree_path_new_from_indices (index0, index1, -1);
}
else if (widget)
{
/* Widget */
return gtk_tree_path_new_from_indices (g_list_index (sig_model->priv->widgets,
widget), -1);
}
g_assert_not_reached();
}
static void
glade_signal_model_get_value (GtkTreeModel *model,
GtkTreeIter *iter,
gint column,
GValue *value)
{
const gchar *widget;
GladeSignal *signal;
GladeSignalModel *sig_model;
g_return_if_fail (iter != NULL);
g_return_if_fail (GLADE_IS_SIGNAL_MODEL(model));
widget = iter->user_data;
signal = iter->user_data2;
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 (signal)
{
g_value_set_static_string (value, glade_signal_get_name (signal));
break;
}
else
g_value_set_static_string (value, widget);
break;
case GLADE_SIGNAL_COLUMN_SHOW_NAME:
if (signal)
{
GPtrArray *handlers = g_hash_table_lookup (sig_model->priv->signals,
glade_signal_get_name (signal));
guint index;
if (!handlers || !handlers->len || (g_ptr_array_find (handlers, signal, &index) && index == 0))
g_value_set_boolean (value, TRUE);
else
g_value_set_boolean (value, FALSE);
break;
}
else if (widget)
g_value_set_boolean (value, TRUE);
break;
case GLADE_SIGNAL_COLUMN_HANDLER:
if (signal)
{
const gchar *handler = glade_signal_get_handler (signal);
g_value_set_static_string (value, handler ? handler : HANDLER_DEFAULT);
}
else
g_value_set_static_string (value, "");
break;
case GLADE_SIGNAL_COLUMN_OBJECT:
if (signal)
{
const gchar *userdata = glade_signal_get_userdata (signal);
if (userdata && strlen (userdata))
g_value_set_static_string (value, userdata);
else
g_value_set_static_string (value, USERDATA_DEFAULT);
break;
}
else
g_value_set_static_string (value, "");
break;
case GLADE_SIGNAL_COLUMN_SWAP:
if (signal)
g_value_set_boolean (value, glade_signal_get_swapped (signal));
else
g_value_set_boolean (value, FALSE);
break;
case GLADE_SIGNAL_COLUMN_AFTER:
if (signal)
g_value_set_boolean (value, glade_signal_get_after (signal));
else
g_value_set_boolean (value, FALSE);
break;
case GLADE_SIGNAL_COLUMN_TOOLTIP:
if (signal)
g_value_set_string (value, glade_signal_get_support_warning (signal));
else
g_value_set_static_string (value, NULL);
break;
case GLADE_SIGNAL_COLUMN_SIGNAL:
g_value_set_object (value, signal);
break;
case GLADE_SIGNAL_COLUMN_DETAIL:
if (signal)
{
const gchar *detail = glade_signal_get_detail (signal);
g_value_set_static_string (value, detail ? detail : DETAIL_DEFAULT);
}
else
g_value_set_static_string (value, "");
break;
default:
g_assert_not_reached();
}
}
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,
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;
GladeSignal *handler;
GtkTreeIter parent;
GladeSignalModel *sig_model;
g_return_val_if_fail (iter != NULL, FALSE);
g_return_val_if_fail (GLADE_IS_SIGNAL_MODEL(model), FALSE);
widget = iter->user_data;
handler = iter->user_data2;
sig_model = GLADE_SIGNAL_MODEL (model);
gtk_tree_model_iter_parent (model, &parent, iter);
if (handler)
{
const GladeSignalClass *sig_class = glade_signal_get_class (handler);
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));
if (glade_signal_model_is_dummy_handler (sig_model, handler))
{
return glade_signal_model_iter_next_signal (sig_model, widget, iter, signal);
}
else if (handlers)
{
guint new_index = 0;
if (g_ptr_array_find (handlers, handler, &new_index))
new_index++;
if (new_index < handlers->len)
{
glade_signal_model_create_signal_iter (sig_model, widget,
g_ptr_array_index (handlers, new_index),
iter);
g_list_free (signals);
return TRUE;
}
else if (new_index == handlers->len)
{
glade_signal_model_create_signal_iter (sig_model, widget,
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
{
g_list_free (signals);
return FALSE;
}
}
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;
iter->user_data2 = NULL;
iter->user_data3 = NULL;
iter->stamp = 0;
return FALSE;
}
static gint
glade_signal_model_iter_n_children (GtkTreeModel *model, GtkTreeIter *iter)
{
GladeSignal *handler;
GladeSignalModel *sig_model;
const gchar *widget;
g_return_val_if_fail (GLADE_IS_SIGNAL_MODEL(model), 0);
/* FIXME: return the number of toplevels, if it makes sense in this context */
if (iter == NULL) return 0;
handler = iter->user_data2;
sig_model = GLADE_SIGNAL_MODEL (model);
widget = iter->user_data;
if (handler)
{
return 0;
}
else if (widget)
{
GList *signals = glade_signal_model_create_signal_list (sig_model,
widget);
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 ();
}
static gboolean
glade_signal_model_iter_has_child (GtkTreeModel *model, GtkTreeIter *iter)
{
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);
}
static gboolean
glade_signal_model_iter_nth_child (GtkTreeModel *model,
GtkTreeIter *iter,
GtkTreeIter *parent,
gint n)
{
GladeSignal *handler;
GladeSignalModel *sig_model;
const gchar *widget;
g_return_val_if_fail (iter != NULL, 0);
g_return_val_if_fail (GLADE_IS_SIGNAL_MODEL(model), 0);
handler = parent ? parent->user_data2 : NULL;
sig_model = GLADE_SIGNAL_MODEL (model);
widget = parent ? parent->user_data : NULL;
if (handler)
{
return FALSE;
}
else if (widget)
{
GList *signals = glade_signal_model_create_signal_list (sig_model,
widget);
GList *signal;
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)
{
if (n >= handlers->len)
n -= handlers->len;
else
{
glade_signal_model_create_signal_iter (sig_model,
widget,
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,
handler,
iter);
g_list_free (signals);
return TRUE;
}
n--;
}
return FALSE;
}
else
{
if (g_list_length (sig_model->priv->widgets) > n)
{
glade_signal_model_create_widget_iter (sig_model,
g_list_nth_data (sig_model->priv->widgets, n),
iter);
return TRUE;
}
}
return FALSE;
}
static gboolean
glade_signal_model_iter_children (GtkTreeModel *model,
GtkTreeIter *iter,
GtkTreeIter *parent)
{
return glade_signal_model_iter_nth_child (model, iter, parent, 0);
}
static gboolean
glade_signal_model_iter_parent (GtkTreeModel *model,
GtkTreeIter *iter,
GtkTreeIter *child)
{
GladeSignalModel *sig_model;
GladeSignal *handler;
const gchar *widget;
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_data2;
widget = child->user_data;
if (handler)
{
glade_signal_model_create_widget_iter (sig_model, widget, iter);
return TRUE;
}
return FALSE;
}
static void
gtk_tree_model_iface_init (GtkTreeModelIface *iface)
{
iface->get_flags = glade_signal_model_get_flags;
iface->get_column_type = glade_signal_model_get_column_type;
iface->get_n_columns = glade_signal_model_get_n_columns;
iface->get_iter = glade_signal_model_get_iter;
iface->get_path = glade_signal_model_get_path;
iface->get_value = glade_signal_model_get_value;
iface->iter_next = glade_signal_model_iter_next;
iface->iter_children = glade_signal_model_iter_children;
iface->iter_has_child = glade_signal_model_iter_has_child;
iface->iter_n_children = glade_signal_model_iter_n_children;
iface->iter_nth_child = glade_signal_model_iter_nth_child;
iface->iter_parent = glade_signal_model_iter_parent;
}
static gboolean
glade_signal_model_row_draggable (GtkTreeDragSource *model, GtkTreePath *path)
{
GtkTreeIter iter;
GladeSignal *signal;
gboolean retval;
gtk_tree_model_get_iter (GTK_TREE_MODEL (model), &iter, path);
gtk_tree_model_get (GTK_TREE_MODEL (model), &iter,
GLADE_SIGNAL_COLUMN_SIGNAL, &signal,
-1);
retval = signal && !glade_signal_model_is_dummy_handler (GLADE_SIGNAL_MODEL (model),
signal);
g_object_unref (signal);
return retval;
}
static gboolean
glade_signal_model_drag_data_get (GtkTreeDragSource *model,
GtkTreePath *path,
GtkSelectionData *data)
{
GtkTreeIter iter;
if (gtk_tree_model_get_iter (GTK_TREE_MODEL (model), &iter, path))
{
GladeSignal *signal;
const gchar *widget = iter.user_data;
gchar *dnd_text;
const gchar *user_data;
gtk_tree_model_get (GTK_TREE_MODEL (model), &iter,
GLADE_SIGNAL_COLUMN_SIGNAL, &signal, -1);
user_data = glade_signal_get_userdata (signal);
dnd_text = g_strdup_printf ("%s:%s:%s:%s:%d:%d", widget,
glade_signal_get_name (signal),
glade_signal_get_handler (signal),
user_data && strlen (user_data) ? user_data : "(none)",
glade_signal_get_swapped (signal),
glade_signal_get_after (signal));
gtk_selection_data_set (data,
gdk_atom_intern_static_string ("application/x-glade-signal"),
8,
(guchar*) dnd_text,
strlen (dnd_text));
g_free (dnd_text);
return TRUE;
}
else
{
return FALSE;
}
}
static gboolean
glade_signal_model_drag_data_delete (GtkTreeDragSource *model,
GtkTreePath *path)
{
/* We don't move rows... */
return FALSE;
}
static void
gtk_tree_drag_source_iface_init (GtkTreeDragSourceIface *iface)
{
iface->row_draggable = glade_signal_model_row_draggable;
iface->drag_data_get = glade_signal_model_drag_data_get;
iface->drag_data_delete = glade_signal_model_drag_data_delete;
}