sharpetronics/glade
1
0
Fork 0
mirror of https://gitlab.gnome.org/GNOME/glade.git synced 2025-09-26 00:05:38 -04:00
Code Issues Projects Releases Wiki Activity

Some work on the signal editor.

Browse Source
This commit is contained in:
Paolo Borelli 2003-06-17 20:21:21 +00:00
parent 89c5026669
commit 3c4f3938d6
8 changed files with 297 additions and 253 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
ChangeLog
View File

@ -1,3 +1,10 @@
2003-06-17 Paolo BOrelli <pborelli@katamail.com>
* src/glade-widget.[ch]: add signal related functions.
* src/glade-signal.[ch]: add glade_signal_new.
* src/glade-signal-editor.[ch]: use the above functions.
Also some ui love and misc code cleanups.
2003-06-15 Paolo Borelli <pborelli@katamail.com>
* src/glade-property.[ch]: gtk_object -> g_object cleanup.

333
src/glade-signal-editor.c
View File

@ -21,14 +21,9 @@
*/
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include <string.h>
#include "glade.h"
#include "glade-widget.h"
#include "glade-widget-class.h"
#include "glade-signal.h"
@ -111,8 +106,8 @@ glade_signal_editor_dialog_construct (GladeSignalEditor *editor, GtkWidget **vie
_("Select signal"),
NULL,
GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT, NULL);
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OK, GTK_RESPONSE_OK, NULL);
vbox = gtk_bin_get_child (GTK_BIN (dialog));
@ -132,7 +127,8 @@ glade_signal_editor_dialog_construct (GladeSignalEditor *editor, GtkWidget **vie
static GtkTreeIter *
glade_signal_editor_dialog_append_signal (GtkTreeStore *lst_model,
const gchar *label_text, GtkTreeIter *parent)
const gchar *label_text,
GtkTreeIter *parent)
{
GtkTreeIter *iter;
GValue *label;
@ -171,7 +167,6 @@ glade_signal_editor_dialog_load_signals (GladeSignalEditor *editor, GtkWidget *v
}
}
static void
glade_signal_editor_dialog_cb (GtkButton *button, GladeSignalEditor *editor)
{
@ -181,68 +176,68 @@ glade_signal_editor_dialog_cb (GtkButton *button, GladeSignalEditor *editor)
GtkTreeSelection *lst_selected;
GtkWidget *dialog;
GtkWidget *view;
gint response;
g_return_if_fail (editor->class->signals != NULL);
dialog = glade_signal_editor_dialog_construct (editor, &view);
glade_signal_editor_dialog_load_signals (editor, view);
switch (gtk_dialog_run (GTK_DIALOG (dialog))) {
case GTK_RESPONSE_ACCEPT:
lst_model = gtk_tree_view_get_model (GTK_TREE_VIEW (view));
lst_selected = gtk_tree_view_get_selection (GTK_TREE_VIEW (view));
response = gtk_dialog_run (GTK_DIALOG (dialog));
if (response == GTK_RESPONSE_OK) {
lst_model = gtk_tree_view_get_model (GTK_TREE_VIEW (view));
lst_selected = gtk_tree_view_get_selection (GTK_TREE_VIEW (view));
iter = g_new0 (GtkTreeIter, 1);
if (gtk_tree_selection_get_selected (lst_selected, &lst_model, iter)) {
label = g_new0 (GValue, 1);
gtk_tree_model_get_value (lst_model, iter, 0, label);
gtk_entry_set_text (GTK_ENTRY (editor->signal_name_entry), (gchar *) label->data[0].v_pointer);
}
break;
default:
break;
iter = g_new0 (GtkTreeIter, 1);
if (gtk_tree_selection_get_selected (lst_selected, &lst_model, iter)) {
label = g_new0 (GValue, 1);
gtk_tree_model_get_value (lst_model, iter, 0, label);
gtk_entry_set_text (GTK_ENTRY (editor->signal_name_entry), (gchar *) label->data[0].v_pointer);
}
}
gtk_widget_destroy (dialog);
}
/* glade_signal_editor_update_signal () will add a 'signal' to the list of
/**
* glade_signal_editor_update_signal_view () will add a 'signal' to the list of
* signals displayed by the signal editor if 'iter' is NULL, otherwise it will
* update the item at position 'iter' to the value of 'signal'
*/
static void
glade_signal_editor_update_signal (GladeSignalEditor *editor, GladeSignal *signal,
GtkTreeIter *iter)
glade_signal_editor_update_signal_view (GladeSignalEditor *editor,
GladeSignal *signal,
GtkTreeIter *iter)
{
GtkTreeStore *lst_model;
GValue *label;
lst_model = GTK_TREE_STORE (gtk_tree_view_get_model (GTK_TREE_VIEW (editor->signals_list)));
if (iter == NULL) {
iter = g_new0 (GtkTreeIter, 1);
gtk_tree_store_append (lst_model, iter, NULL);
gtk_tree_store_append (editor->model, iter, NULL);
}
label = g_new0 (GValue, 1);
label = g_value_init (label, G_TYPE_STRING);
label->data[0].v_pointer = g_strdup (signal->name);
gtk_tree_store_set_value (lst_model, iter, 0, label);
gtk_tree_store_set_value (editor->model, iter, 0, label);
label->data[0].v_pointer = g_strdup (signal->handler);
gtk_tree_store_set_value (lst_model, iter, 1, label);
gtk_tree_store_set_value (editor->model, iter, 1, label);
if (signal->after == TRUE)
label->data[0].v_pointer = _("Yes");
else
label->data[0].v_pointer = _("No");
gtk_tree_store_set_value (lst_model, iter, 2, label);
gtk_tree_store_set_value (editor->model, iter, 2, label);
}
static gboolean
glade_signal_editor_list_select_cb (GtkTreeSelection *lst_select,
GtkTreeModel *lst_model, GtkTreePath *lst_path, gboolean path_selected, GladeSignalEditor *editor)
GtkTreeModel *lst_model,
GtkTreePath *lst_path,
gboolean path_selected,
GladeSignalEditor *editor)
{
GtkTreeIter iter;
GValue *label;
@ -271,7 +266,6 @@ glade_signal_editor_list_select_cb (GtkTreeSelection *lst_select,
static void
glade_signal_editor_after_cb (GtkToggleButton *button, GladeSignalEditor *editor)
{
if (gtk_toggle_button_get_active (button)) {
g_object_set (G_OBJECT (button), "label", _("Yes"), NULL);
} else {
@ -279,40 +273,21 @@ glade_signal_editor_after_cb (GtkToggleButton *button, GladeSignalEditor *editor
}
}
static gboolean
static GladeSignal *
glade_signal_editor_validate_entries (GladeSignalEditor *editor)
{
GtkWidget *dialog;
gchar *name_text;
gchar *handler_text;
GList *list;
gboolean found;
GladeWidgetClassSignal *signal;
const gchar *name;
const gchar *handler;
gboolean after;
guint sig_id;
GladeSignal *signal;
name_text = (gchar *) gtk_entry_get_text (GTK_ENTRY (editor->signal_name_entry));
if (!strcmp (name_text, "")) {
/* FIXME: Should fix to use Gnome APIs or a glade dialog */
dialog = gtk_message_dialog_new (NULL,
GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_INFO,
GTK_BUTTONS_CLOSE,
_("Please enter a valid signal name"));
gtk_dialog_run (GTK_DIALOG (dialog));
gtk_widget_destroy (dialog);
return FALSE;
}
name = gtk_entry_get_text (GTK_ENTRY (editor->signal_name_entry));
/* check that signal exists */
found = FALSE;
for (list = editor->class->signals; list != NULL; list = list->next) {
signal = (GladeWidgetClassSignal *) list->data;
if (!strcmp (signal->name, name_text)) {
found = TRUE;
break;
}
}
if (found == FALSE) {
/* FIXME: Should fix to use Gnome APIs or a glade dialog */
sig_id = g_signal_lookup (name, editor->widget->class->type);
if (sig_id == 0) {
dialog = gtk_message_dialog_new (NULL,
GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_INFO,
@ -320,12 +295,13 @@ glade_signal_editor_validate_entries (GladeSignalEditor *editor)
_("Please enter a valid signal name"));
gtk_dialog_run (GTK_DIALOG (dialog));
gtk_widget_destroy (dialog);
return FALSE;
return NULL;
}
handler_text = (gchar *) gtk_entry_get_text (GTK_ENTRY (editor->signal_handler_entry));
if (!strcmp (handler_text, "")) {
/* FIXME: Should fix to use Gnome APIs or a glade dialog */
handler = gtk_entry_get_text (GTK_ENTRY (editor->signal_handler_entry));
/* check hadler is not empty */
if (!strcmp (handler, "")) {
dialog = gtk_message_dialog_new (NULL,
GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_INFO,
@ -333,10 +309,15 @@ glade_signal_editor_validate_entries (GladeSignalEditor *editor)
_("Please enter a signal handler"));
gtk_dialog_run (GTK_DIALOG (dialog));
gtk_widget_destroy (dialog);
return FALSE;
return NULL;
}
return TRUE;
after = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (editor->signal_after_button));
signal = glade_signal_new (name, handler, after);
return signal;
}
static void
@ -346,12 +327,12 @@ glade_signal_editor_clear_entries (GladeSignalEditor *editor)
gtk_entry_set_text (GTK_ENTRY (editor->signal_name_entry), "");
gtk_entry_set_text (GTK_ENTRY (editor->signal_handler_entry), "");
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON
(editor->signal_after_button), FALSE);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (editor->signal_after_button), FALSE);
}
static GladeSignal *
glade_signal_editor_get_signal_at_iter (GladeSignalEditor *editor, GtkTreeIter *iter)
glade_signal_editor_get_signal_at_iter (GladeSignalEditor *editor,
GtkTreeIter *iter)
{
GladeSignal *signal;
GtkTreeModel *model;
@ -379,68 +360,28 @@ glade_signal_editor_get_signal_at_iter (GladeSignalEditor *editor, GtkTreeIter *
return signal;
}
/* glade_signal_editor_update_widget_signal () is used to add signal to a
* widget's internal list of signals. If old_signal is NULL, the signal
* is appended to the list, however if a signal is supplied as old_signal,
* the func will find that signal and update it rather than add a new signal
*/
static GladeSignal *
glade_signal_editor_update_widget_signal (GladeSignalEditor *editor,
GladeSignal *old_signal)
{
GladeSignal *signal = NULL;
GladeSignal *sigtmp;
GList *list;
if (old_signal == NULL) {
signal = g_new0 (GladeSignal, 1);
editor->widget->signals = g_list_append (editor->widget->signals, signal);
} else {
for (list = editor->widget->signals; list != NULL; list = list->next) {
sigtmp = (GladeSignal *) list->data;
if (!strcmp (sigtmp->name, old_signal->name) &&
!strcmp (sigtmp->handler, old_signal->handler) &&
sigtmp->after == old_signal->after) {
signal = sigtmp;
break;
}
}
}
g_return_val_if_fail (signal != NULL, NULL);
signal->name = g_strdup ((gchar *) gtk_entry_get_text (GTK_ENTRY
(editor->signal_name_entry)));
signal->handler = g_strdup ((gchar *) gtk_entry_get_text (GTK_ENTRY
(editor->signal_handler_entry)));
signal->after = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON
(editor->signal_after_button));
return signal;
}
static void
glade_signal_editor_add_cb (GladeSignalEditor *editor)
glade_signal_editor_add_cb (GtkButton *button, GladeSignalEditor *editor)
{
GladeSignal *signal;
g_return_if_fail (editor != NULL);
g_return_if_fail (editor->widget != NULL);
g_return_if_fail (GLADE_IS_SIGNAL_EDITOR (editor));
g_return_if_fail (GLADE_IS_WIDGET (editor->widget));
if (!glade_signal_editor_validate_entries (editor))
signal = glade_signal_editor_validate_entries (editor);
if (!signal)
return;
signal = glade_signal_editor_update_widget_signal (editor, NULL);
glade_signal_editor_update_signal (editor, signal, NULL);
glade_widget_add_signal (editor->widget, signal);
glade_editor_add_signal (editor->editor, g_signal_lookup (signal->name,
editor->widget->class->type), signal->handler);
glade_editor_add_signal (editor->editor, g_signal_lookup (signal->name, editor->widget->class->type),
signal->handler);
glade_signal_editor_update_signal_view (editor, signal, NULL);
glade_signal_editor_clear_entries (editor);
}
static void
glade_signal_editor_update_cb (GladeSignalEditor *editor)
glade_signal_editor_update_cb (GtkButton *button, GladeSignalEditor *editor)
{
GtkTreeIter iter;
GtkTreeSelection *select;
@ -448,64 +389,51 @@ glade_signal_editor_update_cb (GladeSignalEditor *editor)
GladeSignal *old_sig;
GladeSignal *new_sig;
g_return_if_fail (editor != NULL);
g_return_if_fail (editor->widget != NULL);
g_return_if_fail (GLADE_IS_SIGNAL_EDITOR (editor));
g_return_if_fail (GLADE_IS_WIDGET (editor->widget));
if (!glade_signal_editor_validate_entries (editor))
new_sig = glade_signal_editor_validate_entries (editor);
if (!new_sig)
return;
model = GTK_TREE_MODEL (editor->model);
select = gtk_tree_view_get_selection (GTK_TREE_VIEW (editor->signals_list));
model = gtk_tree_view_get_model (GTK_TREE_VIEW (editor->signals_list));
if (gtk_tree_selection_get_selected (select, &model, &iter) == TRUE) {
old_sig = glade_signal_editor_get_signal_at_iter (editor, &iter);
new_sig = glade_signal_editor_update_widget_signal (editor, old_sig);
glade_signal_editor_update_signal (editor, new_sig, &iter);
glade_widget_update_signal (editor->widget, new_sig, old_sig);
glade_signal_editor_update_signal_view (editor, new_sig, &iter);
}
}
static void
glade_signal_editor_delete_cb (GladeSignalEditor *editor)
glade_signal_editor_remove_cb (GtkButton *button, GladeSignalEditor *editor)
{
GtkTreeIter iter;
GtkTreeSelection *select;
GtkTreeModel *model;
GladeSignal *signal;
GladeSignal *sig;
GList *list;
g_return_if_fail (editor != NULL);
g_return_if_fail (editor->widget != NULL);
g_return_if_fail (GLADE_IS_SIGNAL_EDITOR (editor));
g_return_if_fail (GLADE_IS_WIDGET (editor->widget));
model = GTK_TREE_MODEL (editor->model);
select = gtk_tree_view_get_selection (GTK_TREE_VIEW (editor->signals_list));
model = gtk_tree_view_get_model (GTK_TREE_VIEW (editor->signals_list));
if (gtk_tree_selection_get_selected (select, &model, &iter) == TRUE) {
signal = glade_signal_editor_get_signal_at_iter (editor, &iter);
gtk_tree_store_remove (GTK_TREE_STORE (model), &iter);
list = editor->widget->signals;
for ( ; list != NULL; list = list->next) {
sig = (GladeSignal *) list->data;
if (!strcmp (sig->name, signal->name) &&
!strcmp (sig->handler, signal->handler) &&
sig->after == signal->after) {
editor->widget->signals = g_list_remove (editor->widget->signals, list->data);
break;
}
}
glade_widget_remove_signal (editor->widget, signal);
gtk_tree_store_remove (GTK_TREE_STORE (editor->model), &iter);
glade_signal_editor_clear_entries (editor);
}
}
static void
glade_signal_editor_clear_cb (GladeSignalEditor *editor)
glade_signal_editor_clear_cb (GtkButton *button, GladeSignalEditor *editor)
{
g_return_if_fail (editor != NULL);
g_return_if_fail (GLADE_IS_SIGNAL_EDITOR (editor));
glade_signal_editor_clear_entries (editor);
}
@ -514,16 +442,16 @@ static GtkWidget *
glade_signal_editor_construct_signals_list (GladeSignalEditor *editor)
{
GtkTreeSelection *selection;
GtkTreeStore *model;
GtkTreeView *view;
GtkWidget *view_widget;
model = gtk_tree_store_new (3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);
editor->model = gtk_tree_store_new (3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);
view_widget = gtk_tree_view_new_with_model (GTK_TREE_MODEL (model));
view_widget = gtk_tree_view_new_with_model (GTK_TREE_MODEL (editor->model));
view = GTK_TREE_VIEW (view_widget);
g_object_unref (G_OBJECT (model));
/* the view now holds a reference, we can get rid of our own */
g_object_unref (G_OBJECT (editor->model));
glade_signal_editor_append_column (view, 0, _("Signal"));
glade_signal_editor_append_column (view, 1, _("Handler"));
@ -580,9 +508,8 @@ glade_signal_editor_construct_table (GladeSignalEditor *editor)
/* The "..." button */
button = gtk_button_new_with_label ("...");
gtk_signal_connect (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC (glade_signal_editor_dialog_cb),
editor);
g_signal_connect (G_OBJECT (button), "clicked",
G_CALLBACK (glade_signal_editor_dialog_cb), editor);
gtk_box_pack_start_defaults (GTK_BOX (hbox), button);
hbox = gtk_hbox_new (FALSE, 0);
@ -592,9 +519,8 @@ glade_signal_editor_construct_table (GladeSignalEditor *editor)
/* The Yes/No button */
hbox = gtk_hbox_new (FALSE, 0);
button = gtk_toggle_button_new_with_label (_("No"));
gtk_signal_connect (GTK_OBJECT (button), "toggled",
GTK_SIGNAL_FUNC (glade_signal_editor_after_cb),
editor);
g_signal_connect (G_OBJECT (button), "toggled",
G_CALLBACK (glade_signal_editor_after_cb), editor);
gtk_box_pack_start_defaults (GTK_BOX (hbox), button);
gtk_table_attach_defaults (GTK_TABLE (table), hbox, 1, 2, 2, 3);
editor->signal_after_button = button;
@ -602,53 +528,36 @@ glade_signal_editor_construct_table (GladeSignalEditor *editor)
return table;
}
static void
glade_signal_editor_clicked_cb (GtkWidget *button, GladeSignalEditor *editor)
{
g_return_if_fail (GLADE_IS_SIGNAL_EDITOR (editor));
if (button == editor->add_button)
glade_signal_editor_add_cb (editor);
else if (button == editor->update_button)
glade_signal_editor_update_cb (editor);
else if (button == editor->delete_button)
glade_signal_editor_delete_cb (editor);
else if (button == editor->clear_button)
glade_signal_editor_clear_cb (editor);
}
static GtkWidget *
glade_signal_editor_append_button (GladeSignalEditor *editor,
GtkWidget *hbox,
const gchar *name)
{
GtkWidget *button;
button = gtk_button_new_with_label (name);
gtk_signal_connect (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC (glade_signal_editor_clicked_cb),
editor);
gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
return button;
}
static GtkWidget *
glade_signal_editor_construct_buttons (GladeSignalEditor *editor)
{
GtkWidget *hbox;
GtkWidget *hbuttonbox;
hbox = gtk_hbox_new (FALSE, 0);
hbuttonbox = gtk_hbutton_box_new ();
editor->add_button = glade_signal_editor_append_button (editor, hbox, _("Add"));
editor->update_button = glade_signal_editor_append_button (editor, hbox, _("Update"));
editor->delete_button = glade_signal_editor_append_button (editor, hbox, _("Delete"));
editor->clear_button = glade_signal_editor_append_button (editor, hbox, _("Clear"));
editor->add_button = gtk_button_new_from_stock (GTK_STOCK_ADD);
editor->update_button = gtk_button_new_with_mnemonic (_("_Update"));
editor->remove_button = gtk_button_new_from_stock (GTK_STOCK_REMOVE);
editor->clear_button = gtk_button_new_from_stock (GTK_STOCK_CLEAR);
return hbox;
g_signal_connect (G_OBJECT (editor->add_button), "clicked",
G_CALLBACK (glade_signal_editor_add_cb), editor);
g_signal_connect (G_OBJECT (editor->update_button), "clicked",
G_CALLBACK (glade_signal_editor_update_cb), editor);
g_signal_connect (G_OBJECT (editor->remove_button), "clicked",
G_CALLBACK (glade_signal_editor_remove_cb), editor);
g_signal_connect (G_OBJECT (editor->clear_button), "clicked",
G_CALLBACK (glade_signal_editor_clear_cb), editor);
gtk_container_add (GTK_CONTAINER (hbuttonbox), editor->add_button);
gtk_container_add (GTK_CONTAINER (hbuttonbox), editor->update_button);
gtk_container_add (GTK_CONTAINER (hbuttonbox), editor->remove_button);
gtk_container_add (GTK_CONTAINER (hbuttonbox), editor->clear_button);
return hbuttonbox;
}
void
static void
glade_signal_editor_construct (GladeSignalEditor *editor)
{
GtkWidget *vbox;
@ -663,11 +572,14 @@ glade_signal_editor_construct (GladeSignalEditor *editor)
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_box_pack_start (GTK_BOX (vbox), scroll, TRUE, TRUE, 0);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scroll),
GTK_SHADOW_IN);
editor->signals_list = glade_signal_editor_construct_signals_list (editor);
gtk_container_add (GTK_CONTAINER (scroll), editor->signals_list);
gtk_box_pack_start (GTK_BOX (vbox), scroll, TRUE, TRUE, 0);
table = glade_signal_editor_construct_table (editor);
gtk_box_pack_start (GTK_BOX (vbox), table, FALSE, FALSE, 0);
@ -677,7 +589,6 @@ glade_signal_editor_construct (GladeSignalEditor *editor)
gtk_widget_show_all (editor->main_window);
}
GtkWidget *
glade_signal_editor_get_widget (GladeSignalEditor *editor)
{
@ -687,7 +598,7 @@ glade_signal_editor_get_widget (GladeSignalEditor *editor)
return editor->main_window;
}
GladeSignalEditor*
GladeSignalEditor *
glade_signal_editor_new (GladeEditor *editor)
{
GladeSignalEditor *signal_editor;
@ -701,14 +612,15 @@ glade_signal_editor_new (GladeEditor *editor)
}
void
glade_signal_editor_load_widget (GladeSignalEditor *editor, GladeWidget *widget)
glade_signal_editor_load_widget (GladeSignalEditor *editor,
GladeWidget *widget)
{
GladeSignal *signal;
GtkTreeStore *model;
GList *list;
model = GTK_TREE_STORE (gtk_tree_view_get_model (GTK_TREE_VIEW (editor->signals_list)));
gtk_tree_store_clear (model);
g_return_if_fail (GLADE_IS_SIGNAL_EDITOR (editor));
g_return_if_fail (widget == NULL || GLADE_IS_WIDGET (widget));
gtk_tree_store_clear (editor->model);
editor->widget = widget;
editor->class = widget ? widget->class : NULL;
@ -717,11 +629,12 @@ glade_signal_editor_load_widget (GladeSignalEditor *editor, GladeWidget *widget)
if (!widget)
return;
list = widget->signals;
for (; list != NULL; list = list->next) {
for (list = widget->signals; list; list = list->next) {
GladeSignal *signal;
signal = list->data;
glade_signal_editor_update_signal (editor, signal, NULL);
glade_signal_editor_update_signal_view (editor, signal, NULL);
}
}

22
src/glade-signal-editor.h
View File

@ -4,23 +4,25 @@
G_BEGIN_DECLS
#define GLADE_SIGNAL_EDITOR(e) ((GladeSignalEditor *)e)
#define GLADE_IS_SIGNAL_EDITOR(e) (e != NULL)
/* The GladeSignalEditor is used to house the signal editor interface and
* associated functionality.
*/
struct _GladeSignalEditor {
struct _GladeSignalEditor
{
GtkWidget *main_window; /* A vbox where all the widgets are added */
GladeWidget *widget;
GladeWidgetClass *class;
GladeEditor *editor;
GtkWidget *signals_list;
GtkTreeStore *model;
GtkWidget *signal_name_entry;
GtkWidget *signal_handler_entry;
GtkWidget *signal_after_button;
@ -28,13 +30,17 @@ struct _GladeSignalEditor {
/* Buttons */
GtkWidget *add_button;
GtkWidget *update_button;
GtkWidget *delete_button;
GtkWidget *remove_button;
GtkWidget *clear_button;
};
GtkWidget * glade_signal_editor_get_widget (GladeSignalEditor *editor);
GladeSignalEditor * glade_signal_editor_new (GladeEditor *editor);
void glade_signal_editor_load_widget (GladeSignalEditor *editor, GladeWidget *widget);
GtkWidget *glade_signal_editor_get_widget (GladeSignalEditor *editor);
GladeSignalEditor *glade_signal_editor_new (GladeEditor *editor);
void glade_signal_editor_load_widget (GladeSignalEditor *editor, GladeWidget *widget);
G_END_DECLS

26
src/glade-signal.c
View File

@ -27,6 +27,25 @@
#include "glade.h"
#include "glade-signal.h"
GladeSignal *
glade_signal_new (const gchar *name, const gchar *handler, gboolean after)
{
GladeSignal *signal = g_new0 (GladeSignal, 1);
signal->name = g_strdup (name);
signal->handler = g_strdup (handler);
signal->after = after;
return signal;
}
void
glade_signal_free (GladeSignal *signal)
{
g_free (signal->name);
g_free (signal->handler);
g_free (signal);
}
GladeXmlNode *
glade_signal_write (GladeXmlContext *context, GladeSignal *signal)
@ -42,10 +61,3 @@ glade_signal_write (GladeXmlContext *context, GladeSignal *signal)
return node;
}
void
glade_signal_free (GladeSignal *signal)
{
g_free (signal->name);
g_free (signal->handler);
g_free (signal);
}

13
src/glade-signal.h
View File

@ -4,18 +4,27 @@
G_BEGIN_DECLS
#define GLADE_SIGNAL(s) ((GladeSignal *)s)
#define GLADE_IS_SIGNAL(s) (s != NULL)
struct _GladeSignal {
struct _GladeSignal
{
gchar *name; /* Signal name eg "clicked" */
gchar *handler; /* Handler function eg "gtk_main_quit" */
gboolean after; /* Connect after TRUE or FALSE */
};
GladeXmlNode * glade_signal_write (GladeXmlContext *context, GladeSignal *signal);
GladeSignal *glade_signal_new (const gchar *name,
const gchar *handler,
gboolean after);
void glade_signal_free (GladeSignal *signal);
GladeXmlNode *glade_signal_write (GladeXmlContext *context, GladeSignal *signal);
G_END_DECLS
#endif /* __GLADE_SIGNAL_H__ */

35
src/glade-widget-class.h
View File

@ -4,6 +4,7 @@
G_BEGIN_DECLS
typedef enum {
GLADE_TOPLEVEL = 1 << 2,
GLADE_ADD_PLACEHOLDER = 1 << 3,
@ -27,16 +28,16 @@ typedef enum {
* type. It is also used to store information that has been loaded to memory
* for that object like the icon/mask.
*/
struct _GladeWidgetClass {
GType type; /* GType of the widget */
struct _GladeWidgetClass
{
GType type; /* GType of the widget */
gchar *name; /* Name of the widget, for example GtkButton */
gchar *xml_file; /* Name of the xml file for this type without a path */
GdkPixmap *pixmap; /* The loaded pixmap for the icon of this widget type */
GdkBitmap *mask; /* The mask for the loaded pixmap */
GdkPixbuf *pixbuf; /* Temp for glade-project-view-tree. */
GdkPixbuf *pixbuf; /* Temp for glade-project-view-tree. */
gchar *generic_name; /* Use to generate names of new widgets, for
* example "button" so that we generate button1,
@ -68,30 +69,32 @@ struct _GladeWidgetClass {
/* GladeWidgetClassSignal contains all the info we need for a given signal, such as
* the signal name, and maybe more in the future
*/
struct _GladeWidgetClassSignal {
struct _GladeWidgetClassSignal
{
gchar *name; /* Name of the signal, eg clicked */
gchar *type; /* Name of the object class that this signal belongs to
* eg GtkButton */
};
GladeWidgetClass * glade_widget_class_new_from_name (const gchar *name);
GladeWidgetClass * glade_widget_class_new_from_node (GladeXmlNode *node);
GladeWidgetClass * glade_widget_class_get_by_name (const gchar *name);
GladeWidgetClass *glade_widget_class_new_from_name (const gchar *name);
GladeWidgetClass *glade_widget_class_new_from_node (GladeXmlNode *node);
GladeWidgetClass *glade_widget_class_get_by_name (const gchar *name);
const gchar * glade_widget_class_get_name (GladeWidgetClass *class);
GType glade_widget_class_get_type (GladeWidgetClass *class);
gboolean glade_widget_class_has_queries (GladeWidgetClass *class);
const gchar *glade_widget_class_get_name (GladeWidgetClass *class);
GType glade_widget_class_get_type (GladeWidgetClass *class);
gboolean glade_widget_class_has_queries (GladeWidgetClass *class);
gboolean glade_widget_class_is (GladeWidgetClass *class, const gchar *name);
gboolean glade_widget_class_is (GladeWidgetClass *class, const gchar *name);
/* ParamSpec stuff */
void glade_widget_class_get_specs (GladeWidgetClass *class,
GParamSpec ***specs, gint *n_specs);
GParamSpec * glade_widget_class_find_spec (GladeWidgetClass *class, const gchar *name);
void glade_widget_class_dump_param_specs (GladeWidgetClass *class);
GParamSpec *glade_widget_class_find_spec (GladeWidgetClass *class, const gchar *name);
void glade_widget_class_dump_param_specs (GladeWidgetClass *class);
/* Packing properties */
void glade_widget_class_load_packing_properties (GladeWidgetClass *class);
void glade_widget_class_load_packing_properties (GladeWidgetClass *class);
G_END_DECLS

95
src/glade-widget.c
View File

@ -1252,6 +1252,101 @@ glade_widget_replace_with_placeholder (GladeWidget *widget, GladePlaceholder *pl
return placeholder;
}
/**
* Find the list element in the signal list with the same signal
* or NULL if is not present.
*/
static GList *
glade_widget_find_signal (GladeWidget *widget, GladeSignal *signal)
{
GList *list;
for (list = widget->signals; list; list = list->next) {
GladeSignal *tmp = GLADE_SIGNAL (list->data);
if (!strcmp (tmp->name, signal->name) &&
!strcmp (tmp->handler, signal->handler) &&
tmp->after == signal->after)
return list;
}
/* not found... */
return NULL;
}
/**
* glade_widget_add_signal:
* @widget
* @signal
*
* Add @signal to the widget's signal list.
**/
void
glade_widget_add_signal (GladeWidget *widget, GladeSignal *signal)
{
GList *found;
g_return_if_fail (GLADE_IS_WIDGET (widget));
g_return_if_fail (GLADE_IS_SIGNAL (signal));
found = glade_widget_find_signal (widget, signal);
if (found)
return;
widget->signals = g_list_append (widget->signals, signal);
return;
}
/**
* glade_widget_update_signal:
* @widget
* @new_signal
* @old_signal
*
* Updates @old_signal in the widget's signal list with @new_signal.
**/
void
glade_widget_update_signal (GladeWidget *widget,
GladeSignal *new_signal,
GladeSignal *old_signal)
{
GList *found;
g_return_if_fail (GLADE_IS_WIDGET (widget));
g_return_if_fail (GLADE_IS_SIGNAL (new_signal));
g_return_if_fail (GLADE_IS_SIGNAL (old_signal));
found = glade_widget_find_signal (widget, old_signal);
if (found) {
found->data = new_signal;
return;
}
/* if we didn't find the signal in the list, add it */
widget->signals = g_list_append (widget->signals, new_signal);
}
/**
* glade_widget_remove_signal:
* @widget
* @signal
*
* Remove @signal from the widget's signal list.
**/
void
glade_widget_remove_signal (GladeWidget *widget, GladeSignal *signal)
{
GList *found;
g_return_if_fail (GLADE_IS_WIDGET (widget));
g_return_if_fail (GLADE_IS_SIGNAL (signal));
found = glade_widget_find_signal (widget, signal);
if (found) {
g_list_remove_link (widget->signals, found);
g_list_free_1 (found);
}
}
GladeXmlNode *
glade_widget_write (GladeXmlContext *context, GladeWidget *widget)
{

19
src/glade-widget.h
View File

@ -40,7 +40,7 @@ struct _GladeWidget {
* property is "Ok".
*/
GList *signals; /* A list of GladeWidgetSignals */
GList *signals; /* A list of GladeSignals */
/* Tree Structure */
GladeWidget *parent; /* The parent of this widget, NULL if this is a
@ -52,15 +52,6 @@ struct _GladeWidget {
gboolean selected;
};
/* GladeWidgetSignal is a structure that holds information about a signal a
* widget wants for handle / listen for.
*/
struct _GladeWidgetSignal {
gchar *name; /* Signal name eg "clicked" */
gchar *handler; /* Handler function eg "gtk_main_quit" */
gboolean after; /* Connect after TRUE or FALSE */
};
gchar * glade_widget_new_name (GladeProject *project, GladeWidgetClass *class);
gboolean glade_widget_create_gtk_widget (GladeWidget *glade_widget);
@ -94,6 +85,14 @@ GladePlaceholder *glade_widget_replace_with_placeholder (GladeWidget *widget,
GladePlaceholder *placeholder);
GladeWidget *glade_widget_get_from_gtk_widget (GtkWidget *widget);
/* Widget signal*/
void glade_widget_add_signal (GladeWidget *widget, GladeSignal *signal);
void glade_widget_update_signal (GladeWidget *widget,
GladeSignal *new_signal,
GladeSignal *old_signal);
void glade_widget_remove_signal (GladeWidget *widget, GladeSignal *signal);
/* Xml saving & reading */
GladeXmlNode * glade_widget_write (GladeXmlContext *context, GladeWidget *widget);
GladeWidget * glade_widget_new_from_node (GladeXmlNode *node, GladeProject *project);