From d8e4ebebc320c72ae93c88dc43d8ae220a94331d Mon Sep 17 00:00:00 2001 From: Chris Toshok Date: Sat, 16 Nov 2002 23:49:31 +0000 Subject: Lots of GObject work. 2002-11-16 Chris Toshok * gal/e-text/e-completion-test.c: Lots of GObject work. * gal/e-text/e-completion-view.[ch]: same. * gal/e-text/e-completion.[ch]: same. * gal/e-text/e-entry.[ch]: same. * gal/e-text/e-table-text-model.[ch]: same. * gal/e-text/e-text-model-uri.[ch]: same. * gal/e-text/e-text-model.[ch]: same. * gal/e-text/e-text-test.c: same. * gal/e-text/e-text.[ch]: same. svn path=/trunk/; revision=18800 --- widgets/text/e-completion-test.c | 32 +- widgets/text/e-completion-view.c | 257 +++++----- widgets/text/e-completion-view.h | 8 +- widgets/text/e-completion.c | 199 ++++---- widgets/text/e-completion.h | 8 +- widgets/text/e-entry-test.c | 15 +- widgets/text/e-entry.c | 811 ++++++++++++++++--------------- widgets/text/e-entry.h | 8 +- widgets/text/e-table-text-model.c | 79 ++- widgets/text/e-table-text-model.h | 8 +- widgets/text/e-text-model-uri.c | 50 +- widgets/text/e-text-model-uri.h | 8 +- widgets/text/e-text-model.c | 121 +++-- widgets/text/e-text-model.h | 8 +- widgets/text/e-text-test.c | 41 +- widgets/text/e-text.c | 992 ++++++++++++++++++++++---------------- widgets/text/e-text.h | 8 +- 17 files changed, 1404 insertions(+), 1249 deletions(-) (limited to 'widgets/text') diff --git a/widgets/text/e-completion-test.c b/widgets/text/e-completion-test.c index bfa53982a3..dfefe23e1b 100644 --- a/widgets/text/e-completion-test.c +++ b/widgets/text/e-completion-test.c @@ -188,28 +188,28 @@ main (int argc, gchar **argv) read_dict (); complete = e_completion_new (); - gtk_signal_connect (GTK_OBJECT (complete), - "request_completion", - GTK_SIGNAL_FUNC (request_dict_search), - NULL); - gtk_signal_connect (GTK_OBJECT (complete), - "end_completion", - GTK_SIGNAL_FUNC (end_dict_search), - NULL); - gtk_signal_connect (GTK_OBJECT (complete), - "cancel_completion", - GTK_SIGNAL_FUNC (end_dict_search), - NULL); + g_signal_connect (complete, + "request_completion", + G_CALLBACK (request_dict_search), + NULL); + g_signal_connect (complete, + "end_completion", + G_CALLBACK (end_dict_search), + NULL); + g_signal_connect (complete, + "cancel_completion", + G_CALLBACK (end_dict_search), + NULL); win = gtk_window_new (GTK_WINDOW_TOPLEVEL); entry = e_entry_new (); e_entry_enable_completion_full (E_ENTRY (entry), complete, 0, NULL); e_entry_set_editable (E_ENTRY (entry), TRUE); - gtk_signal_connect (GTK_OBJECT (entry), - "popup", - GTK_SIGNAL_FUNC (popup_cb), - NULL); + g_signal_connect (entry, + "popup", + G_CALLBACK (popup_cb), + NULL); gtk_container_add (GTK_CONTAINER (win), entry); gtk_widget_show_all (win); diff --git a/widgets/text/e-completion-view.c b/widgets/text/e-completion-view.c index d09176c98a..4e5bba3f9e 100644 --- a/widgets/text/e-completion-view.c +++ b/widgets/text/e-completion-view.c @@ -31,6 +31,7 @@ #include #include #include +#include "gal/util/e-marshal.h" enum { E_COMPLETION_VIEW_NONEMPTY, @@ -54,8 +55,9 @@ static gint e_completion_view_key_press_handler (GtkWidget *w, GdkEventKey *k static void e_completion_view_class_init (ECompletionViewClass *klass); static void e_completion_view_init (ECompletionView *completion); -static void e_completion_view_destroy (GtkObject *object); +static void e_completion_view_dispose (GObject *object); +#define PARENT_TYPE GTK_TYPE_EVENT_BOX static GtkObjectClass *parent_class; @@ -193,89 +195,78 @@ e_completion_view_size_allocate (GtkWidget *widget, GtkAllocation *allocation) } } -GtkType -e_completion_view_get_type (void) -{ - static GtkType completion_view_type = 0; - - if (!completion_view_type) { - GtkTypeInfo completion_view_info = { - "ECompletionView", - sizeof (ECompletionView), - sizeof (ECompletionViewClass), - (GtkClassInitFunc) e_completion_view_class_init, - (GtkObjectInitFunc) e_completion_view_init, - NULL, NULL, /* reserved */ - (GtkClassInitFunc) NULL - }; - - completion_view_type = gtk_type_unique (gtk_event_box_get_type (), &completion_view_info); - } - - return completion_view_type; -} - +E_MAKE_TYPE (e_completion_view, + "ECompletionView", + ECompletionView, + e_completion_view_class_init, + e_completion_view_init, + PARENT_TYPE) + static void e_completion_view_class_init (ECompletionViewClass *klass) { - GtkObjectClass *object_class = (GtkObjectClass *) klass; + GObjectClass *object_class = (GObjectClass *) klass; GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass); - parent_class = GTK_OBJECT_CLASS (gtk_type_class (gtk_event_box_get_type ())); + parent_class = g_type_class_ref (PARENT_TYPE); e_completion_view_signals[E_COMPLETION_VIEW_NONEMPTY] = - gtk_signal_new ("nonempty", - GTK_RUN_LAST, - E_OBJECT_CLASS_TYPE (object_class), - GTK_SIGNAL_OFFSET (ECompletionViewClass, nonempty), - gtk_marshal_NONE__NONE, - GTK_TYPE_NONE, 0); + g_signal_new ("nonempty", + G_OBJECT_CLASS_TYPE (object_class), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (ECompletionViewClass, nonempty), + NULL, NULL, + e_marshal_NONE__NONE, + G_TYPE_NONE, 0); e_completion_view_signals[E_COMPLETION_VIEW_ADDED] = - gtk_signal_new ("added", - GTK_RUN_LAST, - E_OBJECT_CLASS_TYPE (object_class), - GTK_SIGNAL_OFFSET (ECompletionViewClass, added), - gtk_marshal_NONE__NONE, - GTK_TYPE_NONE, 0); + g_signal_new ("added", + G_OBJECT_CLASS_TYPE (object_class), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (ECompletionViewClass, added), + NULL, NULL, + e_marshal_NONE__NONE, + G_TYPE_NONE, 0); e_completion_view_signals[E_COMPLETION_VIEW_FULL] = - gtk_signal_new ("full", - GTK_RUN_LAST, - E_OBJECT_CLASS_TYPE (object_class), - GTK_SIGNAL_OFFSET (ECompletionViewClass, full), - gtk_marshal_NONE__NONE, - GTK_TYPE_NONE, 0); + g_signal_new ("full", + G_OBJECT_CLASS_TYPE (object_class), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (ECompletionViewClass, full), + NULL, NULL, + e_marshal_NONE__NONE, + G_TYPE_NONE, 0); e_completion_view_signals[E_COMPLETION_VIEW_BROWSE] = - gtk_signal_new ("browse", - GTK_RUN_LAST, - E_OBJECT_CLASS_TYPE (object_class), - GTK_SIGNAL_OFFSET (ECompletionViewClass, browse), - gtk_marshal_NONE__POINTER, - GTK_TYPE_NONE, 1, - GTK_TYPE_POINTER); + g_signal_new ("browse", + G_OBJECT_CLASS_TYPE (object_class), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (ECompletionViewClass, browse), + NULL, NULL, + e_marshal_NONE__POINTER, + G_TYPE_NONE, 1, + G_TYPE_POINTER); e_completion_view_signals[E_COMPLETION_VIEW_UNBROWSE] = - gtk_signal_new ("unbrowse", - GTK_RUN_LAST, - E_OBJECT_CLASS_TYPE (object_class), - GTK_SIGNAL_OFFSET (ECompletionViewClass, unbrowse), - gtk_marshal_NONE__NONE, - GTK_TYPE_NONE, 0); + g_signal_new ("unbrowse", + G_OBJECT_CLASS_TYPE (object_class), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (ECompletionViewClass, unbrowse), + NULL, NULL, + e_marshal_NONE__NONE, + G_TYPE_NONE, 0); e_completion_view_signals[E_COMPLETION_VIEW_ACTIVATE] = - gtk_signal_new ("activate", - GTK_RUN_LAST, - E_OBJECT_CLASS_TYPE (object_class), - GTK_SIGNAL_OFFSET (ECompletionViewClass, activate), - gtk_marshal_NONE__POINTER, - GTK_TYPE_NONE, 1, - GTK_TYPE_POINTER); - - E_OBJECT_CLASS_ADD_SIGNALS (object_class, e_completion_view_signals, E_COMPLETION_VIEW_LAST_SIGNAL); + g_signal_new ("activate", + G_OBJECT_CLASS_TYPE (object_class), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (ECompletionViewClass, activate), + NULL, NULL, + e_marshal_NONE__POINTER, + G_TYPE_NONE, 1, + G_TYPE_POINTER); - object_class->destroy = e_completion_view_destroy; + object_class->dispose = e_completion_view_dispose; widget_class->key_press_event = e_completion_view_local_key_press_handler; widget_class->expose_event = e_completion_view_expose_event; @@ -291,7 +282,7 @@ e_completion_view_init (ECompletionView *completion) } static void -e_completion_view_destroy (GtkObject *object) +e_completion_view_dispose (GObject *object) { ECompletionView *cv = E_COMPLETION_VIEW (object); @@ -305,17 +296,17 @@ e_completion_view_destroy (GtkObject *object) } if (cv->key_widget) { - gtk_signal_disconnect (GTK_OBJECT (cv->key_widget), cv->key_signal_id); - gtk_object_unref (GTK_OBJECT (cv->key_widget)); + g_signal_handler_disconnect (cv->key_widget, cv->key_signal_id); + g_object_unref (cv->key_widget); cv->key_widget = NULL; } if (cv->completion) - gtk_object_unref (GTK_OBJECT (cv->completion)); + g_object_unref (cv->completion); cv->completion = NULL; - if (parent_class->destroy) - (parent_class->destroy) (object); + if (G_OBJECT_CLASS (parent_class)->dispose) + (G_OBJECT_CLASS (parent_class)->dispose) (object); } static void @@ -325,19 +316,19 @@ e_completion_view_disconnect (ECompletionView *cv) g_return_if_fail (E_IS_COMPLETION_VIEW (cv)); if (cv->begin_signal_id) - gtk_signal_disconnect (GTK_OBJECT (cv->completion), cv->begin_signal_id); + g_signal_handler_disconnect (cv->completion, cv->begin_signal_id); if (cv->comp_signal_id) - gtk_signal_disconnect (GTK_OBJECT (cv->completion), cv->comp_signal_id); + g_signal_handler_disconnect (cv->completion, cv->comp_signal_id); if (cv->restart_signal_id) - gtk_signal_disconnect (GTK_OBJECT (cv->completion), cv->restart_signal_id); + g_signal_handler_disconnect (cv->completion, cv->restart_signal_id); if (cv->cancel_signal_id) - gtk_signal_disconnect (GTK_OBJECT (cv->completion), cv->cancel_signal_id); + g_signal_handler_disconnect (cv->completion, cv->cancel_signal_id); if (cv->end_signal_id) - gtk_signal_disconnect (GTK_OBJECT (cv->completion), cv->end_signal_id); + g_signal_handler_disconnect (cv->completion, cv->end_signal_id); if (cv->clear_signal_id) - gtk_signal_disconnect (GTK_OBJECT (cv->completion), cv->clear_signal_id); + g_signal_handler_disconnect (cv->completion, cv->clear_signal_id); if (cv->lost_signal_id) - gtk_signal_disconnect (GTK_OBJECT (cv->completion), cv->lost_signal_id); + g_signal_handler_disconnect (cv->completion, cv->lost_signal_id); cv->begin_signal_id = 0; cv->comp_signal_id = 0; @@ -450,7 +441,7 @@ e_completion_view_select (ECompletionView *cv, gint r) cv->selection = r; e_completion_view_set_cursor_row (cv, r); - gtk_signal_emit (GTK_OBJECT (cv), e_completion_view_signals[E_COMPLETION_VIEW_ACTIVATE], match); + g_signal_emit (cv, e_completion_view_signals[E_COMPLETION_VIEW_ACTIVATE], 0, match); } static gint @@ -474,14 +465,14 @@ e_completion_view_key_press_handler (GtkWidget *w, GdkEventKey *key_event, gpoin /* Start up a completion.*/ if (complete_key && !cv->editable) { - gtk_signal_emit (GTK_OBJECT (cv), e_completion_view_signals[E_COMPLETION_VIEW_BROWSE], NULL); + g_signal_emit (cv, e_completion_view_signals[E_COMPLETION_VIEW_BROWSE], 0, NULL); goto stop_emission; } /* Stop our completion. */ if (uncomplete_key && cv->editable && cv->selection < 0) { e_completion_view_set_cursor_row (cv, -1); - gtk_signal_emit (GTK_OBJECT (cv), e_completion_view_signals[E_COMPLETION_VIEW_UNBROWSE]); + g_signal_emit (cv, e_completion_view_signals[E_COMPLETION_VIEW_UNBROWSE], 0); goto stop_emission; } @@ -577,15 +568,15 @@ e_completion_view_key_press_handler (GtkWidget *w, GdkEventKey *key_event, gpoin e_completion_view_set_cursor_row (cv, cv->selection); if (cv->selection >= 0) - gtk_signal_emit (GTK_OBJECT (cv), e_completion_view_signals[E_COMPLETION_VIEW_BROWSE], - g_ptr_array_index (cv->choices, cv->selection)); + g_signal_emit (cv, e_completion_view_signals[E_COMPLETION_VIEW_BROWSE], 0, + g_ptr_array_index (cv->choices, cv->selection)); else - gtk_signal_emit (GTK_OBJECT (cv), e_completion_view_signals[E_COMPLETION_VIEW_UNBROWSE]); + g_signal_emit (cv, e_completion_view_signals[E_COMPLETION_VIEW_UNBROWSE], 0); stop_emission: if (key_handled) - gtk_signal_emit_stop_by_name (GTK_OBJECT (w), "key_press_event"); + g_signal_stop_emission_by_name (w, "key_press_event"); return key_handled; } @@ -619,7 +610,7 @@ cancel_completion_cb (ECompletion *completion, gpointer user_data) e_completion_view_set_cursor_row (cv, -1); e_table_model_changed (cv->model); - gtk_signal_emit (GTK_OBJECT (cv), e_completion_view_signals[E_COMPLETION_VIEW_UNBROWSE]); + g_signal_emit (cv, e_completion_view_signals[E_COMPLETION_VIEW_UNBROWSE] ,0); } static void @@ -635,9 +626,9 @@ completion_cb (ECompletion *completion, ECompletionMatch *match, gpointer user_d e_table_model_row_inserted (cv->model, r); if (first) - gtk_signal_emit (GTK_OBJECT (cv), e_completion_view_signals[E_COMPLETION_VIEW_NONEMPTY]); + g_signal_emit (cv, e_completion_view_signals[E_COMPLETION_VIEW_NONEMPTY], 0); - gtk_signal_emit (GTK_OBJECT (cv), e_completion_view_signals[E_COMPLETION_VIEW_ADDED]); + g_signal_emit (cv, e_completion_view_signals[E_COMPLETION_VIEW_ADDED], 0); } static void @@ -649,7 +640,7 @@ end_completion_cb (ECompletion *completion, gpointer user_data) e_table_model_changed (cv->model); cv->have_all_choices = TRUE; - gtk_signal_emit (GTK_OBJECT (cv), e_completion_view_signals[E_COMPLETION_VIEW_FULL]); + g_signal_emit (cv, e_completion_view_signals[E_COMPLETION_VIEW_FULL], 0); } static void @@ -755,36 +746,36 @@ e_completion_view_construct (ECompletionView *cv, ECompletion *completion) GTK_WIDGET_SET_FLAGS (GTK_WIDGET (cv), GTK_CAN_FOCUS); cv->completion = completion; - gtk_object_ref (GTK_OBJECT (completion)); - - cv->begin_signal_id = gtk_signal_connect (GTK_OBJECT (completion), - "begin_completion", - GTK_SIGNAL_FUNC (begin_completion_cb), - cv); - cv->comp_signal_id = gtk_signal_connect (GTK_OBJECT (completion), - "completion", - GTK_SIGNAL_FUNC (completion_cb), - cv); - cv->restart_signal_id = gtk_signal_connect (GTK_OBJECT (completion), - "restart_completion", - GTK_SIGNAL_FUNC (restart_completion_cb), - cv); - cv->cancel_signal_id = gtk_signal_connect (GTK_OBJECT (completion), - "cancel_completion", - GTK_SIGNAL_FUNC (cancel_completion_cb), - cv); - cv->end_signal_id = gtk_signal_connect (GTK_OBJECT (completion), - "end_completion", - GTK_SIGNAL_FUNC (end_completion_cb), - cv); - cv->clear_signal_id = gtk_signal_connect (GTK_OBJECT (completion), - "clear_completion", - GTK_SIGNAL_FUNC (clear_completion_cb), - cv); - cv->lost_signal_id = gtk_signal_connect (GTK_OBJECT (completion), - "lost_completion", - GTK_SIGNAL_FUNC (lost_completion_cb), - cv); + g_object_ref (completion); + + cv->begin_signal_id = g_signal_connect (completion, + "begin_completion", + G_CALLBACK (begin_completion_cb), + cv); + cv->comp_signal_id = g_signal_connect (completion, + "completion", + G_CALLBACK (completion_cb), + cv); + cv->restart_signal_id = g_signal_connect (completion, + "restart_completion", + G_CALLBACK (restart_completion_cb), + cv); + cv->cancel_signal_id = g_signal_connect (completion, + "cancel_completion", + G_CALLBACK (cancel_completion_cb), + cv); + cv->end_signal_id = g_signal_connect (completion, + "end_completion", + G_CALLBACK (end_completion_cb), + cv); + cv->clear_signal_id = g_signal_connect (completion, + "clear_completion", + G_CALLBACK (clear_completion_cb), + cv); + cv->lost_signal_id = g_signal_connect (completion, + "lost_completion", + G_CALLBACK (lost_completion_cb), + cv); cv->model = e_table_simple_new (table_col_count, table_row_count, @@ -801,7 +792,7 @@ e_completion_view_construct (ECompletionView *cv, ECompletion *completion) cv); cv->table = e_table_scrolled_new (cv->model, NULL, simple_spec, NULL); - gtk_object_unref (GTK_OBJECT (cv->model)); + g_object_unref (cv->model); e_scroll_frame_set_shadow_type (E_SCROLL_FRAME (cv->table), GTK_SHADOW_NONE); e_scroll_frame_set_scrollbar_spacing (E_SCROLL_FRAME (cv->table), 0); @@ -810,10 +801,10 @@ e_completion_view_construct (ECompletionView *cv, ECompletion *completion) gtk_container_add (GTK_CONTAINER (cv), cv->table); gtk_widget_show_all (cv->table); - gtk_signal_connect (GTK_OBJECT (e_completion_view_table (cv)), - "click", - GTK_SIGNAL_FUNC (table_click_cb), - cv); + g_signal_connect (e_completion_view_table (cv), + "click", + G_CALLBACK (table_click_cb), + cv); cv->selection = -1; } @@ -826,7 +817,7 @@ e_completion_view_new (ECompletion *completion) g_return_val_if_fail (completion != NULL, NULL); g_return_val_if_fail (E_IS_COMPLETION (completion), NULL); - p = gtk_type_new (e_completion_view_get_type ()); + p = g_object_new (E_COMPLETION_VIEW_TYPE, NULL); e_completion_view_construct (E_COMPLETION_VIEW (p), completion); @@ -841,18 +832,18 @@ e_completion_view_connect_keys (ECompletionView *cv, GtkWidget *w) g_return_if_fail (w == NULL || GTK_IS_WIDGET (w)); if (cv->key_widget) { - gtk_signal_disconnect (GTK_OBJECT (cv->key_widget), cv->key_signal_id); - gtk_object_unref (GTK_OBJECT (cv->key_widget)); + g_signal_handler_disconnect (cv->key_widget, cv->key_signal_id); + g_object_unref (cv->key_widget); } if (w) { cv->key_widget = w; - gtk_object_ref (GTK_OBJECT (w)); + g_object_ref (w); - cv->key_signal_id = gtk_signal_connect (GTK_OBJECT (w), - "key_press_event", - GTK_SIGNAL_FUNC (e_completion_view_key_press_handler), - cv); + cv->key_signal_id = g_signal_connect (w, + "key_press_event", + G_CALLBACK (e_completion_view_key_press_handler), + cv); } else { cv->key_widget = NULL; cv->key_signal_id = 0; diff --git a/widgets/text/e-completion-view.h b/widgets/text/e-completion-view.h index f869b92725..9aa3860ebd 100644 --- a/widgets/text/e-completion-view.h +++ b/widgets/text/e-completion-view.h @@ -32,10 +32,10 @@ G_BEGIN_DECLS #define E_COMPLETION_VIEW_TYPE (e_completion_view_get_type ()) -#define E_COMPLETION_VIEW(o) (GTK_CHECK_CAST ((o), E_COMPLETION_VIEW_TYPE, ECompletionView)) -#define E_COMPLETION_VIEW_CLASS(k) (GTK_CHECK_CLASS_CAST ((k), E_COMPLETION_VIEW_TYPE, ECompletionViewClass)) -#define E_IS_COMPLETION_VIEW(o) (GTK_CHECK_TYPE ((o), E_COMPLETION_VIEW_TYPE)) -#define E_IS_COMPLETION_VIEW_CLASS(k) (GTK_CHECK_CLASS_TYPE ((k), E_COMPLETION_VIEW_TYPE)) +#define E_COMPLETION_VIEW(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), E_COMPLETION_VIEW_TYPE, ECompletionView)) +#define E_COMPLETION_VIEW_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), E_COMPLETION_VIEW_TYPE, ECompletionViewClass)) +#define E_IS_COMPLETION_VIEW(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), E_COMPLETION_VIEW_TYPE)) +#define E_IS_COMPLETION_VIEW_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), E_COMPLETION_VIEW_TYPE)) typedef struct _ECompletionView ECompletionView; typedef struct _ECompletionViewClass ECompletionViewClass; diff --git a/widgets/text/e-completion.c b/widgets/text/e-completion.c index f96e4cb258..cddd6ed4f4 100644 --- a/widgets/text/e-completion.c +++ b/widgets/text/e-completion.c @@ -26,9 +26,9 @@ #include #include #include -#include #include "e-completion.h" #include "gal/util/e-util.h" +#include "gal/util/e-marshal.h" enum { E_COMPLETION_REQUEST_COMPLETION, @@ -65,7 +65,7 @@ typedef struct { static void e_completion_class_init (ECompletionClass *klass); static void e_completion_init (ECompletion *complete); -static void e_completion_destroy (GtkObject *object); +static void e_completion_dispose (GObject *object); static void e_completion_add_match (ECompletion *complete, ECompletionMatch *); static void e_completion_clear_search_stack (ECompletion *complete); @@ -73,109 +73,101 @@ static void e_completion_clear_matches (ECompletion *complete); static gboolean e_completion_sort (ECompletion *complete); static void e_completion_restart (ECompletion *complete); +#define PARENT_TYPE GTK_TYPE_OBJECT static GtkObjectClass *parent_class; -GtkType -e_completion_get_type (void) -{ - static GtkType complete_type = 0; - - if (!complete_type) { - GtkTypeInfo complete_info = { - "ECompletion", - sizeof (ECompletion), - sizeof (ECompletionClass), - (GtkClassInitFunc) e_completion_class_init, - (GtkObjectInitFunc) e_completion_init, - NULL, NULL, /* reserved */ - (GtkClassInitFunc) NULL - }; - - complete_type = gtk_type_unique (gtk_object_get_type (), &complete_info); - } - - return complete_type; -} +E_MAKE_TYPE (e_completion, + "ECompletion", + ECompletion, + e_completion_class_init, + e_completion_init, + PARENT_TYPE) static void e_completion_class_init (ECompletionClass *klass) { - GtkObjectClass *object_class = (GtkObjectClass *) klass; + GObjectClass *object_class = (GObjectClass *) klass; - parent_class = GTK_OBJECT_CLASS (gtk_type_class (gtk_object_get_type ())); + parent_class = g_type_class_ref (PARENT_TYPE); e_completion_signals[E_COMPLETION_REQUEST_COMPLETION] = - gtk_signal_new ("request_completion", - GTK_RUN_LAST, - E_OBJECT_CLASS_TYPE (object_class), - GTK_SIGNAL_OFFSET (ECompletionClass, request_completion), - e_marshal_NONE__POINTER_INT_INT, - GTK_TYPE_NONE, 3, - GTK_TYPE_POINTER, GTK_TYPE_INT, GTK_TYPE_INT); + g_signal_new ("request_completion", + G_OBJECT_CLASS_TYPE (object_class), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (ECompletionClass, request_completion), + NULL, NULL, + e_marshal_NONE__POINTER_INT_INT, + G_TYPE_NONE, 3, + G_TYPE_POINTER, G_TYPE_INT, G_TYPE_INT); e_completion_signals[E_COMPLETION_BEGIN_COMPLETION] = - gtk_signal_new ("begin_completion", - GTK_RUN_LAST, - E_OBJECT_CLASS_TYPE (object_class), - GTK_SIGNAL_OFFSET (ECompletionClass, begin_completion), - e_marshal_NONE__POINTER_INT_INT, - GTK_TYPE_NONE, 3, - GTK_TYPE_POINTER, GTK_TYPE_INT, GTK_TYPE_INT); + g_signal_new ("begin_completion", + G_OBJECT_CLASS_TYPE (object_class), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (ECompletionClass, begin_completion), + NULL, NULL, + e_marshal_NONE__POINTER_INT_INT, + G_TYPE_NONE, 3, + G_TYPE_POINTER, G_TYPE_INT, G_TYPE_INT); e_completion_signals[E_COMPLETION_COMPLETION] = - gtk_signal_new ("completion", - GTK_RUN_LAST, - E_OBJECT_CLASS_TYPE (object_class), - GTK_SIGNAL_OFFSET (ECompletionClass, completion), - gtk_marshal_NONE__POINTER, - GTK_TYPE_NONE, 1, - GTK_TYPE_POINTER); + g_signal_new ("completion", + G_OBJECT_CLASS_TYPE (object_class), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (ECompletionClass, completion), + NULL, NULL, + e_marshal_NONE__POINTER, + G_TYPE_NONE, 1, + G_TYPE_POINTER); e_completion_signals[E_COMPLETION_RESTART_COMPLETION] = - gtk_signal_new ("restart_completion", - GTK_RUN_LAST, - E_OBJECT_CLASS_TYPE (object_class), - GTK_SIGNAL_OFFSET (ECompletionClass, restart_completion), - gtk_marshal_NONE__NONE, - GTK_TYPE_NONE, 0); - + g_signal_new ("restart_completion", + G_OBJECT_CLASS_TYPE (object_class), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (ECompletionClass, restart_completion), + NULL, NULL, + e_marshal_NONE__NONE, + G_TYPE_NONE, 0); + e_completion_signals[E_COMPLETION_CANCEL_COMPLETION] = - gtk_signal_new ("cancel_completion", - GTK_RUN_LAST, - E_OBJECT_CLASS_TYPE (object_class), - GTK_SIGNAL_OFFSET (ECompletionClass, cancel_completion), - gtk_marshal_NONE__NONE, - GTK_TYPE_NONE, 0); - + g_signal_new ("cancel_completion", + G_OBJECT_CLASS_TYPE (object_class), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (ECompletionClass, cancel_completion), + NULL, NULL, + e_marshal_NONE__NONE, + G_TYPE_NONE, 0); + e_completion_signals[E_COMPLETION_END_COMPLETION] = - gtk_signal_new ("end_completion", - GTK_RUN_LAST, - E_OBJECT_CLASS_TYPE (object_class), - GTK_SIGNAL_OFFSET (ECompletionClass, end_completion), - gtk_marshal_NONE__NONE, - GTK_TYPE_NONE, 0); + g_signal_new ("end_completion", + G_OBJECT_CLASS_TYPE (object_class), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (ECompletionClass, end_completion), + NULL, NULL, + e_marshal_NONE__NONE, + G_TYPE_NONE, 0); e_completion_signals[E_COMPLETION_CLEAR_COMPLETION] = - gtk_signal_new ("clear_completion", - GTK_RUN_LAST, - E_OBJECT_CLASS_TYPE (object_class), - GTK_SIGNAL_OFFSET (ECompletionClass, clear_completion), - gtk_marshal_NONE__NONE, - GTK_TYPE_NONE, 0); + g_signal_new ("clear_completion", + G_OBJECT_CLASS_TYPE (object_class), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (ECompletionClass, clear_completion), + NULL, NULL, + e_marshal_NONE__NONE, + G_TYPE_NONE, 0); e_completion_signals[E_COMPLETION_LOST_COMPLETION] = - gtk_signal_new ("lost_completion", - GTK_RUN_LAST, - E_OBJECT_CLASS_TYPE (object_class), - GTK_SIGNAL_OFFSET (ECompletionClass, lost_completion), - gtk_marshal_NONE__POINTER, - GTK_TYPE_NONE, 1, GTK_TYPE_POINTER); - - E_OBJECT_CLASS_ADD_SIGNALS (object_class, e_completion_signals, E_COMPLETION_LAST_SIGNAL); - - object_class->destroy = e_completion_destroy; + g_signal_new ("lost_completion", + G_OBJECT_CLASS_TYPE (object_class), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (ECompletionClass, lost_completion), + NULL, NULL, + e_marshal_NONE__POINTER, + G_TYPE_NONE, 1, G_TYPE_POINTER); + + object_class->dispose = e_completion_dispose; } static void @@ -186,7 +178,7 @@ e_completion_init (ECompletion *complete) } static void -e_completion_destroy (GtkObject *object) +e_completion_dispose (GObject *object) { ECompletion *complete = E_COMPLETION (object); @@ -204,8 +196,8 @@ e_completion_destroy (GtkObject *object) complete->priv = NULL; } - if (parent_class->destroy) - (parent_class->destroy) (object); + if (G_OBJECT_CLASS (parent_class)->dispose) + (G_OBJECT_CLASS (parent_class)->dispose) (object); } static void @@ -262,7 +254,7 @@ e_completion_clear (ECompletion *complete) e_completion_clear_search_stack (complete); complete->priv->refinement_count = 0; complete->priv->match_count = 0; - gtk_signal_emit (GTK_OBJECT (complete), e_completion_signals[E_COMPLETION_CLEAR_COMPLETION]); + g_signal_emit (complete, e_completion_signals[E_COMPLETION_CLEAR_COMPLETION], 0); } static void @@ -328,7 +320,7 @@ e_completion_refine_search (ECompletion *comp, const gchar *text, gint pos, ECom e_completion_push_search (comp, text, pos); - gtk_signal_emit (GTK_OBJECT (comp), e_completion_signals[E_COMPLETION_BEGIN_COMPLETION], text, pos, comp->priv->limit); + g_signal_emit (comp, e_completion_signals[E_COMPLETION_BEGIN_COMPLETION], 0, text, pos, comp->priv->limit); comp->priv->match_count = 0; @@ -340,14 +332,14 @@ e_completion_refine_search (ECompletion *comp, const gchar *text, gint pos, ECom if (comp->priv->refinement_count == match->hit_count && refine_fn (comp, match, text, pos)) { ++match->hit_count; - gtk_signal_emit (GTK_OBJECT (comp), e_completion_signals[E_COMPLETION_COMPLETION], match); + g_signal_emit (comp, e_completion_signals[E_COMPLETION_COMPLETION], 0, match); ++comp->priv->match_count; } } ++comp->priv->refinement_count; - gtk_signal_emit (GTK_OBJECT (comp), e_completion_signals[E_COMPLETION_END_COMPLETION]); + g_signal_emit (comp, e_completion_signals[E_COMPLETION_END_COMPLETION], 0); comp->priv->searching = FALSE; comp->priv->refining = FALSE; @@ -363,7 +355,8 @@ e_completion_unrefine_search (ECompletion *comp) e_completion_pop_search (comp); - gtk_signal_emit (GTK_OBJECT (comp), e_completion_signals[E_COMPLETION_BEGIN_COMPLETION], comp->priv->search_text, comp->priv->pos, comp->priv->limit); + g_signal_emit (comp, e_completion_signals[E_COMPLETION_BEGIN_COMPLETION], 0, + comp->priv->search_text, comp->priv->pos, comp->priv->limit); comp->priv->match_count = 0; --comp->priv->refinement_count; @@ -375,12 +368,12 @@ e_completion_unrefine_search (ECompletion *comp) ECompletionMatch *match = g_ptr_array_index (m, i); if (comp->priv->refinement_count <= match->hit_count) { match->hit_count = comp->priv->refinement_count; - gtk_signal_emit (GTK_OBJECT (comp), e_completion_signals[E_COMPLETION_COMPLETION], match); + g_signal_emit (comp, e_completion_signals[E_COMPLETION_COMPLETION], 0, match); ++comp->priv->match_count; } } - gtk_signal_emit (GTK_OBJECT (comp), e_completion_signals[E_COMPLETION_END_COMPLETION]); + g_signal_emit (comp, e_completion_signals[E_COMPLETION_END_COMPLETION], 0); comp->priv->searching = FALSE; comp->priv->refining = FALSE; @@ -439,8 +432,8 @@ e_completion_begin_search (ECompletion *complete, const gchar *text, gint pos, g complete->priv->limit = limit > 0 ? limit : G_MAXINT; complete->priv->refinement_count = 0; - gtk_signal_emit (GTK_OBJECT (complete), e_completion_signals[E_COMPLETION_BEGIN_COMPLETION], text, pos, limit); - gtk_signal_emit (GTK_OBJECT (complete), e_completion_signals[E_COMPLETION_REQUEST_COMPLETION], text, pos, limit); + g_signal_emit (complete, e_completion_signals[E_COMPLETION_BEGIN_COMPLETION], 0, text, pos, limit); + g_signal_emit (complete, e_completion_signals[E_COMPLETION_REQUEST_COMPLETION], 0, text, pos, limit); } void @@ -453,7 +446,7 @@ e_completion_cancel_search (ECompletion *complete) if (!complete->priv->searching) return; - gtk_signal_emit (GTK_OBJECT (complete), e_completion_signals[E_COMPLETION_CANCEL_COMPLETION]); + g_signal_emit (complete, e_completion_signals[E_COMPLETION_CANCEL_COMPLETION], 0); complete->priv->searching = FALSE; } @@ -527,7 +520,7 @@ e_completion_foreach_match (ECompletion *complete, ECompletionMatchFn fn, gpoint ECompletion * e_completion_new (void) { - return E_COMPLETION (gtk_type_new (e_completion_get_type ())); + return E_COMPLETION (g_object_new (E_COMPLETION_TYPE, NULL)); } static gboolean @@ -568,15 +561,15 @@ e_completion_restart (ECompletion *complete) GPtrArray *m; gint i, count; - gtk_signal_emit (GTK_OBJECT (complete), e_completion_signals[E_COMPLETION_RESTART_COMPLETION]); + g_signal_emit (complete, e_completion_signals[E_COMPLETION_RESTART_COMPLETION], 0); m = complete->priv->matches; for (i = count = 0; i < m->len && count < complete->priv->limit; i++, count++) { - gtk_signal_emit (GTK_OBJECT (complete), - e_completion_signals[E_COMPLETION_COMPLETION], - g_ptr_array_index (m, i)); + g_signal_emit (complete, + e_completion_signals[E_COMPLETION_COMPLETION], 0, + g_ptr_array_index (m, i)); } } @@ -601,7 +594,7 @@ e_completion_found_match (ECompletion *complete, ECompletionMatch *match) e_completion_add_match (complete, match); - gtk_signal_emit (GTK_OBJECT (complete), e_completion_signals[E_COMPLETION_COMPLETION], match); + g_signal_emit (complete, e_completion_signals[E_COMPLETION_COMPLETION], 0, match); } /* to optimize this, make the match a hash table */ @@ -620,7 +613,7 @@ e_completion_lost_match (ECompletion *complete, ECompletionMatch *match) /* maybe just return here? */ g_return_if_fail (removed); - gtk_signal_emit (GTK_OBJECT (complete), e_completion_signals[E_COMPLETION_LOST_COMPLETION], match); + g_signal_emit (complete, e_completion_signals[E_COMPLETION_LOST_COMPLETION], 0, match); e_completion_match_unref (match); } @@ -639,7 +632,7 @@ e_completion_end_search (ECompletion *complete) if (e_completion_sort (complete)) e_completion_restart (complete); - gtk_signal_emit (GTK_OBJECT (complete), e_completion_signals[E_COMPLETION_END_COMPLETION]); + g_signal_emit (complete, e_completion_signals[E_COMPLETION_END_COMPLETION], 0); complete->priv->searching = FALSE; complete->priv->done_search = TRUE; diff --git a/widgets/text/e-completion.h b/widgets/text/e-completion.h index 2f228ac130..f8d38e45a7 100644 --- a/widgets/text/e-completion.h +++ b/widgets/text/e-completion.h @@ -31,10 +31,10 @@ G_BEGIN_DECLS #define E_COMPLETION_TYPE (e_completion_get_type ()) -#define E_COMPLETION(o) (GTK_CHECK_CAST ((o), E_COMPLETION_TYPE, ECompletion)) -#define E_COMPLETION_CLASS(k) (GTK_CHECK_CLASS_CAST ((k), E_COMPLETION_TYPE, ECompletionClass)) -#define E_IS_COMPLETION(o) (GTK_CHECK_TYPE ((o), E_COMPLETION_TYPE)) -#define E_IS_COMPLETION_CLASS(k) (GTK_CHECK_CLASS_TYPE ((k), E_COMPLETION_TYPE)) +#define E_COMPLETION(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), E_COMPLETION_TYPE, ECompletion)) +#define E_COMPLETION_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), E_COMPLETION_TYPE, ECompletionClass)) +#define E_IS_COMPLETION(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), E_COMPLETION_TYPE)) +#define E_IS_COMPLETION_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), E_COMPLETION_TYPE)) typedef struct _ECompletion ECompletion; typedef struct _ECompletionClass ECompletionClass; diff --git a/widgets/text/e-entry-test.c b/widgets/text/e-entry-test.c index 5dc78364d4..d30ba20a9f 100644 --- a/widgets/text/e-entry-test.c +++ b/widgets/text/e-entry-test.c @@ -27,7 +27,7 @@ #include "e-entry.h" #include -static void destroy_callback(GtkWidget *app, gpointer data) +static void destroy_callback(gpointer data, GObject *where_object_was) { exit(0); } @@ -64,16 +64,15 @@ int main( int argc, char *argv[] ) app = gnome_app_new("EEntry Test", NULL); entry = e_entry_new(); - gtk_object_set(GTK_OBJECT(entry), - "editable", TRUE, - "use_ellipsis", TRUE, - NULL); + g_object_set(entry, + "editable", TRUE, + "use_ellipsis", TRUE, + NULL); gnome_app_set_contents( GNOME_APP( app ), entry ); /* Connect the signals */ - gtk_signal_connect( GTK_OBJECT( app ), "destroy", - GTK_SIGNAL_FUNC( destroy_callback ), - ( gpointer ) app ); + g_object_weak_ref (G_OBJECT (app), + destroy_callback, app); gtk_widget_show_all( app ); diff --git a/widgets/text/e-entry.c b/widgets/text/e-entry.c index bb1c8266f6..746fba6121 100644 --- a/widgets/text/e-entry.c +++ b/widgets/text/e-entry.c @@ -35,6 +35,7 @@ #include #include #include "gal/util/e-util.h" +#include "gal/util/e-i18n.h" #include "gal/widgets/e-canvas.h" #include "gal/widgets/e-canvas-utils.h" #include "e-completion-view.h" @@ -69,33 +70,33 @@ static guint e_entry_signals[E_ENTRY_LAST_SIGNAL] = { 0 }; /* Object argument IDs */ enum { - ARG_0, - ARG_MODEL, - ARG_EVENT_PROCESSOR, - ARG_TEXT, - ARG_FONT, - ARG_FONTSET, - ARG_FONT_GDK, - ARG_ANCHOR, - ARG_JUSTIFICATION, - ARG_X_OFFSET, - ARG_Y_OFFSET, - ARG_FILL_COLOR, - ARG_FILL_COLOR_GDK, - ARG_FILL_COLOR_RGBA, - ARG_FILL_STIPPLE, - ARG_EDITABLE, - ARG_USE_ELLIPSIS, - ARG_ELLIPSIS, - ARG_LINE_WRAP, - ARG_BREAK_CHARACTERS, - ARG_MAX_LINES, - ARG_ALLOW_NEWLINES, - ARG_DRAW_BORDERS, - ARG_DRAW_BACKGROUND, - ARG_DRAW_BUTTON, - ARG_EMULATE_LABEL_RESIZE, - ARG_CURSOR_POS + PROP_0, + PROP_MODEL, + PROP_EVENT_PROCESSOR, + PROP_TEXT, + PROP_FONT, + PROP_FONTSET, + PROP_FONT_GDK, + PROP_ANCHOR, + PROP_JUSTIFICATION, + PROP_X_OFFSET, + PROP_Y_OFFSET, + PROP_FILL_COLOR, + PROP_FILL_COLOR_GDK, + PROP_FILL_COLOR_RGBA, + PROP_FILL_STIPPLE, + PROP_EDITABLE, + PROP_USE_ELLIPSIS, + PROP_ELLIPSIS, + PROP_LINE_WRAP, + PROP_BREAK_CHARACTERS, + PROP_MAX_LINES, + PROP_ALLOW_NEWLINES, + PROP_DRAW_BORDERS, + PROP_DRAW_BACKGROUND, + PROP_DRAW_BUTTON, + PROP_EMULATE_LABEL_RESIZE, + PROP_CURSOR_POS }; typedef struct _EEntryPrivate EEntryPrivate; @@ -143,10 +144,10 @@ canvas_size_allocate (GtkWidget *widget, GtkAllocation *alloc, { gnome_canvas_set_scroll_region (entry->canvas, 0, 0, alloc->width, alloc->height); - gtk_object_set (GTK_OBJECT (entry->item), - "clip_width", (double) (alloc->width), - "clip_height", (double) (alloc->height), - NULL); + g_object_set (entry->item, + "clip_width", (double) (alloc->width), + "clip_height", (double) (alloc->height), + NULL); switch (entry->priv->justification) { case GTK_JUSTIFY_RIGHT: @@ -183,9 +184,9 @@ canvas_size_request (GtkWidget *widget, GtkRequisition *requisition, if (entry->priv->emulate_label_resize) { gdouble width; - gtk_object_get (GTK_OBJECT (entry->item), - "text_width", &width, - NULL); + g_object_get (entry->item, + "text_width", &width, + NULL); requisition->width = 2 + xthick + width; } else { requisition->width = 2 + MIN_ENTRY_WIDTH + xthick; @@ -251,19 +252,19 @@ e_entry_proxy_changed (EText *text, EEntry *entry) entry->priv->changed_since_keypress = TRUE; entry->priv->changed_since_keypress_tag = gtk_timeout_add (20, changed_since_keypress_timeout_fn, entry); - gtk_signal_emit (GTK_OBJECT (entry), e_entry_signals [E_ENTRY_CHANGED]); + g_signal_emit (entry, e_entry_signals [E_ENTRY_CHANGED], 0); } static void e_entry_proxy_activate (EText *text, EEntry *entry) { - gtk_signal_emit (GTK_OBJECT (entry), e_entry_signals [E_ENTRY_ACTIVATE]); + g_signal_emit (entry, e_entry_signals [E_ENTRY_ACTIVATE], 0); } static void e_entry_proxy_popup (EText *text, GdkEventButton *ev, gint pos, EEntry *entry) { - gtk_signal_emit (GTK_OBJECT (entry), e_entry_signals [E_ENTRY_POPUP], ev, pos); + g_signal_emit (entry, e_entry_signals [E_ENTRY_POPUP], 0, ev, pos); } static void @@ -280,20 +281,20 @@ e_entry_init (GtkObject *object) entry->canvas = GNOME_CANVAS (e_canvas_new ()); - gtk_signal_connect (GTK_OBJECT (entry->canvas), - "size_allocate", - GTK_SIGNAL_FUNC (canvas_size_allocate), - entry); + g_signal_connect (entry->canvas, + "size_allocate", + G_CALLBACK (canvas_size_allocate), + entry); - gtk_signal_connect (GTK_OBJECT (entry->canvas), - "size_request", - GTK_SIGNAL_FUNC (canvas_size_request), - entry); + g_signal_connect (entry->canvas, + "size_request", + G_CALLBACK (canvas_size_request), + entry); - gtk_signal_connect(GTK_OBJECT (entry->canvas), - "focus_in_event", - GTK_SIGNAL_FUNC(canvas_focus_in_event), - entry); + g_signal_connect (entry->canvas, + "focus_in_event", + G_CALLBACK(canvas_focus_in_event), + entry); entry->priv->draw_borders = TRUE; entry->priv->last_width = -1; @@ -312,10 +313,10 @@ e_entry_init (GtkObject *object) "allow_newlines", FALSE, NULL)); - gtk_signal_connect (GTK_OBJECT (entry->item), - "keypress", - GTK_SIGNAL_FUNC (e_entry_text_keypress), - entry); + g_signal_connect (entry->item, + "keypress", + G_CALLBACK (e_entry_text_keypress), + entry); entry->priv->justification = GTK_JUSTIFY_LEFT; gtk_table_attach (gtk_table, GTK_WIDGET (entry->canvas), @@ -329,21 +330,18 @@ e_entry_init (GtkObject *object) * Proxy functions: we proxy the changed and activate signals * from the item to ourselves */ - entry->priv->changed_proxy_tag = gtk_signal_connect ( - GTK_OBJECT (entry->item), - "changed", - GTK_SIGNAL_FUNC (e_entry_proxy_changed), - entry); - entry->priv->activate_proxy_tag = gtk_signal_connect ( - GTK_OBJECT (entry->item), - "activate", - GTK_SIGNAL_FUNC (e_entry_proxy_activate), - entry); - entry->priv->popup_proxy_tag = gtk_signal_connect ( - GTK_OBJECT (entry->item), - "popup", - GTK_SIGNAL_FUNC (e_entry_proxy_popup), - entry); + entry->priv->changed_proxy_tag = g_signal_connect (entry->item, + "changed", + G_CALLBACK (e_entry_proxy_changed), + entry); + entry->priv->activate_proxy_tag = g_signal_connect (entry->item, + "activate", + G_CALLBACK (e_entry_proxy_activate), + entry); + entry->priv->popup_proxy_tag = g_signal_connect (entry->item, + "popup", + G_CALLBACK (e_entry_proxy_popup), + entry); entry->priv->completion_delay = 1; } @@ -372,7 +370,7 @@ GtkWidget * e_entry_new (void) { EEntry *entry; - entry = gtk_type_new (e_entry_get_type ()); + entry = g_object_new (E_ENTRY_TYPE, NULL); e_entry_construct (entry); return GTK_WIDGET (entry); @@ -399,9 +397,9 @@ e_entry_set_text_quiet (EEntry *entry, const gchar *txt) { g_return_if_fail (entry != NULL && E_IS_ENTRY (entry)); - gtk_signal_handler_block (GTK_OBJECT (entry->item), entry->priv->changed_proxy_tag); + g_signal_handler_block (entry->item, entry->priv->changed_proxy_tag); e_entry_set_text (entry, txt); - gtk_signal_handler_unblock (GTK_OBJECT (entry->item), entry->priv->changed_proxy_tag); + g_signal_handler_unblock (entry->item, entry->priv->changed_proxy_tag); } @@ -410,7 +408,7 @@ e_entry_set_editable (EEntry *entry, gboolean am_i_editable) { g_return_if_fail (entry != NULL && E_IS_ENTRY (entry)); - gtk_object_set (GTK_OBJECT (entry->item), "editable", am_i_editable, NULL); + g_object_set (entry->item, "editable", am_i_editable, NULL); } gint @@ -559,7 +557,7 @@ e_entry_show_popup (EEntry *entry, gboolean visible) if (entry->priv->popup_is_visible != visible) { entry->priv->popup_is_visible = visible; - gtk_signal_emit (GTK_OBJECT (entry), e_entry_signals[E_ENTRY_COMPLETION_POPUP], (gint) visible); + g_signal_emit (entry, e_entry_signals[E_ENTRY_COMPLETION_POPUP], 0, (gint) visible); } } @@ -745,7 +743,7 @@ key_press_cb (GtkWidget *w, GdkEventKey *ev, gpointer user_data) { gint rv = 0; /* Forward signal */ - gtk_signal_emit_by_name (GTK_OBJECT (user_data), "key_press_event", ev, &rv); + g_signal_emit_by_name (user_data, "key_press_event", ev, &rv); return rv; } @@ -754,7 +752,7 @@ key_release_cb (GtkWidget *w, GdkEventKey *ev, gpointer user_data) { gint rv = 0; /* Forward signal */ - gtk_signal_emit_by_name (GTK_OBJECT (user_data), "key_release_event", ev, &rv); + g_signal_emit_by_name (user_data, "key_release_event", ev, &rv); return rv; } @@ -787,7 +785,7 @@ e_entry_enable_completion_full (EEntry *entry, ECompletion *completion, gint del g_return_if_fail (entry->priv->completion == NULL); entry->priv->completion = completion; - gtk_object_ref (GTK_OBJECT (completion)); + g_object_ref (completion); gtk_object_sink (GTK_OBJECT (completion)); entry->priv->completion_delay = delay; @@ -798,63 +796,63 @@ e_entry_enable_completion_full (EEntry *entry, ECompletion *completion, gint del e_completion_view_set_complete_key (E_COMPLETION_VIEW (entry->priv->completion_view), GDK_Down); e_completion_view_set_uncomplete_key (E_COMPLETION_VIEW (entry->priv->completion_view), GDK_Up); - gtk_signal_connect_after (GTK_OBJECT (entry->priv->completion_view), - "button_press_event", - GTK_SIGNAL_FUNC (button_press_cb), - entry); + g_signal_connect_after (entry->priv->completion_view, + "button_press_event", + G_CALLBACK (button_press_cb), + entry); + + entry->priv->nonempty_signal_id = g_signal_connect (entry->priv->completion_view, + "nonempty", + G_CALLBACK (nonempty_cb), + entry); - entry->priv->nonempty_signal_id = gtk_signal_connect (GTK_OBJECT (entry->priv->completion_view), - "nonempty", - GTK_SIGNAL_FUNC (nonempty_cb), - entry); + entry->priv->added_signal_id = g_signal_connect (entry->priv->completion_view, + "added", + G_CALLBACK (added_cb), + entry); - entry->priv->added_signal_id = gtk_signal_connect (GTK_OBJECT (entry->priv->completion_view), - "added", - GTK_SIGNAL_FUNC (added_cb), - entry); + entry->priv->full_signal_id = g_signal_connect (entry->priv->completion_view, + "full", + G_CALLBACK (full_cb), + entry); - entry->priv->full_signal_id = gtk_signal_connect (GTK_OBJECT (entry->priv->completion_view), - "full", - GTK_SIGNAL_FUNC (full_cb), + entry->priv->browse_signal_id = g_signal_connect (entry->priv->completion_view, + "browse", + G_CALLBACK (browse_cb), entry); - entry->priv->browse_signal_id = gtk_signal_connect (GTK_OBJECT (entry->priv->completion_view), - "browse", - GTK_SIGNAL_FUNC (browse_cb), + entry->priv->unbrowse_signal_id = g_signal_connect (entry->priv->completion_view, + "unbrowse", + G_CALLBACK (unbrowse_cb), entry); - entry->priv->unbrowse_signal_id = gtk_signal_connect (GTK_OBJECT (entry->priv->completion_view), - "unbrowse", - GTK_SIGNAL_FUNC (unbrowse_cb), - entry); - - entry->priv->activate_signal_id = gtk_signal_connect (GTK_OBJECT (entry->priv->completion_view), - "activate", - GTK_SIGNAL_FUNC (activate_cb), - entry); + entry->priv->activate_signal_id = g_signal_connect (entry->priv->completion_view, + "activate", + G_CALLBACK (activate_cb), + entry); entry->priv->completion_view_popup = gtk_window_new (GTK_WINDOW_POPUP); e_entry_make_completion_window_transient (entry); - gtk_signal_connect (GTK_OBJECT (entry->item->model), - "cancel_completion", - GTK_SIGNAL_FUNC (cancel_completion_cb), - entry); + g_signal_connect (entry->item->model, + "cancel_completion", + G_CALLBACK (cancel_completion_cb), + entry); - gtk_signal_connect (GTK_OBJECT (entry->priv->completion_view_popup), - "key_press_event", - GTK_SIGNAL_FUNC (key_press_cb), - entry->canvas); - gtk_signal_connect (GTK_OBJECT (entry->priv->completion_view_popup), - "key_release_event", - GTK_SIGNAL_FUNC (key_release_cb), - entry->canvas); + g_signal_connect (entry->priv->completion_view_popup, + "key_press_event", + G_CALLBACK (key_press_cb), + entry->canvas); + g_signal_connect (entry->priv->completion_view_popup, + "key_release_event", + G_CALLBACK (key_release_cb), + entry->canvas); e_completion_view_connect_keys (E_COMPLETION_VIEW (entry->priv->completion_view), GTK_WIDGET (entry->canvas)); - gtk_object_ref (GTK_OBJECT (entry->priv->completion_view_popup)); + g_object_ref (entry->priv->completion_view_popup); gtk_object_sink (GTK_OBJECT (entry->priv->completion_view_popup)); gtk_window_set_policy (GTK_WINDOW (entry->priv->completion_view_popup), TRUE, TRUE, TRUE); gtk_container_add (GTK_CONTAINER (entry->priv->completion_view_popup), entry->priv->completion_view); @@ -872,136 +870,104 @@ e_entry_completion_popup_is_visible (EEntry *entry) /** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** **/ static void -et_get_arg (GtkObject *o, GtkArg *arg, guint arg_id) +et_get_property (GObject *object, + guint prop_id, + GValue *value, + GParamSpec *pspec) { - EEntry *entry = E_ENTRY (o); + EEntry *entry = E_ENTRY (object); GtkObject *item = GTK_OBJECT (entry->item); - switch (arg_id){ - case ARG_MODEL: - gtk_object_get(item, - "model", >K_VALUE_OBJECT (*arg), - NULL); + switch (prop_id){ + case PROP_MODEL: + g_object_get_property (G_OBJECT (item), "model", value); break; - - case ARG_EVENT_PROCESSOR: - gtk_object_get(item, - "event_processor", >K_VALUE_OBJECT (*arg), - NULL); + case PROP_EVENT_PROCESSOR: + g_object_get_property (G_OBJECT (item), "event_processor", value); break; - - case ARG_TEXT: - gtk_object_get(item, - "text", >K_VALUE_STRING (*arg), - NULL); + case PROP_TEXT: + g_object_get_property (G_OBJECT (item), "text", value); break; - case ARG_FONT_GDK: - gtk_object_get(item, - "font_gdk", >K_VALUE_BOXED (*arg), - NULL); + case PROP_FONT_GDK: + g_object_get_property (G_OBJECT (item), "font_gdk", value); break; - case ARG_JUSTIFICATION: - gtk_object_get(item, - "justification", >K_VALUE_INT (*arg), - NULL); + case PROP_JUSTIFICATION: + g_object_get_property (G_OBJECT (item), "justification", value); break; - case ARG_FILL_COLOR_GDK: - gtk_object_get(item, - "fill_color_gdk", >K_VALUE_BOXED (*arg), - NULL); + case PROP_FILL_COLOR_GDK: + g_object_get_property (G_OBJECT (item), "fill_color_gdk", value); break; - case ARG_FILL_COLOR_RGBA: - gtk_object_get(item, - "fill_color_rgba", >K_VALUE_UINT (*arg), - NULL); + case PROP_FILL_COLOR_RGBA: + g_object_get_property (G_OBJECT (item), "fill_color_rgba", value); break; - case ARG_FILL_STIPPLE: - gtk_object_get(item, - "fill_stiple", >K_VALUE_BOXED (*arg), - NULL); + case PROP_FILL_STIPPLE: + g_object_get_property (G_OBJECT (item), "fill_stiple", value); break; - case ARG_EDITABLE: - gtk_object_get(item, - "editable", >K_VALUE_BOOL (*arg), - NULL); + case PROP_EDITABLE: + g_object_get_property (G_OBJECT (item), "editable", value); break; - case ARG_USE_ELLIPSIS: - gtk_object_get(item, - "use_ellipsis", >K_VALUE_BOOL (*arg), - NULL); + case PROP_USE_ELLIPSIS: + g_object_get_property (G_OBJECT (item), "use_ellipsis", value); break; - case ARG_ELLIPSIS: - gtk_object_get(item, - "ellipsis", >K_VALUE_STRING (*arg), - NULL); + case PROP_ELLIPSIS: + g_object_get_property (G_OBJECT (item), "ellipsis", value); break; - case ARG_LINE_WRAP: - gtk_object_get(item, - "line_wrap", >K_VALUE_BOOL (*arg), - NULL); + case PROP_LINE_WRAP: + g_object_get_property (G_OBJECT (item), "line_wrap", value); break; - case ARG_BREAK_CHARACTERS: - gtk_object_get(item, - "break_characters", >K_VALUE_STRING (*arg), - NULL); + case PROP_BREAK_CHARACTERS: + g_object_get_property (G_OBJECT (item), "break_characters", value); break; - case ARG_MAX_LINES: - gtk_object_get(item, - "max_lines", >K_VALUE_INT (*arg), - NULL); + case PROP_MAX_LINES: + g_object_get_property (G_OBJECT (item), "max_lines", value); break; - case ARG_ALLOW_NEWLINES: - gtk_object_get(item, - "allow_newlines", >K_VALUE_BOOL (*arg), - NULL); + case PROP_ALLOW_NEWLINES: + g_object_get_property (G_OBJECT (item), "allow_newlines", value); break; - case ARG_DRAW_BORDERS: - GTK_VALUE_BOOL (*arg) = entry->priv->draw_borders; + case PROP_DRAW_BORDERS: + g_value_set_boolean (value, entry->priv->draw_borders); break; - case ARG_DRAW_BACKGROUND: - gtk_object_get (item, - "draw_background", >K_VALUE_BOOL (*arg), - NULL); + case PROP_DRAW_BACKGROUND: + g_object_get_property (G_OBJECT (item), "draw_background", value); break; - case ARG_DRAW_BUTTON: - gtk_object_get (item, - "draw_button", >K_VALUE_BOOL (*arg), - NULL); + case PROP_DRAW_BUTTON: + g_object_get_property (G_OBJECT (item), "draw_button", value); break; - case ARG_EMULATE_LABEL_RESIZE: - GTK_VALUE_BOOL (*arg) = entry->priv->emulate_label_resize; + case PROP_EMULATE_LABEL_RESIZE: + g_value_set_boolean (value, entry->priv->emulate_label_resize); break; - case ARG_CURSOR_POS: - gtk_object_get (item, - "cursor_pos", >K_VALUE_INT (*arg), - NULL); + case PROP_CURSOR_POS: + g_object_get_property (G_OBJECT (item), "cursor_pos", value); default: - arg->type = GTK_TYPE_INVALID; + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } } static void -et_set_arg (GtkObject *o, GtkArg *arg, guint arg_id) +et_set_property (GObject *object, + guint prop_id, + const GValue *value, + GParamSpec *pspec) { - EEntry *entry = E_ENTRY (o); + EEntry *entry = E_ENTRY (object); GtkObject *item = GTK_OBJECT (entry->item); GtkAnchorType anchor; double width, height; @@ -1009,63 +975,51 @@ et_set_arg (GtkObject *o, GtkArg *arg, guint arg_id) gint ythick; GtkWidget *widget = GTK_WIDGET(entry->canvas); - d(g_print("%s: arg_id: %d\n", __FUNCTION__, arg_id)); + d(g_print("%s: prop_id: %d\n", __FUNCTION__, prop_id)); - switch (arg_id){ - case ARG_MODEL: - gtk_object_set(item, - "model", GTK_VALUE_OBJECT (*arg), - NULL); + switch (prop_id){ + case PROP_MODEL: + g_object_set_property (G_OBJECT (item), "model", value); if (entry->priv->emulate_label_resize) gtk_widget_queue_resize (widget); break; - case ARG_EVENT_PROCESSOR: - gtk_object_set(item, - "event_processor", GTK_VALUE_OBJECT (*arg), - NULL); + case PROP_EVENT_PROCESSOR: + g_object_set_property (G_OBJECT (item), "event_processor", value); break; - case ARG_TEXT: - gtk_object_set(item, - "text", GTK_VALUE_STRING (*arg), - NULL); - d(g_print("%s: text: %s\n", __FUNCTION__, GTK_VALUE_STRING (*arg))); + case PROP_TEXT: + g_object_set_property (G_OBJECT (item), "text", value); + d(g_print("%s: text: %s\n", __FUNCTION__, g_value_get_string (value))); if (entry->priv->emulate_label_resize) gtk_widget_queue_resize (widget); break; - case ARG_FONT: - gtk_object_set(item, - "font", GTK_VALUE_STRING (*arg), - NULL); - d(g_print("%s: font: %s\n", __FUNCTION__, GTK_VALUE_STRING (*arg))); + case PROP_FONT: + g_object_set_property (G_OBJECT (item), "font", value); + d(g_print("%s: font: %s\n", __FUNCTION__, g_value_get_string (value))); if (entry->priv->emulate_label_resize) gtk_widget_queue_resize (widget); break; - case ARG_FONTSET: - gtk_object_set(item, - "fontset", GTK_VALUE_STRING (*arg), - NULL); + case PROP_FONTSET: + g_object_set_property (G_OBJECT (item), "fontset", value); if (entry->priv->emulate_label_resize) gtk_widget_queue_resize (widget); break; - case ARG_FONT_GDK: - gtk_object_set(item, - "font_gdk", GTK_VALUE_BOXED (*arg), - NULL); + case PROP_FONT_GDK: + g_object_set_property (G_OBJECT (item), "font_gdk", value); if (entry->priv->emulate_label_resize) gtk_widget_queue_resize (widget); break; - case ARG_JUSTIFICATION: - entry->priv->justification = GTK_VALUE_INT (*arg); - gtk_object_get(item, - "clip_width", &width, - "clip_height", &height, - NULL); + case PROP_JUSTIFICATION: + entry->priv->justification = g_value_get_enum (value); + g_object_get(item, + "clip_width", &width, + "clip_height", &height, + NULL); if (entry->priv->draw_borders) { xthick = 0; @@ -1089,116 +1043,91 @@ et_set_arg (GtkObject *o, GtkArg *arg, guint arg_id) e_canvas_item_move_absolute(GNOME_CANVAS_ITEM(entry->item), xthick, ythick); break; } - gtk_object_set(item, - "justification", entry->priv->justification, - "anchor", anchor, - NULL); + g_object_set(item, + "justification", entry->priv->justification, + "anchor", anchor, + NULL); break; - case ARG_FILL_COLOR: - gtk_object_set(item, - "fill_color", GTK_VALUE_STRING (*arg), - NULL); + case PROP_FILL_COLOR: + g_object_set_property (G_OBJECT (item), "fill_color", value); break; - case ARG_FILL_COLOR_GDK: - gtk_object_set(item, - "fill_color_gdk", GTK_VALUE_BOXED (*arg), - NULL); + case PROP_FILL_COLOR_GDK: + g_object_set_property (G_OBJECT (item), "fill_color_gdk", value); break; - case ARG_FILL_COLOR_RGBA: - gtk_object_set(item, - "fill_color_rgba", GTK_VALUE_UINT (*arg), - NULL); + case PROP_FILL_COLOR_RGBA: + g_object_set_property (G_OBJECT (item), "fill_color_rgba", value); break; - case ARG_FILL_STIPPLE: - gtk_object_set(item, - "fill_stiple", GTK_VALUE_BOXED (*arg), - NULL); + case PROP_FILL_STIPPLE: + g_object_set_property (G_OBJECT (item), "fill_stiple", value); break; - case ARG_EDITABLE: - gtk_object_set(item, - "editable", GTK_VALUE_BOOL (*arg), - NULL); + case PROP_EDITABLE: + g_object_set_property (G_OBJECT (item), "editable", value); break; - case ARG_USE_ELLIPSIS: - gtk_object_set(item, - "use_ellipsis", GTK_VALUE_BOOL (*arg), - NULL); + case PROP_USE_ELLIPSIS: + g_object_set_property (G_OBJECT (item), "use_ellipsis", value); if (entry->priv->emulate_label_resize) gtk_widget_queue_resize (widget); break; - case ARG_ELLIPSIS: - gtk_object_set(item, - "ellipsis", GTK_VALUE_STRING (*arg), - NULL); + case PROP_ELLIPSIS: + g_object_set_property (G_OBJECT (item), "ellipsis", value); if (entry->priv->emulate_label_resize) gtk_widget_queue_resize (widget); break; - case ARG_LINE_WRAP: - gtk_object_set(item, - "line_wrap", GTK_VALUE_BOOL (*arg), - NULL); + case PROP_LINE_WRAP: + g_object_set_property (G_OBJECT (item), "line_wrap", value); if (entry->priv->emulate_label_resize) gtk_widget_queue_resize (widget); break; - case ARG_BREAK_CHARACTERS: - gtk_object_set(item, - "break_characters", GTK_VALUE_STRING (*arg), - NULL); + case PROP_BREAK_CHARACTERS: + g_object_set_property (G_OBJECT (item), "break_characters", value); if (entry->priv->emulate_label_resize) gtk_widget_queue_resize (widget); break; - case ARG_MAX_LINES: - gtk_object_set(item, - "max_lines", GTK_VALUE_INT (*arg), - NULL); + case PROP_MAX_LINES: + g_object_set_property (G_OBJECT (item), "max_lines", value); if (entry->priv->emulate_label_resize) gtk_widget_queue_resize (widget); break; - case ARG_ALLOW_NEWLINES: - gtk_object_set(item, - "allow_newlines", GTK_VALUE_BOOL (*arg), - NULL); + case PROP_ALLOW_NEWLINES: + g_object_set_property (G_OBJECT (item), "allow_newlines", value); break; - case ARG_DRAW_BORDERS: - if (entry->priv->draw_borders != GTK_VALUE_BOOL (*arg)) { - entry->priv->draw_borders = GTK_VALUE_BOOL (*arg); - gtk_object_set (item, - "draw_borders", entry->priv->draw_borders, - NULL); + case PROP_DRAW_BORDERS: + if (entry->priv->draw_borders != g_value_get_boolean (value)) { + entry->priv->draw_borders = g_value_get_boolean (value); + g_object_set (item, + "draw_borders", entry->priv->draw_borders, + NULL); gtk_widget_queue_resize (GTK_WIDGET (entry)); } break; - case ARG_CURSOR_POS: - gtk_object_set (item, - "cursor_pos", GTK_VALUE_INT (*arg), NULL); + case PROP_CURSOR_POS: + g_object_set_property (G_OBJECT (item), "cursor_pos", value); break; - case ARG_DRAW_BACKGROUND: - gtk_object_set (item, "draw_background", - GTK_VALUE_BOOL (*arg), NULL); + case PROP_DRAW_BACKGROUND: + g_object_set_property (G_OBJECT (item), "draw_background", value); break; - case ARG_DRAW_BUTTON: - gtk_object_set (item, "draw_button", - GTK_VALUE_BOOL (*arg), NULL); + case PROP_DRAW_BUTTON: + g_object_set_property (G_OBJECT (item), "draw_button", value); break; - case ARG_EMULATE_LABEL_RESIZE: - if (entry->priv->emulate_label_resize != GTK_VALUE_BOOL (*arg)) { - entry->priv->emulate_label_resize = GTK_VALUE_BOOL (*arg); + case PROP_EMULATE_LABEL_RESIZE: + if (entry->priv->emulate_label_resize != g_value_get_boolean (value)) { + entry->priv->emulate_label_resize = g_value_get_boolean (value); gtk_widget_queue_resize (widget); } break; @@ -1206,7 +1135,7 @@ et_set_arg (GtkObject *o, GtkArg *arg, guint arg_id) } static void -e_entry_destroy (GtkObject *object) +e_entry_dispose (GObject *object) { EEntry *entry = E_ENTRY (object); @@ -1215,10 +1144,10 @@ e_entry_destroy (GtkObject *object) gtk_timeout_remove (entry->priv->completion_delay_tag); if (entry->priv->completion) - gtk_object_unref (GTK_OBJECT (entry->priv->completion)); + g_object_unref (entry->priv->completion); if (entry->priv->completion_view_popup) { gtk_widget_destroy (GTK_WIDGET (entry->priv->completion_view_popup)); - gtk_object_unref (GTK_OBJECT (entry->priv->completion_view_popup)); + g_object_unref (entry->priv->completion_view_popup); } g_free (entry->priv->pre_browse_text); @@ -1232,8 +1161,8 @@ e_entry_destroy (GtkObject *object) entry->priv = NULL; } - if (GTK_OBJECT_CLASS (parent_class)->destroy) - (* GTK_OBJECT_CLASS (parent_class)->destroy) (object); + if (G_OBJECT_CLASS (parent_class)->dispose) + (* G_OBJECT_CLASS (parent_class)->dispose) (object); } static void @@ -1255,16 +1184,16 @@ e_entry_realize (GtkWidget *widget) } static void -e_entry_class_init (GtkObjectClass *object_class) +e_entry_class_init (GObjectClass *object_class) { EEntryClass *klass = E_ENTRY_CLASS(object_class); GtkWidgetClass *widget_class = GTK_WIDGET_CLASS(object_class); - parent_class = gtk_type_class (PARENT_TYPE); + parent_class = g_type_class_ref (PARENT_TYPE); - object_class->set_arg = et_set_arg; - object_class->get_arg = et_get_arg; - object_class->destroy = e_entry_destroy; + object_class->set_property = et_set_property; + object_class->get_property = et_get_property; + object_class->dispose = e_entry_dispose; widget_class->realize = e_entry_realize; @@ -1272,86 +1201,200 @@ e_entry_class_init (GtkObjectClass *object_class) klass->activate = NULL; e_entry_signals[E_ENTRY_CHANGED] = - gtk_signal_new ("changed", - GTK_RUN_LAST, - E_OBJECT_CLASS_TYPE (object_class), - GTK_SIGNAL_OFFSET (EEntryClass, changed), - gtk_marshal_NONE__NONE, - GTK_TYPE_NONE, 0); + g_signal_new ("changed", + G_OBJECT_CLASS_TYPE (object_class), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (EEntryClass, changed), + NULL, NULL, + e_marshal_NONE__NONE, + G_TYPE_NONE, 0); e_entry_signals[E_ENTRY_ACTIVATE] = - gtk_signal_new ("activate", - GTK_RUN_LAST, - E_OBJECT_CLASS_TYPE (object_class), - GTK_SIGNAL_OFFSET (EEntryClass, activate), - gtk_marshal_NONE__NONE, - GTK_TYPE_NONE, 0); + g_signal_new ("activate", + G_OBJECT_CLASS_TYPE (object_class), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (EEntryClass, activate), + NULL, NULL, + e_marshal_NONE__NONE, + G_TYPE_NONE, 0); e_entry_signals[E_ENTRY_POPUP] = - gtk_signal_new ("popup", - GTK_RUN_LAST, - E_OBJECT_CLASS_TYPE (object_class), - GTK_SIGNAL_OFFSET (EEntryClass, popup), - e_marshal_NONE__POINTER_INT, - GTK_TYPE_NONE, 2, GTK_TYPE_POINTER, GTK_TYPE_INT); + g_signal_new ("popup", + G_OBJECT_CLASS_TYPE (object_class), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (EEntryClass, popup), + NULL, NULL, + e_marshal_NONE__POINTER_INT, + G_TYPE_NONE, 2, G_TYPE_POINTER, G_TYPE_INT); e_entry_signals[E_ENTRY_COMPLETION_POPUP] = - gtk_signal_new ("completion_popup", - GTK_RUN_LAST, - E_OBJECT_CLASS_TYPE (object_class), - GTK_SIGNAL_OFFSET (EEntryClass, completion_popup), - gtk_marshal_NONE__INT, - GTK_TYPE_NONE, 1, GTK_TYPE_INT); - - - E_OBJECT_CLASS_ADD_SIGNALS (object_class, e_entry_signals, E_ENTRY_LAST_SIGNAL); - - gtk_object_add_arg_type ("EEntry::model", - GTK_TYPE_OBJECT, GTK_ARG_READWRITE, ARG_MODEL); - gtk_object_add_arg_type ("EEntry::event_processor", - GTK_TYPE_OBJECT, GTK_ARG_READWRITE, ARG_EVENT_PROCESSOR); - gtk_object_add_arg_type ("EEntry::text", - GTK_TYPE_STRING, GTK_ARG_READWRITE, ARG_TEXT); - gtk_object_add_arg_type ("EEntry::font", - GTK_TYPE_STRING, GTK_ARG_WRITABLE, ARG_FONT); - gtk_object_add_arg_type ("EEntry::fontset", - GTK_TYPE_STRING, GTK_ARG_WRITABLE, ARG_FONTSET); - gtk_object_add_arg_type ("EEntry::font_gdk", - GDK_TYPE_FONT, GTK_ARG_READWRITE, ARG_FONT_GDK); - gtk_object_add_arg_type ("EEntry::justification", - GTK_TYPE_JUSTIFICATION, GTK_ARG_READWRITE, ARG_JUSTIFICATION); - gtk_object_add_arg_type ("EEntry::fill_color", - GTK_TYPE_STRING, GTK_ARG_WRITABLE, ARG_FILL_COLOR); - gtk_object_add_arg_type ("EEntry::fill_color_gdk", - GDK_TYPE_COLOR, GTK_ARG_READWRITE, ARG_FILL_COLOR_GDK); - gtk_object_add_arg_type ("EEntry::fill_color_rgba", - GTK_TYPE_UINT, GTK_ARG_READWRITE, ARG_FILL_COLOR_RGBA); - gtk_object_add_arg_type ("EEntry::fill_stipple", - GDK_TYPE_WINDOW, GTK_ARG_READWRITE, ARG_FILL_STIPPLE); - gtk_object_add_arg_type ("EEntry::editable", - GTK_TYPE_BOOL, GTK_ARG_READWRITE, ARG_EDITABLE); - gtk_object_add_arg_type ("EEntry::use_ellipsis", - GTK_TYPE_BOOL, GTK_ARG_READWRITE, ARG_USE_ELLIPSIS); - gtk_object_add_arg_type ("EEntry::ellipsis", - GTK_TYPE_STRING, GTK_ARG_READWRITE, ARG_ELLIPSIS); - gtk_object_add_arg_type ("EEntry::line_wrap", - GTK_TYPE_BOOL, GTK_ARG_READWRITE, ARG_LINE_WRAP); - gtk_object_add_arg_type ("EEntry::break_characters", - GTK_TYPE_STRING, GTK_ARG_READWRITE, ARG_BREAK_CHARACTERS); - gtk_object_add_arg_type ("EEntry::max_lines", - GTK_TYPE_INT, GTK_ARG_READWRITE, ARG_MAX_LINES); - gtk_object_add_arg_type ("EEntry::allow_newlines", - GTK_TYPE_BOOL, GTK_ARG_READWRITE, ARG_ALLOW_NEWLINES); - gtk_object_add_arg_type ("EEntry::draw_borders", - GTK_TYPE_BOOL, GTK_ARG_READWRITE, ARG_DRAW_BORDERS); - gtk_object_add_arg_type ("EEntry::draw_background", - GTK_TYPE_BOOL, GTK_ARG_READWRITE, ARG_DRAW_BACKGROUND); - gtk_object_add_arg_type ("EEntry::draw_button", - GTK_TYPE_BOOL, GTK_ARG_READWRITE, ARG_DRAW_BUTTON); - gtk_object_add_arg_type ("EEntry::emulate_label_resize", - GTK_TYPE_BOOL, GTK_ARG_READWRITE, ARG_EMULATE_LABEL_RESIZE); - gtk_object_add_arg_type ("EEntry::cursor_pos", - GTK_TYPE_INT, GTK_ARG_READWRITE, ARG_CURSOR_POS); + g_signal_new ("completion_popup", + G_OBJECT_CLASS_TYPE (object_class), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (EEntryClass, completion_popup), + NULL, NULL, + gtk_marshal_NONE__INT, + G_TYPE_NONE, 1, G_TYPE_INT); + + g_object_class_install_property (object_class, PROP_MODEL, + g_param_spec_object ("model", + _( "Model" ), + _( "Model" ), + E_TYPE_TEXT_MODEL, + G_PARAM_READWRITE)); + + g_object_class_install_property (object_class, PROP_EVENT_PROCESSOR, + g_param_spec_object ("event_processor", + _( "Event Processor" ), + _( "Event Processor" ), + E_TEXT_EVENT_PROCESSOR_TYPE, + G_PARAM_READWRITE)); + + g_object_class_install_property (object_class, PROP_TEXT, + g_param_spec_string ("text", + _( "Text" ), + _( "Text" ), + NULL, + G_PARAM_READWRITE)); + + g_object_class_install_property (object_class, PROP_FONT, + g_param_spec_string ("font", + _( "Font" ), + _( "Font" ), + NULL, + G_PARAM_READWRITE)); + + g_object_class_install_property (object_class, PROP_FONTSET, + g_param_spec_string ("fontset", + _( "Fontset" ), + _( "Fontset" ), + NULL, + G_PARAM_READWRITE)); + + g_object_class_install_property (object_class, PROP_FONT_GDK, + g_param_spec_boxed ("font_gdk", + _( "GDKFont" ), + _( "GDKFont" ), + GDK_TYPE_FONT, + G_PARAM_WRITABLE)); + + g_object_class_install_property (object_class, PROP_JUSTIFICATION, + g_param_spec_enum ("justification", + _( "Justification" ), + _( "Justification" ), + GTK_TYPE_JUSTIFICATION, GTK_JUSTIFY_LEFT, + G_PARAM_READWRITE)); + + g_object_class_install_property (object_class, PROP_FILL_COLOR, + g_param_spec_string ("fill_color", + _( "Fill color" ), + _( "Fill color" ), + NULL, + G_PARAM_READWRITE)); + + g_object_class_install_property (object_class, PROP_FILL_COLOR_GDK, + g_param_spec_pointer ("fill_color_gdk", + _( "GDK fill color" ), + _( "GDK fill color" ), + G_PARAM_READWRITE)); + + g_object_class_install_property (object_class, PROP_FILL_COLOR_RGBA, + g_param_spec_uint ("fill_color_rgba", + _( "GDK fill color" ), + _( "GDK fill color" ), + 0, G_MAXUINT, 0, + G_PARAM_READWRITE)); + + g_object_class_install_property (object_class, PROP_FILL_STIPPLE, + g_param_spec_object ("fill_stipple", + _( "Fill stipple" ), + _( "FIll stipple" ), + GDK_TYPE_WINDOW, + G_PARAM_READWRITE)); + + g_object_class_install_property (object_class, PROP_EDITABLE, + g_param_spec_boolean ("editable", + _( "Editable" ), + _( "Editable" ), + FALSE, + G_PARAM_READWRITE)); + + g_object_class_install_property (object_class, PROP_USE_ELLIPSIS, + g_param_spec_boolean ("use_ellipsis", + _( "Use ellipsis" ), + _( "Use ellipsis" ), + FALSE, + G_PARAM_READWRITE)); + + g_object_class_install_property (object_class, PROP_ELLIPSIS, + g_param_spec_string ("ellipsis", + _( "Ellipsis" ), + _( "Ellipsis" ), + NULL, + G_PARAM_READWRITE)); + + g_object_class_install_property (object_class, PROP_LINE_WRAP, + g_param_spec_boolean ("line_wrap", + _( "Line wrap" ), + _( "Line wrap" ), + FALSE, + G_PARAM_READWRITE)); + + g_object_class_install_property (object_class, PROP_BREAK_CHARACTERS, + g_param_spec_string ("break_characters", + _( "Break characters" ), + _( "Break characters" ), + NULL, + G_PARAM_READWRITE)); + + g_object_class_install_property (object_class, PROP_MAX_LINES, + g_param_spec_int ("max_lines", + _( "Max lines" ), + _( "Max lines" ), + 0, G_MAXINT, 0, + G_PARAM_READWRITE)); + + g_object_class_install_property (object_class, PROP_ALLOW_NEWLINES, + g_param_spec_boolean ("allow_newlines", + _( "Allow newlines" ), + _( "Allow newlines" ), + FALSE, + G_PARAM_READWRITE)); + + g_object_class_install_property (object_class, PROP_DRAW_BORDERS, + g_param_spec_boolean ("draw_borders", + _( "Draw borders" ), + _( "Draw borders" ), + FALSE, + G_PARAM_READWRITE)); + + g_object_class_install_property (object_class, PROP_DRAW_BACKGROUND, + g_param_spec_boolean ("draw_background", + _( "Draw background" ), + _( "Draw background" ), + FALSE, + G_PARAM_READWRITE)); + + g_object_class_install_property (object_class, PROP_DRAW_BUTTON, + g_param_spec_boolean ("draw_button", + _( "Draw button" ), + _( "Draw button" ), + FALSE, + G_PARAM_READWRITE)); + + g_object_class_install_property (object_class, PROP_CURSOR_POS, + g_param_spec_int ("cursor_pos", + _( "Cursor position" ), + _( "Cursor position" ), + 0, G_MAXINT, 0, + G_PARAM_READWRITE)); + + g_object_class_install_property (object_class, PROP_EMULATE_LABEL_RESIZE, + g_param_spec_boolean ("emulate_label_resize", + _( "Emulate label resize" ), + _( "Emulate label resize" ), + FALSE, + G_PARAM_READWRITE)); } E_MAKE_TYPE(e_entry, "EEntry", EEntry, e_entry_class_init, e_entry_init, PARENT_TYPE) diff --git a/widgets/text/e-entry.h b/widgets/text/e-entry.h index 1e073a87e8..8c1093638b 100644 --- a/widgets/text/e-entry.h +++ b/widgets/text/e-entry.h @@ -34,10 +34,10 @@ G_BEGIN_DECLS #define E_ENTRY_TYPE (e_entry_get_type ()) -#define E_ENTRY(o) (GTK_CHECK_CAST ((o), E_ENTRY_TYPE, EEntry)) -#define E_ENTRY_CLASS(k) (GTK_CHECK_CLASS_CAST((k), E_ENTRY_TYPE, EEntryClass)) -#define E_IS_ENTRY(o) (GTK_CHECK_TYPE ((o), E_ENTRY_TYPE)) -#define E_IS_ENTRY_CLASS(k) (GTK_CHECK_CLASS_TYPE ((k), E_ENTRY_TYPE)) +#define E_ENTRY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), E_ENTRY_TYPE, EEntry)) +#define E_ENTRY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k), E_ENTRY_TYPE, EEntryClass)) +#define E_IS_ENTRY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), E_ENTRY_TYPE)) +#define E_IS_ENTRY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), E_ENTRY_TYPE)) typedef struct _EEntry EEntry; typedef struct _EEntryClass EEntryClass; diff --git a/widgets/text/e-table-text-model.c b/widgets/text/e-table-text-model.c index cd47f0ff43..909a982528 100644 --- a/widgets/text/e-table-text-model.c +++ b/widgets/text/e-table-text-model.c @@ -29,7 +29,7 @@ static void e_table_text_model_class_init (ETableTextModelClass *class); static void e_table_text_model_init (ETableTextModel *model); -static void e_table_text_model_destroy (GtkObject *object); +static void e_table_text_model_dispose (GObject *object); static const gchar *e_table_text_model_get_text (ETextModel *model); static void e_table_text_model_set_text (ETextModel *model, const gchar *text); @@ -37,6 +37,7 @@ static void e_table_text_model_insert (ETextModel *model, gint postion, const gc static void e_table_text_model_insert_length (ETextModel *model, gint postion, const gchar *text, gint length); static void e_table_text_model_delete (ETextModel *model, gint postion, gint length); +#define PARENT_TYPE E_TYPE_TEXT_MODEL static GtkObject *parent_class; @@ -50,40 +51,24 @@ static GtkObject *parent_class; * * Return value: The type ID of the &ETableTextModel class. **/ -GtkType -e_table_text_model_get_type (void) -{ - static GtkType model_type = 0; - - if (!model_type) { - GtkTypeInfo model_info = { - "ETableTextModel", - sizeof (ETableTextModel), - sizeof (ETableTextModelClass), - (GtkClassInitFunc) e_table_text_model_class_init, - (GtkObjectInitFunc) e_table_text_model_init, - NULL, /* reserved_1 */ - NULL, /* reserved_2 */ - (GtkClassInitFunc) NULL - }; - - model_type = gtk_type_unique (e_text_model_get_type (), &model_info); - } - - return model_type; -} - +E_MAKE_TYPE (e_table_text_model, + "ETableTextModel", + ETableTextModel, + e_table_text_model_class_init, + e_table_text_model_init, + PARENT_TYPE) + /* Class initialization function for the text item */ static void e_table_text_model_class_init (ETableTextModelClass *klass) { - GtkObjectClass *object_class; + GObjectClass *object_class; ETextModelClass *model_class; - object_class = (GtkObjectClass *) klass; + object_class = (GObjectClass *) klass; model_class = (ETextModelClass *) klass; - parent_class = gtk_type_class (e_text_model_get_type ()); + parent_class = g_type_class_ref (PARENT_TYPE); model_class->get_text = e_table_text_model_get_text; model_class->set_text = e_table_text_model_set_text; @@ -91,7 +76,7 @@ e_table_text_model_class_init (ETableTextModelClass *klass) model_class->insert_length = e_table_text_model_insert_length; model_class->delete = e_table_text_model_delete; - object_class->destroy = e_table_text_model_destroy; + object_class->dispose = e_table_text_model_dispose; } /* Object initialization function for the text item */ @@ -105,9 +90,9 @@ e_table_text_model_init (ETableTextModel *model) model->row_changed_signal_id = 0; } -/* Destroy handler for the text item */ +/* Dispose handler for the text item */ static void -e_table_text_model_destroy (GtkObject *object) +e_table_text_model_dispose (GObject *object) { ETableTextModel *model; @@ -120,21 +105,21 @@ e_table_text_model_destroy (GtkObject *object) g_assert (GTK_IS_OBJECT (model->model)); if (model->cell_changed_signal_id) - gtk_signal_disconnect (GTK_OBJECT(model->model), - model->cell_changed_signal_id); + g_signal_handler_disconnect (model->model, + model->cell_changed_signal_id); model->cell_changed_signal_id = 0; if (model->row_changed_signal_id) - gtk_signal_disconnect (GTK_OBJECT(model->model), - model->row_changed_signal_id); + g_signal_handler_disconnect (model->model, + model->row_changed_signal_id); model->row_changed_signal_id = 0; if (model->model) - gtk_object_unref (GTK_OBJECT(model->model)); + g_object_unref (model->model); model->model = NULL; - if (GTK_OBJECT_CLASS (parent_class)->destroy) - (* GTK_OBJECT_CLASS (parent_class)->destroy) (object); + if (G_OBJECT_CLASS (parent_class)->dispose) + (* G_OBJECT_CLASS (parent_class)->dispose) (object); } static const gchar * e_table_text_model_get_text (ETextModel *text_model) @@ -227,20 +212,20 @@ e_table_text_model_new (ETableModel *table_model, int row, int model_col) g_return_val_if_fail(table_model != NULL, NULL); g_return_val_if_fail(E_IS_TABLE_MODEL(table_model), NULL); - model = gtk_type_new (e_table_text_model_get_type ()); + model = g_object_new (E_TYPE_TABLE_TEXT_MODEL, NULL); model->model = table_model; if (model->model){ - gtk_object_ref (GTK_OBJECT(model->model)); + g_object_ref (model->model); model->cell_changed_signal_id = - gtk_signal_connect (GTK_OBJECT(model->model), - "model_cell_changed", - GTK_SIGNAL_FUNC(cell_changed), - model); + g_signal_connect (model->model, + "model_cell_changed", + G_CALLBACK(cell_changed), + model); model->row_changed_signal_id = - gtk_signal_connect (GTK_OBJECT(model->model), - "model_row_changed", - GTK_SIGNAL_FUNC(row_changed), - model); + g_signal_connect (model->model, + "model_row_changed", + G_CALLBACK(row_changed), + model); } model->row = row; model->model_col = model_col; diff --git a/widgets/text/e-table-text-model.h b/widgets/text/e-table-text-model.h index 1c1a88dd47..46e82de1c4 100644 --- a/widgets/text/e-table-text-model.h +++ b/widgets/text/e-table-text-model.h @@ -30,10 +30,10 @@ G_BEGIN_DECLS #define E_TYPE_TABLE_TEXT_MODEL (e_table_text_model_get_type ()) -#define E_TABLE_TEXT_MODEL(obj) (GTK_CHECK_CAST ((obj), E_TYPE_TABLE_TEXT_MODEL, ETableTextModel)) -#define E_TABLE_TEXT_MODEL_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), E_TYPE_TABLE_TEXT_MODEL, ETableTextModelClass)) -#define E_IS_TABLE_TEXT_MODEL(obj) (GTK_CHECK_TYPE ((obj), E_TYPE_TABLE_TEXT_MODEL)) -#define E_IS_TABLE_TEXT_MODEL_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), E_TYPE_TABLE_TEXT_MODEL)) +#define E_TABLE_TEXT_MODEL(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), E_TYPE_TABLE_TEXT_MODEL, ETableTextModel)) +#define E_TABLE_TEXT_MODEL_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), E_TYPE_TABLE_TEXT_MODEL, ETableTextModelClass)) +#define E_IS_TABLE_TEXT_MODEL(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), E_TYPE_TABLE_TEXT_MODEL)) +#define E_IS_TABLE_TEXT_MODEL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), E_TYPE_TABLE_TEXT_MODEL)) typedef struct _ETableTextModel ETableTextModel; typedef struct _ETableTextModelClass ETableTextModelClass; diff --git a/widgets/text/e-text-model-uri.c b/widgets/text/e-text-model-uri.c index 7292d2954e..858771b481 100644 --- a/widgets/text/e-text-model-uri.c +++ b/widgets/text/e-text-model-uri.c @@ -30,10 +30,11 @@ #include #include #include +#include static void e_text_model_uri_class_init (ETextModelURIClass *class); static void e_text_model_uri_init (ETextModelURI *model); -static void e_text_model_uri_destroy (GtkObject *object); +static void e_text_model_uri_dispose (GObject *object); static void objectify_uris (ETextModelURI *model); @@ -48,43 +49,28 @@ struct _ObjInfo { gint offset, len; }; +#define PARENT_TYPE E_TYPE_TEXT_MODEL static GtkObject *parent_class; -GtkType -e_text_model_uri_get_type (void) -{ - static GtkType model_uri_type = 0; - - if (!model_uri_type) { - GtkTypeInfo model_uri_info = { - "ETextModelURI", - sizeof (ETextModelURI), - sizeof (ETextModelURIClass), - (GtkClassInitFunc) e_text_model_uri_class_init, - (GtkObjectInitFunc) e_text_model_uri_init, - NULL, /* reserved_1 */ - NULL, /* reserved_2 */ - (GtkClassInitFunc) NULL - }; - - model_uri_type = gtk_type_unique (e_text_model_get_type (), &model_uri_info); - } - - return model_uri_type; -} - +E_MAKE_TYPE (e_text_model_uri, + "ETextModelURI", + ETextModelURI, + e_text_model_uri_class_init, + e_text_model_uri_init, + PARENT_TYPE) + static void e_text_model_uri_class_init (ETextModelURIClass *klass) { - GtkObjectClass *object_class; + GObjectClass *object_class; ETextModelClass *model_class; - object_class = (GtkObjectClass *) klass; + object_class = (GObjectClass *) klass; model_class = E_TEXT_MODEL_CLASS (klass); - parent_class = gtk_type_class (e_text_model_get_type ()); + parent_class = g_type_class_ref (PARENT_TYPE); - object_class->destroy = e_text_model_uri_destroy; + object_class->dispose = e_text_model_uri_dispose; model_class->object_activated = e_text_model_uri_activate_nth_object; @@ -102,7 +88,7 @@ e_text_model_uri_init (ETextModelURI *model) } static void -e_text_model_uri_destroy (GtkObject *object) +e_text_model_uri_dispose (GObject *object) { ETextModelURI *model_uri = E_TEXT_MODEL_URI (object); GList *iter; @@ -117,8 +103,8 @@ e_text_model_uri_destroy (GtkObject *object) g_list_free (model_uri->uris); model_uri->uris = NULL; - if (GTK_OBJECT_CLASS (parent_class)->destroy) - (* GTK_OBJECT_CLASS (parent_class)->destroy) (object); + if (G_OBJECT_CLASS (parent_class)->dispose) + (* G_OBJECT_CLASS (parent_class)->dispose) (object); } @@ -351,7 +337,7 @@ e_text_model_uri_activate_nth_object (ETextModel *model, gint i) ETextModel * e_text_model_uri_new (void) { - return E_TEXT_MODEL (gtk_type_new (e_text_model_uri_get_type ())); + return E_TEXT_MODEL (g_object_new (E_TYPE_TEXT_MODEL_URI, NULL)); } diff --git a/widgets/text/e-text-model-uri.h b/widgets/text/e-text-model-uri.h index 9293a8f63f..2dcbddbaf6 100644 --- a/widgets/text/e-text-model-uri.h +++ b/widgets/text/e-text-model-uri.h @@ -29,10 +29,10 @@ G_BEGIN_DECLS #define E_TYPE_TEXT_MODEL_URI (e_text_model_get_type ()) -#define E_TEXT_MODEL_URI(obj) (GTK_CHECK_CAST ((obj), E_TYPE_TEXT_MODEL_URI, ETextModelURI)) -#define E_TEXT_MODEL_URI_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), E_TYPE_TEXT_MODEL_URI, ETextModelURIClass)) -#define E_IS_TEXT_MODEL_URI(obj) (GTK_CHECK_TYPE ((obj), E_TYPE_TEXT_MODEL_URI)) -#define E_IS_TEXT_MODEL_URI_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), E_TYPE_TEXT_MODEL_URI)) +#define E_TEXT_MODEL_URI(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), E_TYPE_TEXT_MODEL_URI, ETextModelURI)) +#define E_TEXT_MODEL_URI_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), E_TYPE_TEXT_MODEL_URI, ETextModelURIClass)) +#define E_IS_TEXT_MODEL_URI(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), E_TYPE_TEXT_MODEL_URI)) +#define E_IS_TEXT_MODEL_URI_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), E_TYPE_TEXT_MODEL_URI)) typedef struct _ETextModelURI ETextModelURI; typedef struct _ETextModelURIClass ETextModelURIClass; diff --git a/widgets/text/e-text-model.c b/widgets/text/e-text-model.c index d761f8e193..b7287156f5 100644 --- a/widgets/text/e-text-model.c +++ b/widgets/text/e-text-model.c @@ -53,7 +53,7 @@ struct _ETextModelPrivate { static void e_text_model_class_init (ETextModelClass *class); static void e_text_model_init (ETextModel *model); -static void e_text_model_destroy (GtkObject *object); +static void e_text_model_dispose (GObject *object); static gint e_text_model_real_validate_position (ETextModel *, gint pos); static const gchar *e_text_model_real_get_text (ETextModel *model); @@ -63,6 +63,7 @@ static void e_text_model_real_insert (ETextModel *model, gint static void e_text_model_real_insert_length (ETextModel *model, gint postion, const gchar *text, gint length); static void e_text_model_real_delete (ETextModel *model, gint postion, gint length); +#define PARENT_TYPE GTK_TYPE_OBJECT static GtkObject *parent_class; @@ -76,74 +77,60 @@ static GtkObject *parent_class; * * Return value: The type ID of the &ETextModel class. **/ -GtkType -e_text_model_get_type (void) -{ - static GtkType model_type = 0; - - if (!model_type) { - GtkTypeInfo model_info = { - "ETextModel", - sizeof (ETextModel), - sizeof (ETextModelClass), - (GtkClassInitFunc) e_text_model_class_init, - (GtkObjectInitFunc) e_text_model_init, - NULL, /* reserved_1 */ - NULL, /* reserved_2 */ - (GtkClassInitFunc) NULL - }; - - model_type = gtk_type_unique (gtk_object_get_type (), &model_info); - } - - return model_type; -} +E_MAKE_TYPE (e_text_model, + "ETextModel", + ETextModel, + e_text_model_class_init, + e_text_model_init, + PARENT_TYPE) /* Class initialization function for the text item */ static void e_text_model_class_init (ETextModelClass *klass) { - GtkObjectClass *object_class; + GObjectClass *object_class; - object_class = (GtkObjectClass *) klass; + object_class = (GObjectClass *) klass; - parent_class = gtk_type_class (gtk_object_get_type ()); + parent_class = g_type_class_ref (PARENT_TYPE); e_text_model_signals[E_TEXT_MODEL_CHANGED] = - gtk_signal_new ("changed", - GTK_RUN_LAST, - E_OBJECT_CLASS_TYPE (object_class), - GTK_SIGNAL_OFFSET (ETextModelClass, changed), - gtk_marshal_NONE__NONE, - GTK_TYPE_NONE, 0); + g_signal_new ("changed", + G_OBJECT_CLASS_TYPE (object_class), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (ETextModelClass, changed), + NULL, NULL, + e_marshal_NONE__NONE, + G_TYPE_NONE, 0); e_text_model_signals[E_TEXT_MODEL_REPOSITION] = - gtk_signal_new ("reposition", - GTK_RUN_LAST, - E_OBJECT_CLASS_TYPE (object_class), - GTK_SIGNAL_OFFSET (ETextModelClass, reposition), - e_marshal_NONE__POINTER_POINTER, - GTK_TYPE_NONE, 2, - GTK_TYPE_POINTER, GTK_TYPE_POINTER); + g_signal_new ("reposition", + G_OBJECT_CLASS_TYPE (object_class), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (ETextModelClass, reposition), + NULL, NULL, + e_marshal_NONE__POINTER_POINTER, + G_TYPE_NONE, 2, + G_TYPE_POINTER, G_TYPE_POINTER); e_text_model_signals[E_TEXT_MODEL_OBJECT_ACTIVATED] = - gtk_signal_new ("object_activated", - GTK_RUN_LAST, - E_OBJECT_CLASS_TYPE (object_class), - GTK_SIGNAL_OFFSET (ETextModelClass, object_activated), - gtk_marshal_NONE__INT, - GTK_TYPE_NONE, 1, - GTK_TYPE_INT); + g_signal_new ("object_activated", + G_OBJECT_CLASS_TYPE (object_class), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (ETextModelClass, object_activated), + NULL, NULL, + e_marshal_NONE__INT, + G_TYPE_NONE, 1, + G_TYPE_INT); e_text_model_signals[E_TEXT_MODEL_CANCEL_COMPLETION] = - gtk_signal_new ("cancel_completion", - GTK_RUN_LAST, - E_OBJECT_CLASS_TYPE (object_class), - GTK_SIGNAL_OFFSET (ETextModelClass, cancel_completion), - gtk_marshal_NONE__NONE, - GTK_TYPE_NONE, 0); - - E_OBJECT_CLASS_ADD_SIGNALS (object_class, e_text_model_signals, E_TEXT_MODEL_LAST_SIGNAL); + g_signal_new ("cancel_completion", + G_OBJECT_CLASS_TYPE (object_class), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (ETextModelClass, cancel_completion), + NULL, NULL, + e_marshal_NONE__NONE, + G_TYPE_NONE, 0); /* No default signal handlers. */ klass->changed = NULL; @@ -164,7 +151,7 @@ e_text_model_class_init (ETextModelClass *klass) klass->obj_count = NULL; klass->get_nth_obj = NULL; - object_class->destroy = e_text_model_destroy; + object_class->dispose = e_text_model_dispose; } /* Object initialization function for the text item */ @@ -176,9 +163,9 @@ e_text_model_init (ETextModel *model) model->priv->len = 0; } -/* Destroy handler for the text item */ +/* Dispose handler for the text item */ static void -e_text_model_destroy (GtkObject *object) +e_text_model_dispose (GObject *object) { ETextModel *model; @@ -194,8 +181,8 @@ e_text_model_destroy (GtkObject *object) model->priv = NULL; } - if (GTK_OBJECT_CLASS (parent_class)->destroy) - GTK_OBJECT_CLASS (parent_class)->destroy (object); + if (G_OBJECT_CLASS (parent_class)->dispose) + G_OBJECT_CLASS (parent_class)->dispose (object); } static gint @@ -370,8 +357,8 @@ e_text_model_changed (ETextModel *model) if (CLASS (model)->objectify) CLASS (model)->objectify (model); - gtk_signal_emit (GTK_OBJECT (model), - e_text_model_signals[E_TEXT_MODEL_CHANGED]); + g_signal_emit (model, + e_text_model_signals[E_TEXT_MODEL_CHANGED], 0); } void @@ -379,7 +366,7 @@ e_text_model_cancel_completion (ETextModel *model) { g_return_if_fail (E_IS_TEXT_MODEL (model)); - gtk_signal_emit (GTK_OBJECT (model), e_text_model_signals[E_TEXT_MODEL_CANCEL_COMPLETION]); + g_signal_emit (model, e_text_model_signals[E_TEXT_MODEL_CANCEL_COMPLETION], 0); } void @@ -389,9 +376,9 @@ e_text_model_reposition (ETextModel *model, ETextModelReposFn fn, gpointer repos g_return_if_fail (E_IS_TEXT_MODEL (model)); g_return_if_fail (fn != NULL); - gtk_signal_emit (GTK_OBJECT (model), - e_text_model_signals[E_TEXT_MODEL_REPOSITION], - fn, repos_data); + g_signal_emit (model, + e_text_model_signals[E_TEXT_MODEL_REPOSITION], 0, + fn, repos_data); } gint @@ -637,12 +624,12 @@ e_text_model_activate_nth_object (ETextModel *model, gint n) g_return_if_fail (n >= 0); g_return_if_fail (n < e_text_model_object_count (model)); - gtk_signal_emit (GTK_OBJECT (model), e_text_model_signals[E_TEXT_MODEL_OBJECT_ACTIVATED], n); + g_signal_emit (model, e_text_model_signals[E_TEXT_MODEL_OBJECT_ACTIVATED], 0, n); } ETextModel * e_text_model_new (void) { - ETextModel *model = gtk_type_new (e_text_model_get_type ()); + ETextModel *model = g_object_new (E_TYPE_TEXT_MODEL, NULL); return model; } diff --git a/widgets/text/e-text-model.h b/widgets/text/e-text-model.h index 8b5c7aab23..c79376d9d0 100644 --- a/widgets/text/e-text-model.h +++ b/widgets/text/e-text-model.h @@ -30,10 +30,10 @@ G_BEGIN_DECLS #define E_TYPE_TEXT_MODEL (e_text_model_get_type ()) -#define E_TEXT_MODEL(obj) (GTK_CHECK_CAST ((obj), E_TYPE_TEXT_MODEL, ETextModel)) -#define E_TEXT_MODEL_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), E_TYPE_TEXT_MODEL, ETextModelClass)) -#define E_IS_TEXT_MODEL(obj) (GTK_CHECK_TYPE ((obj), E_TYPE_TEXT_MODEL)) -#define E_IS_TEXT_MODEL_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), E_TYPE_TEXT_MODEL)) +#define E_TEXT_MODEL(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), E_TYPE_TEXT_MODEL, ETextModel)) +#define E_TEXT_MODEL_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), E_TYPE_TEXT_MODEL, ETextModelClass)) +#define E_IS_TEXT_MODEL(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), E_TYPE_TEXT_MODEL)) +#define E_IS_TEXT_MODEL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), E_TYPE_TEXT_MODEL)) typedef struct _ETextModel ETextModel; typedef struct _ETextModelClass ETextModelClass; diff --git a/widgets/text/e-text-test.c b/widgets/text/e-text-test.c index 45b39d3352..d10a745d85 100644 --- a/widgets/text/e-text-test.c +++ b/widgets/text/e-text-test.c @@ -34,9 +34,9 @@ static void allocate_callback(GtkWidget *canvas, GtkAllocation *allocation, Gnom gnome_canvas_item_set( item, "width", (double) allocation->width, NULL ); - gtk_object_get(GTK_OBJECT(item), - "height", &height, - NULL); + g_object_get(item, + "height", &height, + NULL); height = MAX(height, allocation->height); gnome_canvas_set_scroll_region(GNOME_CANVAS( canvas ), 0, 0, allocation->width, height ); gnome_canvas_item_set( rect, @@ -49,9 +49,9 @@ static void reflow (GtkWidget *canvas, GnomeCanvasItem *item) { double height; - gtk_object_get(GTK_OBJECT(item), - "height", &height, - NULL); + g_object_get(item, + "height", &height, + NULL); height = MAX(height, canvas->allocation.height); gnome_canvas_set_scroll_region(GNOME_CANVAS( canvas ), 0, 0, canvas->allocation.width, height ); gnome_canvas_item_set( rect, @@ -61,8 +61,7 @@ reflow (GtkWidget *canvas, GnomeCanvasItem *item) } static void -quit_cb (GtkWidget *widget, - gpointer data) +quit_cb (gpointer data, GObject *where_object_was) { gtk_main_quit (); } @@ -102,8 +101,8 @@ main (int argc, gnome_init ("ETextTest", "0.0.1", argc, argv); window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_title (GTK_WINDOW (window), "EText Test"); - gtk_signal_connect (GTK_OBJECT (window), "destroy", - GTK_SIGNAL_FUNC (quit_cb), NULL); + g_object_weak_ref (G_OBJECT (window), + quit_cb, NULL); gtk_widget_push_colormap (gdk_rgb_get_cmap ()); canvas = e_canvas_new (); @@ -150,17 +149,17 @@ main (int argc, "width", 150.0, NULL); - gtk_signal_connect (GTK_OBJECT (text), "activate", - GTK_SIGNAL_FUNC (change_text_cb), item); - gtk_signal_connect (GTK_OBJECT (font), "activate", - GTK_SIGNAL_FUNC (change_font_cb), item); - - gtk_signal_connect( GTK_OBJECT( canvas ), "size_allocate", - GTK_SIGNAL_FUNC( allocate_callback ), - item ); - gtk_signal_connect( GTK_OBJECT( canvas ), "reflow", - GTK_SIGNAL_FUNC( reflow ), - item ); + g_signal_connect (text, "activate", + G_CALLBACK (change_text_cb), item); + g_signal_connect (font, "activate", + G_CALLBACK (change_font_cb), item); + + g_signal_connect (canvas , "size_allocate", + G_CALLBACK (allocate_callback), + item ); + g_signal_connect (canvas , "reflow", + G_CALLBACK (reflow), + item ); gnome_canvas_set_scroll_region (GNOME_CANVAS (canvas), 0.0, 0.0, 400.0, 400.0); gtk_widget_show_all (window); gtk_main (); diff --git a/widgets/text/e-text.c b/widgets/text/e-text.c index abaa788a98..237818f624 100644 --- a/widgets/text/e-text.c +++ b/widgets/text/e-text.c @@ -50,6 +50,7 @@ #include #include "gal/util/e-util.h" +#include "gal/util/e-i18n.h" #include "gal/widgets/e-canvas.h" #include "gal/widgets/e-canvas-utils.h" #include "gal/widgets/e-unicode.h" @@ -85,43 +86,43 @@ struct line { /* Object argument IDs */ enum { - ARG_0, - ARG_MODEL, - ARG_EVENT_PROCESSOR, - ARG_TEXT, - ARG_FONT, - ARG_FONTSET, - ARG_FONT_GDK, - ARG_FONT_E, - ARG_BOLD, - ARG_STRIKEOUT, - ARG_ANCHOR, - ARG_JUSTIFICATION, - ARG_CLIP_WIDTH, - ARG_CLIP_HEIGHT, - ARG_CLIP, - ARG_FILL_CLIP_RECTANGLE, - ARG_X_OFFSET, - ARG_Y_OFFSET, - ARG_FILL_COLOR, - ARG_FILL_COLOR_GDK, - ARG_FILL_COLOR_RGBA, - ARG_FILL_STIPPLE, - ARG_TEXT_WIDTH, - ARG_TEXT_HEIGHT, - ARG_EDITABLE, - ARG_USE_ELLIPSIS, - ARG_ELLIPSIS, - ARG_LINE_WRAP, - ARG_BREAK_CHARACTERS, - ARG_MAX_LINES, - ARG_WIDTH, - ARG_HEIGHT, - ARG_DRAW_BORDERS, - ARG_ALLOW_NEWLINES, - ARG_DRAW_BACKGROUND, - ARG_DRAW_BUTTON, - ARG_CURSOR_POS + PROP_0, + PROP_MODEL, + PROP_EVENT_PROCESSOR, + PROP_TEXT, + PROP_FONT, + PROP_FONTSET, + PROP_FONT_GDK, + PROP_FONT_E, + PROP_BOLD, + PROP_STRIKEOUT, + PROP_ANCHOR, + PROP_JUSTIFICATION, + PROP_CLIP_WIDTH, + PROP_CLIP_HEIGHT, + PROP_CLIP, + PROP_FILL_CLIP_RECTANGLE, + PROP_X_OFFSET, + PROP_Y_OFFSET, + PROP_FILL_COLOR, + PROP_FILL_COLOR_GDK, + PROP_FILL_COLOR_RGBA, + PROP_FILL_STIPPLE, + PROP_TEXT_WIDTH, + PROP_TEXT_HEIGHT, + PROP_EDITABLE, + PROP_USE_ELLIPSIS, + PROP_ELLIPSIS, + PROP_LINE_WRAP, + PROP_BREAK_CHARACTERS, + PROP_MAX_LINES, + PROP_WIDTH, + PROP_HEIGHT, + PROP_DRAW_BORDERS, + PROP_ALLOW_NEWLINES, + PROP_DRAW_BACKGROUND, + PROP_DRAW_BUTTON, + PROP_CURSOR_POS }; @@ -177,6 +178,7 @@ static void calc_height (EText *text); static void calc_line_widths (EText *text); static void split_into_lines (EText *text); +#define PARENT_TYPE GNOME_TYPE_CANVAS_ITEM static GnomeCanvasItemClass *parent_class; static GdkAtom clipboard_atom = GDK_NONE; @@ -198,7 +200,7 @@ e_text_style_set (EText *text, GtkStyle *previous_style) } static void -e_text_destroy (GtkObject *object) +e_text_dispose (GObject *object) { EText *text; @@ -212,30 +214,30 @@ e_text_destroy (GtkObject *object) text->tooltip_owner = 0; if (text->model_changed_signal_id) - gtk_signal_disconnect (GTK_OBJECT (text->model), - text->model_changed_signal_id); + g_signal_handler_disconnect (text->model, + text->model_changed_signal_id); text->model_changed_signal_id = 0; if (text->model_repos_signal_id) - gtk_signal_disconnect (GTK_OBJECT (text->model), - text->model_repos_signal_id); + g_signal_handler_disconnect (text->model, + text->model_repos_signal_id); text->model_repos_signal_id = 0; if (text->model) - gtk_object_unref(GTK_OBJECT(text->model)); + g_object_unref(text->model); text->model = NULL; if (text->tep_command_id) - gtk_signal_disconnect(GTK_OBJECT(text->tep), - text->tep_command_id); + g_signal_handler_disconnect(text->tep, + text->tep_command_id); text->tep_command_id = 0; if (text->tep) - gtk_object_unref (GTK_OBJECT(text->tep)); + g_object_unref (text->tep); text->tep = NULL; if (text->invisible) - gtk_object_unref (GTK_OBJECT(text->invisible)); + g_object_unref (text->invisible); text->invisible = NULL; g_free (text->lines); @@ -289,8 +291,8 @@ e_text_destroy (GtkObject *object) text->tpl_timeout = 0; } - if (GTK_OBJECT_CLASS (parent_class)->destroy) - (* GTK_OBJECT_CLASS (parent_class)->destroy) (object); + if (G_OBJECT_CLASS (parent_class)->dispose) + (* G_OBJECT_CLASS (parent_class)->dispose) (object); } static void @@ -309,7 +311,7 @@ e_text_text_model_changed (ETextModel *model, EText *text) e_canvas_item_request_reflow (GNOME_CANVAS_ITEM(text)); gnome_canvas_item_request_update (GNOME_CANVAS_ITEM (text)); - gtk_signal_emit (GTK_OBJECT (text), e_text_signals[E_TEXT_CHANGED]); + g_signal_emit (text, e_text_signals[E_TEXT_CHANGED], 0); } static void @@ -842,7 +844,10 @@ set_stipple (EText *text, GdkBitmap *stipple, int reconfigure) /* Set_arg handler for the text item */ static void -e_text_set_arg (GtkObject *object, GtkArg *arg, guint arg_id) +e_text_set_property (GObject *object, + guint prop_id, + const GValue *value, + GParamSpec *pspec) { GnomeCanvasItem *item; EText *text; @@ -860,71 +865,71 @@ e_text_set_arg (GtkObject *object, GtkArg *arg, guint arg_id) color_changed = FALSE; have_pixel = FALSE; - switch (arg_id) { - case ARG_MODEL: + switch (prop_id) { + case PROP_MODEL: if ( text->model_changed_signal_id ) - gtk_signal_disconnect (GTK_OBJECT (text->model), - text->model_changed_signal_id); + g_signal_handler_disconnect (text->model, + text->model_changed_signal_id); if ( text->model_repos_signal_id ) - gtk_signal_disconnect (GTK_OBJECT (text->model), - text->model_repos_signal_id); + g_signal_handler_disconnect (text->model, + text->model_repos_signal_id); - gtk_object_unref (GTK_OBJECT (text->model)); - text->model = E_TEXT_MODEL (GTK_VALUE_OBJECT (*arg)); - gtk_object_ref (GTK_OBJECT (text->model)); + g_object_unref (text->model); + text->model = E_TEXT_MODEL (g_value_get_object (value)); + g_object_ref (text->model); text->model_changed_signal_id = - gtk_signal_connect (GTK_OBJECT (text->model), - "changed", - GTK_SIGNAL_FUNC (e_text_text_model_changed), - text); + g_signal_connect (text->model, + "changed", + G_CALLBACK (e_text_text_model_changed), + text); text->model_repos_signal_id = - gtk_signal_connect (GTK_OBJECT (text->model), - "reposition", - GTK_SIGNAL_FUNC (e_text_text_model_reposition), - text); + g_signal_connect (text->model, + "reposition", + G_CALLBACK (e_text_text_model_reposition), + text); e_text_free_lines(text); text->text = e_text_model_get_text(text->model); - gtk_signal_emit (GTK_OBJECT (text), e_text_signals[E_TEXT_CHANGED]); + g_signal_emit (text, e_text_signals[E_TEXT_CHANGED], 0); text->needs_split_into_lines = 1; needs_reflow = 1; break; - case ARG_EVENT_PROCESSOR: + case PROP_EVENT_PROCESSOR: if ( text->tep && text->tep_command_id ) - gtk_signal_disconnect(GTK_OBJECT(text->tep), - text->tep_command_id); + g_signal_handler_disconnect(text->tep, + text->tep_command_id); if ( text->tep ) { - gtk_object_unref(GTK_OBJECT(text->tep)); + g_object_unref(text->tep); } - text->tep = E_TEXT_EVENT_PROCESSOR(GTK_VALUE_OBJECT (*arg)); - gtk_object_ref(GTK_OBJECT(text->tep)); + text->tep = E_TEXT_EVENT_PROCESSOR(g_value_get_object (value)); + g_object_ref(text->tep); text->tep_command_id = - gtk_signal_connect(GTK_OBJECT(text->tep), - "command", - GTK_SIGNAL_FUNC(e_text_command), - text); + g_signal_connect (text->tep, + "command", + G_CALLBACK(e_text_command), + text); if (!text->allow_newlines) - gtk_object_set (GTK_OBJECT (text->tep), - "allow_newlines", FALSE, - NULL); + g_object_set (text->tep, + "allow_newlines", FALSE, + NULL); break; - case ARG_TEXT: - e_text_model_set_text(text->model, GTK_VALUE_STRING (*arg)); + case PROP_TEXT: + e_text_model_set_text(text->model, g_value_get_string (value)); break; - case ARG_FONT: + case PROP_FONT: if (text->font) e_font_unref (text->font); - text->font = e_font_from_gdk_name (GTK_VALUE_STRING (*arg)); + text->font = e_font_from_gdk_name (g_value_get_string (value)); calc_ellipsis (text); if ( text->line_wrap ) @@ -936,11 +941,11 @@ e_text_set_arg (GtkObject *object, GtkArg *arg, guint arg_id) needs_reflow = 1; break; - case ARG_FONTSET: + case PROP_FONTSET: if (text->font) e_font_unref (text->font); - text->font = e_font_from_gdk_name (GTK_VALUE_STRING (*arg)); + text->font = e_font_from_gdk_name (g_value_get_string (value)); calc_ellipsis (text); if ( text->line_wrap ) @@ -952,14 +957,14 @@ e_text_set_arg (GtkObject *object, GtkArg *arg, guint arg_id) needs_reflow = 1; break; - case ARG_FONT_GDK: + case PROP_FONT_GDK: /* Ref the font in case it was the font that is stored in the e-font */ - gdk_font_ref (GTK_VALUE_POINTER (*arg)); + gdk_font_ref (g_value_get_boxed (value)); if (text->font) e_font_unref (text->font); - text->font = e_font_from_gdk_font (GTK_VALUE_POINTER (*arg)); + text->font = e_font_from_gdk_font (g_value_get_boxed (value)); calc_ellipsis (text); if ( text->line_wrap ) @@ -971,11 +976,11 @@ e_text_set_arg (GtkObject *object, GtkArg *arg, guint arg_id) needs_reflow = 1; break; - case ARG_FONT_E: + case PROP_FONT_E: if (text->font) e_font_unref (text->font); - text->font = GTK_VALUE_POINTER (*arg); + text->font = g_value_get_pointer (value); e_font_ref (text->font); calc_ellipsis (text); @@ -988,8 +993,8 @@ e_text_set_arg (GtkObject *object, GtkArg *arg, guint arg_id) needs_reflow = 1; break; - case ARG_BOLD: - text->bold = GTK_VALUE_BOOL (*arg); + case PROP_BOLD: + text->bold = g_value_get_boolean (value); text->style = text->bold ? E_FONT_BOLD : E_FONT_PLAIN; text->needs_redraw = 1; @@ -1004,26 +1009,26 @@ e_text_set_arg (GtkObject *object, GtkArg *arg, guint arg_id) needs_reflow = 1; break; - case ARG_STRIKEOUT: - text->strikeout = GTK_VALUE_BOOL (*arg); + case PROP_STRIKEOUT: + text->strikeout = g_value_get_boolean (value); text->needs_redraw = 1; needs_update = 1; break; - case ARG_ANCHOR: - text->anchor = GTK_VALUE_INT (*arg); + case PROP_ANCHOR: + text->anchor = g_value_get_enum (value); text->needs_recalc_bounds = 1; needs_update = 1; break; - case ARG_JUSTIFICATION: - text->justification = GTK_VALUE_INT (*arg); + case PROP_JUSTIFICATION: + text->justification = g_value_get_enum (value); text->needs_redraw = 1; needs_update = 1; break; - case ARG_CLIP_WIDTH: - text->clip_width = fabs (GTK_VALUE_DOUBLE (*arg)); + case PROP_CLIP_WIDTH: + text->clip_width = fabs (g_value_get_double (value)); calc_ellipsis (text); if ( text->line_wrap ) text->needs_split_into_lines = 1; @@ -1034,14 +1039,14 @@ e_text_set_arg (GtkObject *object, GtkArg *arg, guint arg_id) needs_reflow = 1; break; - case ARG_CLIP_HEIGHT: - text->clip_height = fabs (GTK_VALUE_DOUBLE (*arg)); + case PROP_CLIP_HEIGHT: + text->clip_height = fabs (g_value_get_double (value)); text->needs_recalc_bounds = 1; needs_reflow = 1; break; - case ARG_CLIP: - text->clip = GTK_VALUE_BOOL (*arg); + case PROP_CLIP: + text->clip = g_value_get_boolean (value); calc_ellipsis (text); if ( text->line_wrap ) text->needs_split_into_lines = 1; @@ -1052,26 +1057,26 @@ e_text_set_arg (GtkObject *object, GtkArg *arg, guint arg_id) needs_reflow = 1; break; - case ARG_FILL_CLIP_RECTANGLE: - text->fill_clip_rectangle = GTK_VALUE_BOOL (*arg); + case PROP_FILL_CLIP_RECTANGLE: + text->fill_clip_rectangle = g_value_get_boolean (value); needs_update = 1; break; - case ARG_X_OFFSET: - text->xofs = GTK_VALUE_DOUBLE (*arg); + case PROP_X_OFFSET: + text->xofs = g_value_get_double (value); text->needs_recalc_bounds = 1; needs_update = 1; break; - case ARG_Y_OFFSET: - text->yofs = GTK_VALUE_DOUBLE (*arg); + case PROP_Y_OFFSET: + text->yofs = g_value_get_double (value); text->needs_recalc_bounds = 1; needs_update = 1; break; - case ARG_FILL_COLOR: - if (GTK_VALUE_STRING (*arg)) - gdk_color_parse (GTK_VALUE_STRING (*arg), &color); + case PROP_FILL_COLOR: + if (g_value_get_string (value)) + gdk_color_parse (g_value_get_string (value), &color); text->rgba = ((color.red & 0xff00) << 16 | (color.green & 0xff00) << 8 | @@ -1080,8 +1085,8 @@ e_text_set_arg (GtkObject *object, GtkArg *arg, guint arg_id) color_changed = TRUE; break; - case ARG_FILL_COLOR_GDK: - pcolor = GTK_VALUE_BOXED (*arg); + case PROP_FILL_COLOR_GDK: + pcolor = g_value_get_pointer (value); if (pcolor) { color = *pcolor; } @@ -1093,67 +1098,67 @@ e_text_set_arg (GtkObject *object, GtkArg *arg, guint arg_id) color_changed = TRUE; break; - case ARG_FILL_COLOR_RGBA: - text->rgba = GTK_VALUE_UINT (*arg); + case PROP_FILL_COLOR_RGBA: + text->rgba = g_value_get_uint (value); color.red = ((text->rgba >> 24) & 0xff) * 0x101; color.green = ((text->rgba >> 16) & 0xff) * 0x101; color.blue = ((text->rgba >> 8) & 0xff) * 0x101; color_changed = TRUE; break; - case ARG_FILL_STIPPLE: - set_stipple (text, GTK_VALUE_BOXED (*arg), FALSE); + case PROP_FILL_STIPPLE: + set_stipple (text, g_value_get_object (value), FALSE); text->needs_redraw = 1; needs_update = 1; break; - case ARG_EDITABLE: - text->editable = GTK_VALUE_BOOL (*arg); + case PROP_EDITABLE: + text->editable = g_value_get_boolean (value); text->needs_redraw = 1; needs_update = 1; break; - case ARG_USE_ELLIPSIS: - text->use_ellipsis = GTK_VALUE_BOOL (*arg); + case PROP_USE_ELLIPSIS: + text->use_ellipsis = g_value_get_boolean (value); text->needs_calc_line_widths = 1; needs_reflow = 1; break; - case ARG_ELLIPSIS: + case PROP_ELLIPSIS: if (text->ellipsis) g_free (text->ellipsis); - text->ellipsis = g_strdup (GTK_VALUE_STRING (*arg)); + text->ellipsis = g_strdup (g_value_get_string (value)); calc_ellipsis (text); text->needs_calc_line_widths = 1; needs_reflow = 1; break; - case ARG_LINE_WRAP: - text->line_wrap = GTK_VALUE_BOOL (*arg); + case PROP_LINE_WRAP: + text->line_wrap = g_value_get_boolean (value); text->needs_split_into_lines = 1; needs_reflow = 1; break; - case ARG_BREAK_CHARACTERS: + case PROP_BREAK_CHARACTERS: if ( text->break_characters ) { g_free(text->break_characters); text->break_characters = NULL; } - if ( GTK_VALUE_STRING (*arg) ) - text->break_characters = g_strdup( GTK_VALUE_STRING (*arg) ); + if ( g_value_get_string (value) ) + text->break_characters = g_strdup( g_value_get_string (value) ); text->needs_split_into_lines = 1; needs_reflow = 1; break; - case ARG_MAX_LINES: - text->max_lines = GTK_VALUE_INT (*arg); + case PROP_MAX_LINES: + text->max_lines = g_value_get_int (value); text->needs_split_into_lines = 1; needs_reflow = 1; break; - case ARG_WIDTH: - text->clip_width = fabs (GTK_VALUE_DOUBLE (*arg)); + case PROP_WIDTH: + text->clip_width = fabs (g_value_get_double (value)); calc_ellipsis (text); if ( text->line_wrap ) text->needs_split_into_lines = 1; @@ -1164,9 +1169,9 @@ e_text_set_arg (GtkObject *object, GtkArg *arg, guint arg_id) needs_reflow = 1; break; - case ARG_DRAW_BORDERS: - if (text->draw_borders != GTK_VALUE_BOOL (*arg)) { - text->draw_borders = GTK_VALUE_BOOL (*arg); + case PROP_DRAW_BORDERS: + if (text->draw_borders != g_value_get_boolean (value)) { + text->draw_borders = g_value_get_boolean (value); text->needs_calc_height = 1; text->needs_redraw = 1; needs_reflow = 1; @@ -1174,34 +1179,34 @@ e_text_set_arg (GtkObject *object, GtkArg *arg, guint arg_id) } break; - case ARG_DRAW_BACKGROUND: - if (text->draw_background != GTK_VALUE_BOOL (*arg)){ - text->draw_background = GTK_VALUE_BOOL (*arg); + case PROP_DRAW_BACKGROUND: + if (text->draw_background != g_value_get_boolean (value)) { + text->draw_background = g_value_get_boolean (value); text->needs_redraw = 1; } break; - case ARG_DRAW_BUTTON: - if (text->draw_button != GTK_VALUE_BOOL (*arg)){ - text->draw_button = GTK_VALUE_BOOL (*arg); + case PROP_DRAW_BUTTON: + if (text->draw_button != g_value_get_boolean (value)) { + text->draw_button = g_value_get_boolean (value); text->needs_redraw = 1; } break; - case ARG_ALLOW_NEWLINES: - text->allow_newlines = GTK_VALUE_BOOL (*arg); + case PROP_ALLOW_NEWLINES: + text->allow_newlines = g_value_get_boolean (value); _get_tep(text); - gtk_object_set (GTK_OBJECT (text->tep), - "allow_newlines", GTK_VALUE_BOOL (*arg), - NULL); + g_object_set (text->tep, + "allow_newlines", g_value_get_boolean (value), + NULL); break; - case ARG_CURSOR_POS: { + case PROP_CURSOR_POS: { ETextEventProcessorCommand command; command.action = E_TEP_MOVE; command.position = E_TEP_VALUE; - command.value = GTK_VALUE_INT (*arg); + command.value = g_value_get_int (value); command.time = GDK_CURRENT_TIME; e_text_command (text->tep, &command, text); break; @@ -1237,144 +1242,147 @@ e_text_set_arg (GtkObject *object, GtkArg *arg, guint arg_id) /* Get_arg handler for the text item */ static void -e_text_get_arg (GtkObject *object, GtkArg *arg, guint arg_id) +e_text_get_property (GObject *object, + guint prop_id, + GValue *value, + GParamSpec *pspec) { EText *text; text = E_TEXT (object); - switch (arg_id) { - case ARG_MODEL: - GTK_VALUE_OBJECT (*arg) = GTK_OBJECT(text->model); + switch (prop_id) { + case PROP_MODEL: + g_value_set_object (value, text->model); break; - case ARG_EVENT_PROCESSOR: + case PROP_EVENT_PROCESSOR: _get_tep(text); - GTK_VALUE_OBJECT (*arg) = GTK_OBJECT(text->tep); + g_value_set_object (value, text->tep); break; - case ARG_TEXT: - GTK_VALUE_STRING (*arg) = g_strdup (text->text); + case PROP_TEXT: + g_value_set_string (value, g_strdup (text->text)); break; - case ARG_FONT_E: - GTK_VALUE_BOXED (*arg) = text->font; + case PROP_FONT_E: + g_value_set_pointer (value, text->font); break; - case ARG_BOLD: - GTK_VALUE_BOOL (*arg) = text->bold; + case PROP_BOLD: + g_value_set_boolean (value, text->bold); break; - case ARG_STRIKEOUT: - GTK_VALUE_BOOL (*arg) = text->strikeout; + case PROP_STRIKEOUT: + g_value_set_boolean (value, text->strikeout); break; - case ARG_ANCHOR: - GTK_VALUE_INT (*arg) = text->anchor; + case PROP_ANCHOR: + g_value_set_enum (value, text->anchor); break; - case ARG_JUSTIFICATION: - GTK_VALUE_INT (*arg) = text->justification; + case PROP_JUSTIFICATION: + g_value_set_enum (value, text->justification); break; - case ARG_CLIP_WIDTH: - GTK_VALUE_DOUBLE (*arg) = text->clip_width; + case PROP_CLIP_WIDTH: + g_value_set_double (value, text->clip_width); break; - case ARG_CLIP_HEIGHT: - GTK_VALUE_DOUBLE (*arg) = text->clip_height; + case PROP_CLIP_HEIGHT: + g_value_set_double (value, text->clip_height); break; - case ARG_CLIP: - GTK_VALUE_BOOL (*arg) = text->clip; + case PROP_CLIP: + g_value_set_boolean (value, text->clip); break; - case ARG_FILL_CLIP_RECTANGLE: - GTK_VALUE_BOOL (*arg) = text->fill_clip_rectangle; + case PROP_FILL_CLIP_RECTANGLE: + g_value_set_boolean (value, text->fill_clip_rectangle); break; - case ARG_X_OFFSET: - GTK_VALUE_DOUBLE (*arg) = text->xofs; + case PROP_X_OFFSET: + g_value_set_double (value, text->xofs); break; - case ARG_Y_OFFSET: - GTK_VALUE_DOUBLE (*arg) = text->yofs; + case PROP_Y_OFFSET: + g_value_set_double (value, text->yofs); break; - case ARG_FILL_COLOR_GDK: - GTK_VALUE_BOXED (*arg) = gdk_color_copy (&text->color); + case PROP_FILL_COLOR_GDK: + g_value_set_pointer (value, gdk_color_copy (&text->color)); break; - case ARG_FILL_COLOR_RGBA: - GTK_VALUE_UINT (*arg) = text->rgba; + case PROP_FILL_COLOR_RGBA: + g_value_set_uint (value, text->rgba); break; - case ARG_FILL_STIPPLE: - GTK_VALUE_BOXED (*arg) = text->stipple; + case PROP_FILL_STIPPLE: + g_value_set_object (value, text->stipple); break; - case ARG_TEXT_WIDTH: - GTK_VALUE_DOUBLE (*arg) = text->max_width / text->item.canvas->pixels_per_unit; + case PROP_TEXT_WIDTH: + g_value_set_double (value, text->max_width / text->item.canvas->pixels_per_unit); break; - case ARG_TEXT_HEIGHT: - GTK_VALUE_DOUBLE (*arg) = text->height / text->item.canvas->pixels_per_unit; + case PROP_TEXT_HEIGHT: + g_value_set_double (value, text->height / text->item.canvas->pixels_per_unit); break; - case ARG_EDITABLE: - GTK_VALUE_BOOL (*arg) = text->editable; + case PROP_EDITABLE: + g_value_set_boolean (value, text->editable); break; - case ARG_USE_ELLIPSIS: - GTK_VALUE_BOOL (*arg) = text->use_ellipsis; + case PROP_USE_ELLIPSIS: + g_value_set_boolean (value, text->use_ellipsis); break; - case ARG_ELLIPSIS: - GTK_VALUE_STRING (*arg) = g_strdup (text->ellipsis); + case PROP_ELLIPSIS: + g_value_set_string (value, g_strdup (text->ellipsis)); break; - case ARG_LINE_WRAP: - GTK_VALUE_BOOL (*arg) = text->line_wrap; + case PROP_LINE_WRAP: + g_value_set_boolean (value, text->line_wrap); break; - case ARG_BREAK_CHARACTERS: - GTK_VALUE_STRING (*arg) = g_strdup (text->break_characters); + case PROP_BREAK_CHARACTERS: + g_value_set_string (value, g_strdup (text->break_characters)); break; - case ARG_MAX_LINES: - GTK_VALUE_INT (*arg) = text->max_lines; + case PROP_MAX_LINES: + g_value_set_int (value, text->max_lines); break; - case ARG_WIDTH: - GTK_VALUE_DOUBLE (*arg) = text->clip_width; + case PROP_WIDTH: + g_value_set_double (value, text->clip_width); break; - case ARG_HEIGHT: - GTK_VALUE_DOUBLE (*arg) = text->clip && text->clip_height != -1 ? text->clip_height : text->height / text->item.canvas->pixels_per_unit; + case PROP_HEIGHT: + g_value_set_double (value, text->clip && text->clip_height != -1 ? text->clip_height : text->height / text->item.canvas->pixels_per_unit); break; - case ARG_DRAW_BORDERS: - GTK_VALUE_BOOL (*arg) = text->draw_borders; + case PROP_DRAW_BORDERS: + g_value_set_boolean (value, text->draw_borders); break; - case ARG_DRAW_BACKGROUND: - GTK_VALUE_BOOL (*arg) = text->draw_background; + case PROP_DRAW_BACKGROUND: + g_value_set_boolean (value, text->draw_background); break; - case ARG_DRAW_BUTTON: - GTK_VALUE_BOOL (*arg) = text->draw_button; + case PROP_DRAW_BUTTON: + g_value_set_boolean (value, text->draw_button); break; - case ARG_ALLOW_NEWLINES: - GTK_VALUE_BOOL (*arg) = text->allow_newlines; + case PROP_ALLOW_NEWLINES: + g_value_set_boolean (value, text->allow_newlines); break; - case ARG_CURSOR_POS: - GTK_VALUE_INT (*arg) = text->selection_start; + case PROP_CURSOR_POS: + g_value_set_int (value, text->selection_start); break; default: - arg->type = GTK_TYPE_INVALID; + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } } @@ -1671,13 +1679,13 @@ _get_tep(EText *text) { if (!text->tep) { text->tep = e_text_event_processor_emacs_like_new(); - gtk_object_ref (GTK_OBJECT (text->tep)); + g_object_ref (text->tep); gtk_object_sink (GTK_OBJECT (text->tep)); text->tep_command_id = - gtk_signal_connect(GTK_OBJECT(text->tep), - "command", - GTK_SIGNAL_FUNC(e_text_command), - (gpointer) text); + g_signal_connect (text->tep, + "command", + G_CALLBACK(e_text_command), + (gpointer) text); } } @@ -1715,10 +1723,10 @@ e_text_draw (GnomeCanvasItem *item, GdkDrawable *drawable, gdouble thiswidth, thisheight; GtkWidget *widget = GTK_WIDGET(item->canvas); - gtk_object_get(GTK_OBJECT(text), - "width", &thiswidth, - "height", &thisheight, - NULL); + g_object_get(text, + "width", &thiswidth, + "height", &thisheight, + NULL); if (text->draw_borders){ @@ -2530,8 +2538,8 @@ tooltip_event(GtkWidget *tooltip, GdkEvent *event, EText *text) e_canvas_hide_tooltip (E_CANVAS(GNOME_CANVAS_ITEM(text)->canvas)); } /* Forward events to the text item */ - gtk_signal_emit_by_name (GTK_OBJECT (text), "event", event, - &ret_val); + g_signal_emit_by_name (text, "event", event, + &ret_val); if (!ret_val) gtk_propagate_event (GTK_WIDGET(GNOME_CANVAS_ITEM(text)->canvas), event); ret_val = TRUE; @@ -2542,10 +2550,11 @@ tooltip_event(GtkWidget *tooltip, GdkEvent *event, EText *text) } static void -tooltip_destroy(GtkWidget *tooltip, EText *text) +tooltip_destroy(gpointer data, GObject *where_object_was) { + EText *text = data; text->tooltip_owner = FALSE; - gtk_object_unref (GTK_OBJECT (text)); + g_object_unref (text); } static gboolean @@ -2723,11 +2732,11 @@ _do_tooltip (gpointer data) (double)tooltip_height + (text->draw_borders ? BORDER_INDENT * 2 : 0)); gtk_widget_show (canvas); gtk_widget_realize (tooltip_window); - gtk_signal_connect (GTK_OBJECT(tooltip_window), "event", - GTK_SIGNAL_FUNC(tooltip_event), text); - gtk_signal_connect (GTK_OBJECT(tooltip_window), "destroy", - GTK_SIGNAL_FUNC(tooltip_destroy), text); - gtk_object_ref (GTK_OBJECT (text)); + g_signal_connect (tooltip_window, "event", + G_CALLBACK(tooltip_event), text); + g_object_weak_ref (G_OBJECT (tooltip_window), + tooltip_destroy, text); + g_object_ref (text); e_canvas_popup_tooltip (E_CANVAS(GNOME_CANVAS_ITEM(text)->canvas), tooltip_window, @@ -2861,8 +2870,8 @@ e_text_event (GnomeCanvasItem *item, GdkEvent *event) ret = e_text_event_processor_handle_event (text->tep, &e_tep_event); if (event->type == GDK_KEY_PRESS) - gtk_signal_emit (GTK_OBJECT (text), e_text_signals[E_TEXT_KEYPRESS], - e_tep_event.key.keyval, e_tep_event.key.state); + g_signal_emit (text, e_text_signals[E_TEXT_KEYPRESS], 0, + e_tep_event.key.keyval, e_tep_event.key.state); if (e_tep_event.key.string) @@ -2912,10 +2921,10 @@ e_text_event (GnomeCanvasItem *item, GdkEvent *event) /* We follow convention and emit popup events on right-clicks. */ if (event->type == GDK_BUTTON_PRESS && event->button.button == 3) { - gtk_signal_emit (GTK_OBJECT (text), - e_text_signals[E_TEXT_POPUP], - &(event->button), - _get_position_from_xy (text, event->button.x, event->button.y)); + g_signal_emit (text, + e_text_signals[E_TEXT_POPUP], 0, + &(event->button), + _get_position_from_xy (text, event->button.x, event->button.y)); break; } @@ -3444,7 +3453,7 @@ e_text_command(ETextEventProcessor *tep, ETextEventProcessorCommand *command, gp e_text_get_selection (text, GDK_SELECTION_PRIMARY, command->time); break; case E_TEP_ACTIVATE: - gtk_signal_emit (GTK_OBJECT (text), e_text_signals[E_TEXT_ACTIVATE]); + g_signal_emit (text, e_text_signals[E_TEXT_ACTIVATE], 0); if (text->timer) { g_timer_reset(text->timer); } @@ -3530,9 +3539,9 @@ e_text_command(ETextEventProcessor *tep, ETextEventProcessorCommand *command, gp } static void -_invisible_destroy (GtkInvisible *invisible, - EText *text) +_invisible_destroy (gpointer data, GObject *where_object_was) { + EText *text = data; text->invisible = NULL; } @@ -3562,19 +3571,18 @@ e_text_get_invisible(EText *text) clipboard_atom, targets, n_targets); - gtk_signal_connect (GTK_OBJECT(invisible), "selection_get", - GTK_SIGNAL_FUNC (_selection_get), - text); - gtk_signal_connect (GTK_OBJECT(invisible), "selection_clear_event", - GTK_SIGNAL_FUNC (_selection_clear_event), - text); - gtk_signal_connect (GTK_OBJECT(invisible), "selection_received", - GTK_SIGNAL_FUNC (_selection_received), - text); + g_signal_connect (invisible, "selection_get", + G_CALLBACK (_selection_get), + text); + g_signal_connect (invisible, "selection_clear_event", + G_CALLBACK (_selection_clear_event), + text); + g_signal_connect (invisible, "selection_received", + G_CALLBACK (_selection_received), + text); - gtk_signal_connect (GTK_OBJECT(invisible), "destroy", - GTK_SIGNAL_FUNC (_invisible_destroy), - text); + g_object_weak_ref (G_OBJECT (invisible), + _invisible_destroy, text); } return invisible; } @@ -3968,133 +3976,20 @@ e_suck_font_free (ETextSuckFont *suckfont) static void e_text_class_init (ETextClass *klass) { - GtkObjectClass *object_class; + GObjectClass *object_class; GnomeCanvasItemClass *item_class; - object_class = (GtkObjectClass *) klass; + object_class = (GObjectClass *) klass; item_class = (GnomeCanvasItemClass *) klass; - parent_class = gtk_type_class (gnome_canvas_item_get_type ()); - - e_text_signals[E_TEXT_CHANGED] = - gtk_signal_new ("changed", - GTK_RUN_LAST, - E_OBJECT_CLASS_TYPE (object_class), - GTK_SIGNAL_OFFSET (ETextClass, changed), - gtk_marshal_NONE__NONE, - GTK_TYPE_NONE, 0); - - e_text_signals[E_TEXT_ACTIVATE] = - gtk_signal_new ("activate", - GTK_RUN_LAST, - E_OBJECT_CLASS_TYPE (object_class), - GTK_SIGNAL_OFFSET (ETextClass, activate), - gtk_marshal_NONE__NONE, - GTK_TYPE_NONE, 0); - - e_text_signals[E_TEXT_KEYPRESS] = - gtk_signal_new ("keypress", - GTK_RUN_LAST, - E_OBJECT_CLASS_TYPE (object_class), - GTK_SIGNAL_OFFSET (ETextClass, keypress), - gtk_marshal_NONE__INT_INT, - GTK_TYPE_NONE, 2, GTK_TYPE_UINT, GTK_TYPE_UINT); - - e_text_signals[E_TEXT_POPUP] = - gtk_signal_new ("popup", - GTK_RUN_LAST, - E_OBJECT_CLASS_TYPE (object_class), - GTK_SIGNAL_OFFSET (ETextClass, popup), - e_marshal_NONE__POINTER_INT, - GTK_TYPE_NONE, 2, GTK_TYPE_POINTER, GTK_TYPE_INT); - - E_OBJECT_CLASS_ADD_SIGNALS (object_class, e_text_signals, E_TEXT_LAST_SIGNAL); - - - gtk_object_add_arg_type ("EText::model", - GTK_TYPE_OBJECT, GTK_ARG_READWRITE, ARG_MODEL); - gtk_object_add_arg_type ("EText::event_processor", - GTK_TYPE_OBJECT, GTK_ARG_READWRITE, ARG_EVENT_PROCESSOR); - gtk_object_add_arg_type ("EText::text", - GTK_TYPE_STRING, GTK_ARG_READWRITE, ARG_TEXT); - gtk_object_add_arg_type ("EText::font", - GTK_TYPE_STRING, GTK_ARG_WRITABLE, ARG_FONT); - gtk_object_add_arg_type ("EText::fontset", - GTK_TYPE_STRING, GTK_ARG_WRITABLE, ARG_FONTSET); - gtk_object_add_arg_type ("EText::font_gdk", - GDK_TYPE_FONT, GTK_ARG_WRITABLE, ARG_FONT_GDK); - gtk_object_add_arg_type ("EText::font_e", - GTK_TYPE_POINTER, GTK_ARG_READWRITE, ARG_FONT_E); - gtk_object_add_arg_type ("EText::bold", - GTK_TYPE_BOOL, GTK_ARG_READWRITE, ARG_BOLD); - gtk_object_add_arg_type ("EText::strikeout", - GTK_TYPE_BOOL, GTK_ARG_READWRITE, ARG_STRIKEOUT); - gtk_object_add_arg_type ("EText::anchor", - GTK_TYPE_ANCHOR_TYPE, GTK_ARG_READWRITE, ARG_ANCHOR); - gtk_object_add_arg_type ("EText::justification", - GTK_TYPE_JUSTIFICATION, GTK_ARG_READWRITE, ARG_JUSTIFICATION); - gtk_object_add_arg_type ("EText::clip_width", - GTK_TYPE_DOUBLE, GTK_ARG_READWRITE, ARG_CLIP_WIDTH); - gtk_object_add_arg_type ("EText::clip_height", - GTK_TYPE_DOUBLE, GTK_ARG_READWRITE, ARG_CLIP_HEIGHT); - gtk_object_add_arg_type ("EText::clip", - GTK_TYPE_BOOL, GTK_ARG_READWRITE, ARG_CLIP); - gtk_object_add_arg_type ("EText::fill_clip_rectangle", - GTK_TYPE_BOOL, GTK_ARG_READWRITE, ARG_FILL_CLIP_RECTANGLE); - gtk_object_add_arg_type ("EText::x_offset", - GTK_TYPE_DOUBLE, GTK_ARG_READWRITE, ARG_X_OFFSET); - gtk_object_add_arg_type ("EText::y_offset", - GTK_TYPE_DOUBLE, GTK_ARG_READWRITE, ARG_Y_OFFSET); - gtk_object_add_arg_type ("EText::fill_color", - GTK_TYPE_STRING, GTK_ARG_WRITABLE, ARG_FILL_COLOR); - gtk_object_add_arg_type ("EText::fill_color_gdk", - GDK_TYPE_COLOR, GTK_ARG_READWRITE, ARG_FILL_COLOR_GDK); - gtk_object_add_arg_type ("EText::fill_color_rgba", - GTK_TYPE_UINT, GTK_ARG_READWRITE, ARG_FILL_COLOR_RGBA); - gtk_object_add_arg_type ("EText::fill_stipple", - GDK_TYPE_WINDOW, GTK_ARG_READWRITE, ARG_FILL_STIPPLE); - gtk_object_add_arg_type ("EText::text_width", - GTK_TYPE_DOUBLE, GTK_ARG_READABLE, ARG_TEXT_WIDTH); - gtk_object_add_arg_type ("EText::text_height", - GTK_TYPE_DOUBLE, GTK_ARG_READABLE, ARG_TEXT_HEIGHT); - gtk_object_add_arg_type ("EText::editable", - GTK_TYPE_BOOL, GTK_ARG_READWRITE, ARG_EDITABLE); - gtk_object_add_arg_type ("EText::use_ellipsis", - GTK_TYPE_BOOL, GTK_ARG_READWRITE, ARG_USE_ELLIPSIS); - gtk_object_add_arg_type ("EText::ellipsis", - GTK_TYPE_STRING, GTK_ARG_READWRITE, ARG_ELLIPSIS); - gtk_object_add_arg_type ("EText::line_wrap", - GTK_TYPE_BOOL, GTK_ARG_READWRITE, ARG_LINE_WRAP); - gtk_object_add_arg_type ("EText::break_characters", - GTK_TYPE_STRING, GTK_ARG_READWRITE, ARG_BREAK_CHARACTERS); - gtk_object_add_arg_type ("EText::max_lines", - GTK_TYPE_INT, GTK_ARG_READWRITE, ARG_MAX_LINES); - gtk_object_add_arg_type ("EText::width", - GTK_TYPE_DOUBLE, GTK_ARG_READWRITE, ARG_WIDTH); - gtk_object_add_arg_type ("EText::height", - GTK_TYPE_DOUBLE, GTK_ARG_READABLE, ARG_HEIGHT); - gtk_object_add_arg_type ("EText::draw_borders", - GTK_TYPE_BOOL, GTK_ARG_READWRITE, ARG_DRAW_BORDERS); - gtk_object_add_arg_type ("EText::allow_newlines", - GTK_TYPE_BOOL, GTK_ARG_READWRITE, ARG_ALLOW_NEWLINES); - gtk_object_add_arg_type ("EText::draw_background", - GTK_TYPE_BOOL, GTK_ARG_READWRITE, ARG_DRAW_BACKGROUND); - gtk_object_add_arg_type ("EText::draw_button", - GTK_TYPE_BOOL, GTK_ARG_READWRITE, ARG_DRAW_BUTTON); - gtk_object_add_arg_type ("EText::cursor_pos", - GTK_TYPE_INT, GTK_ARG_READWRITE, ARG_CURSOR_POS); - - if (!clipboard_atom) - clipboard_atom = gdk_atom_intern ("CLIPBOARD", FALSE); - - + parent_class = g_type_class_ref (PARENT_TYPE); klass->changed = NULL; klass->activate = NULL; - object_class->destroy = e_text_destroy; - object_class->set_arg = e_text_set_arg; - object_class->get_arg = e_text_get_arg; + object_class->dispose = e_text_dispose; + object_class->set_property = e_text_set_property; + object_class->get_property = e_text_get_property; item_class->update = e_text_update; item_class->realize = e_text_realize; @@ -4104,6 +3999,300 @@ e_text_class_init (ETextClass *klass) item_class->bounds = e_text_bounds; item_class->render = e_text_render; item_class->event = e_text_event; + + e_text_signals[E_TEXT_CHANGED] = + g_signal_new ("changed", + G_OBJECT_CLASS_TYPE (object_class), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (ETextClass, changed), + NULL, NULL, + e_marshal_NONE__NONE, + G_TYPE_NONE, 0); + + e_text_signals[E_TEXT_ACTIVATE] = + g_signal_new ("activate", + G_OBJECT_CLASS_TYPE (object_class), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (ETextClass, activate), + NULL, NULL, + e_marshal_NONE__NONE, + G_TYPE_NONE, 0); + + e_text_signals[E_TEXT_KEYPRESS] = + g_signal_new ("keypress", + G_OBJECT_CLASS_TYPE (object_class), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (ETextClass, keypress), + NULL, NULL, + e_marshal_NONE__INT_INT, + G_TYPE_NONE, 2, G_TYPE_UINT, G_TYPE_UINT); + + e_text_signals[E_TEXT_POPUP] = + g_signal_new ("popup", + G_OBJECT_CLASS_TYPE (object_class), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (ETextClass, popup), + NULL, NULL, + e_marshal_NONE__POINTER_INT, + G_TYPE_NONE, 2, G_TYPE_POINTER, G_TYPE_INT); + + g_object_class_install_property (object_class, PROP_MODEL, + g_param_spec_object ("model", + _( "Model" ), + _( "Model" ), + E_TYPE_TEXT_MODEL, + G_PARAM_READWRITE)); + + g_object_class_install_property (object_class, PROP_EVENT_PROCESSOR, + g_param_spec_object ("event_processor", + _( "Event Processor" ), + _( "Event Processor" ), + E_TEXT_EVENT_PROCESSOR_TYPE, + G_PARAM_READWRITE)); + + g_object_class_install_property (object_class, PROP_TEXT, + g_param_spec_string ("text", + _( "Text" ), + _( "Text" ), + NULL, + G_PARAM_READWRITE)); + + g_object_class_install_property (object_class, PROP_FONT, + g_param_spec_string ("font", + _( "Font" ), + _( "Font" ), + NULL, + G_PARAM_READWRITE)); + + g_object_class_install_property (object_class, PROP_FONTSET, + g_param_spec_string ("fontset", + _( "Fontset" ), + _( "Fontset" ), + NULL, + G_PARAM_READWRITE)); + + g_object_class_install_property (object_class, PROP_FONT_GDK, + g_param_spec_boxed ("font_gdk", + _( "GDKFont" ), + _( "GDKFont" ), + GDK_TYPE_FONT, + G_PARAM_WRITABLE)); + + g_object_class_install_property (object_class, PROP_FONT_E, + g_param_spec_pointer ("font_e", + _( "EFont" ), + _( "EFont" ), + G_PARAM_READWRITE)); + + g_object_class_install_property (object_class, PROP_BOLD, + g_param_spec_boolean ("bold", + _( "Bold" ), + _( "Bold" ), + FALSE, + G_PARAM_READWRITE)); + + g_object_class_install_property (object_class, PROP_STRIKEOUT, + g_param_spec_boolean ("strikeout", + _( "Strikeout" ), + _( "Strikeout" ), + FALSE, + G_PARAM_READWRITE)); + + g_object_class_install_property (object_class, PROP_ANCHOR, + g_param_spec_enum ("anchor", + _( "Anchor" ), + _( "Anchor" ), + GTK_TYPE_ANCHOR_TYPE, GTK_ANCHOR_CENTER, + G_PARAM_READWRITE)); + + + g_object_class_install_property (object_class, PROP_JUSTIFICATION, + g_param_spec_enum ("justification", + _( "Justification" ), + _( "Justification" ), + GTK_TYPE_JUSTIFICATION, GTK_JUSTIFY_LEFT, + G_PARAM_READWRITE)); + + g_object_class_install_property (object_class, PROP_CLIP_WIDTH, + g_param_spec_double ("clip_width", + _( "Clip Width" ), + _( "Clip Width" ), + 0.0, G_MAXDOUBLE, 0.0, + G_PARAM_READWRITE)); + + g_object_class_install_property (object_class, PROP_CLIP_HEIGHT, + g_param_spec_double ("clip_height", + _( "Clip Height" ), + _( "Clip Height" ), + 0.0, G_MAXDOUBLE, 0.0, + G_PARAM_READWRITE)); + + g_object_class_install_property (object_class, PROP_CLIP, + g_param_spec_boolean ("clip", + _( "Clip" ), + _( "Clip" ), + FALSE, + G_PARAM_READWRITE)); + + g_object_class_install_property (object_class, PROP_FILL_CLIP_RECTANGLE, + g_param_spec_boolean ("fill_clip_rectangle", + _( "Fill clip rectangle" ), + _( "Fill clip rectangle" ), + FALSE, + G_PARAM_READWRITE)); + + g_object_class_install_property (object_class, PROP_X_OFFSET, + g_param_spec_double ("x_offset", + _( "X Offset" ), + _( "X Offset" ), + 0.0, G_MAXDOUBLE, 0.0, + G_PARAM_READWRITE)); + + g_object_class_install_property (object_class, PROP_Y_OFFSET, + g_param_spec_double ("y_offset", + _( "Y Offset" ), + _( "Y Offset" ), + 0.0, G_MAXDOUBLE, 0.0, + G_PARAM_READWRITE)); + + g_object_class_install_property (object_class, PROP_FILL_COLOR, + g_param_spec_string ("fill_color", + _( "Fill color" ), + _( "Fill color" ), + NULL, + G_PARAM_READWRITE)); + + g_object_class_install_property (object_class, PROP_FILL_COLOR_GDK, + g_param_spec_pointer ("fill_color_gdk", + _( "GDK fill color" ), + _( "GDK fill color" ), + G_PARAM_READWRITE)); + + + g_object_class_install_property (object_class, PROP_FILL_COLOR_RGBA, + g_param_spec_uint ("fill_color_rgba", + _( "GDK fill color" ), + _( "GDK fill color" ), + 0, G_MAXUINT, 0, + G_PARAM_READWRITE)); + + g_object_class_install_property (object_class, PROP_FILL_STIPPLE, + g_param_spec_object ("fill_stipple", + _( "Fill stipple" ), + _( "FIll stipple" ), + GDK_TYPE_WINDOW, + G_PARAM_READWRITE)); + + g_object_class_install_property (object_class, PROP_TEXT_WIDTH, + g_param_spec_double ("text_width", + _( "Text width" ), + _( "Text width" ), + 0.0, G_MAXDOUBLE, 0.0, + G_PARAM_READABLE)); + + g_object_class_install_property (object_class, PROP_TEXT_HEIGHT, + g_param_spec_double ("text_height", + _( "Text height" ), + _( "Text height" ), + 0.0, G_MAXDOUBLE, 0.0, + G_PARAM_READABLE)); + + + g_object_class_install_property (object_class, PROP_EDITABLE, + g_param_spec_boolean ("editable", + _( "Editable" ), + _( "Editable" ), + FALSE, + G_PARAM_READWRITE)); + + g_object_class_install_property (object_class, PROP_USE_ELLIPSIS, + g_param_spec_boolean ("use_ellipsis", + _( "Use ellipsis" ), + _( "Use ellipsis" ), + FALSE, + G_PARAM_READWRITE)); + + g_object_class_install_property (object_class, PROP_ELLIPSIS, + g_param_spec_string ("ellipsis", + _( "Ellipsis" ), + _( "Ellipsis" ), + NULL, + G_PARAM_READWRITE)); + + g_object_class_install_property (object_class, PROP_LINE_WRAP, + g_param_spec_boolean ("line_wrap", + _( "Line wrap" ), + _( "Line wrap" ), + FALSE, + G_PARAM_READWRITE)); + + g_object_class_install_property (object_class, PROP_BREAK_CHARACTERS, + g_param_spec_string ("break_characters", + _( "Break characters" ), + _( "Break characters" ), + NULL, + G_PARAM_READWRITE)); + + + g_object_class_install_property (object_class, PROP_MAX_LINES, + g_param_spec_int ("max_lines", + _( "Max lines" ), + _( "Max lines" ), + 0, G_MAXINT, 0, + G_PARAM_READWRITE)); + + g_object_class_install_property (object_class, PROP_WIDTH, + g_param_spec_double ("width", + _( "Width" ), + _( "Width" ), + 0.0, G_MAXDOUBLE, 0.0, + G_PARAM_READWRITE)); + + + g_object_class_install_property (object_class, PROP_HEIGHT, + g_param_spec_double ("height", + _( "Height" ), + _( "Height" ), + 0.0, G_MAXDOUBLE, 0.0, + G_PARAM_READWRITE)); + + g_object_class_install_property (object_class, PROP_DRAW_BORDERS, + g_param_spec_boolean ("draw_borders", + _( "Draw borders" ), + _( "Draw borders" ), + FALSE, + G_PARAM_READWRITE)); + + g_object_class_install_property (object_class, PROP_ALLOW_NEWLINES, + g_param_spec_boolean ("allow_newlines", + _( "Allow newlines" ), + _( "Allow newlines" ), + FALSE, + G_PARAM_READWRITE)); + + g_object_class_install_property (object_class, PROP_DRAW_BACKGROUND, + g_param_spec_boolean ("draw_background", + _( "Draw background" ), + _( "Draw background" ), + FALSE, + G_PARAM_READWRITE)); + + g_object_class_install_property (object_class, PROP_DRAW_BUTTON, + g_param_spec_boolean ("draw_button", + _( "Draw button" ), + _( "Draw button" ), + FALSE, + G_PARAM_READWRITE)); + + g_object_class_install_property (object_class, PROP_CURSOR_POS, + g_param_spec_int ("cursor_pos", + _( "Cursor position" ), + _( "Cursor position" ), + 0, G_MAXINT, 0, + G_PARAM_READWRITE)); + + if (!clipboard_atom) + clipboard_atom = gdk_atom_intern ("CLIPBOARD", FALSE); } /* Object initialization function for the text item */ @@ -4115,19 +4304,19 @@ e_text_init (EText *text) text->revert = NULL; - gtk_object_ref (GTK_OBJECT (text->model)); + g_object_ref (text->model); gtk_object_sink (GTK_OBJECT (text->model)); text->model_changed_signal_id = - gtk_signal_connect (GTK_OBJECT (text->model), - "changed", - GTK_SIGNAL_FUNC (e_text_text_model_changed), - text); + g_signal_connect (text->model, + "changed", + G_CALLBACK (e_text_text_model_changed), + text); text->model_repos_signal_id = - gtk_signal_connect (GTK_OBJECT (text->model), - "reposition", - GTK_SIGNAL_FUNC (e_text_text_model_reposition), - text); + g_signal_connect (text->model, + "reposition", + G_CALLBACK (e_text_text_model_reposition), + text); text->anchor = GTK_ANCHOR_CENTER; text->justification = GTK_JUSTIFY_LEFT; @@ -4208,26 +4397,9 @@ e_text_init (EText *text) * * Return value: The type ID of the &EText class. **/ -GtkType -e_text_get_type (void) -{ - static GtkType text_type = 0; - - if (!text_type) { - GtkTypeInfo text_info = { - "EText", - sizeof (EText), - sizeof (ETextClass), - (GtkClassInitFunc) e_text_class_init, - (GtkObjectInitFunc) e_text_init, - NULL, /* reserved_1 */ - NULL, /* reserved_2 */ - (GtkClassInitFunc) NULL - }; - - text_type = gtk_type_unique (gnome_canvas_item_get_type (), &text_info); - } - - return text_type; -} - +E_MAKE_TYPE (e_text, + "EText", + EText, + e_text_class_init, + e_text_init, + PARENT_TYPE) diff --git a/widgets/text/e-text.h b/widgets/text/e-text.h index 911edcd046..32d3e539b4 100644 --- a/widgets/text/e-text.h +++ b/widgets/text/e-text.h @@ -95,10 +95,10 @@ G_BEGIN_DECLS */ #define E_TYPE_TEXT (e_text_get_type ()) -#define E_TEXT(obj) (GTK_CHECK_CAST ((obj), E_TYPE_TEXT, EText)) -#define E_TEXT_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), E_TYPE_TEXT, ETextClass)) -#define E_IS_TEXT(obj) (GTK_CHECK_TYPE ((obj), E_TYPE_TEXT)) -#define E_IS_TEXT_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), E_TYPE_TEXT)) +#define E_TEXT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), E_TYPE_TEXT, EText)) +#define E_TEXT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), E_TYPE_TEXT, ETextClass)) +#define E_IS_TEXT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), E_TYPE_TEXT)) +#define E_IS_TEXT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), E_TYPE_TEXT)) typedef struct _EText EText; -- cgit v1.2.3