diff options
Diffstat (limited to 'widgets/table')
133 files changed, 4096 insertions, 3130 deletions
diff --git a/widgets/table/e-cell-checkbox.c b/widgets/table/e-cell-checkbox.c index 20f56b443e..de26a5df9f 100644 --- a/widgets/table/e-cell-checkbox.c +++ b/widgets/table/e-cell-checkbox.c @@ -61,9 +61,9 @@ ecc_print (ECellView *ecell_view, GtkPrintContext *context, } static void -e_cell_checkbox_class_init (ECellCheckboxClass *klass) +e_cell_checkbox_class_init (ECellCheckboxClass *class) { - ECellClass *ecc = E_CELL_CLASS (klass); + ECellClass *ecc = E_CELL_CLASS (class); ecc->print = ecc_print; checks[0] = gdk_pixbuf_new_from_xpm_data (check_empty_xpm); @@ -93,5 +93,5 @@ e_cell_checkbox_init (ECellCheckbox *eccb) ECell * e_cell_checkbox_new (void) { - return g_object_new (E_CELL_CHECKBOX_TYPE, NULL); + return g_object_new (E_TYPE_CELL_CHECKBOX, NULL); } diff --git a/widgets/table/e-cell-checkbox.h b/widgets/table/e-cell-checkbox.h index fa05ecbb06..8306b2d29a 100644 --- a/widgets/table/e-cell-checkbox.h +++ b/widgets/table/e-cell-checkbox.h @@ -26,24 +26,40 @@ #include <table/e-cell-toggle.h> +/* Standard GObject macros */ +#define E_TYPE_CELL_CHECKBOX \ + (e_cell_checkbox_get_type ()) +#define E_CELL_CHECKBOX(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST \ + ((obj), E_TYPE_CELL_CHECKBOX, ECellCheckbox)) +#define E_CELL_CHECKBOX_CLASS(cls) \ + (G_TYPE_CHECK_CLASS_CAST \ + ((cls), E_TYPE_CELL_CHECKBOX, ECellCheckboxClass)) +#define E_IS_CELL_CHECKBOX(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE \ + ((obj), E_TYPE_CELL_CHECKBOX)) +#define E_IS_CELL_CHECKBOX_CLASS(cls) \ + (G_TYPE_CHECK_CLASS_TYPE \ + ((cls), E_TYPE_CELL_CHECKBOX)) +#define E_CELL_CHECKBOX_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS \ + ((obj), E_TYPE_CELL_CHECKBOX, ECellCheckboxClass)) + G_BEGIN_DECLS -#define E_CELL_CHECKBOX_TYPE (e_cell_checkbox_get_type ()) -#define E_CELL_CHECKBOX(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), E_CELL_CHECKBOX_TYPE, ECellCheckbox)) -#define E_CELL_CHECKBOX_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k), E_CELL_CHECKBOX_TYPE, ECellCheckboxClass)) -#define E_IS_CELL_CHECKBOX(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), E_CELL_CHECKBOX_TYPE)) -#define E_IS_CELL_CHECKBOX_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), E_CELL_CHECKBOX_TYPE)) +typedef struct _ECellCheckbox ECellCheckbox; +typedef struct _ECellCheckboxClass ECellCheckboxClass; -typedef struct { +struct _ECellCheckbox { ECellToggle parent; -} ECellCheckbox; +}; -typedef struct { +struct _ECellCheckboxClass { ECellToggleClass parent_class; -} ECellCheckboxClass; +}; -GType e_cell_checkbox_get_type (void); -ECell *e_cell_checkbox_new (void); +GType e_cell_checkbox_get_type (void) G_GNUC_CONST; +ECell * e_cell_checkbox_new (void); G_END_DECLS diff --git a/widgets/table/e-cell-combo.c b/widgets/table/e-cell-combo.c index c06e5450e8..168061e4e7 100644 --- a/widgets/table/e-cell-combo.c +++ b/widgets/table/e-cell-combo.c @@ -109,13 +109,13 @@ static gint e_cell_combo_key_press (GtkWidget *popup_window, static void e_cell_combo_update_cell (ECellCombo *ecc); static void e_cell_combo_restart_edit (ECellCombo *ecc); -G_DEFINE_TYPE (ECellCombo, e_cell_combo, E_CELL_POPUP_TYPE) +G_DEFINE_TYPE (ECellCombo, e_cell_combo, E_TYPE_CELL_POPUP) static void -e_cell_combo_class_init (ECellComboClass *klass) +e_cell_combo_class_init (ECellComboClass *class) { - ECellPopupClass *ecpc = E_CELL_POPUP_CLASS (klass); - GObjectClass *object_class = G_OBJECT_CLASS (klass); + ECellPopupClass *ecpc = E_CELL_POPUP_CLASS (class); + GObjectClass *object_class = G_OBJECT_CLASS (class); object_class->dispose = e_cell_combo_dispose; @@ -203,11 +203,9 @@ e_cell_combo_init (ECellCombo *ecc) * Returns: an ECellCombo object. */ ECell * -e_cell_combo_new (void) +e_cell_combo_new (void) { - ECellCombo *ecc = g_object_new (E_CELL_COMBO_TYPE, NULL); - - return (ECell*) ecc; + return g_object_new (E_TYPE_CELL_COMBO, NULL); } /* diff --git a/widgets/table/e-cell-combo.h b/widgets/table/e-cell-combo.h index 728addeed9..ec77dcd6f0 100644 --- a/widgets/table/e-cell-combo.h +++ b/widgets/table/e-cell-combo.h @@ -33,29 +33,50 @@ #include <table/e-cell-popup.h> -#define E_CELL_COMBO_TYPE (e_cell_combo_get_type ()) -#define E_CELL_COMBO(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), E_CELL_COMBO_TYPE, ECellCombo)) -#define E_CELL_COMBO_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k), E_CELL_COMBO_TYPE, ECellComboClass)) -#define E_IS_CELL_COMBO(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), E_CELL_COMBO_TYPE)) -#define E_IS_CELL_COMBO_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), E_CELL_COMBO_TYPE)) +/* Standard GObject macros */ +#define E_TYPE_CELL_COMBO \ + (e_cell_combo_get_type ()) +#define E_CELL_COMBO(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST \ + ((obj), E_TYPE_CELL_COMBO, ECellCombo)) +#define E_CELL_COMBO_CLASS(cls) \ + (G_TYPE_CHECK_CLASS_CAST \ + ((cls), E_TYPE_CELL_COMBO, ECellComboClass)) +#define E_IS_CELL_COMBO(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE \ + ((obj), E_TYPE_CELL_COMBO)) +#define E_IS_CELL_COMBO_CLASS(cls) \ + (G_TYPE_CHECK_CLASS_TYPE \ + ((cls), E_TYPE_CELL_COMBO)) +#define E_CELL_COMBO_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS \ + ((obj), E_TYPE_CELL_COMBO, ECellComboClass)) -typedef struct { +G_BEGIN_DECLS + +typedef struct _ECellCombo ECellCombo; +typedef struct _ECellComboClass ECellComboClass; + +struct _ECellCombo { ECellPopup parent; GtkWidget *popup_window; GtkWidget *popup_scrolled_window; GtkWidget *popup_tree_view; -} ECellCombo; +}; -typedef struct { +struct _ECellComboClass { ECellPopupClass parent_class; -} ECellComboClass; +}; -GType e_cell_combo_get_type (void); -ECell *e_cell_combo_new (void); +GType e_cell_combo_get_type (void) G_GNUC_CONST; +ECell * e_cell_combo_new (void); /* These must be UTF-8. */ -void e_cell_combo_set_popdown_strings (ECellCombo *ecc, - GList *strings); +void e_cell_combo_set_popdown_strings + (ECellCombo *ecc, + GList *strings); + +G_END_DECLS #endif /* _E_CELL_COMBO_H_ */ diff --git a/widgets/table/e-cell-date-edit.c b/widgets/table/e-cell-date-edit.c index 31d63d97cf..a71d3cc76c 100644 --- a/widgets/table/e-cell-date-edit.c +++ b/widgets/table/e-cell-date-edit.c @@ -114,7 +114,7 @@ enum { PROP_UPPER_HOUR }; -G_DEFINE_TYPE (ECellDateEdit, e_cell_date_edit, E_CELL_POPUP_TYPE) +G_DEFINE_TYPE (ECellDateEdit, e_cell_date_edit, E_TYPE_CELL_POPUP) static void e_cell_date_edit_class_init (ECellDateEditClass *class) diff --git a/widgets/table/e-cell-date-edit.h b/widgets/table/e-cell-date-edit.h index 4de4dc1819..5224b0ddff 100644 --- a/widgets/table/e-cell-date-edit.h +++ b/widgets/table/e-cell-date-edit.h @@ -32,11 +32,26 @@ #include <time.h> #include <table/e-cell-popup.h> -#define E_CELL_DATE_EDIT_TYPE (e_cell_date_edit_get_type ()) -#define E_CELL_DATE_EDIT(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), E_CELL_DATE_EDIT_TYPE, ECellDateEdit)) -#define E_CELL_DATE_EDIT_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), E_CELL_DATE_EDIT_TYPE, ECellDateEditClass)) -#define E_IS_CELL_DATE_EDIT(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), E_CELL_DATE_EDIT_TYPE)) -#define E_IS_CELL_DATE_EDIT_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), E_CELL_DATE_EDIT_TYPE)) +/* Standard GObject macros */ +#define E_TYPE_CELL_DATE_EDIT \ + (e_cell_date_edit_get_type ()) +#define E_CELL_DATE_EDIT(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST \ + ((obj), E_TYPE_CELL_DATE_EDIT, ECellDateEdit)) +#define E_CELL_DATE_EDIT_CLASS(cls) \ + (G_TYPE_CHECK_CLASS_CAST \ + ((cls), E_TYPE_CELL_DATE_EDIT, ECellDateEditClass)) +#define E_IS_CELL_DATE_EDIT(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE \ + ((obj), E_TYPE_CELL_DATE_EDIT)) +#define E_IS_CELL_DATE_EDIT_CLASS(cls) \ + (G_TYPE_CHECK_CLASS_TYPE \ + ((cls), E_TYPE_CELL_DATE_EDIT)) +#define E_CELL_DATE_EDIT_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS \ + ((obj), E_TYPE_CELL_DATE_EDIT, ECellDateEditClass)) + +G_BEGIN_DECLS typedef struct _ECellDateEdit ECellDateEdit; typedef struct _ECellDateEditClass ECellDateEditClass; @@ -81,7 +96,7 @@ struct _ECellDateEditClass { ECellPopupClass parent_class; }; -GType e_cell_date_edit_get_type (void); +GType e_cell_date_edit_get_type (void) G_GNUC_CONST; ECell * e_cell_date_edit_new (void); /* These freeze and thaw the rebuilding of the time list. They are useful when @@ -99,4 +114,6 @@ void e_cell_date_edit_set_get_time_callback gpointer data, GDestroyNotify destroy); +G_END_DECLS + #endif /* _E_CELL_DATE_EDIT_H_ */ diff --git a/widgets/table/e-cell-date.c b/widgets/table/e-cell-date.c index c005b8371d..c4a4cf3103 100644 --- a/widgets/table/e-cell-date.c +++ b/widgets/table/e-cell-date.c @@ -61,9 +61,9 @@ ecd_free_text (ECellText *cell, gchar *text) } static void -e_cell_date_class_init (ECellDateClass *klass) +e_cell_date_class_init (ECellDateClass *class) { - ECellTextClass *ectc = E_CELL_TEXT_CLASS (klass); + ECellTextClass *ectc = E_CELL_TEXT_CLASS (class); ectc->get_text = ecd_get_text; ectc->free_text = ecd_free_text; diff --git a/widgets/table/e-cell-date.h b/widgets/table/e-cell-date.h index 5753d24642..c498095241 100644 --- a/widgets/table/e-cell-date.h +++ b/widgets/table/e-cell-date.h @@ -58,7 +58,7 @@ struct _ECellDateClass { ECellTextClass parent_class; }; -GType e_cell_date_get_type (void); +GType e_cell_date_get_type (void) G_GNUC_CONST; ECell * e_cell_date_new (const gchar *fontname, GtkJustification justify); void e_cell_date_set_format_component diff --git a/widgets/table/e-cell-hbox.c b/widgets/table/e-cell-hbox.c index 6f587db9d2..4053452705 100644 --- a/widgets/table/e-cell-hbox.c +++ b/widgets/table/e-cell-hbox.c @@ -39,7 +39,7 @@ #include "e-cell-hbox.h" #include "e-table-item.h" -G_DEFINE_TYPE (ECellHbox, e_cell_hbox, E_CELL_TYPE) +G_DEFINE_TYPE (ECellHbox, e_cell_hbox, E_TYPE_CELL) #define INDENT_AMOUNT 16 #define MAX_CELL_SIZE 25 @@ -270,10 +270,10 @@ ecv_dispose (GObject *object) } static void -e_cell_hbox_class_init (ECellHboxClass *klass) +e_cell_hbox_class_init (ECellHboxClass *class) { - GObjectClass *object_class = G_OBJECT_CLASS (klass); - ECellClass *ecc = E_CELL_CLASS (klass); + GObjectClass *object_class = G_OBJECT_CLASS (class); + ECellClass *ecc = E_CELL_CLASS (class); object_class->dispose = ecv_dispose; @@ -287,7 +287,7 @@ e_cell_hbox_class_init (ECellHboxClass *klass) ecc->max_width = ecv_max_width; -/* gal_a11y_e_cell_registry_add_cell_type (NULL, E_CELL_HBOX_TYPE, gal_a11y_e_cell_hbox_new); */ +/* gal_a11y_e_cell_registry_add_cell_type (NULL, E_TYPE_CELL_HBOX, gal_a11y_e_cell_hbox_new); */ } static void @@ -309,9 +309,7 @@ e_cell_hbox_init (ECellHbox *ecv) ECell * e_cell_hbox_new (void) { - ECellHbox *ecv = g_object_new (E_CELL_HBOX_TYPE, NULL); - - return (ECell *) ecv; + return g_object_new (E_TYPE_CELL_HBOX, NULL); } void diff --git a/widgets/table/e-cell-hbox.h b/widgets/table/e-cell-hbox.h index 42b1c60e61..41cc01e6a1 100644 --- a/widgets/table/e-cell-hbox.h +++ b/widgets/table/e-cell-hbox.h @@ -27,41 +27,59 @@ #include <libgnomecanvas/libgnomecanvas.h> #include <table/e-cell.h> +/* Standard GObject macros */ +#define E_TYPE_CELL_HBOX \ + (e_cell_hbox_get_type ()) +#define E_CELL_HBOX(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST \ + ((obj), E_TYPE_CELL_HBOX, ECellHbox)) +#define E_CELL_HBOX_CLASS(cls) \ + (G_TYPE_CHECK_CLASS_CAST \ + ((cls), E_TYPE_CELL_HBOX, ECellHboxClass)) +#define E_IS_CELL_HBOX(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE \ + ((obj), E_TYPE_CELL_HBOX)) +#define E_IS_CELL_HBOX_CLASS(cls) \ + (G_TYPE_CHECK_CLASS_TYPE \ + ((cls), E_TYPE_CELL_HBOX)) +#define E_CELL_HBOX_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS \ + ((obj), E_TYPE_CELL_HBOX, ECellHboxClass)) + G_BEGIN_DECLS -#define E_CELL_HBOX_TYPE (e_cell_hbox_get_type ()) -#define E_CELL_HBOX(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), E_CELL_HBOX_TYPE, ECellHbox)) -#define E_CELL_HBOX_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k), E_CELL_HBOX_TYPE, ECellHboxClass)) -#define E_IS_CELL_HBOX(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), E_CELL_HBOX_TYPE)) -#define E_IS_CELL_HBOX_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), E_CELL_HBOX_TYPE)) +typedef struct _ECellHbox ECellHbox; +typedef struct _ECellHboxView ECellHboxView; +typedef struct _ECellHboxClass ECellHboxClass; -typedef struct { +struct _ECellHbox { ECell parent; - gint subcell_count; + gint subcell_count; ECell **subcells; - gint *model_cols; - gint *def_size_cols; -} ECellHbox; + gint *model_cols; + gint *def_size_cols; +}; + +struct _ECellHboxView { + ECellView cell_view; -typedef struct { - ECellView cell_view; - gint subcell_view_count; - ECellView **subcell_views; - gint *model_cols; - gint *def_size_cols; -} ECellHboxView; + gint subcell_view_count; + ECellView **subcell_views; + gint *model_cols; + gint *def_size_cols; +}; -typedef struct { +struct _ECellHboxClass { ECellClass parent_class; -} ECellHboxClass; +}; -GType e_cell_hbox_get_type (void); -ECell *e_cell_hbox_new (void); -void e_cell_hbox_append (ECellHbox *vbox, - ECell *subcell, - gint model_col, - gint size); +GType e_cell_hbox_get_type (void) G_GNUC_CONST; +ECell * e_cell_hbox_new (void); +void e_cell_hbox_append (ECellHbox *vbox, + ECell *subcell, + gint model_col, + gint size); G_END_DECLS diff --git a/widgets/table/e-cell-number.c b/widgets/table/e-cell-number.c index 3fd5dcb123..72f25ce2f4 100644 --- a/widgets/table/e-cell-number.c +++ b/widgets/table/e-cell-number.c @@ -45,9 +45,9 @@ ecn_free_text (ECellText *cell, gchar *text) } static void -e_cell_number_class_init (ECellNumberClass *klass) +e_cell_number_class_init (ECellNumberClass *class) { - ECellTextClass *ectc = E_CELL_TEXT_CLASS (klass); + ECellTextClass *ectc = E_CELL_TEXT_CLASS (class); ectc->get_text = ecn_get_text; ectc->free_text = ecn_free_text; diff --git a/widgets/table/e-cell-number.h b/widgets/table/e-cell-number.h index 25e4d3aad6..539f27679e 100644 --- a/widgets/table/e-cell-number.h +++ b/widgets/table/e-cell-number.h @@ -58,7 +58,7 @@ struct _ECellNumberClass { ECellTextClass parent_class; }; -GType e_cell_number_get_type (void); +GType e_cell_number_get_type (void) G_GNUC_CONST; ECell * e_cell_number_new (const gchar *fontname, GtkJustification justify); diff --git a/widgets/table/e-cell-percent.h b/widgets/table/e-cell-percent.h index 691c8bc9fe..be4fdac9b7 100644 --- a/widgets/table/e-cell-percent.h +++ b/widgets/table/e-cell-percent.h @@ -63,7 +63,7 @@ struct _ECellPercentClass { ECellTextClass parent_class; }; -GType e_cell_percent_get_type (void); +GType e_cell_percent_get_type (void) G_GNUC_CONST; ECell * e_cell_percent_new (const gchar *fontname, GtkJustification justify); diff --git a/widgets/table/e-cell-pixbuf.c b/widgets/table/e-cell-pixbuf.c index f37d4b8757..b8662b9182 100644 --- a/widgets/table/e-cell-pixbuf.c +++ b/widgets/table/e-cell-pixbuf.c @@ -31,7 +31,7 @@ #include <gtk/gtk.h> #include "e-cell-pixbuf.h" -G_DEFINE_TYPE (ECellPixbuf, e_cell_pixbuf, E_CELL_TYPE) +G_DEFINE_TYPE (ECellPixbuf, e_cell_pixbuf, E_TYPE_CELL) typedef struct _ECellPixbufView ECellPixbufView; @@ -56,19 +56,7 @@ enum { ECell * e_cell_pixbuf_new (void) { - ECellPixbuf *ecp; - - ecp = g_object_new (E_CELL_PIXBUF_TYPE, NULL); - e_cell_pixbuf_construct (ecp); - - return (ECell *) ecp; -} - -void -e_cell_pixbuf_construct (ECellPixbuf *ecp) -{ - /* noop */ - return; + return g_object_new (E_TYPE_CELL_PIXBUF, NULL); } /* @@ -334,10 +322,10 @@ e_cell_pixbuf_init (ECellPixbuf *ecp) } static void -e_cell_pixbuf_class_init (ECellPixbufClass *klass) +e_cell_pixbuf_class_init (ECellPixbufClass *class) { - GObjectClass *object_class = G_OBJECT_CLASS (klass); - ECellClass *ecc = E_CELL_CLASS (klass); + GObjectClass *object_class = G_OBJECT_CLASS (class); + ECellClass *ecc = E_CELL_CLASS (class); object_class->dispose = pixbuf_dispose; object_class->set_property = pixbuf_set_property; diff --git a/widgets/table/e-cell-pixbuf.h b/widgets/table/e-cell-pixbuf.h index f6d3c5173d..f4848f7430 100644 --- a/widgets/table/e-cell-pixbuf.h +++ b/widgets/table/e-cell-pixbuf.h @@ -27,17 +27,32 @@ #include <table/e-table.h> -#define E_CELL_PIXBUF_TYPE (e_cell_pixbuf_get_type ()) -#define E_CELL_PIXBUF(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), E_CELL_PIXBUF_TYPE, ECellPixbuf)) -#define E_CELL_PIXBUF_CLASS(k) (G_TYPE_CHECK_INSTANCE_CAST_CLASS ((k), E_CELL_PIXBUF_TYPE, ECellPixbufClass)) -#define E_IS_CELL_PIXBUF(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), E_CELL_PIXBUF_TYPE)) -#define E_IS_CELL_PIXBUF_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), E_CELL_PIXBUF_TYPE)) +/* Standard GObject macros */ +#define E_TYPE_CELL_PIXBUF \ + (e_cell_pixbuf_get_type ()) +#define E_CELL_PIXBUF(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST \ + ((obj), E_TYPE_CELL_PIXBUF, ECellPixbuf)) +#define E_CELL_PIXBUF_CLASS(cls) \ + (G_TYPE_CHECK_INSTANCE_CAST_CLASS \ + ((cls), E_TYPE_CELL_PIXBUF, ECellPixbufClass)) +#define E_IS_CELL_PIXBUF(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE \ + ((obj), E_TYPE_CELL_PIXBUF)) +#define E_IS_CELL_PIXBUF_CLASS(cls) \ + (G_TYPE_CHECK_CLASS_TYPE \ + ((cls), E_TYPE_CELL_PIXBUF)) +#define E_CELL_PIXBUF_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS \ + ((obj), E_TYPE_CELL_PIXBUF, ECellPixbufClass)) + +G_BEGIN_DECLS typedef struct _ECellPixbuf ECellPixbuf; typedef struct _ECellPixbufClass ECellPixbufClass; struct _ECellPixbuf { - ECell parent; + ECell parent; gint selected_column; gint focused_column; @@ -45,11 +60,12 @@ struct _ECellPixbuf { }; struct _ECellPixbufClass { - ECellClass parent_class; + ECellClass parent_class; }; -GType e_cell_pixbuf_get_type (void); -ECell *e_cell_pixbuf_new (void); -void e_cell_pixbuf_construct (ECellPixbuf *ecp); +GType e_cell_pixbuf_get_type (void) G_GNUC_CONST; +ECell * e_cell_pixbuf_new (void); + +G_END_DECLS -#endif +#endif /* _E_CELL_PIXBUF_H */ diff --git a/widgets/table/e-cell-popup.c b/widgets/table/e-cell-popup.c index ad2009d0ac..5e89b6c37d 100644 --- a/widgets/table/e-cell-popup.c +++ b/widgets/table/e-cell-popup.c @@ -109,14 +109,14 @@ static gint e_cell_popup_do_popup (ECellPopupView *ecp_view, gint row, gint model_col); -G_DEFINE_TYPE (ECellPopup, e_cell_popup, E_CELL_TYPE) +G_DEFINE_TYPE (ECellPopup, e_cell_popup, E_TYPE_CELL) static void -e_cell_popup_class_init (ECellPopupClass *klass) +e_cell_popup_class_init (ECellPopupClass *class) { - ECellClass *ecc = E_CELL_CLASS (klass); + ECellClass *ecc = E_CELL_CLASS (class); - G_OBJECT_CLASS (klass)->dispose = e_cell_popup_dispose; + G_OBJECT_CLASS (class)->dispose = e_cell_popup_dispose; ecc->new_view = ecp_new_view; ecc->kill_view = ecp_kill_view; @@ -133,7 +133,7 @@ e_cell_popup_class_init (ECellPopupClass *klass) ecc->get_bg_color = ecp_get_bg_color; gal_a11y_e_cell_registry_add_cell_type (NULL, - E_CELL_POPUP_TYPE, + E_TYPE_CELL_POPUP, gal_a11y_e_cell_popup_new); } @@ -152,11 +152,9 @@ e_cell_popup_init (ECellPopup *ecp) * Returns: an ECellPopup object. */ ECell * -e_cell_popup_new (void) +e_cell_popup_new (void) { - ECellPopup *ecp = g_object_new (E_CELL_POPUP_TYPE, NULL); - - return (ECell*) ecp; + return g_object_new (E_TYPE_CELL_POPUP, NULL); } static void diff --git a/widgets/table/e-cell-popup.h b/widgets/table/e-cell-popup.h index 99b9bd8fb6..6d04fb3c8d 100644 --- a/widgets/table/e-cell-popup.h +++ b/widgets/table/e-cell-popup.h @@ -35,60 +35,79 @@ #include <libgnomecanvas/libgnomecanvas.h> #include <table/e-cell.h> -#define E_CELL_POPUP_TYPE (e_cell_popup_get_type ()) -#define E_CELL_POPUP(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), E_CELL_POPUP_TYPE, ECellPopup)) -#define E_CELL_POPUP_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k), E_CELL_POPUP_TYPE, ECellPopupClass)) -#define E_IS_CELL_POPUP(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), E_CELL_POPUP_TYPE)) -#define E_IS_CELL_POPUP_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), E_CELL_POPUP_TYPE)) - +/* Standard GObject macros */ +#define E_TYPE_CELL_POPUP \ + (e_cell_popup_get_type ()) +#define E_CELL_POPUP(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST \ + ((obj), E_TYPE_CELL_POPUP, ECellPopup)) +#define E_CELL_POPUP_CLASS(cls) \ + (G_TYPE_CHECK_CLASS_CAST \ + ((cls), E_TYPE_CELL_POPUP, ECellPopupClass)) +#define E_IS_CELL_POPUP(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE \ + ((obj), E_TYPE_CELL_POPUP)) +#define E_IS_CELL_POPUP_CLASS(cls) \ + (G_TYPE_CHECK_CLASS_TYPE \ + ((cls), E_TYPE_CELL_POPUP)) +#define E_CELL_POPUP_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS \ + ((obj), E_TYPE_CELL_POPUP, ECellPopupClass)) + +G_BEGIN_DECLS + +typedef struct _ECellPopup ECellPopup; typedef struct _ECellPopupView ECellPopupView; +typedef struct _ECellPopupClass ECellPopupClass; -typedef struct { +struct _ECellPopup { ECell parent; ECell *child; /* This is TRUE if the popup window is shown for the cell being edited. While shown we display the arrow indented. */ - gboolean popup_shown; + gboolean popup_shown; /* This is TRUE if the popup arrow is shown for the cell being edited. This is needed to stop the first click on the cell from popping up the popup window. We only popup the window after we have drawn the arrow. */ - gboolean popup_arrow_shown; + gboolean popup_arrow_shown; /* The view in which the popup is shown. */ - ECellPopupView *popup_cell_view; - - gint popup_view_col; - gint popup_row; - ETableModel *popup_model; -} ECellPopup; + ECellPopupView *popup_cell_view; -typedef struct { - ECellClass parent_class; - - /* Virtual function for subclasses to override. */ - gint (*popup) (ECellPopup *ecp, GdkEvent *event, gint row, gint view_col); -} ECellPopupClass; + gint popup_view_col; + gint popup_row; + ETableModel *popup_model; +}; struct _ECellPopupView { - ECellView cell_view; + ECellView cell_view; - ECellView *child_view; + ECellView *child_view; }; -GType e_cell_popup_get_type (void); -ECell *e_cell_popup_new (void); +struct _ECellPopupClass { + ECellClass parent_class; + + /* Virtual function for subclasses to override. */ + gint (*popup) (ECellPopup *ecp, + GdkEvent *event, + gint row, + gint view_col); +}; -/* Get and set the child ECell. */ -ECell *e_cell_popup_get_child (ECellPopup *ecp); -void e_cell_popup_set_child (ECellPopup *ecp, - ECell *child); +GType e_cell_popup_get_type (void) G_GNUC_CONST; +ECell * e_cell_popup_new (void); +ECell * e_cell_popup_get_child (ECellPopup *ecp); +void e_cell_popup_set_child (ECellPopup *ecp, + ECell *child); +void e_cell_popup_set_shown (ECellPopup *ecp, + gboolean shown); +void e_cell_popup_queue_cell_redraw (ECellPopup *ecp); -void e_cell_popup_set_shown (ECellPopup *ecp, - gboolean shown); -void e_cell_popup_queue_cell_redraw (ECellPopup *ecp); +G_END_DECLS #endif /* _E_CELL_POPUP_H_ */ diff --git a/widgets/table/e-cell-size.c b/widgets/table/e-cell-size.c index 90964c8f11..d624cf6cfa 100644 --- a/widgets/table/e-cell-size.c +++ b/widgets/table/e-cell-size.c @@ -57,9 +57,9 @@ ecd_free_text (ECellText *cell, gchar *text) } static void -e_cell_size_class_init (ECellSizeClass *klass) +e_cell_size_class_init (ECellSizeClass *class) { - ECellTextClass *ectc = E_CELL_TEXT_CLASS (klass); + ECellTextClass *ectc = E_CELL_TEXT_CLASS (class); ectc->get_text = ecd_get_text; ectc->free_text = ecd_free_text; diff --git a/widgets/table/e-cell-size.h b/widgets/table/e-cell-size.h index de4b56b673..8b52343b8a 100644 --- a/widgets/table/e-cell-size.h +++ b/widgets/table/e-cell-size.h @@ -59,7 +59,7 @@ struct _ECellSizeClass { ECellTextClass parent_class; }; -GType e_cell_size_get_type (void); +GType e_cell_size_get_type (void) G_GNUC_CONST; ECell * e_cell_size_new (const gchar *fontname, GtkJustification justify); diff --git a/widgets/table/e-cell-text.c b/widgets/table/e-cell-text.c index 1b0545cc37..a4160419ae 100644 --- a/widgets/table/e-cell-text.c +++ b/widgets/table/e-cell-text.c @@ -105,7 +105,7 @@ static guint signals[LAST_SIGNAL] = { 0 }; static GdkAtom clipboard_atom = GDK_NONE; -G_DEFINE_TYPE (ECellText, e_cell_text, E_CELL_TYPE) +G_DEFINE_TYPE (ECellText, e_cell_text, E_TYPE_CELL) #define UTF8_ATOM gdk_atom_intern ("UTF8_STRING", FALSE) @@ -1153,7 +1153,7 @@ ect_enter_edit (ECellView *ecell_view, gint model_col, gint view_col, gint row) } gtk_im_context_focus_in (edit->im_context); } - + #if 0 if (edit->pointer_in) { if (edit->default_cursor_shown) { @@ -1527,10 +1527,10 @@ static gchar *ellipsis_default = NULL; static gboolean use_ellipsis_default = TRUE; static void -e_cell_text_class_init (ECellTextClass *klass) +e_cell_text_class_init (ECellTextClass *class) { - ECellClass *ecc = E_CELL_CLASS (klass); - GObjectClass *object_class = G_OBJECT_CLASS (klass); + ECellClass *ecc = E_CELL_CLASS (class); + GObjectClass *object_class = G_OBJECT_CLASS (class); const gchar *ellipsis_env; object_class->finalize = ect_finalize; @@ -1553,9 +1553,9 @@ e_cell_text_class_init (ECellTextClass *klass) ecc->max_width_by_row = ect_max_width_by_row; ecc->get_bg_color = ect_get_bg_color; - klass->get_text = ect_real_get_text; - klass->free_text = ect_real_free_text; - klass->set_value = ect_real_set_value; + class->get_text = ect_real_get_text; + class->free_text = ect_real_free_text; + class->set_value = ect_real_set_value; object_class->get_property = ect_get_property; object_class->set_property = ect_set_property; diff --git a/widgets/table/e-cell-text.h b/widgets/table/e-cell-text.h index 758e6d77af..ee3e1f5202 100644 --- a/widgets/table/e-cell-text.h +++ b/widgets/table/e-cell-text.h @@ -127,7 +127,7 @@ struct _ECellTextClass { gint model_col); }; -GType e_cell_text_get_type (void); +GType e_cell_text_get_type (void) G_GNUC_CONST; ECell * e_cell_text_new (const gchar *fontname, GtkJustification justify); ECell * e_cell_text_construct (ECellText *cell, diff --git a/widgets/table/e-cell-toggle.c b/widgets/table/e-cell-toggle.c index c59cffa081..8ceca7c966 100644 --- a/widgets/table/e-cell-toggle.c +++ b/widgets/table/e-cell-toggle.c @@ -54,7 +54,7 @@ struct _ECellTogglePrivate { gint height; }; -G_DEFINE_TYPE (ECellToggle, e_cell_toggle, E_CELL_TYPE) +G_DEFINE_TYPE (ECellToggle, e_cell_toggle, E_TYPE_CELL) typedef struct { ECellView cell_view; diff --git a/widgets/table/e-cell-toggle.h b/widgets/table/e-cell-toggle.h index be693b2e28..3bc223c229 100644 --- a/widgets/table/e-cell-toggle.h +++ b/widgets/table/e-cell-toggle.h @@ -64,7 +64,7 @@ struct _ECellToggleClass { ECellClass parent_class; }; -GType e_cell_toggle_get_type (void); +GType e_cell_toggle_get_type (void) G_GNUC_CONST; ECell * e_cell_toggle_new (const gchar **icon_names, guint n_icon_names); void e_cell_toggle_construct (ECellToggle *cell_toggle, diff --git a/widgets/table/e-cell-tree.c b/widgets/table/e-cell-tree.c index 9129fba446..3793652524 100644 --- a/widgets/table/e-cell-tree.c +++ b/widgets/table/e-cell-tree.c @@ -48,7 +48,7 @@ #include "e-tree-model.h" #include "e-tree-table-adapter.h" -G_DEFINE_TYPE (ECellTree, e_cell_tree, E_CELL_TYPE) +G_DEFINE_TYPE (ECellTree, e_cell_tree, E_TYPE_CELL) typedef struct { ECellView cell_view; @@ -701,10 +701,10 @@ ect_dispose (GObject *object) } static void -e_cell_tree_class_init (ECellTreeClass *klass) +e_cell_tree_class_init (ECellTreeClass *class) { - GObjectClass *object_class = G_OBJECT_CLASS (klass); - ECellClass *ecc = E_CELL_CLASS (klass); + GObjectClass *object_class = G_OBJECT_CLASS (class); + ECellClass *ecc = E_CELL_CLASS (class); object_class->dispose = ect_dispose; @@ -722,7 +722,7 @@ e_cell_tree_class_init (ECellTreeClass *klass) ecc->max_width = ect_max_width; ecc->get_bg_color = ect_get_bg_color; - gal_a11y_e_cell_registry_add_cell_type (NULL, E_CELL_TREE_TYPE, gal_a11y_e_cell_tree_new); + gal_a11y_e_cell_registry_add_cell_type (NULL, E_TYPE_CELL_TREE, gal_a11y_e_cell_tree_new); } static void @@ -771,7 +771,7 @@ ECell * e_cell_tree_new (gboolean draw_lines, ECell *subcell) { - ECellTree *ect = g_object_new (E_CELL_TREE_TYPE, NULL); + ECellTree *ect = g_object_new (E_TYPE_CELL_TREE, NULL); e_cell_tree_construct (ect, draw_lines, subcell); diff --git a/widgets/table/e-cell-tree.h b/widgets/table/e-cell-tree.h index 98e874cb1f..cf43c47a1c 100644 --- a/widgets/table/e-cell-tree.h +++ b/widgets/table/e-cell-tree.h @@ -34,34 +34,50 @@ #include <libgnomecanvas/libgnomecanvas.h> #include <table/e-cell.h> +/* Standard GObject macros */ +#define E_TYPE_CELL_TREE \ + (e_cell_tree_get_type ()) +#define E_CELL_TREE(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST \ + ((obj), E_TYPE_CELL_TREE, ECellTree)) +#define E_CELL_TREE_CLASS(cls) \ + (G_TYPE_CHECK_CLASS_CAST \ + ((cls), E_TYPE_CELL_TREE, ECellTreeClass)) +#define E_IS_CELL_TREE(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE \ + ((obj), E_TYPE_CELL_TREE)) +#define E_IS_CELL_TREE_CLASS(cls) \ + (G_TYPE_CHECK_CLASS_TYPE \ + ((cls), E_TYPE_CELL_TREE)) +#define E_CELL_TREE_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS \ + ((obj), E_TYPE_CELL_TREE, ECellTreeClass)) + G_BEGIN_DECLS -#define E_CELL_TREE_TYPE (e_cell_tree_get_type ()) -#define E_CELL_TREE(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), E_CELL_TREE_TYPE, ECellTree)) -#define E_CELL_TREE_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k), E_CELL_TREE_TYPE, ECellTreeClass)) -#define E_IS_CELL_TREE(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), E_CELL_TREE_TYPE)) -#define E_IS_CELL_TREE_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), E_CELL_TREE_TYPE)) +typedef struct _ECellTree ECellTree; +typedef struct _ECellTreeClass ECellTreeClass; -typedef struct { +struct _ECellTree { ECell parent; gboolean draw_lines; ECell *subcell; -} ECellTree; +}; -typedef struct { +struct _ECellTreeClass { ECellClass parent_class; -} ECellTreeClass; - -GType e_cell_tree_get_type (void); -ECell *e_cell_tree_new (gboolean draw_lines, - ECell *subcell); -void e_cell_tree_construct (ECellTree *ect, - gboolean draw_lines, - ECell *subcell); +}; -ECellView *e_cell_tree_view_get_subcell_view (ECellView *ect); +GType e_cell_tree_get_type (void) G_GNUC_CONST; +ECell * e_cell_tree_new (gboolean draw_lines, + ECell *subcell); +void e_cell_tree_construct (ECellTree *ect, + gboolean draw_lines, + ECell *subcell); +ECellView * e_cell_tree_view_get_subcell_view + (ECellView *ect); G_END_DECLS diff --git a/widgets/table/e-cell-vbox.c b/widgets/table/e-cell-vbox.c index b170604ade..f57cd0e113 100644 --- a/widgets/table/e-cell-vbox.c +++ b/widgets/table/e-cell-vbox.c @@ -36,7 +36,7 @@ #include "e-cell-vbox.h" #include "e-table-item.h" -G_DEFINE_TYPE (ECellVbox, e_cell_vbox, E_CELL_TYPE) +G_DEFINE_TYPE (ECellVbox, e_cell_vbox, E_TYPE_CELL) #define INDENT_AMOUNT 16 @@ -267,10 +267,10 @@ ecv_finalize (GObject *object) } static void -e_cell_vbox_class_init (ECellVboxClass *klass) +e_cell_vbox_class_init (ECellVboxClass *class) { - GObjectClass *object_class = G_OBJECT_CLASS (klass); - ECellClass *ecc = E_CELL_CLASS (klass); + GObjectClass *object_class = G_OBJECT_CLASS (class); + ECellClass *ecc = E_CELL_CLASS (class); object_class->dispose = ecv_dispose; object_class->finalize = ecv_finalize; @@ -284,7 +284,7 @@ e_cell_vbox_class_init (ECellVboxClass *klass) ecc->height = ecv_height; ecc->max_width = ecv_max_width; - gal_a11y_e_cell_registry_add_cell_type (NULL, E_CELL_VBOX_TYPE, gal_a11y_e_cell_vbox_new); + gal_a11y_e_cell_registry_add_cell_type (NULL, E_TYPE_CELL_VBOX, gal_a11y_e_cell_vbox_new); } static void @@ -306,9 +306,7 @@ e_cell_vbox_init (ECellVbox *ecv) ECell * e_cell_vbox_new (void) { - ECellVbox *ecv = g_object_new (E_CELL_VBOX_TYPE, NULL); - - return (ECell *) ecv; + return g_object_new (E_TYPE_CELL_VBOX, NULL); } void diff --git a/widgets/table/e-cell-vbox.h b/widgets/table/e-cell-vbox.h index 52550a952f..2ab522c4ae 100644 --- a/widgets/table/e-cell-vbox.h +++ b/widgets/table/e-cell-vbox.h @@ -32,38 +32,56 @@ #include <libgnomecanvas/libgnomecanvas.h> #include <table/e-cell.h> +/* Standard GObject macros */ +#define E_TYPE_CELL_VBOX \ + (e_cell_vbox_get_type ()) +#define E_CELL_VBOX(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST \ + ((obj), E_TYPE_CELL_VBOX, ECellVbox)) +#define E_CELL_VBOX_CLASS(cls) \ + (G_TYPE_CHECK_CLASS_CAST \ + ((cls), E_TYPE_CELL_VBOX, ECellVboxClass)) +#define E_IS_CELL_VBOX(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE \ + ((obj), E_TYPE_CELL_VBOX)) +#define E_IS_CELL_VBOX_CLASS(cls) \ + (G_TYPE_CHECK_CLASS_TYPE \ + ((cls), E_TYPE_CELL_VBOX)) +#define E_CELL_VBOX_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS \ + ((obj), E_TYPE_CELL_VBOX, ECellVboxClass)) + G_BEGIN_DECLS -#define E_CELL_VBOX_TYPE (e_cell_vbox_get_type ()) -#define E_CELL_VBOX(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), E_CELL_VBOX_TYPE, ECellVbox)) -#define E_CELL_VBOX_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k), E_CELL_VBOX_TYPE, ECellVboxClass)) -#define E_IS_CELL_VBOX(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), E_CELL_VBOX_TYPE)) -#define E_IS_CELL_VBOX_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), E_CELL_VBOX_TYPE)) +typedef struct _ECellVbox ECellVbox; +typedef struct _ECellVboxView ECellVboxView; +typedef struct _ECellVboxClass ECellVboxClass; -typedef struct { +struct _ECellVbox { ECell parent; - gint subcell_count; + gint subcell_count; ECell **subcells; - gint *model_cols; -} ECellVbox; + gint *model_cols; +}; + +struct _ECellVboxView { + ECellView cell_view; -typedef struct { - ECellView cell_view; - gint subcell_view_count; - ECellView **subcell_views; - gint *model_cols; -} ECellVboxView; + gint subcell_view_count; + ECellView **subcell_views; + gint *model_cols; +}; -typedef struct { +struct _ECellVboxClass { ECellClass parent_class; -} ECellVboxClass; +}; -GType e_cell_vbox_get_type (void); -ECell *e_cell_vbox_new (void); -void e_cell_vbox_append (ECellVbox *vbox, - ECell *subcell, - gint model_col); +GType e_cell_vbox_get_type (void) G_GNUC_CONST; +ECell * e_cell_vbox_new (void); +void e_cell_vbox_append (ECellVbox *vbox, + ECell *subcell, + gint model_col); G_END_DECLS diff --git a/widgets/table/e-cell.c b/widgets/table/e-cell.c index c45ed680d4..f54b644045 100644 --- a/widgets/table/e-cell.c +++ b/widgets/table/e-cell.c @@ -127,26 +127,26 @@ ec_free_state (ECellView *ecell_view, gint model_col, gint view_col, gint row, g } static void -e_cell_class_init (ECellClass *klass) -{ - klass->realize = ec_realize; - klass->unrealize = ec_unrealize; - klass->new_view = ec_new_view; - klass->kill_view = ec_kill_view; - klass->draw = ec_draw; - klass->event = ec_event; - klass->focus = ec_focus; - klass->unfocus = ec_unfocus; - klass->height = ec_height; - klass->enter_edit = ec_enter_edit; - klass->leave_edit = ec_leave_edit; - klass->save_state = ec_save_state; - klass->load_state = ec_load_state; - klass->free_state = ec_free_state; - klass->print = NULL; - klass->print_height = NULL; - klass->max_width = NULL; - klass->max_width_by_row = NULL; +e_cell_class_init (ECellClass *class) +{ + class->realize = ec_realize; + class->unrealize = ec_unrealize; + class->new_view = ec_new_view; + class->kill_view = ec_kill_view; + class->draw = ec_draw; + class->event = ec_event; + class->focus = ec_focus; + class->unfocus = ec_unfocus; + class->height = ec_height; + class->enter_edit = ec_enter_edit; + class->leave_edit = ec_leave_edit; + class->save_state = ec_save_state; + class->load_state = ec_load_state; + class->free_state = ec_free_state; + class->print = NULL; + class->print_height = NULL; + class->max_width = NULL; + class->max_width_by_row = NULL; } static void diff --git a/widgets/table/e-cell.h b/widgets/table/e-cell.h index f38e47bfc4..111736f41c 100644 --- a/widgets/table/e-cell.h +++ b/widgets/table/e-cell.h @@ -27,14 +27,33 @@ #include <gtk/gtk.h> #include <table/e-table-model.h> +/* Standard GObject macros */ +#define E_TYPE_CELL \ + (e_cell_get_type ()) +#define E_CELL(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST \ + ((obj), E_TYPE_CELL, ECell)) +#define E_CELL_CLASS(cls) \ + (G_TYPE_CHECK_CLASS_CAST \ + ((cls), E_TYPE_CELL, ECellClass)) +#define E_CELL_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS \ + ((obj), E_TYPE_CELL, ECellClass)) +#define E_IS_CELL(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE \ + ((obj), E_TYPE_CELL)) +#define E_IS_CELL_CLASS(cls) \ + (G_TYPE_CHECK_CLASS_TYPE \ + ((cls), E_TYPE_CELL)) +#define E_CELL_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS \ + ((obj), E_TYPE_CELL, ECellClass)) + G_BEGIN_DECLS -#define E_CELL_TYPE (e_cell_get_type ()) -#define E_CELL(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), E_CELL_TYPE, ECell)) -#define E_CELL_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k), E_CELL_TYPE, ECellClass)) -#define E_CELL_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS((o), E_CELL_TYPE, ECellClass)) -#define E_IS_CELL(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), E_CELL_TYPE)) -#define E_IS_CELL_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), E_CELL_TYPE)) +typedef struct _ECell ECell; +typedef struct _ECellClass ECellClass; +typedef struct _ECellView ECellView; typedef gboolean (*ETableSearchFunc) (gconstpointer haystack, const gchar *needle); @@ -65,11 +84,7 @@ typedef enum { E_CELL_UNGRAB = 1 << 1 } ECellActions; -typedef struct { - GObject parent; -} ECell; - -typedef struct _ECellView { +struct _ECellView { ECell *ecell; ETableModel *e_table_model; void *e_table_item_view; @@ -79,137 +94,200 @@ typedef struct _ECellView { void (*kill_view_cb) (struct _ECellView*, gpointer ); GList *kill_view_cb_data; -} ECellView; +}; #define E_CELL_IS_FOCUSED(ecell_view) (ecell_view->focus_x1 != -1) -typedef struct { +struct _ECell { + GObject parent; +}; + +struct _ECellClass { GObjectClass parent_class; - ECellView *(*new_view) (ECell *ecell, ETableModel *table_model, gpointer e_table_item_view); - void (*kill_view) (ECellView *ecell_view); - - void (*realize) (ECellView *ecell_view); - void (*unrealize) (ECellView *ecell_view); - - void (*draw) (ECellView *ecell_view, GdkDrawable *drawable, - gint model_col, gint view_col, gint row, - ECellFlags flags, gint x1, gint y1, gint x2, gint y2); - gint (*event) (ECellView *ecell_view, GdkEvent *event, gint model_col, gint view_col, gint row, ECellFlags flags, ECellActions *actions); - void (*focus) (ECellView *ecell_view, gint model_col, gint view_col, - gint row, gint x1, gint y1, gint x2, gint y2); - void (*unfocus) (ECellView *ecell_view); - gint (*height) (ECellView *ecell_view, gint model_col, gint view_col, gint row); - - void *(*enter_edit) (ECellView *ecell_view, gint model_col, gint view_col, gint row); - void (*leave_edit) (ECellView *ecell_view, gint model_col, gint view_col, gint row, gpointer context); - void *(*save_state) (ECellView *ecell_view, gint model_col, gint view_col, gint row, gpointer context); - void (*load_state) (ECellView *ecell_view, gint model_col, gint view_col, gint row, gpointer context, gpointer save_state); - void (*free_state) (ECellView *ecell_view, gint model_col, gint view_col, gint row, gpointer save_state); - void (*print) (ECellView *ecell_view, GtkPrintContext *context, - gint model_col, gint view_col, gint row, - gdouble width, gdouble height); - gdouble (*print_height) (ECellView *ecell_view,GtkPrintContext *context, - gint model_col, gint view_col, gint row, gdouble width); - gint (*max_width) (ECellView *ecell_view, gint model_col, gint view_col); - gint (*max_width_by_row) (ECellView *ecell_view, gint model_col, gint view_col, gint row); - gchar *(*get_bg_color) (ECellView *ecell_view, gint row); - - void (*style_set) (ECellView *ecell_view, GtkStyle *previous_style); -} ECellClass; - -GType e_cell_get_type (void); + ECellView * (*new_view) (ECell *ecell, + ETableModel *table_model, + gpointer e_table_item_view); + void (*kill_view) (ECellView *ecell_view); + + void (*realize) (ECellView *ecell_view); + void (*unrealize) (ECellView *ecell_view); + + void (*draw) (ECellView *ecell_view, + GdkDrawable *drawable, + gint model_col, + gint view_col, gint row, + ECellFlags flags, + gint x1, + gint y1, + gint x2, + gint y2); + gint (*event) (ECellView *ecell_view, + GdkEvent *event, + gint model_col, + gint view_col, + gint row, + ECellFlags flags, + ECellActions *actions); + void (*focus) (ECellView *ecell_view, + gint model_col, + gint view_col, + gint row, + gint x1, + gint y1, + gint x2, + gint y2); + void (*unfocus) (ECellView *ecell_view); + gint (*height) (ECellView *ecell_view, + gint model_col, + gint view_col, + gint row); + + gpointer (*enter_edit) (ECellView *ecell_view, + gint model_col, + gint view_col, + gint row); + void (*leave_edit) (ECellView *ecell_view, + gint model_col, + gint view_col, + gint row, + gpointer context); + gpointer (*save_state) (ECellView *ecell_view, + gint model_col, + gint view_col, + gint row, + gpointer context); + void (*load_state) (ECellView *ecell_view, + gint model_col, + gint view_col, + gint row, + gpointer context, + gpointer save_state); + void (*free_state) (ECellView *ecell_view, + gint model_col, + gint view_col, + gint row, + gpointer save_state); + void (*print) (ECellView *ecell_view, + GtkPrintContext *context, + gint model_col, + gint view_col, + gint row, + gdouble width, + gdouble height); + gdouble (*print_height) (ECellView *ecell_view, + GtkPrintContext *context, + gint model_col, + gint view_col, + gint row, + gdouble width); + gint (*max_width) (ECellView *ecell_view, + gint model_col, + gint view_col); + gint (*max_width_by_row) (ECellView *ecell_view, + gint model_col, + gint view_col, + gint row); + gchar * (*get_bg_color) (ECellView *ecell_view, + gint row); + + void (*style_set) (ECellView *ecell_view, + GtkStyle *previous_style); +}; + +GType e_cell_get_type (void) G_GNUC_CONST; /* View creation methods. */ -ECellView *e_cell_new_view (ECell *ecell, - ETableModel *table_model, - void *e_table_item_view); -void e_cell_kill_view (ECellView *ecell_view); +ECellView * e_cell_new_view (ECell *ecell, + ETableModel *table_model, + gpointer e_table_item_view); +void e_cell_kill_view (ECellView *ecell_view); /* Cell View methods. */ -gint e_cell_event (ECellView *ecell_view, - GdkEvent *event, - gint model_col, - gint view_col, - gint row, - ECellFlags flags, - ECellActions *actions); -void e_cell_realize (ECellView *ecell_view); -void e_cell_unrealize (ECellView *ecell_view); -void e_cell_draw (ECellView *ecell_view, - GdkDrawable *drawable, - gint model_col, - gint view_col, - gint row, - ECellFlags flags, - gint x1, - gint y1, - gint x2, - gint y2); -void e_cell_print (ECellView *ecell_view, +gint e_cell_event (ECellView *ecell_view, + GdkEvent *event, + gint model_col, + gint view_col, + gint row, + ECellFlags flags, + ECellActions *actions); +void e_cell_realize (ECellView *ecell_view); +void e_cell_unrealize (ECellView *ecell_view); +void e_cell_draw (ECellView *ecell_view, + GdkDrawable *drawable, + gint model_col, + gint view_col, + gint row, + ECellFlags flags, + gint x1, + gint y1, + gint x2, + gint y2); +void e_cell_print (ECellView *ecell_view, GtkPrintContext *context, - gint model_col, - gint view_col, - gint row, - gdouble width, - gdouble height); -gdouble e_cell_print_height (ECellView *ecell_view, + gint model_col, + gint view_col, + gint row, + gdouble width, + gdouble height); +gdouble e_cell_print_height (ECellView *ecell_view, GtkPrintContext *context, - gint model_col, - gint view_col, - gint row, - gdouble width); -gint e_cell_max_width (ECellView *ecell_view, - gint model_col, - gint view_col); -gint e_cell_max_width_by_row (ECellView *ecell_view, - gint model_col, - gint view_col, - gint row); -gboolean e_cell_max_width_by_row_implemented (ECellView *ecell_view); -gchar *e_cell_get_bg_color (ECellView *ecell_view, - gint row); -void e_cell_style_set (ECellView *ecell_view, - GtkStyle *previous_style); - -void e_cell_focus (ECellView *ecell_view, - gint model_col, - gint view_col, - gint row, - gint x1, - gint y1, - gint x2, - gint y2); -void e_cell_unfocus (ECellView *ecell_view); -gint e_cell_height (ECellView *ecell_view, - gint model_col, - gint view_col, - gint row); -void *e_cell_enter_edit (ECellView *ecell_view, - gint model_col, - gint view_col, - gint row); -void e_cell_leave_edit (ECellView *ecell_view, - gint model_col, - gint view_col, - gint row, - void *edit_context); -void *e_cell_save_state (ECellView *ecell_view, - gint model_col, - gint view_col, - gint row, - void *edit_context); -void e_cell_load_state (ECellView *ecell_view, - gint model_col, - gint view_col, - gint row, - void *edit_context, - void *state); -void e_cell_free_state (ECellView *ecell_view, - gint model_col, - gint view_col, - gint row, - void *state); + gint model_col, + gint view_col, + gint row, + gdouble width); +gint e_cell_max_width (ECellView *ecell_view, + gint model_col, + gint view_col); +gint e_cell_max_width_by_row (ECellView *ecell_view, + gint model_col, + gint view_col, + gint row); +gboolean e_cell_max_width_by_row_implemented + (ECellView *ecell_view); +gchar * e_cell_get_bg_color (ECellView *ecell_view, + gint row); +void e_cell_style_set (ECellView *ecell_view, + GtkStyle *previous_style); + +void e_cell_focus (ECellView *ecell_view, + gint model_col, + gint view_col, + gint row, + gint x1, + gint y1, + gint x2, + gint y2); +void e_cell_unfocus (ECellView *ecell_view); +gint e_cell_height (ECellView *ecell_view, + gint model_col, + gint view_col, + gint row); +gpointer e_cell_enter_edit (ECellView *ecell_view, + gint model_col, + gint view_col, + gint row); +void e_cell_leave_edit (ECellView *ecell_view, + gint model_col, + gint view_col, + gint row, + gpointer edit_context); +gpointer e_cell_save_state (ECellView *ecell_view, + gint model_col, + gint view_col, + gint row, + gpointer edit_context); +void e_cell_load_state (ECellView *ecell_view, + gint model_col, + gint view_col, + gint row, + gpointer edit_context, + gpointer state); +void e_cell_free_state (ECellView *ecell_view, + gint model_col, + gint view_col, + gint row, + gpointer state); G_END_DECLS diff --git a/widgets/table/e-table-click-to-add.c b/widgets/table/e-table-click-to-add.c index b3294ff293..d983c1b935 100644 --- a/widgets/table/e-table-click-to-add.c +++ b/widgets/table/e-table-click-to-add.c @@ -492,13 +492,13 @@ etcta_reflow (GnomeCanvasItem *item, gint flags) } static void -etcta_class_init (ETableClickToAddClass *klass) +etcta_class_init (ETableClickToAddClass *class) { - GnomeCanvasItemClass *item_class = GNOME_CANVAS_ITEM_CLASS (klass); - GObjectClass *object_class = G_OBJECT_CLASS (klass); + GnomeCanvasItemClass *item_class = GNOME_CANVAS_ITEM_CLASS (class); + GObjectClass *object_class = G_OBJECT_CLASS (class); - klass->cursor_change = NULL; - klass->style_set = etcta_style_set; + class->cursor_change = NULL; + class->style_set = etcta_style_set; object_class->dispose = etcta_dispose; object_class->set_property = etcta_set_property; @@ -512,14 +512,14 @@ etcta_class_init (ETableClickToAddClass *klass) g_param_spec_object ("header", "Header", NULL, - E_TABLE_HEADER_TYPE, + E_TYPE_TABLE_HEADER, G_PARAM_READWRITE)); g_object_class_install_property (object_class, PROP_MODEL, g_param_spec_object ("model", "Model", NULL, - E_TABLE_MODEL_TYPE, + E_TYPE_TABLE_MODEL, G_PARAM_READWRITE)); g_object_class_install_property (object_class, PROP_MESSAGE, diff --git a/widgets/table/e-table-click-to-add.h b/widgets/table/e-table-click-to-add.h index 782cc6285a..49f8df334c 100644 --- a/widgets/table/e-table-click-to-add.h +++ b/widgets/table/e-table-click-to-add.h @@ -30,15 +30,31 @@ #include <table/e-table-item.h> #include <table/e-table-selection-model.h> +/* Standard GObject macros */ +#define E_TYPE_TABLE_CLICK_TO_ADD \ + (e_table_click_to_add_get_type ()) +#define E_TABLE_CLICK_TO_ADD(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST \ + ((obj), E_TYPE_TABLE_CLICK_TO_ADD, ETableClickToAdd)) +#define E_TABLE_CLICK_TO_ADD_CLASS(cls) \ + (G_TYPE_CHECK_CLASS_CAST \ + ((cls), E_TYPE_TABLE_CLICK_TO_ADD, ETableClickToAddClass)) +#define E_IS_TABLE_CLICK_TO_ADD(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE \ + ((obj), E_TYPE_TABLE_CLICK_TO_ADD)) +#define E_IS_TABLE_CLICK_TO_ADD_CLASS(cls) \ + (G_TYPE_CHECK_CLASS_TYPE \ + ((cls), E_TYPE_TABLE_CLICK_TO_ADD)) +#define E_TABLE_CLICK_TO_ADD_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS \ + ((obj), E_TYPE_TABLE_CLICK_TO_ADD, ETableClickToAddClass)) + G_BEGIN_DECLS -#define E_TABLE_CLICK_TO_ADD_TYPE (e_table_click_to_add_get_type ()) -#define E_TABLE_CLICK_TO_ADD(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), E_TABLE_CLICK_TO_ADD_TYPE, ETableClickToAdd)) -#define E_TABLE_CLICK_TO_ADD_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k), E_TABLE_CLICK_TO_ADD_TYPE, ETableClickToAddClass)) -#define E_IS_TABLE_CLICK_TO_ADD(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), E_TABLE_CLICK_TO_ADD_TYPE)) -#define E_IS_TABLE_CLICK_TO_ADD_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), E_TABLE_CLICK_TO_ADD_TYPE)) +typedef struct _ETableClickToAdd ETableClickToAdd; +typedef struct _ETableClickToAddClass ETableClickToAddClass; -typedef struct { +struct _ETableClickToAdd { GnomeCanvasGroup parent; ETableModel *one; /* The ETableOne. */ @@ -56,21 +72,21 @@ typedef struct { gdouble height; ETableSelectionModel *selection; -} ETableClickToAdd; +}; -typedef struct { +struct _ETableClickToAddClass { GnomeCanvasGroupClass parent_class; - /* - * signals - */ - void (*cursor_change) (ETableClickToAdd *etcta, gint row, gint col); - void (*style_set) (ETableClickToAdd *etcta, GtkStyle *previous_style); -} ETableClickToAddClass; - -GType e_table_click_to_add_get_type (void); + /* Signals */ + void (*cursor_change) (ETableClickToAdd *etcta, + gint row, + gint col); + void (*style_set) (ETableClickToAdd *etcta, + GtkStyle *previous_style); +}; -void e_table_click_to_add_commit (ETableClickToAdd *etcta); +GType e_table_click_to_add_get_type (void) G_GNUC_CONST; +void e_table_click_to_add_commit (ETableClickToAdd *etcta); G_END_DECLS diff --git a/widgets/table/e-table-col.c b/widgets/table/e-table-col.c index e4881ff755..1238d5c017 100644 --- a/widgets/table/e-table-col.c +++ b/widgets/table/e-table-col.c @@ -114,9 +114,9 @@ etc_get_property (GObject *object, } static void -e_table_col_class_init (ETableColClass *klass) +e_table_col_class_init (ETableColClass *class) { - GObjectClass *object_class = G_OBJECT_CLASS (klass); + GObjectClass *object_class = G_OBJECT_CLASS (class); object_class->dispose = etc_dispose; object_class->set_property = etc_set_property; diff --git a/widgets/table/e-table-col.h b/widgets/table/e-table-col.h index cbe3dc3a80..b82886a5ca 100644 --- a/widgets/table/e-table-col.h +++ b/widgets/table/e-table-col.h @@ -92,7 +92,7 @@ struct _ETableColClass { GObjectClass parent_class; }; -GType e_table_col_get_type (void); +GType e_table_col_get_type (void) G_GNUC_CONST; ETableCol * e_table_col_new (gint col_idx, const gchar *text, const gchar *icon_name, diff --git a/widgets/table/e-table-column-specification.c b/widgets/table/e-table-column-specification.c index e4e642db4f..9f7ea53ebe 100644 --- a/widgets/table/e-table-column-specification.c +++ b/widgets/table/e-table-column-specification.c @@ -66,9 +66,9 @@ etcs_finalize (GObject *object) } static void -etcs_class_init (ETableColumnSpecificationClass *klass) +etcs_class_init (ETableColumnSpecificationClass *class) { - GObjectClass *object_class = G_OBJECT_CLASS (klass); + GObjectClass *object_class = G_OBJECT_CLASS (class); object_class->finalize = etcs_finalize; } @@ -95,9 +95,7 @@ etcs_init (ETableColumnSpecification *specification) ETableColumnSpecification * e_table_column_specification_new (void) { - ETableColumnSpecification *etcs = g_object_new (E_TABLE_COLUMN_SPECIFICATION_TYPE, NULL); - - return (ETableColumnSpecification *) etcs; + return g_object_new (E_TYPE_TABLE_COLUMN_SPECIFICATION, NULL); } void diff --git a/widgets/table/e-table-column-specification.h b/widgets/table/e-table-column-specification.h index 048decdf54..e20d7de6b5 100644 --- a/widgets/table/e-table-column-specification.h +++ b/widgets/table/e-table-column-specification.h @@ -23,21 +23,36 @@ #ifndef _E_TABLE_COLUMN_SPECIFICATION_H_ #define _E_TABLE_COLUMN_SPECIFICATION_H_ -#include <glib.h> #include <glib-object.h> #include <libxml/tree.h> +/* Standard GObject macros */ +#define E_TYPE_TABLE_COLUMN_SPECIFICATION \ + (e_table_column_specification_get_type ()) +#define E_TABLE_COLUMN_SPECIFICATION(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST \ + ((obj), E_TYPE_TABLE_COLUMN_SPECIFICATION, ETableColumnSpecification)) +#define E_TABLE_COLUMN_SPECIFICATION_CLASS(cls) \ + (G_TYPE_CHECK_CLASS_CAST \ + ((cls), E_TYPE_TABLE_COLUMN_SPECIFICATION, ETableColumnSpecificationClass)) +#define E_IS_TABLE_COLUMN_SPECIFICATION(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE \ + ((obj), E_TYPE_TABLE_COLUMN_SPECIFICATION)) +#define E_IS_TABLE_COLUMN_SPECIFICATION_CLASS(cls) \ + (G_TYPE_CHECK_CLASS_TYPE \ + ((cls), E_TYPE_TABLE_COLUMN_SPECIFICATION)) +#define E_TABLE_COLUMN_SPECIFICATION_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS \ + ((obj), E_TYPE_TABLE_COLUMN_SPECIFICATION, ETableColumnSpecificationClass)) + G_BEGIN_DECLS -#define E_TABLE_COLUMN_SPECIFICATION_TYPE (e_table_column_specification_get_type ()) -#define E_TABLE_COLUMN_SPECIFICATION(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), E_TABLE_COLUMN_SPECIFICATION_TYPE, ETableColumnSpecification)) -#define E_TABLE_COLUMN_SPECIFICATION_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k), E_TABLE_COLUMN_SPECIFICATION_TYPE, ETableColumnSpecificationClass)) -#define E_IS_TABLE_COLUMN_SPECIFICATION(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), E_TABLE_COLUMN_SPECIFICATION_TYPE)) -#define E_IS_TABLE_COLUMN_SPECIFICATION_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), E_TABLE_COLUMN_SPECIFICATION_TYPE)) -#define E_TABLE_COLUMN_SPECIFICATION_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS((o), E_TABLE_COLUMN_SPECIFICATION_TYPE, ETableColumnSpecificationClass)) +typedef struct _ETableColumnSpecification ETableColumnSpecification; +typedef struct _ETableColumnSpecificationClass ETableColumnSpecificationClass; + +struct _ETableColumnSpecification { + GObject parent; -typedef struct { - GObject base; gint model_col; gint compare_col; gchar *title; @@ -53,20 +68,21 @@ typedef struct { gchar *search; gchar *sortable; gint priority; -} ETableColumnSpecification; +}; -typedef struct { +struct _ETableColumnSpecificationClass { GObjectClass parent_class; -} ETableColumnSpecificationClass; - -GType e_table_column_specification_get_type (void); - -ETableColumnSpecification *e_table_column_specification_new (void); +}; -void e_table_column_specification_load_from_node (ETableColumnSpecification *state, - const xmlNode *node); -xmlNode *e_table_column_specification_save_to_node (ETableColumnSpecification *state, - xmlNode *parent); +GType e_table_column_specification_get_type (void) G_GNUC_CONST; +ETableColumnSpecification * + e_table_column_specification_new (void); +void e_table_column_specification_load_from_node + (ETableColumnSpecification *state, + const xmlNode *node); +xmlNode * e_table_column_specification_save_to_node + (ETableColumnSpecification *state, + xmlNode *parent); G_END_DECLS diff --git a/widgets/table/e-table-config.c b/widgets/table/e-table-config.c index cce43dc3c8..62db1d32b1 100644 --- a/widgets/table/e-table-config.c +++ b/widgets/table/e-table-config.c @@ -127,11 +127,11 @@ config_get_property (GObject *object, } static void -e_table_config_class_init (ETableConfigClass *klass) +e_table_config_class_init (ETableConfigClass *class) { - GObjectClass *object_class = G_OBJECT_CLASS (klass); + GObjectClass *object_class = G_OBJECT_CLASS (class); - klass->changed = NULL; + class->changed = NULL; object_class->finalize = config_finalize; object_class->get_property = config_get_property; @@ -149,7 +149,7 @@ e_table_config_class_init (ETableConfigClass *klass) g_param_spec_object ("state", "State", NULL, - E_TABLE_STATE_TYPE, + E_TYPE_TABLE_STATE, G_PARAM_READABLE)); } @@ -1383,7 +1383,7 @@ e_table_config_new (const gchar *header, ETableState *state, GtkWindow *parent_window) { - ETableConfig *config = g_object_new (E_TABLE_CONFIG_TYPE, NULL); + ETableConfig *config = g_object_new (E_TYPE_TABLE_CONFIG, NULL); GtkDialog *dialog; GtkWidget *widget; diff --git a/widgets/table/e-table-config.h b/widgets/table/e-table-config.h index 4f690c97cc..083160772f 100644 --- a/widgets/table/e-table-config.h +++ b/widgets/table/e-table-config.h @@ -31,16 +31,33 @@ #include <table/e-table.h> #include <gtk/gtk.h> +/* Standard GObject macros */ +#define E_TYPE_TABLE_CONFIG \ + (e_table_config_get_type ()) +#define E_TABLE_CONFIG(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST \ + ((obj), E_TYPE_TABLE_CONFIG, ETableConfig)) +#define E_TABLE_CONFIG_CLASS(cls) \ + (G_TYPE_CHECK_CLASS_CAST \ + ((cls), E_TYPE_TABLE_CONFIG, ETableConfigClass)) +#define E_IS_TABLE_CONFIG(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE \ + ((obj), E_TYPE_TABLE_CONFIG)) +#define E_IS_TABLE_CONFIG_CLASS(cls) \ + (G_TYPE_CHECK_CLASS_TYPE \ + ((cls), E_TYPE_TABLE_CONFIG)) +#define E_TABLE_CONFIG_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS \ + ((obj), E_TYPE_TABLE_CONFIG, ETableConfigClass)) + G_BEGIN_DECLS -#define E_TABLE_CONFIG_TYPE (e_table_config_get_type ()) -#define E_TABLE_CONFIG(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), E_TABLE_CONFIG_TYPE, ETableConfig)) -#define E_TABLE_CONFIG_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k), E_TABLE_CONFIG_TYPE, ETableConfigClass)) -#define E_IS_TABLE_CONFIG(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), E_TABLE_CONFIG_TYPE)) -#define E_IS_TABLE_CONFIG_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), E_TABLE_CONFIG_TYPE)) -#define E_TABLE_CONFIG_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS((o), E_TABLE_CONFIG_TYPE, ETableConfigClass)) +typedef struct _ETableConfigSortWidgets ETableConfigSortWidgets; + +typedef struct _ETableConfig ETableConfig; +typedef struct _ETableConfigClass ETableConfigClass; -typedef struct { +struct _ETableConfigSortWidgets { GtkWidget *combo; GtkWidget *frames; GtkWidget *radio_ascending; @@ -48,9 +65,9 @@ typedef struct { GtkWidget *view_check; /* Only for group dialog */ guint changed_id, toggled_id; gpointer e_table_config; -} ETableConfigSortWidgets; +}; -typedef struct { +struct _ETableConfig { GObject parent; gchar *header; @@ -86,26 +103,26 @@ typedef struct { * List of valid column names */ GSList *column_names; -} ETableConfig; +}; -typedef struct { +struct _ETableConfigClass { GObjectClass parent_class; /* Signals */ - void (*changed) (ETableConfig *config); -} ETableConfigClass; - -GType e_table_config_get_type (void); -ETableConfig *e_table_config_new (const gchar *header, - ETableSpecification *spec, - ETableState *state, - GtkWindow *parent_window); -ETableConfig *e_table_config_construct (ETableConfig *etco, - const gchar *header, - ETableSpecification *spec, - ETableState *state, - GtkWindow *parent_window); -void e_table_config_raise (ETableConfig *config); + void (*changed) (ETableConfig *config); +}; + +GType e_table_config_get_type (void) G_GNUC_CONST; +ETableConfig * e_table_config_new (const gchar *header, + ETableSpecification *spec, + ETableState *state, + GtkWindow *parent_window); +ETableConfig *e_table_config_construct (ETableConfig *etco, + const gchar *header, + ETableSpecification *spec, + ETableState *state, + GtkWindow *parent_window); +void e_table_config_raise (ETableConfig *config); G_END_DECLS diff --git a/widgets/table/e-table-extras.h b/widgets/table/e-table-extras.h index 55af6a14d0..6b1ed4200f 100644 --- a/widgets/table/e-table-extras.h +++ b/widgets/table/e-table-extras.h @@ -27,6 +27,7 @@ #include <table/e-cell.h> #include <gdk-pixbuf/gdk-pixbuf.h> +/* Standard GObject macros */ #define E_TYPE_TABLE_EXTRAS \ (e_table_extras_get_type ()) #define E_TABLE_EXTRAS(obj) \ @@ -60,7 +61,7 @@ struct _ETableExtrasClass { GObjectClass parent_class; }; -GType e_table_extras_get_type (void); +GType e_table_extras_get_type (void) G_GNUC_CONST; ETableExtras * e_table_extras_new (void); void e_table_extras_add_cell (ETableExtras *extras, const gchar *id, diff --git a/widgets/table/e-table-field-chooser-dialog.c b/widgets/table/e-table-field-chooser-dialog.c index a4e96ec99c..9c24a64496 100644 --- a/widgets/table/e-table-field-chooser-dialog.c +++ b/widgets/table/e-table-field-chooser-dialog.c @@ -46,13 +46,13 @@ enum { G_DEFINE_TYPE (ETableFieldChooserDialog, e_table_field_chooser_dialog, GTK_TYPE_DIALOG) static void -e_table_field_chooser_dialog_class_init (ETableFieldChooserDialogClass *klass) +e_table_field_chooser_dialog_class_init (ETableFieldChooserDialogClass *class) { GObjectClass *object_class; GtkDialogClass *dialog_class; - object_class = (GObjectClass*) klass; - dialog_class = GTK_DIALOG_CLASS (klass); + object_class = (GObjectClass*) class; + dialog_class = GTK_DIALOG_CLASS (class); object_class->dispose = e_table_field_chooser_dialog_dispose; object_class->set_property = e_table_field_chooser_dialog_set_property; @@ -71,14 +71,14 @@ e_table_field_chooser_dialog_class_init (ETableFieldChooserDialogClass *klass) g_param_spec_object ("full_header", "Full Header", NULL, - E_TABLE_HEADER_TYPE, + E_TYPE_TABLE_HEADER, G_PARAM_READWRITE)); g_object_class_install_property (object_class, PROP_HEADER, g_param_spec_object ("header", "Header", NULL, - E_TABLE_HEADER_TYPE, + E_TYPE_TABLE_HEADER, G_PARAM_READWRITE)); } @@ -120,8 +120,7 @@ e_table_field_chooser_dialog_init (ETableFieldChooserDialog *e_table_field_choos GtkWidget* e_table_field_chooser_dialog_new (void) { - GtkWidget *widget = g_object_new (E_TABLE_FIELD_CHOOSER_DIALOG_TYPE, NULL); - return widget; + return g_object_new (E_TYPE_TABLE_FIELD_CHOOSER_DIALOG, NULL); } static void diff --git a/widgets/table/e-table-field-chooser-dialog.h b/widgets/table/e-table-field-chooser-dialog.h index 01129ffa09..bd378bc89d 100644 --- a/widgets/table/e-table-field-chooser-dialog.h +++ b/widgets/table/e-table-field-chooser-dialog.h @@ -27,27 +27,30 @@ #include <table/e-table-field-chooser.h> #include <table/e-table-header.h> -G_BEGIN_DECLS - -/* ETableFieldChooserDialog - A dialog displaying information about a contact. - * - * The following arguments are available: - * - * name type read/write description - * -------------------------------------------------------------------------------- - */ +#define E_TYPE_TABLE_FIELD_CHOOSER_DIALOG \ + (e_table_field_chooser_dialog_get_type ()) +#define E_TABLE_FIELD_CHOOSER_DIALOG(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST \ + ((obj), E_TYPE_TABLE_FIELD_CHOOSER_DIALOG, ETableFieldChooserDialog)) +#define E_TABLE_FIELD_CHOOSER_DIALOG_CLASS(cls) \ + (G_TYPE_CHECK_CLASS_CAST \ + ((cls), E_TYPE_TABLE_FIELD_CHOOSER_DIALOG, ETableFieldChooserDialogClass)) +#define E_IS_TABLE_FIELD_CHOOSER_DIALOG(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE \ + ((obj), E_TYPE_TABLE_FIELD_CHOOSER_DIALOG)) +#define E_IS_TABLE_FIELD_CHOOSER_DIALOG_CLASS(cls) \ + (G_TYPE_CHECK_CLASS_TYPE \ + ((cls), E_TYPE_TABLE_FIELD_CHOOSER_DIALOG)) +#define E_TABLE_FIELD_CHOOSER_DIALOG_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS \ + ((obj), E_TYPE_TABLE_FIELD_CHOOSER_DIALOG, ETableFieldChooserDialogClass)) -#define E_TABLE_FIELD_CHOOSER_DIALOG_TYPE (e_table_field_chooser_dialog_get_type ()) -#define E_TABLE_FIELD_CHOOSER_DIALOG(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), E_TABLE_FIELD_CHOOSER_DIALOG_TYPE, ETableFieldChooserDialog)) -#define E_TABLE_FIELD_CHOOSER_DIALOG_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), E_TABLE_FIELD_CHOOSER_DIALOG_TYPE, ETableFieldChooserDialogClass)) -#define E_IS_TABLE_FIELD_CHOOSER_DIALOG(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), E_TABLE_FIELD_CHOOSER_DIALOG_TYPE)) -#define E_IS_TABLE_FIELD_CHOOSER_DIALOG_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((obj), E_TABLE_FIELD_CHOOSER_DIALOG_TYPE)) +G_BEGIN_DECLS -typedef struct _ETableFieldChooserDialog ETableFieldChooserDialog; -typedef struct _ETableFieldChooserDialogClass ETableFieldChooserDialogClass; +typedef struct _ETableFieldChooserDialog ETableFieldChooserDialog; +typedef struct _ETableFieldChooserDialogClass ETableFieldChooserDialogClass; -struct _ETableFieldChooserDialog -{ +struct _ETableFieldChooserDialog { GtkDialog parent; /* item specific fields */ @@ -57,13 +60,12 @@ struct _ETableFieldChooserDialog ETableHeader *header; }; -struct _ETableFieldChooserDialogClass -{ +struct _ETableFieldChooserDialogClass { GtkDialogClass parent_class; }; -GtkWidget *e_table_field_chooser_dialog_new (void); -GType e_table_field_chooser_dialog_get_type (void); +GType e_table_field_chooser_dialog_get_type (void) G_GNUC_CONST; +GtkWidget * e_table_field_chooser_dialog_new (void); G_END_DECLS diff --git a/widgets/table/e-table-field-chooser-item.c b/widgets/table/e-table-field-chooser-item.c index 880731e5be..7a87db4302 100644 --- a/widgets/table/e-table-field-chooser-item.c +++ b/widgets/table/e-table-field-chooser-item.c @@ -639,10 +639,10 @@ etfci_event (GnomeCanvasItem *item, GdkEvent *e) } static void -etfci_class_init (ETableFieldChooserItemClass *klass) +etfci_class_init (ETableFieldChooserItemClass *class) { - GnomeCanvasItemClass *item_class = GNOME_CANVAS_ITEM_CLASS (klass); - GObjectClass *object_class = G_OBJECT_CLASS (klass); + GnomeCanvasItemClass *item_class = GNOME_CANVAS_ITEM_CLASS (class); + GObjectClass *object_class = G_OBJECT_CLASS (class); object_class->dispose = etfci_dispose; object_class->set_property = etfci_set_property; @@ -666,14 +666,14 @@ etfci_class_init (ETableFieldChooserItemClass *klass) g_param_spec_object ("full_header", "Full Header", NULL, - E_TABLE_HEADER_TYPE, + E_TYPE_TABLE_HEADER, G_PARAM_READWRITE)); g_object_class_install_property (object_class, PROP_HEADER, g_param_spec_object ("header", "Header", NULL, - E_TABLE_HEADER_TYPE, + E_TYPE_TABLE_HEADER, G_PARAM_READWRITE)); g_object_class_install_property (object_class, PROP_WIDTH, diff --git a/widgets/table/e-table-field-chooser-item.h b/widgets/table/e-table-field-chooser-item.h index 5e38ba7037..066dd52ffb 100644 --- a/widgets/table/e-table-field-chooser-item.h +++ b/widgets/table/e-table-field-chooser-item.h @@ -28,16 +28,33 @@ #include <libxml/tree.h> #include <table/e-table-header.h> +/* Standard GObject macros */ +#define E_TYPE_TABLE_FIELD_CHOOSER_ITEM \ + (e_table_field_chooser_item_get_type ()) +#define E_TABLE_FIELD_CHOOSER_ITEM(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST \ + ((obj), E_TYPE_TABLE_FIELD_CHOOSER_ITEM, ETableFieldChooserItem)) +#define E_TABLE_FIELD_CHOOSER_ITEM_CLASS(cls) \ + (G_TYPE_CHECK_CLASS_CAST \ + ((cls), E_TYPE_TABLE_FIELD_CHOOSER_ITEM, ETableFieldChooserItemClass)) +#define E_IS_TABLE_FIELD_CHOOSER_ITEM(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE \ + ((obj), E_TYPE_TABLE_FIELD_CHOOSER_ITEM)) +#define E_IS_TABLE_FIELD_CHOOSER_ITEM_CLASS(cls) \ + (G_TYPE_CHECK_CLASS_TYPE \ + ((cls), E_TYPE_TABLE_FIELD_CHOOSER_ITEM)) +#define E_TABLE_FIELD_CHOOSER_ITEM_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS \ + ((obj), E_TYPE_TABLE_FIELD_CHOOSER_ITEM, ETableFieldChooserItemClass)) + G_BEGIN_DECLS -#define E_TABLE_FIELD_CHOOSER_ITEM_TYPE (e_table_field_chooser_item_get_type ()) -#define E_TABLE_FIELD_CHOOSER_ITEM(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), E_TABLE_FIELD_CHOOSER_ITEM_TYPE, ETableFieldChooserItem)) -#define E_TABLE_FIELD_CHOOSER_ITEM_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k), E_TABLE_FIELD_CHOOSER_ITEM_TYPE, ETableFieldChooserItemClass)) -#define E_IS_TABLE_FIELD_CHOOSER_ITEM(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), E_TABLE_FIELD_CHOOSER_ITEM_TYPE)) -#define E_IS_TABLE_FIELD_CHOOSER_ITEM_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), E_TABLE_FIELD_CHOOSER_ITEM_TYPE)) +typedef struct _ETableFieldChooserItem ETableFieldChooserItem; +typedef struct _ETableFieldChooserItemClass ETableFieldChooserItemClass; -typedef struct { +struct _ETableFieldChooserItem { GnomeCanvasItem parent; + ETableHeader *full_header; ETableHeader *header; ETableHeader *combined_header; @@ -62,13 +79,13 @@ typedef struct { gint drag_col; guint drag_data_get_id; guint drag_end_id; -} ETableFieldChooserItem; +}; -typedef struct { +struct _ETableFieldChooserItemClass { GnomeCanvasItemClass parent_class; -} ETableFieldChooserItemClass; +}; -GType e_table_field_chooser_item_get_type (void); +GType e_table_field_chooser_item_get_type (void) G_GNUC_CONST; G_END_DECLS diff --git a/widgets/table/e-table-field-chooser.c b/widgets/table/e-table-field-chooser.c index 374507e1ee..557785df0c 100644 --- a/widgets/table/e-table-field-chooser.c +++ b/widgets/table/e-table-field-chooser.c @@ -52,11 +52,11 @@ enum { G_DEFINE_TYPE (ETableFieldChooser, e_table_field_chooser, GTK_TYPE_VBOX) static void -e_table_field_chooser_class_init (ETableFieldChooserClass *klass) +e_table_field_chooser_class_init (ETableFieldChooserClass *class) { GObjectClass *object_class; - object_class = (GObjectClass*) klass; + object_class = (GObjectClass*) class; object_class->set_property = e_table_field_chooser_set_property; object_class->get_property = e_table_field_chooser_get_property; @@ -73,14 +73,14 @@ e_table_field_chooser_class_init (ETableFieldChooserClass *klass) g_param_spec_object ("full_header", "Full Header", NULL, - E_TABLE_HEADER_TYPE, + E_TYPE_TABLE_HEADER, G_PARAM_READWRITE)); g_object_class_install_property (object_class, PROP_HEADER, g_param_spec_object ("header", "Header", NULL, - E_TABLE_HEADER_TYPE, + E_TYPE_TABLE_HEADER, G_PARAM_READWRITE)); } @@ -242,8 +242,7 @@ e_table_field_chooser_dispose (GObject *object) GtkWidget* e_table_field_chooser_new (void) { - GtkWidget *widget = GTK_WIDGET (g_object_new (E_TABLE_FIELD_CHOOSER_TYPE, NULL)); - return widget; + return g_object_new (E_TYPE_TABLE_FIELD_CHOOSER, NULL); } static void diff --git a/widgets/table/e-table-field-chooser.h b/widgets/table/e-table-field-chooser.h index 01cbc39c64..743bf9eabe 100644 --- a/widgets/table/e-table-field-chooser.h +++ b/widgets/table/e-table-field-chooser.h @@ -28,27 +28,31 @@ #include <table/e-table-header.h> #include <libgnomecanvas/libgnomecanvas.h> -G_BEGIN_DECLS - -/* ETableFieldChooser - A dialog displaying information about a contact. - * - * The following arguments are available: - * - * name type read/write description - * -------------------------------------------------------------------------------- - */ +/* Standard GObject macros */ +#define E_TYPE_TABLE_FIELD_CHOOSER \ + (e_table_field_chooser_get_type ()) +#define E_TABLE_FIELD_CHOOSER(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST \ + ((obj), E_TYPE_TABLE_FIELD_CHOOSER, ETableFieldChooser)) +#define E_TABLE_FIELD_CHOOSER_CLASS(cls) \ + (G_TYPE_CHECK_CLASS_CAST \ + ((cls), E_TYPE_TABLE_FIELD_CHOOSER, ETableFieldChooserClass)) +#define E_IS_TABLE_FIELD_CHOOSER(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE \ + ((obj), E_TYPE_TABLE_FIELD_CHOOSER)) +#define E_IS_TABLE_FIELD_CHOOSER_CLASS(cls) \ + (G_TYPE_CHECK_CLASS_TYPE \ + ((cls), E_TYPE_TABLE_FIELD_CHOOSER)) +#define E_TABLE_FIELD_CHOOSER_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS \ + ((obj), E_TYPE_TABLE_FIELD_CHOOSER, ETableFieldChooserClass)) -#define E_TABLE_FIELD_CHOOSER_TYPE (e_table_field_chooser_get_type ()) -#define E_TABLE_FIELD_CHOOSER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), E_TABLE_FIELD_CHOOSER_TYPE, ETableFieldChooser)) -#define E_TABLE_FIELD_CHOOSER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), E_TABLE_FIELD_CHOOSER_TYPE, ETableFieldChooserClass)) -#define E_IS_TABLE_FIELD_CHOOSER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), E_TABLE_FIELD_CHOOSER_TYPE)) -#define E_IS_TABLE_FIELD_CHOOSER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((obj), E_TABLE_FIELD_CHOOSER_TYPE)) +G_BEGIN_DECLS -typedef struct _ETableFieldChooser ETableFieldChooser; -typedef struct _ETableFieldChooserClass ETableFieldChooserClass; +typedef struct _ETableFieldChooser ETableFieldChooser; +typedef struct _ETableFieldChooserClass ETableFieldChooserClass; -struct _ETableFieldChooser -{ +struct _ETableFieldChooser { GtkVBox parent; /* item specific fields */ @@ -63,13 +67,12 @@ struct _ETableFieldChooser ETableHeader *header; }; -struct _ETableFieldChooserClass -{ +struct _ETableFieldChooserClass { GtkVBoxClass parent_class; }; -GtkWidget *e_table_field_chooser_new (void); -GType e_table_field_chooser_get_type (void); +GType e_table_field_chooser_get_type (void) G_GNUC_CONST; +GtkWidget * e_table_field_chooser_new (void); G_END_DECLS diff --git a/widgets/table/e-table-group-container.c b/widgets/table/e-table-group-container.c index 12788ad6c4..6e8bbf4e61 100644 --- a/widgets/table/e-table-group-container.c +++ b/widgets/table/e-table-group-container.c @@ -46,7 +46,7 @@ /* workaround for avoiding API breakage */ #define etgc_get_type e_table_group_container_get_type -G_DEFINE_TYPE (ETableGroupContainer, etgc, E_TABLE_GROUP_TYPE) +G_DEFINE_TYPE (ETableGroupContainer, etgc, E_TYPE_TABLE_GROUP) /* The arguments we take */ enum { @@ -195,7 +195,7 @@ e_table_group_container_new (GnomeCanvasGroup *parent, ETableHeader *full_header g_return_val_if_fail (parent != NULL, NULL); - etgc = g_object_new (E_TABLE_GROUP_CONTAINER_TYPE, NULL); + etgc = g_object_new (E_TYPE_TABLE_GROUP_CONTAINER, NULL); e_table_group_container_construct (parent, etgc, full_header, header, model, sort_info, n); @@ -916,11 +916,11 @@ etgc_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *ps } static void -etgc_class_init (ETableGroupContainerClass *klass) +etgc_class_init (ETableGroupContainerClass *class) { - GnomeCanvasItemClass *item_class = GNOME_CANVAS_ITEM_CLASS (klass); - GObjectClass *object_class = G_OBJECT_CLASS (klass); - ETableGroupClass *e_group_class = E_TABLE_GROUP_CLASS (klass); + GnomeCanvasItemClass *item_class = GNOME_CANVAS_ITEM_CLASS (class); + GObjectClass *object_class = G_OBJECT_CLASS (class); + ETableGroupClass *e_group_class = E_TABLE_GROUP_CLASS (class); object_class->dispose = etgc_dispose; object_class->set_property = etgc_set_property; diff --git a/widgets/table/e-table-group-container.h b/widgets/table/e-table-group-container.h index b0d819be2b..5ea0910ef0 100644 --- a/widgets/table/e-table-group-container.h +++ b/widgets/table/e-table-group-container.h @@ -30,15 +30,33 @@ #include <table/e-table-group.h> #include <table/e-table-item.h> +/* Standard GObject macros */ +#define E_TYPE_TABLE_GROUP_CONTAINER \ + (e_table_group_container_get_type ()) +#define E_TABLE_GROUP_CONTAINER(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST \ + ((obj), E_TYPE_TABLE_GROUP_CONTAINER, ETableGroupContainer)) +#define E_TABLE_GROUP_CONTAINER_CLASS(cls) \ + (G_TYPE_CHECK_CLASS_CAST \ + ((cls), E_TYPE_TABLE_GROUP_CONTAINER, ETableGroupContainerClass)) +#define E_IS_TABLE_GROUP_CONTAINER(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE \ + ((obj), E_TYPE_TABLE_GROUP_CONTAINER)) +#define E_IS_TABLE_GROUP_CONTAINER_CLASS(cls) \ + (G_TYPE_CHECK_CLASS_TYPE \ + ((cls), E_TYPE_TABLE_GROUP_CONTAINER)) +#define E_TABLE_GROUP_CONTAINER_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS \ + ((obj), E_TYPE_TABLE_GROUP_CONTAINER, ETableGroupContainerClass)) + G_BEGIN_DECLS -#define E_TABLE_GROUP_CONTAINER_TYPE (e_table_group_container_get_type ()) -#define E_TABLE_GROUP_CONTAINER(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), E_TABLE_GROUP_CONTAINER_TYPE, ETableGroupContainer)) -#define E_TABLE_GROUP_CONTAINER_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k), E_TABLE_GROUP_CONTAINER_TYPE, ETableGroupContainerClass)) -#define E_IS_TABLE_GROUP_CONTAINER(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), E_TABLE_GROUP_CONTAINER_TYPE)) -#define E_IS_TABLE_GROUP_CONTAINER_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), E_TABLE_GROUP_CONTAINER_TYPE)) +typedef struct _ETableGroupContainer ETableGroupContainer; +typedef struct _ETableGroupContainerClass ETableGroupContainerClass; + +typedef struct _ETableGroupContainerChildNode ETableGroupContainerChildNode; -typedef struct { +struct _ETableGroupContainer { ETableGroup group; /* @@ -78,29 +96,37 @@ typedef struct { * State: the ETableGroup is open or closed */ guint open:1; -} ETableGroupContainer; +}; -typedef struct { +struct _ETableGroupContainerClass { ETableGroupClass parent_class; -} ETableGroupContainerClass; - -typedef struct { - ETableGroup *child; - gpointer key; - gchar *string; - GnomeCanvasItem *text; - GnomeCanvasItem *rect; - gint count; -} ETableGroupContainerChildNode; - -ETableGroup *e_table_group_container_new (GnomeCanvasGroup *parent, ETableHeader *full_header, ETableHeader *header, - ETableModel *model, ETableSortInfo *sort_info, gint n); -void e_table_group_container_construct (GnomeCanvasGroup *parent, ETableGroupContainer *etgc, - ETableHeader *full_header, - ETableHeader *header, - ETableModel *model, ETableSortInfo *sort_info, gint n); - -GType e_table_group_container_get_type (void); +}; + +struct _ETableGroupContainerChildNode { + ETableGroup *child; + gpointer key; + gchar *string; + GnomeCanvasItem *text; + GnomeCanvasItem *rect; + gint count; +}; + +GType e_table_group_container_get_type + (void) G_GNUC_CONST; +ETableGroup * e_table_group_container_new (GnomeCanvasGroup *parent, + ETableHeader *full_header, + ETableHeader *header, + ETableModel *model, + ETableSortInfo *sort_info, + gint n); +void e_table_group_container_construct + (GnomeCanvasGroup *parent, + ETableGroupContainer *etgc, + ETableHeader *full_header, + ETableHeader *header, + ETableModel *model, + ETableSortInfo *sort_info, + gint n); G_END_DECLS diff --git a/widgets/table/e-table-group-leaf.c b/widgets/table/e-table-group-leaf.c index a874e44601..2f287c2abf 100644 --- a/widgets/table/e-table-group-leaf.c +++ b/widgets/table/e-table-group-leaf.c @@ -37,7 +37,7 @@ /* workaround for avoiding APi breakage */ #define etgl_get_type e_table_group_leaf_get_type -G_DEFINE_TYPE (ETableGroupLeaf, etgl, E_TABLE_GROUP_TYPE) +G_DEFINE_TYPE (ETableGroupLeaf, etgl, E_TYPE_TABLE_GROUP) /* The arguments we take */ enum { @@ -158,7 +158,7 @@ e_table_group_leaf_new (GnomeCanvasGroup *parent, g_return_val_if_fail (parent != NULL, NULL); - etgl = g_object_new (E_TABLE_GROUP_LEAF_TYPE, NULL); + etgl = g_object_new (E_TYPE_TABLE_GROUP_LEAF, NULL); e_table_group_leaf_construct (parent, etgl, full_header, header, model, sort_info); @@ -584,11 +584,11 @@ etgl_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *ps } static void -etgl_class_init (ETableGroupLeafClass *klass) +etgl_class_init (ETableGroupLeafClass *class) { - GnomeCanvasItemClass *item_class = GNOME_CANVAS_ITEM_CLASS (klass); - ETableGroupClass *e_group_class = E_TABLE_GROUP_CLASS (klass); - GObjectClass *object_class = G_OBJECT_CLASS (klass); + GnomeCanvasItemClass *item_class = GNOME_CANVAS_ITEM_CLASS (class); + ETableGroupClass *e_group_class = E_TABLE_GROUP_CLASS (class); + GObjectClass *object_class = G_OBJECT_CLASS (class); object_class->dispose = etgl_dispose; object_class->set_property = etgl_set_property; diff --git a/widgets/table/e-table-group-leaf.h b/widgets/table/e-table-group-leaf.h index 55efc2d655..beed62e7d1 100644 --- a/widgets/table/e-table-group-leaf.h +++ b/widgets/table/e-table-group-leaf.h @@ -29,15 +29,31 @@ #include <table/e-table-subset.h> #include <table/e-table-item.h> +/* Standard GObject macros */ +#define E_TYPE_TABLE_GROUP_LEAF \ + (e_table_group_leaf_get_type ()) +#define E_TABLE_GROUP_LEAF(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST \ + ((obj), E_TYPE_TABLE_GROUP_LEAF, ETableGroupLeaf)) +#define E_TABLE_GROUP_LEAF_CLASS(cls) \ + (G_TYPE_CHECK_CLASS_CAST \ + ((cls), E_TYPE_TABLE_GROUP_LEAF, ETableGroupLeafClass)) +#define E_IS_TABLE_GROUP_LEAF(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE \ + ((obj), E_TYPE_TABLE_GROUP_LEAF)) +#define E_IS_TABLE_GROUP_LEAF_CLASS(cls) \ + (G_TYPE_CHECK_CLASS_TYPE \ + ((cls), E_TYPE_TABLE_GROUP_LEAF)) +#define E_TABLE_GROUP_LEAF_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS \ + ((obj), E_TYPE_TABLE_GROUP_LEAF, ETableGroupLeafClass)) + G_BEGIN_DECLS -#define E_TABLE_GROUP_LEAF_TYPE (e_table_group_leaf_get_type ()) -#define E_TABLE_GROUP_LEAF(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), E_TABLE_GROUP_LEAF_TYPE, ETableGroupLeaf)) -#define E_TABLE_GROUP_LEAF_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k), E_TABLE_GROUP_LEAF_TYPE, ETableGroupLeafClass)) -#define E_IS_TABLE_GROUP_LEAF(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), E_TABLE_GROUP_LEAF_TYPE)) -#define E_IS_TABLE_GROUP_LEAF_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), E_TABLE_GROUP_LEAF_TYPE)) +typedef struct _ETableGroupLeaf ETableGroupLeaf; +typedef struct _ETableGroupLeafClass ETableGroupLeafClass; -typedef struct { +struct _ETableGroupLeaf { ETableGroup group; /* @@ -70,18 +86,18 @@ typedef struct { gint etgl_start_drag_id; ESelectionModel *selection_model; -} ETableGroupLeaf; +}; -typedef struct { +struct _ETableGroupLeafClass { ETableGroupClass parent_class; -} ETableGroupLeafClass; - -ETableGroup *e_table_group_leaf_new (GnomeCanvasGroup *parent, - ETableHeader *full_header, - ETableHeader *header, - ETableModel *model, - ETableSortInfo *sort_info); -GType e_table_group_leaf_get_type (void); +}; + +GType e_table_group_leaf_get_type (void) G_GNUC_CONST; +ETableGroup * e_table_group_leaf_new (GnomeCanvasGroup *parent, + ETableHeader *full_header, + ETableHeader *header, + ETableModel *model, + ETableSortInfo *sort_info); G_END_DECLS diff --git a/widgets/table/e-table-group.c b/widgets/table/e-table-group.c index c69b23d4d5..2b6f3e971a 100644 --- a/widgets/table/e-table-group.c +++ b/widgets/table/e-table-group.c @@ -642,36 +642,36 @@ etg_get_focus (ETableGroup *etg) } static void -etg_class_init (ETableGroupClass *klass) +etg_class_init (ETableGroupClass *class) { - GnomeCanvasItemClass *item_class = GNOME_CANVAS_ITEM_CLASS (klass); - GObjectClass *object_class = G_OBJECT_CLASS (klass); + GnomeCanvasItemClass *item_class = GNOME_CANVAS_ITEM_CLASS (class); + GObjectClass *object_class = G_OBJECT_CLASS (class); object_class->dispose = etg_dispose; item_class->event = etg_event; - klass->cursor_change = NULL; - klass->cursor_activated = NULL; - klass->double_click = NULL; - klass->right_click = NULL; - klass->click = NULL; - klass->key_press = NULL; - klass->start_drag = NULL; - - klass->add = NULL; - klass->add_array = NULL; - klass->add_all = NULL; - klass->remove = NULL; - klass->row_count = NULL; - klass->increment = NULL; - klass->decrement = NULL; - klass->set_focus = NULL; - klass->get_focus = etg_get_focus; - klass->get_printable = NULL; - klass->compute_location = NULL; - klass->get_mouse_over = NULL; - klass->get_cell_geometry = NULL; + class->cursor_change = NULL; + class->cursor_activated = NULL; + class->double_click = NULL; + class->right_click = NULL; + class->click = NULL; + class->key_press = NULL; + class->start_drag = NULL; + + class->add = NULL; + class->add_array = NULL; + class->add_all = NULL; + class->remove = NULL; + class->row_count = NULL; + class->increment = NULL; + class->decrement = NULL; + class->set_focus = NULL; + class->get_focus = etg_get_focus; + class->get_printable = NULL; + class->compute_location = NULL; + class->get_mouse_over = NULL; + class->get_cell_geometry = NULL; etg_signals[CURSOR_CHANGE] = g_signal_new ("cursor_change", diff --git a/widgets/table/e-table-group.h b/widgets/table/e-table-group.h index 157c70756a..5731dfdeaf 100644 --- a/widgets/table/e-table-group.h +++ b/widgets/table/e-table-group.h @@ -7,7 +7,7 @@ * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public @@ -32,15 +32,31 @@ #include <e-util/e-util.h> #include <misc/e-printable.h> +/* Standard GObject macros */ +#define E_TYPE_TABLE_GROUP \ + (e_table_group_get_type ()) +#define E_TABLE_GROUP(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST \ + ((obj), E_TYPE_TABLE_GROUP, ETableGroup)) +#define E_TABLE_GROUP_CLASS(cls) \ + (G_TYPE_CHECK_CLASS_CAST \ + ((cls), E_TYPE_TABLE_GROUP, ETableGroupClass)) +#define E_IS_TABLE_GROUP(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE \ + ((obj), E_TYPE_TABLE_GROUP)) +#define E_IS_TABLE_GROUP_CLASS(cls) \ + (G_TYPE_CHECK_CLASS_TYPE \ + ((cls), E_TYPE_TABLE_GROUP)) +#define E_TABLE_GROUP_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS \ + ((obj), E_TYPE_TABLE_GROUP, ETableGroupClass)) + G_BEGIN_DECLS -#define E_TABLE_GROUP_TYPE (e_table_group_get_type ()) -#define E_TABLE_GROUP(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), E_TABLE_GROUP_TYPE, ETableGroup)) -#define E_TABLE_GROUP_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k), E_TABLE_GROUP_TYPE, ETableGroupClass)) -#define E_IS_TABLE_GROUP(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), E_TABLE_GROUP_TYPE)) -#define E_IS_TABLE_GROUP_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), E_TABLE_GROUP_TYPE)) +typedef struct _ETableGroup ETableGroup; +typedef struct _ETableGroupClass ETableGroupClass; -typedef struct { +struct _ETableGroup { GnomeCanvasGroup group; /* @@ -63,119 +79,158 @@ typedef struct { guint has_focus : 1; guint frozen : 1; -} ETableGroup; +}; -typedef struct { +struct _ETableGroupClass { GnomeCanvasGroupClass parent_class; /* Signals */ - void (*cursor_change) (ETableGroup *etg, gint row); - void (*cursor_activated) (ETableGroup *etg, gint row); - void (*double_click) (ETableGroup *etg, gint row, gint col, GdkEvent *event); - gboolean (*right_click) (ETableGroup *etg, gint row, gint col, GdkEvent *event); - gboolean (*click) (ETableGroup *etg, gint row, gint col, GdkEvent *event); - gboolean (*key_press) (ETableGroup *etg, gint row, gint col, GdkEvent *event); - gint (*start_drag) (ETableGroup *etg, gint row, gint col, GdkEvent *event); + void (*cursor_change) (ETableGroup *etg, + gint row); + void (*cursor_activated) (ETableGroup *etg, + gint row); + void (*double_click) (ETableGroup *etg, + gint row, + gint col, + GdkEvent *event); + gboolean (*right_click) (ETableGroup *etg, + gint row, + gint col, + GdkEvent *event); + gboolean (*click) (ETableGroup *etg, + gint row, + gint col, + GdkEvent *event); + gboolean (*key_press) (ETableGroup *etg, + gint row, + gint col, + GdkEvent *event); + gint (*start_drag) (ETableGroup *etg, + gint row, + gint col, + GdkEvent *event); /* Virtual functions. */ - void (*add) (ETableGroup *etg, gint row); - void (*add_array) (ETableGroup *etg, const gint *array, gint count); - void (*add_all) (ETableGroup *etg); - gboolean (*remove) (ETableGroup *etg, gint row); - gint (*row_count) (ETableGroup *etg); - void (*increment) (ETableGroup *etg, gint position, gint amount); - void (*decrement) (ETableGroup *etg, gint position, gint amount); - void (*set_focus) (ETableGroup *etg, EFocus direction, gint view_col); - gboolean (*get_focus) (ETableGroup *etg); - gint (*get_focus_column) (ETableGroup *etg); - EPrintable *(*get_printable) (ETableGroup *etg); - void (*compute_location) (ETableGroup *etg, gint *x, gint *y, gint *row, gint *col); - void (*get_mouse_over) (ETableGroup *etg, gint *row, gint *col); - void (*get_cell_geometry) (ETableGroup *etg, gint *row, gint *col, gint *x, gint *y, gint *width, gint *height); - -} ETableGroupClass; + void (*add) (ETableGroup *etg, + gint row); + void (*add_array) (ETableGroup *etg, + const gint *array, + gint count); + void (*add_all) (ETableGroup *etg); + gboolean (*remove) (ETableGroup *etg, + gint row); + gint (*row_count) (ETableGroup *etg); + void (*increment) (ETableGroup *etg, + gint position, + gint amount); + void (*decrement) (ETableGroup *etg, + gint position, + gint amount); + void (*set_focus) (ETableGroup *etg, + EFocus direction, + gint view_col); + gboolean (*get_focus) (ETableGroup *etg); + gint (*get_focus_column) (ETableGroup *etg); + EPrintable * (*get_printable) (ETableGroup *etg); + void (*compute_location) (ETableGroup *etg, + gint *x, + gint *y, + gint *row, + gint *col); + void (*get_mouse_over) (ETableGroup *etg, + gint *row, + gint *col); + void (*get_cell_geometry) (ETableGroup *etg, + gint *row, + gint *col, + gint *x, + gint *y, + gint *width, + gint *height); +}; + +GType e_table_group_get_type (void) G_GNUC_CONST; +ETableGroup * e_table_group_new (GnomeCanvasGroup *parent, + ETableHeader *full_header, + ETableHeader *header, + ETableModel *model, + ETableSortInfo *sort_info, + gint n); +void e_table_group_construct (GnomeCanvasGroup *parent, + ETableGroup *etg, + ETableHeader *full_header, + ETableHeader *header, + ETableModel *model); /* Virtual functions */ -void e_table_group_add (ETableGroup *etg, - gint row); -void e_table_group_add_array (ETableGroup *etg, - const gint *array, - gint count); -void e_table_group_add_all (ETableGroup *etg); -gboolean e_table_group_remove (ETableGroup *etg, - gint row); -void e_table_group_increment (ETableGroup *etg, - gint position, - gint amount); -void e_table_group_decrement (ETableGroup *etg, - gint position, - gint amount); -gint e_table_group_row_count (ETableGroup *etg); -void e_table_group_set_focus (ETableGroup *etg, - EFocus direction, - gint view_col); -gboolean e_table_group_get_focus (ETableGroup *etg); -gint e_table_group_get_focus_column (ETableGroup *etg); -ETableHeader *e_table_group_get_header (ETableGroup *etg); -EPrintable *e_table_group_get_printable (ETableGroup *etg); -void e_table_group_compute_location (ETableGroup *etg, - gint *x, - gint *y, - gint *row, - gint *col); -void e_table_group_get_mouse_over (ETableGroup *etg, - gint *row, - gint *col); -void e_table_group_get_cell_geometry (ETableGroup *etg, - gint *row, - gint *col, - gint *x, - gint *y, - gint *width, - gint *height); -ETableGroup *e_table_group_new (GnomeCanvasGroup *parent, - ETableHeader *full_header, - ETableHeader *header, - ETableModel *model, - ETableSortInfo *sort_info, - gint n); -void e_table_group_construct (GnomeCanvasGroup *parent, - ETableGroup *etg, - ETableHeader *full_header, - ETableHeader *header, - ETableModel *model); +void e_table_group_add (ETableGroup *etg, + gint row); +void e_table_group_add_array (ETableGroup *etg, + const gint *array, + gint count); +void e_table_group_add_all (ETableGroup *etg); +gboolean e_table_group_remove (ETableGroup *etg, + gint row); +void e_table_group_increment (ETableGroup *etg, + gint position, + gint amount); +void e_table_group_decrement (ETableGroup *etg, + gint position, + gint amount); +gint e_table_group_row_count (ETableGroup *etg); +void e_table_group_set_focus (ETableGroup *etg, + EFocus direction, + gint view_col); +gboolean e_table_group_get_focus (ETableGroup *etg); +gint e_table_group_get_focus_column (ETableGroup *etg); +ETableHeader * e_table_group_get_header (ETableGroup *etg); +EPrintable * e_table_group_get_printable (ETableGroup *etg); +void e_table_group_compute_location (ETableGroup *etg, + gint *x, + gint *y, + gint *row, + gint *col); +void e_table_group_get_mouse_over (ETableGroup *etg, + gint *row, + gint *col); +void e_table_group_get_cell_geometry (ETableGroup *etg, + gint *row, + gint *col, + gint *x, + gint *y, + gint *width, + gint *height); /* For emitting the signals */ -void e_table_group_cursor_change (ETableGroup *etg, - gint row); -void e_table_group_cursor_activated (ETableGroup *etg, - gint row); -void e_table_group_double_click (ETableGroup *etg, - gint row, - gint col, - GdkEvent *event); -gboolean e_table_group_right_click (ETableGroup *etg, - gint row, - gint col, - GdkEvent *event); -gboolean e_table_group_click (ETableGroup *etg, - gint row, - gint col, - GdkEvent *event); -gboolean e_table_group_key_press (ETableGroup *etg, - gint row, - gint col, - GdkEvent *event); -gint e_table_group_start_drag (ETableGroup *etg, - gint row, - gint col, - GdkEvent *event); -GType e_table_group_get_type (void); +void e_table_group_cursor_change (ETableGroup *etg, + gint row); +void e_table_group_cursor_activated (ETableGroup *etg, + gint row); +void e_table_group_double_click (ETableGroup *etg, + gint row, + gint col, + GdkEvent *event); +gboolean e_table_group_right_click (ETableGroup *etg, + gint row, + gint col, + GdkEvent *event); +gboolean e_table_group_click (ETableGroup *etg, + gint row, + gint col, + GdkEvent *event); +gboolean e_table_group_key_press (ETableGroup *etg, + gint row, + gint col, + GdkEvent *event); +gint e_table_group_start_drag (ETableGroup *etg, + gint row, + gint col, + GdkEvent *event); typedef void (*ETableGroupLeafFn) (gpointer e_table_item, gpointer closure); -void e_table_group_apply_to_leafs (ETableGroup *etg, - ETableGroupLeafFn fn, - void *closure); +void e_table_group_apply_to_leafs (ETableGroup *etg, + ETableGroupLeafFn fn, + gpointer closure); G_END_DECLS diff --git a/widgets/table/e-table-header-item.c b/widgets/table/e-table-header-item.c index 1c97826ef2..2e7b4704ec 100644 --- a/widgets/table/e-table-header-item.c +++ b/widgets/table/e-table-header-item.c @@ -1961,10 +1961,10 @@ ethi_event (GnomeCanvasItem *item, GdkEvent *e) } static void -ethi_class_init (ETableHeaderItemClass *klass) +ethi_class_init (ETableHeaderItemClass *class) { - GnomeCanvasItemClass *item_class = GNOME_CANVAS_ITEM_CLASS (klass); - GObjectClass *object_class = G_OBJECT_CLASS (klass); + GnomeCanvasItemClass *item_class = GNOME_CANVAS_ITEM_CLASS (class); + GObjectClass *object_class = G_OBJECT_CLASS (class); object_class->dispose = ethi_dispose; object_class->set_property = ethi_set_property; @@ -1995,35 +1995,35 @@ ethi_class_init (ETableHeaderItemClass *klass) g_param_spec_object ("full_header", "Full Header", NULL, - E_TABLE_HEADER_TYPE, + E_TYPE_TABLE_HEADER, G_PARAM_READWRITE)); g_object_class_install_property (object_class, PROP_TABLE_HEADER, g_param_spec_object ("ETableHeader", "Header", NULL, - E_TABLE_HEADER_TYPE, + E_TYPE_TABLE_HEADER, G_PARAM_WRITABLE)); g_object_class_install_property (object_class, PROP_SORT_INFO, g_param_spec_object ("sort_info", "Sort Info", NULL, - E_TABLE_SORT_INFO_TYPE, + E_TYPE_TABLE_SORT_INFO, G_PARAM_WRITABLE)); g_object_class_install_property (object_class, PROP_TABLE, g_param_spec_object ("table", "Table", NULL, - E_TABLE_TYPE, + E_TYPE_TABLE, G_PARAM_WRITABLE)); g_object_class_install_property (object_class, PROP_TREE, g_param_spec_object ("tree", "Tree", NULL, - E_TREE_TYPE, + E_TYPE_TREE, G_PARAM_WRITABLE)); ethi_signals[BUTTON_PRESSED] = diff --git a/widgets/table/e-table-header-item.h b/widgets/table/e-table-header-item.h index 49755dcff0..4ab483a4ce 100644 --- a/widgets/table/e-table-header-item.h +++ b/widgets/table/e-table-header-item.h @@ -31,15 +31,31 @@ #include <table/e-table-header.h> #include <table/e-table-sort-info.h> +/* Standard GObject macros */ +#define E_TYPE_TABLE_HEADER_ITEM \ + (e_table_header_item_get_type ()) +#define E_TABLE_HEADER_ITEM(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST \ + ((obj), E_TYPE_TABLE_HEADER_ITEM, ETableHeaderItem)) +#define E_TABLE_HEADER_ITEM_CLASS(cls) \ + (G_TYPE_CHECK_CLASS_CAST \ + ((cls), E_TYPE_TABLE_HEADER_ITEM, ETableHeaderItemClass)) +#define E_IS_TABLE_HEADER_ITEM(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE \ + ((obj), E_TYPE_TABLE_HEADER_ITEM)) +#define E_IS_TABLE_HEADER_ITEM_CLASS(cls) \ + (G_TYPE_CHECK_CLASS_TYPE \ + ((cls), E_TYPE_TABLE_HEADER_ITEM)) +#define E_TABLE_HEADER_ITEM_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS \ + ((obj), E_TYPE_TABLE_HEADER_ITEM, ETableHeaderItemClass)) + G_BEGIN_DECLS -#define E_TABLE_HEADER_ITEM_TYPE (e_table_header_item_get_type ()) -#define E_TABLE_HEADER_ITEM(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), E_TABLE_HEADER_ITEM_TYPE, ETableHeaderItem)) -#define E_TABLE_HEADER_ITEM_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k), E_TABLE_HEADER_ITEM_TYPE, ETableHeaderItemClass)) -#define E_IS_TABLE_HEADER_ITEM(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), E_TABLE_HEADER_ITEM_TYPE)) -#define E_IS_TABLE_HEADER_ITEM_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), E_TABLE_HEADER_ITEM_TYPE)) +typedef struct _ETableHeaderItem ETableHeaderItem; +typedef struct _ETableHeaderItemClass ETableHeaderItemClass; -typedef struct { +struct _ETableHeaderItem { GnomeCanvasItem parent; ETableHeader *eth; @@ -103,22 +119,19 @@ typedef struct { /* For keyboard navigation*/ gint selected_col; +}; -} ETableHeaderItem; - -typedef struct { +struct _ETableHeaderItemClass { GnomeCanvasItemClass parent_class; - /* - * signals - */ - void (*button_pressed) (ETableHeaderItem *ethi, GdkEventButton *button); -} ETableHeaderItemClass; - -void -ethi_change_sort_state (ETableHeaderItem *ethi, ETableCol *col); + /* Signals */ + void (*button_pressed) (ETableHeaderItem *ethi, + GdkEventButton *button); +}; -GType e_table_header_item_get_type (void); +GType e_table_header_item_get_type (void) G_GNUC_CONST; +void ethi_change_sort_state (ETableHeaderItem *ethi, + ETableCol *col); G_END_DECLS diff --git a/widgets/table/e-table-header-utils.h b/widgets/table/e-table-header-utils.h index 16cc867f8c..3ae11a4eca 100644 --- a/widgets/table/e-table-header-utils.h +++ b/widgets/table/e-table-header-utils.h @@ -30,22 +30,22 @@ G_BEGIN_DECLS -gdouble e_table_header_compute_height (ETableCol *ecol, - GtkWidget *widget); -gdouble e_table_header_width_extras (GtkStyle *style); -void e_table_header_draw_button (GdkDrawable *drawable, - ETableCol *ecol, - GtkStyle *style, - GtkStateType state, - GtkWidget *widget, - gint x, - gint y, - gint width, - gint height, - gint button_width, - gint button_height, - ETableColArrow arrow); +gdouble e_table_header_compute_height (ETableCol *ecol, + GtkWidget *widget); +gdouble e_table_header_width_extras (GtkStyle *style); +void e_table_header_draw_button (GdkDrawable *drawable, + ETableCol*ecol, + GtkStyle *style, + GtkStateType state, + GtkWidget *widget, + gint x, + gint y, + gint width, + gint height, + gint button_width, + gint button_height, + ETableColArrow arrow); G_END_DECLS -#endif +#endif /* E_TABLE_HEADER_UTILS_H */ diff --git a/widgets/table/e-table-header.c b/widgets/table/e-table-header.c index 1a3efafa85..df772a3c80 100644 --- a/widgets/table/e-table-header.c +++ b/widgets/table/e-table-header.c @@ -249,9 +249,9 @@ eth_get_property (GObject *object, guint prop_id, GValue *val, GParamSpec *pspec } static void -e_table_header_class_init (ETableHeaderClass *klass) +e_table_header_class_init (ETableHeaderClass *class) { - GObjectClass *object_class = G_OBJECT_CLASS (klass); + GObjectClass *object_class = G_OBJECT_CLASS (class); object_class->finalize = eth_finalize; object_class->set_property = eth_set_property; @@ -274,7 +274,7 @@ e_table_header_class_init (ETableHeaderClass *klass) g_object_class_install_property ( object_class, PROP_SORT_INFO, g_param_spec_object ("sort_info", "Sort Info", "Sort Info", - E_TABLE_SORT_INFO_TYPE, + E_TYPE_TABLE_SORT_INFO, G_PARAM_READWRITE)); eth_signals[STRUCTURE_CHANGE] = @@ -310,10 +310,10 @@ e_table_header_class_init (ETableHeaderClass *klass) e_marshal_INT__INT, G_TYPE_INT, 1, G_TYPE_INT); - klass->structure_change = NULL; - klass->dimension_change = NULL; - klass->expansion_change = NULL; - klass->request_width = NULL; + class->structure_change = NULL; + class->dimension_change = NULL; + class->expansion_change = NULL; + class->request_width = NULL; } static void @@ -342,7 +342,7 @@ ETableHeader * e_table_header_new (void) { - return (ETableHeader *) g_object_new (E_TABLE_HEADER_TYPE, NULL); + return g_object_new (E_TYPE_TABLE_HEADER, NULL); } static void diff --git a/widgets/table/e-table-header.h b/widgets/table/e-table-header.h index d724c2710f..1ac3016c8f 100644 --- a/widgets/table/e-table-header.h +++ b/widgets/table/e-table-header.h @@ -25,29 +25,41 @@ #ifndef _E_TABLE_COLUMN_H_ #define _E_TABLE_COLUMN_H_ -#include <glib-object.h> #include <gdk/gdk.h> #include <table/e-table-sort-info.h> #include <table/e-table-col.h> +/* Standard GObject macros */ +#define E_TYPE_TABLE_HEADER \ + (e_table_header_get_type ()) +#define E_TABLE_HEADER(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST \ + ((obj), E_TYPE_TABLE_HEADER, ETableHeader)) +#define E_TABLE_HEADER_CLASS(cls) \ + (G_TYPE_CHECK_CLASS_CAST \ + ((cls), E_TYPE_TABLE_HEADER, ETableHeaderClass)) +#define E_IS_TABLE_HEADER(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE \ + ((obj), E_TYPE_TABLE_HEADER)) +#define E_IS_TABLE_HEADER_CLASS(cls) \ + (G_TYPE_CHECK_CLASS_TYPE \ + ((cls), E_TYPE_TABLE_HEADER)) +#define E_TABLE_HEADER_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS \ + ((obj), E_TYPE_TABLE_HEADER, ETableHeaderClass)) + G_BEGIN_DECLS typedef struct _ETableHeader ETableHeader; - -#define E_TABLE_HEADER_TYPE (e_table_header_get_type ()) -#define E_TABLE_HEADER(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), E_TABLE_HEADER_TYPE, ETableHeader)) -#define E_TABLE_HEADER_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k), E_TABLE_HEADER_TYPE, ETableHeaderClass)) -#define E_IS_TABLE_HEADER(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), E_TABLE_HEADER_TYPE)) -#define E_IS_TABLE_HEADER_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), E_TABLE_HEADER_TYPE)) -#define E_TABLE_HEADER_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS((o), E_TABLE_HEADER_TYPE, ETableHeaderClass)) +typedef struct _ETableHeaderClass ETableHeaderClass; typedef gboolean (*ETableColCheckFunc) (ETableCol *col, gpointer user_data); /* - * A Columnar header. + * A Column header. */ struct _ETableHeader { - GObject base; + GObject parent; gint col_count; gint width; @@ -63,56 +75,63 @@ struct _ETableHeader { gint idle; }; -typedef struct { +struct _ETableHeaderClass { GObjectClass parent_class; - void (*structure_change) (ETableHeader *eth); - void (*dimension_change) (ETableHeader *eth, gint width); - void (*expansion_change) (ETableHeader *eth); - gint (*request_width) (ETableHeader *eth, gint col); -} ETableHeaderClass; - -GType e_table_header_get_type (void); -ETableHeader *e_table_header_new (void); - -void e_table_header_add_column (ETableHeader *eth, - ETableCol *tc, - gint pos); -ETableCol *e_table_header_get_column (ETableHeader *eth, - gint column); -ETableCol *e_table_header_get_column_by_col_idx (ETableHeader *eth, - gint col_idx); -gint e_table_header_count (ETableHeader *eth); -gint e_table_header_index (ETableHeader *eth, - gint col); -gint e_table_header_get_index_at (ETableHeader *eth, - gint x_offset); -ETableCol **e_table_header_get_columns (ETableHeader *eth); -gint e_table_header_get_selected (ETableHeader *eth); - -gint e_table_header_total_width (ETableHeader *eth); -gint e_table_header_min_width (ETableHeader *eth); -void e_table_header_move (ETableHeader *eth, - gint source_index, - gint target_index); -void e_table_header_remove (ETableHeader *eth, - gint idx); -void e_table_header_set_size (ETableHeader *eth, - gint idx, - gint size); -void e_table_header_set_selection (ETableHeader *eth, - gboolean allow_selection); -gint e_table_header_col_diff (ETableHeader *eth, - gint start_col, - gint end_col); - -void e_table_header_calc_widths (ETableHeader *eth); -GList *e_table_header_get_selected_indexes (ETableHeader *eth); -void e_table_header_update_horizontal (ETableHeader *eth); -gint e_table_header_prioritized_column (ETableHeader *eth); -ETableCol *e_table_header_prioritized_column_selected (ETableHeader *eth, - ETableColCheckFunc check_func, - gpointer user_data); + void (*structure_change) (ETableHeader *eth); + void (*dimension_change) (ETableHeader *eth, + gint width); + void (*expansion_change) (ETableHeader *eth); + gint (*request_width) (ETableHeader *eth, + gint col); +}; + +GType e_table_header_get_type (void) G_GNUC_CONST; +ETableHeader * e_table_header_new (void); + +void e_table_header_add_column (ETableHeader *eth, + ETableCol *tc, + gint pos); +ETableCol * e_table_header_get_column (ETableHeader *eth, + gint column); +ETableCol * e_table_header_get_column_by_col_idx + (ETableHeader *eth, + gint col_idx); +gint e_table_header_count (ETableHeader *eth); +gint e_table_header_index (ETableHeader *eth, + gint col); +gint e_table_header_get_index_at (ETableHeader *eth, + gint x_offset); +ETableCol ** e_table_header_get_columns (ETableHeader *eth); +gint e_table_header_get_selected (ETableHeader *eth); + +gint e_table_header_total_width (ETableHeader *eth); +gint e_table_header_min_width (ETableHeader *eth); +void e_table_header_move (ETableHeader *eth, + gint source_index, + gint target_index); +void e_table_header_remove (ETableHeader *eth, + gint idx); +void e_table_header_set_size (ETableHeader *eth, + gint idx, + gint size); +void e_table_header_set_selection (ETableHeader *eth, + gboolean allow_selection); +gint e_table_header_col_diff (ETableHeader *eth, + gint start_col, + gint end_col); + +void e_table_header_calc_widths (ETableHeader *eth); +GList * e_table_header_get_selected_indexes + (ETableHeader *eth); +void e_table_header_update_horizontal + (ETableHeader *eth); +gint e_table_header_prioritized_column + (ETableHeader *eth); +ETableCol * e_table_header_prioritized_column_selected + (ETableHeader *eth, + ETableColCheckFunc check_func, + gpointer user_data); G_END_DECLS diff --git a/widgets/table/e-table-item.c b/widgets/table/e-table-item.c index 7c45bbe656..b6421bb439 100644 --- a/widgets/table/e-table-item.c +++ b/widgets/table/e-table-item.c @@ -2792,10 +2792,10 @@ eti_style_set (ETableItem *eti, GtkStyle *previous_style) } static void -eti_class_init (ETableItemClass *klass) +eti_class_init (ETableItemClass *class) { - GnomeCanvasItemClass *item_class = GNOME_CANVAS_ITEM_CLASS (klass); - GObjectClass *object_class = G_OBJECT_CLASS (klass); + GnomeCanvasItemClass *item_class = GNOME_CANVAS_ITEM_CLASS (class); + GObjectClass *object_class = G_OBJECT_CLASS (class); object_class->dispose = eti_dispose; object_class->set_property = eti_set_property; @@ -2808,29 +2808,29 @@ eti_class_init (ETableItemClass *klass) item_class->point = eti_point; item_class->event = eti_event; - klass->cursor_change = NULL; - klass->cursor_activated = NULL; - klass->double_click = NULL; - klass->right_click = NULL; - klass->click = NULL; - klass->key_press = NULL; - klass->start_drag = NULL; - klass->style_set = eti_style_set; - klass->selection_model_removed = NULL; - klass->selection_model_added = NULL; + class->cursor_change = NULL; + class->cursor_activated = NULL; + class->double_click = NULL; + class->right_click = NULL; + class->click = NULL; + class->key_press = NULL; + class->start_drag = NULL; + class->style_set = eti_style_set; + class->selection_model_removed = NULL; + class->selection_model_added = NULL; g_object_class_install_property (object_class, PROP_TABLE_HEADER, g_param_spec_object ("ETableHeader", "Table header", "Table header", - E_TABLE_HEADER_TYPE, + E_TYPE_TABLE_HEADER, G_PARAM_WRITABLE)); g_object_class_install_property (object_class, PROP_TABLE_MODEL, g_param_spec_object ("ETableModel", "Table model", "Table model", - E_TABLE_MODEL_TYPE, + E_TYPE_TABLE_MODEL, G_PARAM_WRITABLE)); g_object_class_install_property (object_class, PROP_SELECTION_MODEL, diff --git a/widgets/table/e-table-item.h b/widgets/table/e-table-item.h index 6322bcd395..d2fd2c56d6 100644 --- a/widgets/table/e-table-item.h +++ b/widgets/table/e-table-item.h @@ -32,15 +32,31 @@ #include <misc/e-selection-model.h> #include <misc/e-printable.h> +/* Standard GObject macros */ +#define E_TYPE_TABLE_ITEM \ + (e_table_item_get_type ()) +#define E_TABLE_ITEM(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST \ + ((obj), E_TYPE_TABLE_ITEM, ETableItem)) +#define E_TABLE_ITEM_CLASS(cls) \ + (G_TYPE_CHECK_CLASS_CAST \ + ((cls), E_TYPE_TABLE_ITEM, ETableItemClass)) +#define E_IS_TABLE_ITEM(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE \ + ((obj), E_TYPE_TABLE_ITEM)) +#define E_IS_TABLE_ITEM_CLASS(cls) \ + (G_TYPE_CHECK_CLASS_TYPE \ + ((cls), E_TYPE_TABLE_ITEM)) +#define E_TABLE_ITEM_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS \ + ((obj), E_TYPE_TABLE_ITEM, ETableItemClass)) + G_BEGIN_DECLS -#define E_TABLE_ITEM_TYPE (e_table_item_get_type ()) -#define E_TABLE_ITEM(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), E_TABLE_ITEM_TYPE, ETableItem)) -#define E_TABLE_ITEM_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k), E_TABLE_ITEM_TYPE, ETableItemClass)) -#define E_IS_TABLE_ITEM(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), E_TABLE_ITEM_TYPE)) -#define E_IS_TABLE_ITEM_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), E_TABLE_ITEM_TYPE)) +typedef struct _ETableItem ETableItem; +typedef struct _ETableItemClass ETableItemClass; -typedef struct { +struct _ETableItem { GnomeCanvasItem parent; ETableModel *table_model; ETableHeader *header; @@ -151,67 +167,89 @@ typedef struct { gint grabbed_col, grabbed_row; gint grabbed_count; +}; -} ETableItem; - -typedef struct { +struct _ETableItemClass { GnomeCanvasItemClass parent_class; - void (*cursor_change) (ETableItem *eti, gint row); - void (*cursor_activated) (ETableItem *eti, gint row); - void (*double_click) (ETableItem *eti, gint row, gint col, GdkEvent *event); - gboolean (*right_click) (ETableItem *eti, gint row, gint col, GdkEvent *event); - gboolean (*click) (ETableItem *eti, gint row, gint col, GdkEvent *event); - gboolean (*key_press) (ETableItem *eti, gint row, gint col, GdkEvent *event); - gboolean (*start_drag) (ETableItem *eti, gint row, gint col, GdkEvent *event); - void (*style_set) (ETableItem *eti, GtkStyle *previous_style); - void (*selection_model_removed) (ETableItem *eti, ESelectionModel *selection); - void (*selection_model_added) (ETableItem *eti, ESelectionModel *selection); -} ETableItemClass; -GType e_table_item_get_type (void); + void (*cursor_change) (ETableItem *eti, + gint row); + void (*cursor_activated) (ETableItem *eti, + gint row); + void (*double_click) (ETableItem *eti, + gint row, + gint col, + GdkEvent *event); + gboolean (*right_click) (ETableItem *eti, + gint row, + gint col, + GdkEvent *event); + gboolean (*click) (ETableItem *eti, + gint row, + gint col, + GdkEvent *event); + gboolean (*key_press) (ETableItem *eti, + gint row, + gint col, + GdkEvent *event); + gboolean (*start_drag) (ETableItem *eti, + gint row, + gint col, + GdkEvent *event); + void (*style_set) (ETableItem *eti, + GtkStyle *previous_style); + void (*selection_model_removed) + (ETableItem *eti, + ESelectionModel *selection); + void (*selection_model_added) + (ETableItem *eti, + ESelectionModel *selection); +}; + +GType e_table_item_get_type (void) G_GNUC_CONST; /* * Focus */ -void e_table_item_set_cursor (ETableItem *eti, - gint col, - gint row); - -gint e_table_item_get_focused_column (ETableItem *eti); - -void e_table_item_leave_edit (ETableItem *eti); -void e_table_item_enter_edit (ETableItem *eti, - gint col, - gint row); - -void e_table_item_redraw_range (ETableItem *eti, - gint start_col, - gint start_row, - gint end_col, - gint end_row); - -EPrintable *e_table_item_get_printable (ETableItem *eti); -void e_table_item_compute_location (ETableItem *eti, - gint *x, - gint *y, - gint *row, - gint *col); -void e_table_item_compute_mouse_over (ETableItem *eti, - gint x, - gint y, - gint *row, - gint *col); -void e_table_item_get_cell_geometry (ETableItem *eti, - gint *row, - gint *col, - gint *x, - gint *y, - gint *width, - gint *height); - -gint e_table_item_row_diff (ETableItem *eti, - gint start_row, - gint end_row); +void e_table_item_set_cursor (ETableItem *eti, + gint col, + gint row); + +gint e_table_item_get_focused_column (ETableItem *eti); + +void e_table_item_leave_edit (ETableItem *eti); +void e_table_item_enter_edit (ETableItem *eti, + gint col, + gint row); + +void e_table_item_redraw_range (ETableItem *eti, + gint start_col, + gint start_row, + gint end_col, + gint end_row); + +EPrintable * e_table_item_get_printable (ETableItem *eti); +void e_table_item_compute_location (ETableItem *eti, + gint *x, + gint *y, + gint *row, + gint *col); +void e_table_item_compute_mouse_over (ETableItem *eti, + gint x, + gint y, + gint *row, + gint *col); +void e_table_item_get_cell_geometry (ETableItem *eti, + gint *row, + gint *col, + gint *x, + gint *y, + gint *width, + gint *height); + +gint e_table_item_row_diff (ETableItem *eti, + gint start_row, + gint end_row); G_END_DECLS diff --git a/widgets/table/e-table-memory-callbacks.c b/widgets/table/e-table-memory-callbacks.c index 8bdfc585df..5101e9ec73 100644 --- a/widgets/table/e-table-memory-callbacks.c +++ b/widgets/table/e-table-memory-callbacks.c @@ -27,12 +27,12 @@ #include "e-table-memory-callbacks.h" -G_DEFINE_TYPE (ETableMemoryCalbacks, e_table_memory_callbacks, E_TABLE_MEMORY_TYPE) +G_DEFINE_TYPE (ETableMemoryCallbacks, e_table_memory_callbacks, E_TYPE_TABLE_MEMORY) static gint etmc_column_count (ETableModel *etm) { - ETableMemoryCalbacks *etmc = E_TABLE_MEMORY_CALLBACKS (etm); + ETableMemoryCallbacks *etmc = E_TABLE_MEMORY_CALLBACKS (etm); if (etmc->col_count) return etmc->col_count (etm, etmc->data); @@ -43,7 +43,7 @@ etmc_column_count (ETableModel *etm) static gpointer etmc_value_at (ETableModel *etm, gint col, gint row) { - ETableMemoryCalbacks *etmc = E_TABLE_MEMORY_CALLBACKS (etm); + ETableMemoryCallbacks *etmc = E_TABLE_MEMORY_CALLBACKS (etm); if (etmc->value_at) return etmc->value_at (etm, col, row, etmc->data); @@ -54,7 +54,7 @@ etmc_value_at (ETableModel *etm, gint col, gint row) static void etmc_set_value_at (ETableModel *etm, gint col, gint row, gconstpointer val) { - ETableMemoryCalbacks *etmc = E_TABLE_MEMORY_CALLBACKS (etm); + ETableMemoryCallbacks *etmc = E_TABLE_MEMORY_CALLBACKS (etm); if (etmc->set_value_at) etmc->set_value_at (etm, col, row, val, etmc->data); @@ -63,7 +63,7 @@ etmc_set_value_at (ETableModel *etm, gint col, gint row, gconstpointer val) static gboolean etmc_is_cell_editable (ETableModel *etm, gint col, gint row) { - ETableMemoryCalbacks *etmc = E_TABLE_MEMORY_CALLBACKS (etm); + ETableMemoryCallbacks *etmc = E_TABLE_MEMORY_CALLBACKS (etm); if (etmc->is_cell_editable) return etmc->is_cell_editable (etm, col, row, etmc->data); @@ -75,7 +75,7 @@ etmc_is_cell_editable (ETableModel *etm, gint col, gint row) static gpointer etmc_duplicate_value (ETableModel *etm, gint col, gconstpointer value) { - ETableMemoryCalbacks *etmc = E_TABLE_MEMORY_CALLBACKS (etm); + ETableMemoryCallbacks *etmc = E_TABLE_MEMORY_CALLBACKS (etm); if (etmc->duplicate_value) return etmc->duplicate_value (etm, col, value, etmc->data); @@ -86,7 +86,7 @@ etmc_duplicate_value (ETableModel *etm, gint col, gconstpointer value) static void etmc_free_value (ETableModel *etm, gint col, gpointer value) { - ETableMemoryCalbacks *etmc = E_TABLE_MEMORY_CALLBACKS (etm); + ETableMemoryCallbacks *etmc = E_TABLE_MEMORY_CALLBACKS (etm); if (etmc->free_value) etmc->free_value (etm, col, value, etmc->data); @@ -95,7 +95,7 @@ etmc_free_value (ETableModel *etm, gint col, gpointer value) static gpointer etmc_initialize_value (ETableModel *etm, gint col) { - ETableMemoryCalbacks *etmc = E_TABLE_MEMORY_CALLBACKS (etm); + ETableMemoryCallbacks *etmc = E_TABLE_MEMORY_CALLBACKS (etm); if (etmc->initialize_value) return etmc->initialize_value (etm, col, etmc->data); @@ -106,7 +106,7 @@ etmc_initialize_value (ETableModel *etm, gint col) static gboolean etmc_value_is_empty (ETableModel *etm, gint col, gconstpointer value) { - ETableMemoryCalbacks *etmc = E_TABLE_MEMORY_CALLBACKS (etm); + ETableMemoryCallbacks *etmc = E_TABLE_MEMORY_CALLBACKS (etm); if (etmc->value_is_empty) return etmc->value_is_empty (etm, col, value, etmc->data); @@ -117,7 +117,7 @@ etmc_value_is_empty (ETableModel *etm, gint col, gconstpointer value) static gchar * etmc_value_to_string (ETableModel *etm, gint col, gconstpointer value) { - ETableMemoryCalbacks *etmc = E_TABLE_MEMORY_CALLBACKS (etm); + ETableMemoryCallbacks *etmc = E_TABLE_MEMORY_CALLBACKS (etm); if (etmc->value_to_string) return etmc->value_to_string (etm, col, value, etmc->data); @@ -128,16 +128,16 @@ etmc_value_to_string (ETableModel *etm, gint col, gconstpointer value) static void etmc_append_row (ETableModel *etm, ETableModel *source, gint row) { - ETableMemoryCalbacks *etmc = E_TABLE_MEMORY_CALLBACKS (etm); + ETableMemoryCallbacks *etmc = E_TABLE_MEMORY_CALLBACKS (etm); if (etmc->append_row) etmc->append_row (etm, source, row, etmc->data); } static void -e_table_memory_callbacks_class_init (ETableMemoryCalbacksClass *klass) +e_table_memory_callbacks_class_init (ETableMemoryCallbacksClass *class) { - ETableModelClass *model_class = E_TABLE_MODEL_CLASS (klass); + ETableModelClass *model_class = E_TABLE_MODEL_CLASS (class); model_class->column_count = etmc_column_count; model_class->value_at = etmc_value_at; @@ -153,7 +153,7 @@ e_table_memory_callbacks_class_init (ETableMemoryCalbacksClass *klass) } static void -e_table_memory_callbacks_init (ETableMemoryCalbacks *etmc) +e_table_memory_callbacks_init (ETableMemoryCallbacks *etmc) { /* nothing to do */ } @@ -171,35 +171,35 @@ e_table_memory_callbacks_init (ETableMemoryCalbacks *etmc) * @value_to_string: * @data: closure pointer. * - * This initializes a new ETableMemoryCalbacksModel object. - * ETableMemoryCalbacksModel is an implementaiton of the abstract class - * ETableModel. The ETableMemoryCalbacksModel is designed to allow people + * This initializes a new ETableMemoryCallbacksModel object. + * ETableMemoryCallbacksModel is an implementaiton of the abstract class + * ETableModel. The ETableMemoryCallbacksModel is designed to allow people * to easily create ETableModels without having to create a new GType * derived from ETableModel every time they need one. * - * Instead, ETableMemoryCalbacksModel uses a setup based in callback + * Instead, ETableMemoryCallbacksModel uses a setup based in callback * functions, every callback function signature mimics the signature of * each ETableModel method and passes the extra @data pointer to each one * of the method to provide them with any context they might want to use. * - * Returns: An ETableMemoryCalbacksModel object (which is also an ETableModel + * Returns: An ETableMemoryCallbacksModel object (which is also an ETableModel * object). */ ETableModel * -e_table_memory_callbacks_new (ETableMemoryCalbacksColumnCountFn col_count, - ETableMemoryCalbacksValueAtFn value_at, - ETableMemoryCalbacksSetValueAtFn set_value_at, - ETableMemoryCalbacksIsCellEditableFn is_cell_editable, - ETableMemoryCalbacksDuplicateValueFn duplicate_value, - ETableMemoryCalbacksFreeValueFn free_value, - ETableMemoryCalbacksInitializeValueFn initialize_value, - ETableMemoryCalbacksValueIsEmptyFn value_is_empty, - ETableMemoryCalbacksValueToStringFn value_to_string, +e_table_memory_callbacks_new (ETableMemoryCallbacksColumnCountFn col_count, + ETableMemoryCallbacksValueAtFn value_at, + ETableMemoryCallbacksSetValueAtFn set_value_at, + ETableMemoryCallbacksIsCellEditableFn is_cell_editable, + ETableMemoryCallbacksDuplicateValueFn duplicate_value, + ETableMemoryCallbacksFreeValueFn free_value, + ETableMemoryCallbacksInitializeValueFn initialize_value, + ETableMemoryCallbacksValueIsEmptyFn value_is_empty, + ETableMemoryCallbacksValueToStringFn value_to_string, gpointer data) { - ETableMemoryCalbacks *et; + ETableMemoryCallbacks *et; - et = g_object_new (E_TABLE_MEMORY_CALLBACKS_TYPE, NULL); + et = g_object_new (E_TYPE_TABLE_MEMORY_CALLBACKS, NULL); et->col_count = col_count; et->value_at = value_at; diff --git a/widgets/table/e-table-memory-callbacks.h b/widgets/table/e-table-memory-callbacks.h index 97e2e53421..8feb6e9884 100644 --- a/widgets/table/e-table-memory-callbacks.h +++ b/widgets/table/e-table-memory-callbacks.h @@ -25,64 +25,118 @@ #include <table/e-table-memory.h> -G_BEGIN_DECLS - -#define E_TABLE_MEMORY_CALLBACKS_TYPE (e_table_memory_callbacks_get_type ()) -#define E_TABLE_MEMORY_CALLBACKS(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), E_TABLE_MEMORY_CALLBACKS_TYPE, ETableMemoryCalbacks)) -#define E_TABLE_MEMORY_CALLBACKS_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k), E_TABLE_MEMORY_CALLBACKS_TYPE, ETableMemoryCalbacksClass)) -#define E_IS_TABLE_MEMORY_CALLBACKS(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), E_TABLE_MEMORY_CALLBACKS_TYPE)) -#define E_IS_TABLE_MEMORY_CALLBACKS_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), E_TABLE_MEMORY_CALLBACKS_TYPE)) -#define E_TABLE_MEMORY_CALLBACKS_GET_CLASS(k) (G_TYPE_INSTANCE_GET_CLASS((k), E_TABLE_MEMORY_CALLBACKS_TYPE, ETableMemoryCalbacksClass)) - -typedef gint (*ETableMemoryCalbacksColumnCountFn) (ETableModel *etm, gpointer data); -typedef void (*ETableMemoryCalbacksAppendRowFn) (ETableModel *etm, ETableModel *model, gint row, gpointer data); +/* Standard GObject macros */ +#define E_TYPE_TABLE_MEMORY_CALLBACKS \ + (e_table_memory_callbacks_get_type ()) +#define E_TABLE_MEMORY_CALLBACKS(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST \ + ((obj), E_TYPE_TABLE_MEMORY_CALLBACKS, ETableMemoryCallbacks)) +#define E_TABLE_MEMORY_CALLBACKS_CLASS(cls) \ + (G_TYPE_CHECK_CLASS_CAST \ + ((cls), E_TYPE_TABLE_MEMORY_CALLBACKS, ETableMemoryCallbacksClass)) +#define E_IS_TABLE_MEMORY_CALLBACKS(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE \ + ((obj), E_TYPE_TABLE_MEMORY_CALLBACKS)) +#define E_IS_TABLE_MEMORY_CALLBACKS_CLASS(cls) \ + (G_TYPE_CHECK_CLASS_TYPE \ + ((cls), E_TYPE_TABLE_MEMORY_CALLBACKS)) +#define E_TABLE_MEMORY_CALLBACKS_GET_CLASS(cls) \ + (G_TYPE_INSTANCE_GET_CLASS \ + ((cls), E_TYPE_TABLE_MEMORY_CALLBACKS, ETableMemoryCallbacksClass)) -typedef void *(*ETableMemoryCalbacksValueAtFn) (ETableModel *etm, gint col, gint row, gpointer data); -typedef void (*ETableMemoryCalbacksSetValueAtFn) (ETableModel *etm, gint col, gint row, gconstpointer val, gpointer data); -typedef gboolean (*ETableMemoryCalbacksIsCellEditableFn) (ETableModel *etm, gint col, gint row, gpointer data); - -typedef void *(*ETableMemoryCalbacksDuplicateValueFn) (ETableModel *etm, gint col, gconstpointer val, gpointer data); -typedef void (*ETableMemoryCalbacksFreeValueFn) (ETableModel *etm, gint col, gpointer val, gpointer data); -typedef void *(*ETableMemoryCalbacksInitializeValueFn) (ETableModel *etm, gint col, gpointer data); -typedef gboolean (*ETableMemoryCalbacksValueIsEmptyFn) (ETableModel *etm, gint col, gconstpointer val, gpointer data); -typedef gchar *(*ETableMemoryCalbacksValueToStringFn) (ETableModel *etm, gint col, gconstpointer val, gpointer data); +G_BEGIN_DECLS -typedef struct { +typedef struct _ETableMemoryCallbacks ETableMemoryCallbacks; +typedef struct _ETableMemoryCallbacksClass ETableMemoryCallbacksClass; + +typedef gint (*ETableMemoryCallbacksColumnCountFn) + (ETableModel *etm, + gpointer data); +typedef void (*ETableMemoryCallbacksAppendRowFn) + (ETableModel *etm, + ETableModel *model, + gint row, + gpointer data); + +typedef gpointer (*ETableMemoryCallbacksValueAtFn) + (ETableModel *etm, + gint col, + gint row, + gpointer data); +typedef void (*ETableMemoryCallbacksSetValueAtFn) + (ETableModel *etm, + gint col, + gint row, + gconstpointer val, + gpointer data); +typedef gboolean (*ETableMemoryCallbacksIsCellEditableFn) + (ETableModel *etm, + gint col, + gint row, + gpointer data); + +typedef gpointer (*ETableMemoryCallbacksDuplicateValueFn) + (ETableModel *etm, + gint col, + gconstpointer val, + gpointer data); +typedef void (*ETableMemoryCallbacksFreeValueFn) + (ETableModel *etm, + gint col, + gpointer val, + gpointer data); +typedef gpointer (*ETableMemoryCallbacksInitializeValueFn) + (ETableModel *etm, + gint col, + gpointer data); +typedef gboolean (*ETableMemoryCallbacksValueIsEmptyFn) + (ETableModel *etm, + gint col, + gconstpointer val, + gpointer data); +typedef gchar * (*ETableMemoryCallbacksValueToStringFn) + (ETableModel *etm, + gint col, + gconstpointer val, + gpointer data); + +struct _ETableMemoryCallbacks { ETableMemory parent; - ETableMemoryCalbacksColumnCountFn col_count; - ETableMemoryCalbacksAppendRowFn append_row; + ETableMemoryCallbacksColumnCountFn col_count; + ETableMemoryCallbacksAppendRowFn append_row; - ETableMemoryCalbacksValueAtFn value_at; - ETableMemoryCalbacksSetValueAtFn set_value_at; - ETableMemoryCalbacksIsCellEditableFn is_cell_editable; + ETableMemoryCallbacksValueAtFn value_at; + ETableMemoryCallbacksSetValueAtFn set_value_at; + ETableMemoryCallbacksIsCellEditableFn is_cell_editable; - ETableMemoryCalbacksDuplicateValueFn duplicate_value; - ETableMemoryCalbacksFreeValueFn free_value; - ETableMemoryCalbacksInitializeValueFn initialize_value; - ETableMemoryCalbacksValueIsEmptyFn value_is_empty; - ETableMemoryCalbacksValueToStringFn value_to_string; + ETableMemoryCallbacksDuplicateValueFn duplicate_value; + ETableMemoryCallbacksFreeValueFn free_value; + ETableMemoryCallbacksInitializeValueFn initialize_value; + ETableMemoryCallbacksValueIsEmptyFn value_is_empty; + ETableMemoryCallbacksValueToStringFn value_to_string; gpointer data; -} ETableMemoryCalbacks; +}; -typedef struct { +struct _ETableMemoryCallbacksClass { ETableMemoryClass parent_class; -} ETableMemoryCalbacksClass; - -GType e_table_memory_callbacks_get_type (void); - -ETableModel *e_table_memory_callbacks_new (ETableMemoryCalbacksColumnCountFn col_count, - - ETableMemoryCalbacksValueAtFn value_at, - ETableMemoryCalbacksSetValueAtFn set_value_at, - ETableMemoryCalbacksIsCellEditableFn is_cell_editable, - - ETableMemoryCalbacksDuplicateValueFn duplicate_value, - ETableMemoryCalbacksFreeValueFn free_value, - ETableMemoryCalbacksInitializeValueFn initialize_value, - ETableMemoryCalbacksValueIsEmptyFn value_is_empty, - ETableMemoryCalbacksValueToStringFn value_to_string, - gpointer data); +}; + +GType e_table_memory_callbacks_get_type + (void) G_GNUC_CONST; +ETableModel * e_table_memory_callbacks_new + (ETableMemoryCallbacksColumnCountFn col_count, + + ETableMemoryCallbacksValueAtFn value_at, + ETableMemoryCallbacksSetValueAtFn set_value_at, + ETableMemoryCallbacksIsCellEditableFn is_cell_editable, + + ETableMemoryCallbacksDuplicateValueFn duplicate_value, + ETableMemoryCallbacksFreeValueFn free_value, + ETableMemoryCallbacksInitializeValueFn initialize_value, + ETableMemoryCallbacksValueIsEmptyFn value_is_empty, + ETableMemoryCallbacksValueToStringFn value_to_string, + gpointer data); G_END_DECLS diff --git a/widgets/table/e-table-memory-store.c b/widgets/table/e-table-memory-store.c index 05aad76d35..5a0263b308 100644 --- a/widgets/table/e-table-memory-store.c +++ b/widgets/table/e-table-memory-store.c @@ -28,6 +28,10 @@ #include "e-table-memory-store.h" +#define E_TABLE_MEMORY_STORE_GET_PRIVATE(obj) \ + (G_TYPE_INSTANCE_GET_PRIVATE \ + ((obj), E_TYPE_TABLE_MEMORY_STORE, ETableMemoryStorePrivate)) + #define STORE_LOCATOR(etms, col, row) (*((etms)->priv->store + (row) * (etms)->priv->col_count + (col))) struct _ETableMemoryStorePrivate { @@ -36,7 +40,7 @@ struct _ETableMemoryStorePrivate { gpointer *store; }; -G_DEFINE_TYPE (ETableMemoryStore, e_table_memory_store, E_TABLE_MEMORY_TYPE) +G_DEFINE_TYPE (ETableMemoryStore, e_table_memory_store, E_TYPE_TABLE_MEMORY) static gpointer duplicate_value (ETableMemoryStore *etms, gint col, gconstpointer val) @@ -222,50 +226,49 @@ etms_append_row (ETableModel *etm, ETableModel *source, gint row) } static void -etms_finalize (GObject *obj) +etms_finalize (GObject *object) { - ETableMemoryStore *etms = (ETableMemoryStore *) obj; + ETableMemoryStorePrivate *priv; - if (etms->priv) { - e_table_memory_store_clear (etms); + priv = E_TABLE_MEMORY_STORE_GET_PRIVATE (object); - g_free (etms->priv->columns); - g_free (etms->priv->store); - g_free (etms->priv); - } + e_table_memory_store_clear (E_TABLE_MEMORY_STORE (object)); + + g_free (priv->columns); + g_free (priv->store); - if (G_OBJECT_CLASS (e_table_memory_store_parent_class)->finalize) - G_OBJECT_CLASS (e_table_memory_store_parent_class)->finalize (obj); + /* Chain up to parent's finalize() method. */ + G_OBJECT_CLASS (e_table_memory_store_parent_class)->finalize (object); } static void e_table_memory_store_init (ETableMemoryStore *etms) { - etms->priv = g_new (ETableMemoryStorePrivate, 1); - - etms->priv->col_count = 0; - etms->priv->columns = NULL; - etms->priv->store = NULL; + etms->priv = E_TABLE_MEMORY_STORE_GET_PRIVATE (etms); } static void -e_table_memory_store_class_init (ETableMemoryStoreClass *klass) +e_table_memory_store_class_init (ETableMemoryStoreClass *class) { - ETableModelClass *model_class = E_TABLE_MODEL_CLASS (klass); - GObjectClass *object_class = G_OBJECT_CLASS (klass); + GObjectClass *object_class; + ETableModelClass *model_class; + + g_type_class_add_private (class, sizeof (ETableMemoryStorePrivate)); - object_class->finalize = etms_finalize; + object_class = G_OBJECT_CLASS (class); + object_class->finalize = etms_finalize; - model_class->column_count = etms_column_count; - model_class->value_at = etms_value_at; - model_class->set_value_at = etms_set_value_at; + model_class = E_TABLE_MODEL_CLASS (class); + model_class->column_count = etms_column_count; + model_class->value_at = etms_value_at; + model_class->set_value_at = etms_set_value_at; model_class->is_cell_editable = etms_is_cell_editable; - model_class->duplicate_value = etms_duplicate_value; - model_class->free_value = etms_free_value; + model_class->duplicate_value = etms_duplicate_value; + model_class->free_value = etms_free_value; model_class->initialize_value = etms_initialize_value; - model_class->value_is_empty = etms_value_is_empty; - model_class->value_to_string = etms_value_to_string; - model_class->append_row = etms_append_row; + model_class->value_is_empty = etms_value_is_empty; + model_class->value_to_string = etms_value_to_string; + model_class->append_row = etms_append_row; } /** @@ -297,7 +300,7 @@ e_table_memory_store_class_init (ETableMemoryStoreClass *klass) ETableModel * e_table_memory_store_new (ETableMemoryStoreColumnInfo *columns) { - ETableMemoryStore *et = g_object_new (E_TABLE_MEMORY_STORE_TYPE, NULL); + ETableMemoryStore *et = g_object_new (E_TYPE_TABLE_MEMORY_STORE, NULL); if (e_table_memory_store_construct (et, columns)) { return (ETableModel *) et; diff --git a/widgets/table/e-table-memory-store.h b/widgets/table/e-table-memory-store.h index 96da50f71c..9d3d638e18 100644 --- a/widgets/table/e-table-memory-store.h +++ b/widgets/table/e-table-memory-store.h @@ -27,14 +27,26 @@ #include <table/e-table-memory.h> #include <table/e-table-memory-callbacks.h> -G_BEGIN_DECLS +/* Standard GObject macros */ +#define E_TYPE_TABLE_MEMORY_STORE \ + (e_table_memory_store_get_type ()) +#define E_TABLE_MEMORY_STORE(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST \ + ((obj), E_TYPE_TABLE_MEMORY_STORE, ETableMemoryStore)) +#define E_TABLE_MEMORY_STORE_CLASS(cls) \ + (G_TYPE_CHECK_CLASS_CAST \ + ((cls), E_TYPE_TABLE_MEMORY_STORE, ETableMemoryStoreClass)) +#define E_IS_TABLE_MEMORY_STORE(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE \ + ((obj), E_TYPE_TABLE_MEMORY_STORE)) +#define E_IS_TABLE_MEMORY_STORE_CLASS(cls) \ + (G_TYPE_CHECK_CLASS_TYPE \ + ((cls), E_TYPE_TABLE_MEMORY_STORE)) +#define E_TABLE_MEMORY_STORE_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS \ + ((obj), E_TYPE_TABLE_MEMORY_STORE, ETableMemoryStoreClass)) -#define E_TABLE_MEMORY_STORE_TYPE (e_table_memory_store_get_type ()) -#define E_TABLE_MEMORY_STORE(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), E_TABLE_MEMORY_STORE_TYPE, ETableMemoryStore)) -#define E_TABLE_MEMORY_STORE_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k), E_TABLE_MEMORY_STORE_TYPE, ETableMemoryStoreClass)) -#define E_IS_TABLE_MEMORY_STORE(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), E_TABLE_MEMORY_STORE_TYPE)) -#define E_IS_TABLE_MEMORY_STORE_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), E_TABLE_MEMORY_STORE_TYPE)) -#define E_TABLE_MEMORY_STORE_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((obj), E_TABLE_MEMORY_STORE_TYPE, ETableMemoryStoreClass)) +G_BEGIN_DECLS typedef enum { E_TABLE_MEMORY_STORE_COLUMN_TYPE_TERMINATOR, @@ -46,11 +58,11 @@ typedef enum { } ETableMemoryStoreColumnType; typedef struct { - ETableMemoryCalbacksDuplicateValueFn duplicate_value; - ETableMemoryCalbacksFreeValueFn free_value; - ETableMemoryCalbacksInitializeValueFn initialize_value; - ETableMemoryCalbacksValueIsEmptyFn value_is_empty; - ETableMemoryCalbacksValueToStringFn value_to_string; + ETableMemoryCallbacksDuplicateValueFn duplicate_value; + ETableMemoryCallbacksFreeValueFn free_value; + ETableMemoryCallbacksInitializeValueFn initialize_value; + ETableMemoryCallbacksValueIsEmptyFn value_is_empty; + ETableMemoryCallbacksValueToStringFn value_to_string; } ETableMemoryStoreCustomColumn; typedef struct { @@ -59,79 +71,80 @@ typedef struct { guint editable : 1; } ETableMemoryStoreColumnInfo; -#define E_TABLE_MEMORY_STORE_TERMINATOR { E_TABLE_MEMORY_STORE_COLUMN_TYPE_TERMINATOR, { NULL }, FALSE } -#define E_TABLE_MEMORY_STORE_INTEGER { E_TABLE_MEMORY_STORE_COLUMN_TYPE_INTEGER, { NULL }, FALSE } -#define E_TABLE_MEMORY_STORE_STRING { E_TABLE_MEMORY_STORE_COLUMN_TYPE_STRING, { NULL }, FALSE } -#define E_TABLE_MEMORY_STORE_PIXBUF { E_TABLE_MEMORY_STORE_COLUMN_TYPE_PIXBUF, { NULL }, FALSE } -#define E_TABLE_MEMORY_STORE_EDITABLE_STRING { E_TABLE_MEMORY_STORE_COLUMN_TYPE_STRING, { NULL }, TRUE } -#define E_TABLE_MEMORY_STORE_CUSTOM(editable, duplicate, free, initialize, empty, string) \ - { E_TABLE_MEMORY_STORE_COLUMN_TYPE_CUSTOM, \ - { (duplicate), (free), (initialize), (empty), (string) }, editable } -#define E_TABLE_MEMORY_STORE_OBJECT(editable, initialize, empty, string) \ - { E_TABLE_MEMORY_STORE_COLUMN_TYPE_CUSTOM, \ - { NULL, NULL, (initialize), (empty), (string) }, editable } +#define E_TABLE_MEMORY_STORE_TERMINATOR \ + { E_TABLE_MEMORY_STORE_COLUMN_TYPE_TERMINATOR, { NULL }, FALSE } +#define E_TABLE_MEMORY_STORE_INTEGER \ + { E_TABLE_MEMORY_STORE_COLUMN_TYPE_INTEGER, { NULL }, FALSE } +#define E_TABLE_MEMORY_STORE_STRING \ + { E_TABLE_MEMORY_STORE_COLUMN_TYPE_STRING, { NULL }, FALSE } +typedef struct _ETableMemoryStore ETableMemoryStore; +typedef struct _ETableMemoryStoreClass ETableMemoryStoreClass; typedef struct _ETableMemoryStorePrivate ETableMemoryStorePrivate; -typedef struct { +struct _ETableMemoryStore { ETableMemory parent; - ETableMemoryStorePrivate *priv; -} ETableMemoryStore; +}; -typedef struct { +struct _ETableMemoryStoreClass { ETableMemoryClass parent_class; -} ETableMemoryStoreClass; - -GType e_table_memory_store_get_type (void); +}; -/* Object Creation */ -ETableModel *e_table_memory_store_new (ETableMemoryStoreColumnInfo *columns); -ETableModel *e_table_memory_store_construct (ETableMemoryStore *store, - ETableMemoryStoreColumnInfo *columns); +GType e_table_memory_store_get_type (void) G_GNUC_CONST; +ETableModel * e_table_memory_store_new (ETableMemoryStoreColumnInfo *columns); +ETableModel * e_table_memory_store_construct (ETableMemoryStore *store, + ETableMemoryStoreColumnInfo *columns); /* Adopt a value instead of copying it. */ -void e_table_memory_store_adopt_value_at (ETableMemoryStore *etms, - gint col, - gint row, - void *value); +void e_table_memory_store_adopt_value_at + (ETableMemoryStore *etms, + gint col, + gint row, + gpointer value); /* The size of these arrays is the number of columns. */ -void e_table_memory_store_insert_array (ETableMemoryStore *etms, - gint row, - void **store, - gpointer data); -void e_table_memory_store_insert (ETableMemoryStore *etms, - gint row, - gpointer data, - ...); -void e_table_memory_store_insert_adopt (ETableMemoryStore *etms, - gint row, - gpointer data, - ...); -void e_table_memory_store_insert_adopt_array (ETableMemoryStore *etms, - gint row, - void **store, - gpointer data); -void e_table_memory_store_change_array (ETableMemoryStore *etms, - gint row, - void **store, - gpointer data); -void e_table_memory_store_change (ETableMemoryStore *etms, - gint row, - gpointer data, - ...); -void e_table_memory_store_change_adopt (ETableMemoryStore *etms, - gint row, - gpointer data, - ...); -void e_table_memory_store_change_adopt_array (ETableMemoryStore *etms, - gint row, - void **store, - gpointer data); -void e_table_memory_store_remove (ETableMemoryStore *etms, - gint row); -void e_table_memory_store_clear (ETableMemoryStore *etms); +void e_table_memory_store_insert_array + (ETableMemoryStore *etms, + gint row, + gpointer *store, + gpointer data); +void e_table_memory_store_insert (ETableMemoryStore *etms, + gint row, + gpointer data, + ...); +void e_table_memory_store_insert_adopt + (ETableMemoryStore *etms, + gint row, + gpointer data, + ...); +void e_table_memory_store_insert_adopt_array + (ETableMemoryStore *etms, + gint row, + gpointer *store, + gpointer data); +void e_table_memory_store_change_array + (ETableMemoryStore *etms, + gint row, + gpointer *store, + gpointer data); +void e_table_memory_store_change (ETableMemoryStore *etms, + gint row, + gpointer data, + ...); +void e_table_memory_store_change_adopt + (ETableMemoryStore *etms, + gint row, + gpointer data, + ...); +void e_table_memory_store_change_adopt_array + (ETableMemoryStore *etms, + gint row, + gpointer *store, + gpointer data); +void e_table_memory_store_remove (ETableMemoryStore *etms, + gint row); +void e_table_memory_store_clear (ETableMemoryStore *etms); G_END_DECLS diff --git a/widgets/table/e-table-memory.c b/widgets/table/e-table-memory.c index ca338ab1ca..0c0237531b 100644 --- a/widgets/table/e-table-memory.c +++ b/widgets/table/e-table-memory.c @@ -37,30 +37,28 @@ #include "e-table-memory.h" -G_DEFINE_TYPE (ETableMemory, e_table_memory, E_TABLE_MODEL_TYPE) +#define E_TABLE_MEMORY_GET_PRIVATE(obj) \ + (G_TYPE_INSTANCE_GET_PRIVATE \ + ((obj), E_TYPE_TABLE_MEMORY, ETableMemoryPrivate)) -struct ETableMemoryPriv { +G_DEFINE_TYPE (ETableMemory, e_table_memory, E_TYPE_TABLE_MODEL) + +struct _ETableMemoryPrivate { gpointer *data; gint num_rows; gint frozen; }; - -/* virtual methods */ - static void etmm_finalize (GObject *object) { - ETableMemory *etmm = E_TABLE_MEMORY (object); - ETableMemoryPriv *priv = etmm->priv; + ETableMemoryPrivate *priv; - /* XXX lots of stuff to free here */ - if (priv) { - g_free (priv->data); - g_free (priv); - } - etmm->priv = NULL; + priv = E_TABLE_MEMORY_GET_PRIVATE (object); + + g_free (priv->data); + /* Chain up to parent's finalize() method. */ G_OBJECT_CLASS (e_table_memory_parent_class)->finalize (object); } @@ -72,29 +70,25 @@ etmm_row_count (ETableModel *etm) return etmm->priv->num_rows; } - static void -e_table_memory_class_init (ETableMemoryClass *klass) +e_table_memory_class_init (ETableMemoryClass *class) { - ETableModelClass *table_class = E_TABLE_MODEL_CLASS (klass); - GObjectClass *object_class = G_OBJECT_CLASS (klass); + GObjectClass *object_class; + ETableModelClass *table_model_class; + + g_type_class_add_private (class, sizeof (ETableMemoryPrivate)); - object_class->finalize = etmm_finalize; + object_class = G_OBJECT_CLASS (class); + object_class->finalize = etmm_finalize; - table_class->row_count = etmm_row_count; + table_model_class = E_TABLE_MODEL_CLASS (class); + table_model_class->row_count = etmm_row_count; } static void e_table_memory_init (ETableMemory *etmm) { - ETableMemoryPriv *priv; - - priv = g_new0 (ETableMemoryPriv, 1); - etmm->priv = priv; - - priv->data = NULL; - priv->num_rows = 0; - priv->frozen = 0; + etmm->priv = E_TABLE_MEMORY_GET_PRIVATE (etmm); } /** @@ -107,7 +101,7 @@ e_table_memory_init (ETableMemory *etmm) ETableMemory * e_table_memory_new (void) { - return g_object_new (E_TABLE_MEMORY_TYPE, NULL); + return g_object_new (E_TYPE_TABLE_MEMORY, NULL); } /** @@ -245,7 +239,7 @@ e_table_memory_clear (ETableMemory *etmm) void e_table_memory_freeze (ETableMemory *etmm) { - ETableMemoryPriv *priv = etmm->priv; + ETableMemoryPrivate *priv = etmm->priv; if (priv->frozen == 0) e_table_model_pre_change (E_TABLE_MODEL (etmm)); @@ -265,7 +259,7 @@ e_table_memory_freeze (ETableMemory *etmm) void e_table_memory_thaw (ETableMemory *etmm) { - ETableMemoryPriv *priv = etmm->priv; + ETableMemoryPrivate *priv = etmm->priv; if (priv->frozen > 0) priv->frozen--; diff --git a/widgets/table/e-table-memory.h b/widgets/table/e-table-memory.h index 8de51b7c5e..853f378c9e 100644 --- a/widgets/table/e-table-memory.h +++ b/widgets/table/e-table-memory.h @@ -26,48 +26,60 @@ #include <gdk-pixbuf/gdk-pixbuf.h> #include <table/e-table-model.h> -G_BEGIN_DECLS +/* Standard GObject macros */ +#define E_TYPE_TABLE_MEMORY \ + (e_table_memory_get_type ()) +#define E_TABLE_MEMORY(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST \ + ((obj), E_TYPE_TABLE_MEMORY, ETableMemory)) +#define E_TABLE_MEMORY_CLASS(cls) \ + (G_TYPE_CHECK_CLASS_CAST \ + ((cls), E_TYPE_TABLE_MEMORY, ETableMemoryClass)) +#define E_IS_TABLE_MEMORY(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE \ + ((obj), E_TYPE_TABLE_MEMORY)) +#define E_IS_TABLE_MEMORY_CLASS(cls) \ + (G_TYPE_CHECK_CLASS_TYPE \ + ((cls), E_TYPE_TABLE_MEMORY)) +#define E_TABLE_MEMORY_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS \ + ((obj), E_TYPE_TABLE_MEMORY, ETableMemoryClass)) -#define E_TABLE_MEMORY_TYPE (e_table_memory_get_type ()) -#define E_TABLE_MEMORY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), E_TABLE_MEMORY_TYPE, ETableMemory)) -#define E_TABLE_MEMORY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k), E_TABLE_MEMORY_TYPE, ETableMemoryClass)) -#define E_IS_TABLE_MEMORY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), E_TABLE_MEMORY_TYPE)) -#define E_IS_TABLE_MEMORY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), E_TABLE_MEMORY_TYPE)) -#define E_TABLE_MEMORY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS((o), E_TABLE_MEMORY_TYPE, ETableMemoryClass)) +G_BEGIN_DECLS -typedef struct ETableMemory ETableMemory; -typedef struct ETableMemoryPriv ETableMemoryPriv; -typedef struct ETableMemoryClass ETableMemoryClass; +typedef struct _ETableMemory ETableMemory; +typedef struct _ETableMemoryClass ETableMemoryClass; +typedef struct _ETableMemoryPrivate ETableMemoryPrivate; -struct ETableMemory { - ETableModel base; - ETableMemoryPriv *priv; +struct _ETableMemory { + ETableModel parent; + ETableMemoryPrivate *priv; }; -struct ETableMemoryClass { +struct _ETableMemoryClass { ETableModelClass parent_class; }; -GType e_table_memory_get_type (void); -void e_table_memory_construct (ETableMemory *etable); -ETableMemory *e_table_memory_new (void); +GType e_table_memory_get_type (void) G_GNUC_CONST; +ETableMemory * e_table_memory_new (void); +void e_table_memory_construct (ETableMemory *etable); /* row operations */ -void e_table_memory_insert (ETableMemory *etable, - gint row, - gpointer data); -gpointer e_table_memory_remove (ETableMemory *etable, - gint row); -void e_table_memory_clear (ETableMemory *etable); +void e_table_memory_insert (ETableMemory *etable, + gint row, + gpointer data); +gpointer e_table_memory_remove (ETableMemory *etable, + gint row); +void e_table_memory_clear (ETableMemory *etable); /* Freeze and thaw */ -void e_table_memory_freeze (ETableMemory *etable); -void e_table_memory_thaw (ETableMemory *etable); -gpointer e_table_memory_get_data (ETableMemory *etm, - gint row); -void e_table_memory_set_data (ETableMemory *etm, - gint row, - gpointer data); +void e_table_memory_freeze (ETableMemory *etable); +void e_table_memory_thaw (ETableMemory *etable); +gpointer e_table_memory_get_data (ETableMemory *etm, + gint row); +void e_table_memory_set_data (ETableMemory *etm, + gint row, + gpointer data); G_END_DECLS diff --git a/widgets/table/e-table-model.c b/widgets/table/e-table-model.c index dbe01a345c..308cdb0c58 100644 --- a/widgets/table/e-table-model.c +++ b/widgets/table/e-table-model.c @@ -271,9 +271,9 @@ e_table_model_finalize (GObject *object) } static void -e_table_model_class_init (ETableModelClass *klass) +e_table_model_class_init (ETableModelClass *class) { - GObjectClass *object_class = G_OBJECT_CLASS (klass); + GObjectClass *object_class = G_OBJECT_CLASS (class); object_class->finalize = e_table_model_finalize; @@ -340,31 +340,31 @@ e_table_model_class_init (ETableModelClass *klass) e_marshal_VOID__INT_INT, G_TYPE_NONE, 2, G_TYPE_INT, G_TYPE_INT); - klass->column_count = NULL; - klass->row_count = NULL; - klass->append_row = NULL; + class->column_count = NULL; + class->row_count = NULL; + class->append_row = NULL; - klass->value_at = NULL; - klass->set_value_at = NULL; - klass->is_cell_editable = NULL; + class->value_at = NULL; + class->set_value_at = NULL; + class->is_cell_editable = NULL; - klass->has_save_id = NULL; - klass->get_save_id = NULL; + class->has_save_id = NULL; + class->get_save_id = NULL; - klass->has_change_pending = NULL; + class->has_change_pending = NULL; - klass->duplicate_value = NULL; - klass->free_value = NULL; - klass->initialize_value = NULL; - klass->value_is_empty = NULL; - klass->value_to_string = NULL; + class->duplicate_value = NULL; + class->free_value = NULL; + class->initialize_value = NULL; + class->value_is_empty = NULL; + class->value_to_string = NULL; - klass->model_no_change = NULL; - klass->model_changed = NULL; - klass->model_row_changed = NULL; - klass->model_cell_changed = NULL; - klass->model_rows_inserted = NULL; - klass->model_rows_deleted = NULL; + class->model_no_change = NULL; + class->model_changed = NULL; + class->model_row_changed = NULL; + class->model_cell_changed = NULL; + class->model_rows_inserted = NULL; + class->model_rows_deleted = NULL; } static void @@ -393,7 +393,7 @@ e_table_model_pre_change (ETableModel *e_table_model) return; d (print_tabs ()); - d(g_print("Emitting pre_change on model 0x%p, a %s.\n", e_table_model, g_type_name (G_OBJECT(e_table_model)->klass->type))); + d(g_print("Emitting pre_change on model 0x%p, a %s.\n", e_table_model, g_type_name (G_OBJECT(e_table_model)->class->type))); d (depth++); g_signal_emit (G_OBJECT (e_table_model), e_table_model_signals[MODEL_PRE_CHANGE], 0); @@ -423,7 +423,7 @@ e_table_model_no_change (ETableModel *e_table_model) return; d (print_tabs ()); - d(g_print("Emitting model_no_change on model 0x%p, a %s.\n", e_table_model, g_type_name (G_OBJECT(e_table_model)->klass->type))); + d(g_print("Emitting model_no_change on model 0x%p, a %s.\n", e_table_model, g_type_name (G_OBJECT(e_table_model)->class->type))); d (depth++); g_signal_emit (G_OBJECT (e_table_model), e_table_model_signals[MODEL_NO_CHANGE], 0); @@ -453,7 +453,7 @@ e_table_model_changed (ETableModel *e_table_model) return; d (print_tabs ()); - d(g_print("Emitting model_changed on model 0x%p, a %s.\n", e_table_model, g_type_name (G_OBJECT(e_table_model)->klass->type))); + d(g_print("Emitting model_changed on model 0x%p, a %s.\n", e_table_model, g_type_name (G_OBJECT(e_table_model)->class->type))); d (depth++); g_signal_emit (G_OBJECT (e_table_model), e_table_model_signals[MODEL_CHANGED], 0); @@ -480,7 +480,7 @@ e_table_model_row_changed (ETableModel *e_table_model, gint row) return; d (print_tabs ()); - d(g_print("Emitting row_changed on model 0x%p, a %s, row %d.\n", e_table_model, g_type_name (G_OBJECT(e_table_model)->klass->type), row)); + d(g_print("Emitting row_changed on model 0x%p, a %s, row %d.\n", e_table_model, g_type_name (G_OBJECT(e_table_model)->class->type), row)); d (depth++); g_signal_emit (G_OBJECT (e_table_model), e_table_model_signals[MODEL_ROW_CHANGED], 0, row); @@ -508,7 +508,7 @@ e_table_model_cell_changed (ETableModel *e_table_model, gint col, gint row) return; d (print_tabs ()); - d(g_print("Emitting cell_changed on model 0x%p, a %s, row %d, col %d.\n", e_table_model, g_type_name (G_OBJECT(e_table_model)->klass->type), row, col)); + d(g_print("Emitting cell_changed on model 0x%p, a %s, row %d, col %d.\n", e_table_model, g_type_name (G_OBJECT(e_table_model)->class->type), row, col)); d (depth++); g_signal_emit (G_OBJECT (e_table_model), e_table_model_signals[MODEL_CELL_CHANGED], 0, col, row); @@ -536,7 +536,7 @@ e_table_model_rows_inserted (ETableModel *e_table_model, gint row, gint count) return; d (print_tabs ()); - d(g_print("Emitting row_inserted on model 0x%p, a %s, row %d.\n", e_table_model, g_type_name (G_OBJECT(e_table_model)->klass->type), row)); + d(g_print("Emitting row_inserted on model 0x%p, a %s, row %d.\n", e_table_model, g_type_name (G_OBJECT(e_table_model)->class->type), row)); d (depth++); g_signal_emit (G_OBJECT (e_table_model), e_table_model_signals[MODEL_ROWS_INSERTED], 0, row, count); @@ -579,7 +579,7 @@ e_table_model_rows_deleted (ETableModel *e_table_model, gint row, gint count) return; d (print_tabs ()); - d(g_print("Emitting row_deleted on model 0x%p, a %s, row %d.\n", e_table_model, g_type_name (G_OBJECT(e_table_model)->klass->type), row)); + d(g_print("Emitting row_deleted on model 0x%p, a %s, row %d.\n", e_table_model, g_type_name (G_OBJECT(e_table_model)->class->type), row)); d (depth++); g_signal_emit (G_OBJECT (e_table_model), e_table_model_signals[MODEL_ROWS_DELETED], 0, row, count); diff --git a/widgets/table/e-table-model.h b/widgets/table/e-table-model.h index e319b1ff42..2ff4eacebd 100644 --- a/widgets/table/e-table-model.h +++ b/widgets/table/e-table-model.h @@ -26,48 +26,82 @@ #include <glib-object.h> +/* Standard GObject macros */ +#define E_TYPE_TABLE_MODEL \ + (e_table_model_get_type ()) +#define E_TABLE_MODEL(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST \ + ((obj), E_TYPE_TABLE_MODEL, ETableModel)) +#define E_TABLE_MODEL_CLASS(cls) \ + (G_TYPE_CHECK_CLASS_CAST \ + ((cls), E_TYPE_TABLE_MODEL, ETableModelClass)) +#define E_IS_TABLE_MODEL(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE \ + ((obj), E_TYPE_TABLE_MODEL)) +#define E_IS_TABLE_MODEL_CLASS(cls) \ + (G_TYPE_CHECK_CLASS_TYPE \ + ((cls), E_TYPE_TABLE_MODEL)) +#define E_TABLE_MODEL_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS \ + ((obj), E_TYPE_TABLE_MODEL, ETableModelClass)) + G_BEGIN_DECLS -#define E_TABLE_MODEL_TYPE (e_table_model_get_type ()) -#define E_TABLE_MODEL(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), E_TABLE_MODEL_TYPE, ETableModel)) -#define E_TABLE_MODEL_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k), E_TABLE_MODEL_TYPE, ETableModelClass)) -#define E_IS_TABLE_MODEL(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), E_TABLE_MODEL_TYPE)) -#define E_IS_TABLE_MODEL_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), E_TABLE_MODEL_TYPE)) -#define E_TABLE_MODEL_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS((o), E_TABLE_MODEL_TYPE, ETableModelClass)) +typedef struct _ETableModel ETableModel; +typedef struct _ETableModelClass ETableModelClass; -typedef struct { - GObject base; -} ETableModel; +struct _ETableModel { + GObject parent; +}; -typedef struct { +struct _ETableModelClass { GObjectClass parent_class; /* * Virtual methods */ - gint (*column_count) (ETableModel *etm); - gint (*row_count) (ETableModel *etm); - void (*append_row) (ETableModel *etm, ETableModel *source, gint row); - - void *(*value_at) (ETableModel *etm, gint col, gint row); - void (*set_value_at) (ETableModel *etm, gint col, gint row, gconstpointer value); - gboolean (*is_cell_editable) (ETableModel *etm, gint col, gint row); - - gboolean (*has_save_id) (ETableModel *etm); - gchar *(*get_save_id) (ETableModel *etm, gint row); - - gboolean (*has_change_pending) (ETableModel *etm); + gint (*column_count) (ETableModel *etm); + gint (*row_count) (ETableModel *etm); + void (*append_row) (ETableModel *etm, + ETableModel *source, + gint row); + + gpointer (*value_at) (ETableModel *etm, + gint col, + gint row); + void (*set_value_at) (ETableModel *etm, + gint col, + gint row, + gconstpointer value); + gboolean (*is_cell_editable) (ETableModel *etm, + gint col, + gint row); + + gboolean (*has_save_id) (ETableModel *etm); + gchar * (*get_save_id) (ETableModel *etm, + gint row); + + gboolean (*has_change_pending) (ETableModel *etm); /* Allocate a copy of the given value. */ - void *(*duplicate_value) (ETableModel *etm, gint col, gconstpointer value); + gpointer (*duplicate_value) (ETableModel *etm, + gint col, + gconstpointer value); /* Free an allocated value. */ - void (*free_value) (ETableModel *etm, gint col, gpointer value); + void (*free_value) (ETableModel *etm, + gint col, + gpointer value); /* Return an allocated empty value. */ - void *(*initialize_value) (ETableModel *etm, gint col); + gpointer (*initialize_value) (ETableModel *etm, + gint col); /* Return TRUE if value is equivalent to an empty cell. */ - gboolean (*value_is_empty) (ETableModel *etm, gint col, gconstpointer value); + gboolean (*value_is_empty) (ETableModel *etm, + gint col, + gconstpointer value); /* Return an allocated string. */ - gchar *(*value_to_string) (ETableModel *etm, gint col, gconstpointer value); + gchar * (*value_to_string) (ETableModel *etm, + gint col, + gconstpointer value); /* * Signals @@ -82,89 +116,97 @@ typedef struct { * A row inserted: row_inserted * A row deleted: row_deleted */ - void (*model_pre_change) (ETableModel *etm); - - void (*model_no_change) (ETableModel *etm); - void (*model_changed) (ETableModel *etm); - void (*model_row_changed) (ETableModel *etm, gint row); - void (*model_cell_changed) (ETableModel *etm, gint col, gint row); - void (*model_rows_inserted) (ETableModel *etm, gint row, gint count); - void (*model_rows_deleted) (ETableModel *etm, gint row, gint count); -} ETableModelClass; - -GType e_table_model_get_type (void); + void (*model_pre_change) (ETableModel *etm); + + void (*model_no_change) (ETableModel *etm); + void (*model_changed) (ETableModel *etm); + void (*model_row_changed) (ETableModel *etm, + gint row); + void (*model_cell_changed) (ETableModel *etm, + gint col, + gint row); + void (*model_rows_inserted) (ETableModel *etm, + gint row, + gint count); + void (*model_rows_deleted) (ETableModel *etm, + gint row, + gint count); +}; + +GType e_table_model_get_type (void) G_GNUC_CONST; /**/ -gint e_table_model_column_count (ETableModel *e_table_model); -const gchar *e_table_model_column_name (ETableModel *e_table_model, - gint col); -gint e_table_model_row_count (ETableModel *e_table_model); -void e_table_model_append_row (ETableModel *e_table_model, - ETableModel *source, - gint row); +gint e_table_model_column_count (ETableModel *e_table_model); +const gchar * e_table_model_column_name (ETableModel *e_table_model, + gint col); +gint e_table_model_row_count (ETableModel *e_table_model); +void e_table_model_append_row (ETableModel *e_table_model, + ETableModel *source, + gint row); /**/ -void *e_table_model_value_at (ETableModel *e_table_model, - gint col, - gint row); -void e_table_model_set_value_at (ETableModel *e_table_model, - gint col, - gint row, - const void *value); -gboolean e_table_model_is_cell_editable (ETableModel *e_table_model, - gint col, - gint row); +gpointer e_table_model_value_at (ETableModel *e_table_model, + gint col, + gint row); +void e_table_model_set_value_at (ETableModel *e_table_model, + gint col, + gint row, + gconstpointer value); +gboolean e_table_model_is_cell_editable (ETableModel *e_table_model, + gint col, + gint row); /**/ -gboolean e_table_model_has_save_id (ETableModel *etm); -gchar *e_table_model_get_save_id (ETableModel *etm, - gint row); +gboolean e_table_model_has_save_id (ETableModel *etm); +gchar * e_table_model_get_save_id (ETableModel *etm, + gint row); /**/ -gboolean e_table_model_has_change_pending (ETableModel *etm); +gboolean e_table_model_has_change_pending + (ETableModel *etm); /**/ -void *e_table_model_duplicate_value (ETableModel *e_table_model, - gint col, - const void *value); -void e_table_model_free_value (ETableModel *e_table_model, - gint col, - void *value); -void *e_table_model_initialize_value (ETableModel *e_table_model, - gint col); -gboolean e_table_model_value_is_empty (ETableModel *e_table_model, - gint col, - const void *value); -gchar *e_table_model_value_to_string (ETableModel *e_table_model, - gint col, - const void *value); +gpointer e_table_model_duplicate_value (ETableModel *e_table_model, + gint col, + gconstpointer value); +void e_table_model_free_value (ETableModel *e_table_model, + gint col, + gpointer value); +gpointer e_table_model_initialize_value (ETableModel *e_table_model, + gint col); +gboolean e_table_model_value_is_empty (ETableModel *e_table_model, + gint col, + gconstpointer value); +gchar * e_table_model_value_to_string (ETableModel *e_table_model, + gint col, + gconstpointer value); /* * Routines for emitting signals on the e_table */ -void e_table_model_pre_change (ETableModel *e_table_model); -void e_table_model_no_change (ETableModel *e_table_model); -void e_table_model_changed (ETableModel *e_table_model); -void e_table_model_row_changed (ETableModel *e_table_model, - gint row); -void e_table_model_cell_changed (ETableModel *e_table_model, - gint col, - gint row); -void e_table_model_rows_inserted (ETableModel *e_table_model, -gint row, -gint count); -void e_table_model_rows_deleted (ETableModel *e_table_model, -gint row, -gint count); +void e_table_model_pre_change (ETableModel *e_table_model); +void e_table_model_no_change (ETableModel *e_table_model); +void e_table_model_changed (ETableModel *e_table_model); +void e_table_model_row_changed (ETableModel *e_table_model, + gint row); +void e_table_model_cell_changed (ETableModel *e_table_model, + gint col, + gint row); +void e_table_model_rows_inserted (ETableModel *e_table_model, + gint row, + gint count); +void e_table_model_rows_deleted (ETableModel *e_table_model, + gint row, + gint count); /**/ -void e_table_model_row_inserted (ETableModel *e_table_model, -gint row); -void e_table_model_row_deleted (ETableModel *e_table_model, -gint row); +void e_table_model_row_inserted (ETableModel *e_table_model, + gint row); +void e_table_model_row_deleted (ETableModel *e_table_model, + gint row); -void e_table_model_freeze (ETableModel *e_table_model); -void e_table_model_thaw (ETableModel *e_table_model); +void e_table_model_freeze (ETableModel *e_table_model); +void e_table_model_thaw (ETableModel *e_table_model); G_END_DECLS diff --git a/widgets/table/e-table-one.c b/widgets/table/e-table-one.c index b58b0b8631..ed8a481104 100644 --- a/widgets/table/e-table-one.c +++ b/widgets/table/e-table-one.c @@ -27,7 +27,7 @@ #include "e-table-one.h" -G_DEFINE_TYPE (ETableOne, e_table_one, E_TABLE_MODEL_TYPE) +G_DEFINE_TYPE (ETableOne, e_table_one, E_TYPE_TABLE_MODEL) static gint one_column_count (ETableModel *etm) @@ -167,10 +167,10 @@ one_dispose (GObject *object) } static void -e_table_one_class_init (ETableOneClass *klass) +e_table_one_class_init (ETableOneClass *class) { - GObjectClass *object_class = G_OBJECT_CLASS (klass); - ETableModelClass *model_class = E_TABLE_MODEL_CLASS (klass); + GObjectClass *object_class = G_OBJECT_CLASS (class); + ETableModelClass *model_class = E_TABLE_MODEL_CLASS (class); model_class->column_count = one_column_count; model_class->row_count = one_row_count; @@ -201,7 +201,7 @@ e_table_one_new (ETableModel *source) gint col_count; gint i; - eto = g_object_new (E_TABLE_ONE_TYPE, NULL); + eto = g_object_new (E_TYPE_TABLE_ONE, NULL); eto->source = source; col_count = e_table_model_column_count (source); diff --git a/widgets/table/e-table-one.h b/widgets/table/e-table-one.h index 2984aeaa76..a0d5c7bf88 100644 --- a/widgets/table/e-table-one.h +++ b/widgets/table/e-table-one.h @@ -25,30 +25,45 @@ #include <table/e-table-model.h> +/* Standard GObject macros */ +#define E_TYPE_TABLE_ONE \ + (e_table_one_get_type ()) +#define E_TABLE_ONE(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST \ + ((obj), E_TYPE_TABLE_ONE, ETableOne)) +#define E_TABLE_ONE_CLASS(cls) \ + (G_TYPE_CHECK_CLASS_CAST \ + ((cls), E_TYPE_TABLE_ONE, ETableOneClass)) +#define E_IS_TABLE_ONE(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE \ + ((obj), E_TYPE_TABLE_ONE)) +#define E_IS_TABLE_ONE_CLASS(cls) \ + (G_TYPE_CHECK_CLASS_TYPE \ + ((cls), E_TYPE_TABLE_ONE)) +#define E_TABLE_ONE_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS \ + ((obj), E_TYPE_TABLE_ONE, ETableOneClass)) + G_BEGIN_DECLS -#define E_TABLE_ONE_TYPE (e_table_one_get_type ()) -#define E_TABLE_ONE(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), E_TABLE_ONE_TYPE, ETableOne)) -#define E_TABLE_ONE_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k), E_TABLE_ONE_TYPE, ETableOneClass)) -#define E_IS_TABLE_ONE(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), E_TABLE_ONE_TYPE)) -#define E_IS_TABLE_ONE_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), E_TABLE_ONE_TYPE)) -#define E_TABLE_ONE_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((obj), E_TABLE_ONE_TYPE, ETableOneClass)) +typedef struct _ETableOne ETableOne; +typedef struct _ETableOneClass ETableOneClass; -typedef struct { - ETableModel parent; +struct _ETableOne { + ETableModel parent; ETableModel *source; - void **data; -} ETableOne; + gpointer *data; +}; -typedef struct { +struct _ETableOneClass { ETableModelClass parent_class; -} ETableOneClass; +}; -GType e_table_one_get_type (void); +GType e_table_one_get_type (void) G_GNUC_CONST; -ETableModel *e_table_one_new (ETableModel *source); -void e_table_one_commit (ETableOne *one); +ETableModel * e_table_one_new (ETableModel *source); +void e_table_one_commit (ETableOne *one); G_END_DECLS diff --git a/widgets/table/e-table-search.c b/widgets/table/e-table-search.c index 1f2f5b1a0b..10ed919571 100644 --- a/widgets/table/e-table-search.c +++ b/widgets/table/e-table-search.c @@ -30,6 +30,10 @@ #define d(x) +#define E_TABLE_SEARCH_GET_PRIVATE(obj) \ + (G_TYPE_INSTANCE_GET_PRIVATE \ + ((obj), E_TYPE_TABLE_SEARCH, ETableSearchPrivate)) + d (static gint depth = 0) struct _ETableSearchPrivate { @@ -106,21 +110,26 @@ add_timeout (ETableSearch *ets) static void e_table_search_finalize (GObject *object) { - ETableSearch *ets = (ETableSearch *) object; + ETableSearchPrivate *priv; - drop_timeout (ets); - g_free (ets->priv->search_string); - g_free (ets->priv); + priv = E_TABLE_SEARCH_GET_PRIVATE (object); + + drop_timeout (E_TABLE_SEARCH (object)); + + g_free (priv->search_string); - if (G_OBJECT_CLASS (e_table_search_parent_class)->finalize) - (*G_OBJECT_CLASS (e_table_search_parent_class)->finalize)(object); + /* Chain up to parent's finalize() method. */ + G_OBJECT_CLASS (e_table_search_parent_class)->finalize (object); } static void -e_table_search_class_init (ETableSearchClass *klass) +e_table_search_class_init (ETableSearchClass *class) { - GObjectClass *object_class = G_OBJECT_CLASS (klass); + GObjectClass *object_class; + g_type_class_add_private (class, sizeof (ETableSearchPrivate)); + + object_class = G_OBJECT_CLASS (class); object_class->finalize = e_table_search_finalize; e_table_search_signals[SEARCH_SEARCH] = @@ -141,26 +150,22 @@ e_table_search_class_init (ETableSearchClass *klass) g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0); - klass->search = NULL; - klass->accept = NULL; + class->search = NULL; + class->accept = NULL; } static void e_table_search_init (ETableSearch *ets) { - ets->priv = g_new (ETableSearchPrivate, 1); + ets->priv = E_TABLE_SEARCH_GET_PRIVATE (ets); - ets->priv->timeout_id = 0; ets->priv->search_string = g_strdup (""); - ets->priv->last_character = 0; } ETableSearch * e_table_search_new (void) { - ETableSearch *ets = g_object_new (E_TABLE_SEARCH_TYPE, NULL); - - return ets; + return g_object_new (E_TYPE_TABLE_SEARCH, NULL); } /** diff --git a/widgets/table/e-table-search.h b/widgets/table/e-table-search.h index 798d81bd2d..ecd56a5d72 100644 --- a/widgets/table/e-table-search.h +++ b/widgets/table/e-table-search.h @@ -26,45 +26,56 @@ #include <glib-object.h> -G_BEGIN_DECLS +/* Standard GObject macros */ +#define E_TYPE_TABLE_SEARCH \ + (e_table_search_get_type ()) +#define E_TABLE_SEARCH(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST \ + ((obj), E_TYPE_TABLE_SEARCH, ETableSearch)) +#define E_TABLE_SEARCH_CLASS(cls) \ + (G_TYPE_CHECK_CLASS_CAST \ + ((cls), E_TYPE_TABLE_SEARCH, ETableSearchClass)) +#define E_IS_TABLE_SEARCH(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE \ + ((obj), E_TYPE_TABLE_SEARCH)) +#define E_IS_TABLE_SEARCH_CLASS(cls) \ + (G_TYPE_CHECK_CLASS_TYPE \ + ((cls), E_TYPE_TABLE_SEARCH)) +#define E_TABLE_SEARCH_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS \ + ((obj), E_TYPE_TABLE_SEARCH, ETableSearchClass)) -#define E_TABLE_SEARCH_TYPE (e_table_search_get_type ()) -#define E_TABLE_SEARCH(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), E_TABLE_SEARCH_TYPE, ETableSearch)) -#define E_TABLE_SEARCH_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k), E_TABLE_SEARCH_TYPE, ETableSearchClass)) -#define E_IS_TABLE_SEARCH(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), E_TABLE_SEARCH_TYPE)) -#define E_IS_TABLE_SEARCH_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), E_TABLE_SEARCH_TYPE)) -#define E_TABLE_SEARCH_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS((o), E_TABLE_SEARCH_TYPE, ETableSearchClass)) +G_BEGIN_DECLS +typedef struct _ETableSearch ETableSearch; +typedef struct _ETableSearchClass ETableSearchClass; typedef struct _ETableSearchPrivate ETableSearchPrivate; typedef enum { E_TABLE_SEARCH_FLAGS_CHECK_CURSOR_FIRST = 1 << 0 } ETableSearchFlags; -typedef struct { - GObject base; - +struct _ETableSearch { + GObject parent; ETableSearchPrivate *priv; -} ETableSearch; +}; -typedef struct { +struct _ETableSearchClass { GObjectClass parent_class; - /* - * Signals - */ - gboolean (*search) (ETableSearch *ets, gchar *string /* utf8 */, ETableSearchFlags flags); - void (*accept) (ETableSearch *ets); -} ETableSearchClass; - -GType e_table_search_get_type (void); -ETableSearch *e_table_search_new (void); + /* Signals */ + gboolean (*search) (ETableSearch *ets, + gchar *string /* utf8 */, + ETableSearchFlags flags); + void (*accept) (ETableSearch *ets); +}; -/**/ -void e_table_search_input_character (ETableSearch *e_table_search, - gunichar character); -gboolean e_table_search_backspace (ETableSearch *e_table_search); -void e_table_search_cancel (ETableSearch *e_table_search); +GType e_table_search_get_type (void) G_GNUC_CONST; +ETableSearch * e_table_search_new (void); +void e_table_search_input_character (ETableSearch *e_table_search, + gunichar character); +gboolean e_table_search_backspace (ETableSearch *e_table_search); +void e_table_search_cancel (ETableSearch *e_table_search); G_END_DECLS diff --git a/widgets/table/e-table-selection-model.c b/widgets/table/e-table-selection-model.c index b459dd1da1..7c11d1bd4a 100644 --- a/widgets/table/e-table-selection-model.c +++ b/widgets/table/e-table-selection-model.c @@ -283,13 +283,13 @@ e_table_selection_model_init (ETableSelectionModel *selection) } static void -e_table_selection_model_class_init (ETableSelectionModelClass *klass) +e_table_selection_model_class_init (ETableSelectionModelClass *class) { GObjectClass *object_class; ESelectionModelArrayClass *esma_class; - object_class = G_OBJECT_CLASS (klass); - esma_class = E_SELECTION_MODEL_ARRAY_CLASS (klass); + object_class = G_OBJECT_CLASS (class); + esma_class = E_SELECTION_MODEL_ARRAY_CLASS (class); object_class->dispose = etsm_dispose; object_class->get_property = etsm_get_property; @@ -301,14 +301,14 @@ e_table_selection_model_class_init (ETableSelectionModelClass *klass) g_param_spec_object ("model", "Model", NULL, - E_TABLE_MODEL_TYPE, + E_TYPE_TABLE_MODEL, G_PARAM_READWRITE)); g_object_class_install_property (object_class, PROP_HEADER, g_param_spec_object ("header", "Header", NULL, - E_TABLE_HEADER_TYPE, + E_TYPE_TABLE_HEADER, G_PARAM_READWRITE)); } @@ -322,7 +322,7 @@ e_table_selection_model_class_init (ETableSelectionModelClass *klass) ETableSelectionModel * e_table_selection_model_new (void) { - return g_object_new (E_TABLE_SELECTION_MODEL_TYPE, NULL); + return g_object_new (E_TYPE_TABLE_SELECTION_MODEL, NULL); } static gint diff --git a/widgets/table/e-table-selection-model.h b/widgets/table/e-table-selection-model.h index ab504ac711..f144980f03 100644 --- a/widgets/table/e-table-selection-model.h +++ b/widgets/table/e-table-selection-model.h @@ -24,21 +24,36 @@ #ifndef _E_TABLE_SELECTION_MODEL_H_ #define _E_TABLE_SELECTION_MODEL_H_ -#include <glib-object.h> #include <misc/e-selection-model-array.h> #include <table/e-table-model.h> #include <table/e-table-header.h> +/* Standard GObject macros */ +#define E_TYPE_TABLE_SELECTION_MODEL \ + (e_table_selection_model_get_type ()) +#define E_TABLE_SELECTION_MODEL(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST \ + ((obj), E_TYPE_TABLE_SELECTION_MODEL, ETableSelectionModel)) +#define E_TABLE_SELECTION_MODEL_CLASS(cls) \ + (G_TYPE-CHECK_CLASS_CAST \ + ((cls), E_TYPE_TABLE_SELECTION_MODEL, ETableSelectionModelClass)) +#define E_IS_TABLE_SELECTION_MODEL(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE \ + ((obj), E_TYPE_TABLE_SELECTION_MODEL)) +#define E_IS_TABLE_SELECTION_MODEL_CLASS(cls) \ + (G_TYPE_CHECK_CLASS_TYPE \ + ((cls), E_TYPE_TABLE_SELECTION_MODEL)) +#define E_TABLE_SELECTION_MODEL_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS \ + ((obj), E_TYPE_TABLE_SELECTION_MODEL, ETableSelectionModelClass)) + G_BEGIN_DECLS -#define E_TABLE_SELECTION_MODEL_TYPE (e_table_selection_model_get_type ()) -#define E_TABLE_SELECTION_MODEL(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), E_TABLE_SELECTION_MODEL_TYPE, ETableSelectionModel)) -#define E_TABLE_SELECTION_MODEL_CLASS(k) (G_TYPE-CHECK_CLASS_CAST((k), E_TABLE_SELECTION_MODEL_TYPE, ETableSelectionModelClass)) -#define E_IS_TABLE_SELECTION_MODEL(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), E_TABLE_SELECTION_MODEL_TYPE)) -#define E_IS_TABLE_SELECTION_MODEL_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), E_TABLE_SELECTION_MODEL_TYPE)) +typedef struct _ETableSelectionModel ETableSelectionModel; +typedef struct _ETableSelectionModelClass ETableSelectionModelClass; -typedef struct { - ESelectionModelArray base; +struct _ETableSelectionModel { + ESelectionModelArray parent; ETableModel *model; ETableHeader *eth; @@ -57,14 +72,15 @@ typedef struct { GHashTable *hash; gchar *cursor_id; -} ETableSelectionModel; +}; -typedef struct { +struct _ETableSelectionModelClass { ESelectionModelArrayClass parent_class; -} ETableSelectionModelClass; +}; -GType e_table_selection_model_get_type (void); -ETableSelectionModel *e_table_selection_model_new (void); +GType e_table_selection_model_get_type (void) G_GNUC_CONST; +ETableSelectionModel * + e_table_selection_model_new (void); G_END_DECLS diff --git a/widgets/table/e-table-sort-info.c b/widgets/table/e-table-sort-info.c index f7a6d89ad5..b238e6b444 100644 --- a/widgets/table/e-table-sort-info.c +++ b/widgets/table/e-table-sort-info.c @@ -71,11 +71,11 @@ e_table_sort_info_init (ETableSortInfo *info) } static void -e_table_sort_info_class_init (ETableSortInfoClass *klass) +e_table_sort_info_class_init (ETableSortInfoClass *class) { - GObjectClass * object_class = G_OBJECT_CLASS (klass); + GObjectClass * object_class = G_OBJECT_CLASS (class); - e_table_sort_info_parent_class = g_type_class_peek_parent (klass); + e_table_sort_info_parent_class = g_type_class_peek_parent (class); object_class->finalize = etsi_finalize; @@ -97,8 +97,8 @@ e_table_sort_info_class_init (ETableSortInfoClass *klass) g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0); - klass->sort_info_changed = NULL; - klass->group_info_changed = NULL; + class->sort_info_changed = NULL; + class->group_info_changed = NULL; } static void @@ -340,7 +340,7 @@ e_table_sort_info_sorting_set_nth (ETableSortInfo *info, gint n, ETableSortCol ETableSortInfo * e_table_sort_info_new (void) { - return g_object_new (E_TABLE_SORT_INFO_TYPE, NULL); + return g_object_new (E_TYPE_TABLE_SORT_INFO, NULL); } /** diff --git a/widgets/table/e-table-sort-info.h b/widgets/table/e-table-sort-info.h index d9ffec9be2..a577481150 100644 --- a/widgets/table/e-table-sort-info.h +++ b/widgets/table/e-table-sort-info.h @@ -6,7 +6,7 @@ * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public @@ -26,24 +26,38 @@ #include <glib-object.h> #include <libxml/tree.h> -G_BEGIN_DECLS +#define E_TYPE_TABLE_SORT_INFO \ + (e_table_sort_info_get_type ()) +#define E_TABLE_SORT_INFO(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST \ + ((obj), E_TYPE_TABLE_SORT_INFO, ETableSortInfo)) +#define E_TABLE_SORT_INFO_CLASS(cls) \ + (G_TYPE_CHECK_CLASS_CAST \ + ((cls), E_TYPE_TABLE_SORT_INFO, ETableSortInfoClass)) +#define E_IS_TABLE_SORT_INFO(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE \ + ((obj), E_TYPE_TABLE_SORT_INFO)) +#define E_IS_TABLE_SORT_INFO_CLASS(cls) \ + (G_TYPE_CHECK_CLASS_TYPE \ + ((cls), E_TYPE_TABLE_SORT_INFO)) +#define E_TABLE_SORT_INFO_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS \ + ((obj), E_TYPE_TABLE_SORT_INFO, ETableSortInfoClass)) -#define E_TABLE_SORT_INFO_TYPE (e_table_sort_info_get_type ()) -#define E_TABLE_SORT_INFO(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), E_TABLE_SORT_INFO_TYPE, ETableSortInfo)) -#define E_TABLE_SORT_INFO_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k), E_TABLE_SORT_INFO_TYPE, ETableSortInfoClass)) -#define E_IS_TABLE_SORT_INFO(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), E_TABLE_SORT_INFO_TYPE)) -#define E_IS_TABLE_SORT_INFO_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), E_TABLE_SORT_INFO_TYPE)) -#define E_TABLE_SORT_INFO_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS((o), E_TABLE_SORT_INFO_TYPE, ETableSortInfoClass)) +G_BEGIN_DECLS typedef struct _ETableSortColumn ETableSortColumn; +typedef struct _ETableSortInfo ETableSortInfo; +typedef struct _ETableSortInfoClass ETableSortInfoClass; + struct _ETableSortColumn { guint column : 31; guint ascending : 1; }; -typedef struct { - GObject base; +struct _ETableSortInfo { + GObject parent; gint group_count; ETableSortColumn *groupings; @@ -55,51 +69,60 @@ typedef struct { guint group_info_changed : 1; guint can_group : 1; -} ETableSortInfo; +}; -typedef struct { +struct _ETableSortInfoClass { GObjectClass parent_class; - /* - * Signals - */ - void (*sort_info_changed) (ETableSortInfo *info); - void (*group_info_changed) (ETableSortInfo *info); -} ETableSortInfoClass; - -GType e_table_sort_info_get_type (void); - -void e_table_sort_info_freeze (ETableSortInfo *info); -void e_table_sort_info_thaw (ETableSortInfo *info); - -guint e_table_sort_info_grouping_get_count (ETableSortInfo *info); -void e_table_sort_info_grouping_truncate (ETableSortInfo *info, - gint length); -ETableSortColumn e_table_sort_info_grouping_get_nth (ETableSortInfo *info, - gint n); -void e_table_sort_info_grouping_set_nth (ETableSortInfo *info, - gint n, - ETableSortColumn column); - -guint e_table_sort_info_sorting_get_count (ETableSortInfo *info); -void e_table_sort_info_sorting_truncate (ETableSortInfo *info, - gint length); -ETableSortColumn e_table_sort_info_sorting_get_nth (ETableSortInfo *info, - gint n); -void e_table_sort_info_sorting_set_nth (ETableSortInfo *info, - gint n, - ETableSortColumn column); - -ETableSortInfo *e_table_sort_info_new (void); -void e_table_sort_info_load_from_node (ETableSortInfo *info, - xmlNode *node, - gdouble state_version); -xmlNode *e_table_sort_info_save_to_node (ETableSortInfo *info, - xmlNode *parent); -ETableSortInfo *e_table_sort_info_duplicate (ETableSortInfo *info); -void e_table_sort_info_set_can_group (ETableSortInfo *info, - gboolean can_group); -gboolean e_table_sort_info_get_can_group (ETableSortInfo *info); + /* Signals */ + void (*sort_info_changed) (ETableSortInfo *info); + void (*group_info_changed) (ETableSortInfo *info); +}; + +GType e_table_sort_info_get_type (void) G_GNUC_CONST; + +void e_table_sort_info_freeze (ETableSortInfo *info); +void e_table_sort_info_thaw (ETableSortInfo *info); + +guint e_table_sort_info_grouping_get_count + (ETableSortInfo *info); +void e_table_sort_info_grouping_truncate + (ETableSortInfo *info, + gint length); +ETableSortColumn + e_table_sort_info_grouping_get_nth + (ETableSortInfo *info, + gint n); +void e_table_sort_info_grouping_set_nth + (ETableSortInfo *info, + gint n, + ETableSortColumn column); + +guint e_table_sort_info_sorting_get_count + (ETableSortInfo *info); +void e_table_sort_info_sorting_truncate + (ETableSortInfo *info, + gint length); +ETableSortColumn + e_table_sort_info_sorting_get_nth + (ETableSortInfo *info, + gint n); +void e_table_sort_info_sorting_set_nth + (ETableSortInfo *info, + gint n, + ETableSortColumn column); + +ETableSortInfo *e_table_sort_info_new (void); +void e_table_sort_info_load_from_node + (ETableSortInfo *info, + xmlNode *node, + gdouble state_version); +xmlNode * e_table_sort_info_save_to_node (ETableSortInfo *info, + xmlNode *parent); +ETableSortInfo *e_table_sort_info_duplicate (ETableSortInfo *info); +void e_table_sort_info_set_can_group (ETableSortInfo *info, + gboolean can_group); +gboolean e_table_sort_info_get_can_group (ETableSortInfo *info); G_END_DECLS diff --git a/widgets/table/e-table-sorted-variable.c b/widgets/table/e-table-sorted-variable.c index b9185994c1..f2970209bf 100644 --- a/widgets/table/e-table-sorted-variable.c +++ b/widgets/table/e-table-sorted-variable.c @@ -39,7 +39,7 @@ /* workaround for avoiding API breakage */ #define etsv_get_type e_table_sorted_variable_get_type -G_DEFINE_TYPE (ETableSortedVariable, etsv, E_TABLE_SUBSET_VARIABLE_TYPE) +G_DEFINE_TYPE (ETableSortedVariable, etsv, E_TYPE_TABLE_SUBSET_VARIABLE) static void etsv_sort_info_changed (ETableSortInfo *info, ETableSortedVariable *etsv); static void etsv_sort (ETableSortedVariable *etsv); @@ -77,10 +77,10 @@ etsv_dispose (GObject *object) } static void -etsv_class_init (ETableSortedVariableClass *klass) +etsv_class_init (ETableSortedVariableClass *class) { - ETableSubsetVariableClass *etssv_class = E_TABLE_SUBSET_VARIABLE_CLASS (klass); - GObjectClass *object_class = G_OBJECT_CLASS (klass); + ETableSubsetVariableClass *etssv_class = E_TABLE_SUBSET_VARIABLE_CLASS (class); + GObjectClass *object_class = G_OBJECT_CLASS (class); object_class->dispose = etsv_dispose; @@ -187,7 +187,7 @@ etsv_add_all (ETableSubsetVariable *etssv) ETableModel * e_table_sorted_variable_new (ETableModel *source, ETableHeader *full_header, ETableSortInfo *sort_info) { - ETableSortedVariable *etsv = g_object_new (E_TABLE_SORTED_VARIABLE_TYPE, NULL); + ETableSortedVariable *etsv = g_object_new (E_TYPE_TABLE_SORTED_VARIABLE, NULL); ETableSubsetVariable *etssv = E_TABLE_SUBSET_VARIABLE (etsv); if (e_table_subset_variable_construct (etssv, source) == NULL) { diff --git a/widgets/table/e-table-sorted-variable.h b/widgets/table/e-table-sorted-variable.h index c778af3c1f..917338ae4d 100644 --- a/widgets/table/e-table-sorted-variable.h +++ b/widgets/table/e-table-sorted-variable.h @@ -24,41 +24,57 @@ #ifndef _E_TABLE_SORTED_VARIABLE_H_ #define _E_TABLE_SORTED_VARIABLE_H_ -#include <glib-object.h> #include <table/e-table-model.h> #include <table/e-table-subset-variable.h> #include <table/e-table-sort-info.h> #include <table/e-table-header.h> +/* Standard GObject macros */ +#define E_TYPE_TABLE_SORTED_VARIABLE \ + (e_table_sorted_variable_get_type ()) +#define E_TABLE_SORTED_VARIABLE(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST \ + ((obj), E_TYPE_TABLE_SORTED_VARIABLE, ETableSortedVariable)) +#define E_TABLE_SORTED_VARIABLE_CLASS(cls) \ + (G_TYPE_CHECK_CLASS_CAST \ + ((cls), E_TYPE_TABLE_SORTED_VARIABLE, ETableSortedVariableClass)) +#define E_IS_TABLE_SORTED_VARIABLE(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE \ + ((obj), E_TYPE_TABLE_SORTED_VARIABLE)) +#define E_IS_TABLE_SORTED_VARIABLE_CLASS(cls) \ + (G_TYPE_CHECK_CLASS_TYPE \ + ((cls), E_TYPE_TABLE_SORTED_VARIABLE)) +#define E_TABLE_SORTED_VARIABLE_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS \ + ((obj), E_TYPE_TABLE_SORTED_VARIABLE, ETableSortedVariableClass)) + G_BEGIN_DECLS -#define E_TABLE_SORTED_VARIABLE_TYPE (e_table_sorted_variable_get_type ()) -#define E_TABLE_SORTED_VARIABLE(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), E_TABLE_SORTED_VARIABLE_TYPE, ETableSortedVariable)) -#define E_TABLE_SORTED_VARIABLE_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k), E_TABLE_SORTED_VARIABLE_TYPE, ETableSortedVariableClass)) -#define E_IS_TABLE_SORTED_VARIABLE(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), E_TABLE_SORTED_VARIABLE_TYPE)) -#define E_IS_TABLE_SORTED_VARIABLE_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), E_TABLE_SORTED_VARIABLE_TYPE)) -#define E_TABLE_SORTED_VARIABLE_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS((o), E_TABLE_SORTED_VARIABLE_TYPE, ETableSortedVariableClass)) +typedef struct _ETableSortedVariable ETableSortedVariable; +typedef struct _ETableSortedVariableClass ETableSortedVariableClass; -typedef struct { - ETableSubsetVariable base; +struct _ETableSortedVariable { + ETableSubsetVariable parent; ETableSortInfo *sort_info; ETableHeader *full_header; - gint sort_info_changed_id; - gint sort_idle_id; - gint insert_idle_id; - gint insert_count; - -} ETableSortedVariable; + gint sort_info_changed_id; + gint sort_idle_id; + gint insert_idle_id; + gint insert_count; +}; -typedef struct { +struct _ETableSortedVariableClass { ETableSubsetVariableClass parent_class; -} ETableSortedVariableClass; +}; -GType e_table_sorted_variable_get_type (void); -ETableModel *e_table_sorted_variable_new (ETableModel *etm, ETableHeader *header, ETableSortInfo *sort_info); +GType e_table_sorted_variable_get_type + (void) G_GNUC_CONST; +ETableModel * e_table_sorted_variable_new (ETableModel *etm, + ETableHeader *header, + ETableSortInfo *sort_info); G_END_DECLS diff --git a/widgets/table/e-table-sorted.c b/widgets/table/e-table-sorted.c index c1ff7740d5..73dbac102e 100644 --- a/widgets/table/e-table-sorted.c +++ b/widgets/table/e-table-sorted.c @@ -36,7 +36,7 @@ /* workaround for avoding API breakage */ #define ets_get_type e_table_sorted_get_type -G_DEFINE_TYPE (ETableSorted, ets, E_TABLE_SUBSET_TYPE) +G_DEFINE_TYPE (ETableSorted, ets, E_TYPE_TABLE_SUBSET) /* maximum insertions between an idle event that we will do without scheduling an idle sort */ #define ETS_INSERT_MAX (4) @@ -77,10 +77,10 @@ ets_dispose (GObject *object) } static void -ets_class_init (ETableSortedClass *klass) +ets_class_init (ETableSortedClass *class) { - ETableSubsetClass *etss_class = E_TABLE_SUBSET_CLASS (klass); - GObjectClass *object_class = G_OBJECT_CLASS (klass); + ETableSubsetClass *etss_class = E_TABLE_SUBSET_CLASS (class); + GObjectClass *object_class = G_OBJECT_CLASS (class); etss_class->proxy_model_changed = ets_proxy_model_changed; etss_class->proxy_model_row_changed = ets_proxy_model_row_changed; @@ -125,7 +125,7 @@ ets_insert_idle (ETableSorted *ets) ETableModel * e_table_sorted_new (ETableModel *source, ETableHeader *full_header, ETableSortInfo *sort_info) { - ETableSorted *ets = g_object_new (E_TABLE_SORTED_TYPE, NULL); + ETableSorted *ets = g_object_new (E_TYPE_TABLE_SORTED, NULL); ETableSubset *etss = E_TABLE_SUBSET (ets); if (E_TABLE_SUBSET_CLASS (ets_parent_class)->proxy_model_pre_change) diff --git a/widgets/table/e-table-sorted.h b/widgets/table/e-table-sorted.h index a9e815ef3a..feff6e2ad5 100644 --- a/widgets/table/e-table-sorted.h +++ b/widgets/table/e-table-sorted.h @@ -24,41 +24,56 @@ #ifndef _E_TABLE_SORTED_H_ #define _E_TABLE_SORTED_H_ -#include <glib-object.h> #include <table/e-table-model.h> #include <table/e-table-subset.h> #include <table/e-table-sort-info.h> #include <table/e-table-header.h> +/* Standard GObject macros */ +#define E_TYPE_TABLE_SORTED \ + (e_table_sorted_get_type ()) +#define E_TABLE_SORTED(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST \ + ((obj), E_TYPE_TABLE_SORTED, ETableSorted)) +#define E_TABLE_SORTED_CLASS(cls) \ + (G_TYPE_CHECK_CLASS_CAST \ + ((cls), E_TYPE_TABLE_SORTED, ETableSortedClass)) +#define E_IS_TABLE_SORTED(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE \ + ((obj), E_TYPE_TABLE_SORTED)) +#define E_IS_TABLE_SORTED_CLASS(cls) \ + (G_TYPE_CHECK_CLASS_TYPE \ + ((cls), E_TYPE_TABLE_SORTED)) +#define E_TABLE_SORTED_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS \ + ((obj), E_TYPE_TABLE_SORTED, ETableSortedClass)) + G_BEGIN_DECLS -#define E_TABLE_SORTED_TYPE (e_table_sorted_get_type ()) -#define E_TABLE_SORTED(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), E_TABLE_SORTED_TYPE, ETableSorted)) -#define E_TABLE_SORTED_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k), E_TABLE_SORTED_TYPE, ETableSortedClass)) -#define E_IS_TABLE_SORTED(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), E_TABLE_SORTED_TYPE)) -#define E_IS_TABLE_SORTED_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), E_TABLE_SORTED_TYPE)) -#define E_TABLE_SORTED_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((obj), E_TABLE_SORTED_TYPE, ETableSortedClass)) +typedef struct _ETableSorted ETableSorted; +typedef struct _ETableSortedClass ETableSortedClass; -typedef struct { - ETableSubset base; +struct _ETableSorted { + ETableSubset parent; ETableSortInfo *sort_info; ETableHeader *full_header; - gint sort_info_changed_id; - gint sort_idle_id; - gint insert_idle_id; - gint insert_count; - -} ETableSorted; + gint sort_info_changed_id; + gint sort_idle_id; + gint insert_idle_id; + gint insert_count; +}; -typedef struct { +struct _ETableSortedClass { ETableSubsetClass parent_class; -} ETableSortedClass; +}; -GType e_table_sorted_get_type (void); -ETableModel *e_table_sorted_new (ETableModel *etm, ETableHeader *header, ETableSortInfo *sort_info); +GType e_table_sorted_get_type (void) G_GNUC_CONST; +ETableModel * e_table_sorted_new (ETableModel *etm, + ETableHeader *header, + ETableSortInfo *sort_info); G_END_DECLS diff --git a/widgets/table/e-table-sorter.c b/widgets/table/e-table-sorter.c index 2a52fbb8d5..491fe7fc6f 100644 --- a/widgets/table/e-table-sorter.c +++ b/widgets/table/e-table-sorter.c @@ -153,10 +153,10 @@ ets_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *psp } static void -ets_class_init (ETableSorterClass *klass) +ets_class_init (ETableSorterClass *class) { - GObjectClass *object_class = G_OBJECT_CLASS (klass); - ESorterClass *sorter_class = E_SORTER_CLASS (klass); + GObjectClass *object_class = G_OBJECT_CLASS (class); + ESorterClass *sorter_class = E_SORTER_CLASS (class); object_class->dispose = ets_dispose; object_class->set_property = ets_set_property; @@ -172,7 +172,7 @@ ets_class_init (ETableSorterClass *klass) g_param_spec_object ("sort_info", "Sort Info", NULL, - E_TABLE_SORT_INFO_TYPE, + E_TYPE_TABLE_SORT_INFO, G_PARAM_READWRITE)); } @@ -197,7 +197,7 @@ ets_init (ETableSorter *ets) ETableSorter * e_table_sorter_new (ETableModel *source, ETableHeader *full_header, ETableSortInfo *sort_info) { - ETableSorter *ets = g_object_new (E_TABLE_SORTER_TYPE, NULL); + ETableSorter *ets = g_object_new (E_TYPE_TABLE_SORTER, NULL); ets->sort_info = sort_info; g_object_ref (ets->sort_info); diff --git a/widgets/table/e-table-sorter.h b/widgets/table/e-table-sorter.h index 067da103f9..0f36f441f6 100644 --- a/widgets/table/e-table-sorter.h +++ b/widgets/table/e-table-sorter.h @@ -23,51 +23,68 @@ #ifndef _E_TABLE_SORTER_H_ #define _E_TABLE_SORTER_H_ -#include <glib-object.h> #include <e-util/e-sorter.h> #include <table/e-table-model.h> #include <table/e-table-subset-variable.h> #include <table/e-table-sort-info.h> #include <table/e-table-header.h> +/* Standard GObject macros */ +#define E_TYPE_TABLE_SORTER \ + (e_table_sorter_get_type ()) +#define E_TABLE_SORTER(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST \ + ((obj), E_TYPE_TABLE_SORTER, ETableSorter)) +#define E_TABLE_SORTER_CLASS(cls) \ + (G_TYPE_CHECK_CLASS_CAST \ + ((cls), E_TYPE_TABLE_SORTER, ETableSorterClass)) +#define E_IS_TABLE_SORTER(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE \ + ((obj), E_TYPE_TABLE_SORTER)) +#define E_IS_TABLE_SORTER_CLASS(cls) \ + (G_TYPE_CHECK_CLASS_TYPE \ + ((cls), E_TYPE_TABLE_SORTER)) +#define E_TABLE_SORTER_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS \ + ((obj), E_TYPE_TABLE_SORTER, ETableSorterClass)) + G_BEGIN_DECLS -#define E_TABLE_SORTER_TYPE (e_table_sorter_get_type ()) -#define E_TABLE_SORTER(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), E_TABLE_SORTER_TYPE, ETableSorter)) -#define E_TABLE_SORTER_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k), E_TABLE_SORTER_TYPE, ETableSorterClass)) -#define E_IS_TABLE_SORTER(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), E_TABLE_SORTER_TYPE)) -#define E_IS_TABLE_SORTER_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), E_TABLE_SORTER_TYPE)) +typedef struct _ETableSorter ETableSorter; +typedef struct _ETableSorterClass ETableSorterClass; -typedef struct { - ESorter base; +struct _ETableSorter { + ESorter parent; - ETableModel *source; - ETableHeader *full_header; + ETableModel *source; + ETableHeader *full_header; ETableSortInfo *sort_info; - /* If needs_sorting is 0, then model_to_sorted and sorted_to_model are no-ops. */ - gint needs_sorting; + /* If needs_sorting is 0, then model_to_sorted + * and sorted_to_model are no-ops. */ + gint needs_sorting; - gint *sorted; - gint *backsorted; + gint *sorted; + gint *backsorted; - gint table_model_changed_id; - gint table_model_row_changed_id; - gint table_model_cell_changed_id; - gint table_model_rows_inserted_id; - gint table_model_rows_deleted_id; - gint sort_info_changed_id; - gint group_info_changed_id; -} ETableSorter; + gint table_model_changed_id; + gint table_model_row_changed_id; + gint table_model_cell_changed_id; + gint table_model_rows_inserted_id; + gint table_model_rows_deleted_id; + gint sort_info_changed_id; + gint group_info_changed_id; +}; -typedef struct { +struct _ETableSorterClass { ESorterClass parent_class; -} ETableSorterClass; +}; + +GType e_table_sorter_get_type (void) G_GNUC_CONST; +ETableSorter * e_table_sorter_new (ETableModel *etm, + ETableHeader *full_header, + ETableSortInfo *sort_info); -GType e_table_sorter_get_type (void); -ETableSorter *e_table_sorter_new (ETableModel *etm, - ETableHeader *full_header, - ETableSortInfo *sort_info); G_END_DECLS #endif /* _E_TABLE_SORTER_H_ */ diff --git a/widgets/table/e-table-sorting-utils.h b/widgets/table/e-table-sorting-utils.h index 3c60df1838..5a0a3cd3d7 100644 --- a/widgets/table/e-table-sorting-utils.h +++ b/widgets/table/e-table-sorting-utils.h @@ -6,7 +6,7 @@ * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public @@ -29,50 +29,62 @@ G_BEGIN_DECLS #include <table/e-tree-model.h> #include <table/e-table-sort-info.h> #include <table/e-table-header.h> -gboolean e_table_sorting_utils_affects_sort (ETableSortInfo *sort_info, - ETableHeader *full_header, - gint col); -void e_table_sorting_utils_sort (ETableModel *source, - ETableSortInfo *sort_info, - ETableHeader *full_header, - gint *map_table, - gint rows); -gint e_table_sorting_utils_insert (ETableModel *source, - ETableSortInfo *sort_info, - ETableHeader *full_header, - gint *map_table, - gint rows, - gint row); -gint e_table_sorting_utils_check_position (ETableModel *source, - ETableSortInfo *sort_info, - ETableHeader *full_header, - gint *map_table, - gint rows, - gint view_row); +gboolean e_table_sorting_utils_affects_sort + (ETableSortInfo *sort_info, + ETableHeader *full_header, + gint col); -void e_table_sorting_utils_tree_sort (ETreeModel *source, - ETableSortInfo *sort_info, - ETableHeader *full_header, - ETreePath *map_table, - gint count); -gint e_table_sorting_utils_tree_check_position (ETreeModel *source, - ETableSortInfo *sort_info, - ETableHeader *full_header, - ETreePath *map_table, - gint count, - gint old_index); -gint e_table_sorting_utils_tree_insert (ETreeModel *source, - ETableSortInfo *sort_info, - ETableHeader *full_header, - ETreePath *map_table, - gint count, - ETreePath path); +void e_table_sorting_utils_sort (ETableModel *source, + ETableSortInfo *sort_info, + ETableHeader *full_header, + gint *map_table, + gint rows); +gint e_table_sorting_utils_insert (ETableModel *source, + ETableSortInfo *sort_info, + ETableHeader *full_header, + gint *map_table, + gint rows, + gint row); +gint e_table_sorting_utils_check_position + (ETableModel *source, + ETableSortInfo *sort_info, + ETableHeader *full_header, + gint *map_table, + gint rows, + gint view_row); -gpointer e_table_sorting_utils_create_cmp_cache (void); -void e_table_sorting_utils_free_cmp_cache (gpointer cmp_cache); -void e_table_sorting_utils_add_to_cmp_cache (gpointer cmp_cache, const gchar *key, gchar *value); -const gchar *e_table_sorting_utils_lookup_cmp_cache (gpointer cmp_cache, const gchar *key); +void e_table_sorting_utils_tree_sort (ETreeModel *source, + ETableSortInfo *sort_info, + ETableHeader *full_header, + ETreePath *map_table, + gint count); +gint e_table_sorting_utils_tree_check_position + (ETreeModel *source, + ETableSortInfo *sort_info, + ETableHeader *full_header, + ETreePath *map_table, + gint count, + gint old_index); +gint e_table_sorting_utils_tree_insert + (ETreeModel *source, + ETableSortInfo *sort_info, + ETableHeader *full_header, + ETreePath *map_table, + gint count, + ETreePath path); + +gpointer e_table_sorting_utils_create_cmp_cache + (void); +void e_table_sorting_utils_free_cmp_cache + (gpointer cmp_cache); +void e_table_sorting_utils_add_to_cmp_cache + (gpointer cmp_cache, + const gchar *key, + gchar *value); +const gchar * e_table_sorting_utils_lookup_cmp_cache + (gpointer cmp_cache, + const gchar *key); G_END_DECLS diff --git a/widgets/table/e-table-specification.c b/widgets/table/e-table-specification.c index 2325aea633..99213ad501 100644 --- a/widgets/table/e-table-specification.c +++ b/widgets/table/e-table-specification.c @@ -69,9 +69,9 @@ etsp_finalize (GObject *object) } static void -etsp_class_init (ETableSpecificationClass *klass) +etsp_class_init (ETableSpecificationClass *class) { - GObjectClass *object_class = G_OBJECT_CLASS (klass); + GObjectClass *object_class = G_OBJECT_CLASS (class); object_class->finalize = etsp_finalize; } diff --git a/widgets/table/e-table-specification.h b/widgets/table/e-table-specification.h index e6f6707ae5..021c0524c5 100644 --- a/widgets/table/e-table-specification.h +++ b/widgets/table/e-table-specification.h @@ -24,24 +24,38 @@ #ifndef _E_TABLE_SPECIFICATION_H_ #define _E_TABLE_SPECIFICATION_H_ -#include <glib-object.h> #include <libxml/tree.h> #include <misc/e-selection-model.h> #include <table/e-table-state.h> #include <table/e-table-column-specification.h> #include <table/e-table-defines.h> +/* Standard GObject macros */ +#define E_TYPE_TABLE_SPECIFICATION \ + (e_table_specification_get_type ()) +#define E_TABLE_SPECIFICATION(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST \ + ((obj), E_TYPE_TABLE_SPECIFICATION, ETableSpecification)) +#define E_TABLE_SPECIFICATION_CLASS(cls) \ + (G_TYPE_CHECK_CLASS_CAST \ + ((cls), E_TYPE_TABLE_SPECIFICATION, ETableSpecificationClass)) +#define E_IS_TABLE_SPECIFICATION(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE \ + ((obj), E_TYPE_TABLE_SPECIFICATION)) +#define E_IS_TABLE_SPECIFICATION_CLASS(cls) \ + (G_TYPE_CHECK_CLASS_TYPE \ + ((cls), E_TYPE_TABLE_SPECIFICATION)) +#define E_TABLE_SPECIFICATION_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS \ + ((obj), E_TYPE_TABLE_SPECIFICATION, ETableSpecificationClass)) + G_BEGIN_DECLS -#define E_TYPE_TABLE_SPECIFICATION (e_table_specification_get_type ()) -#define E_TABLE_SPECIFICATION(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), E_TYPE_TABLE_SPECIFICATION, ETableSpecification)) -#define E_TABLE_SPECIFICATION_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k), E_TYPE_TABLE_SPECIFICATION, ETableSpecificationClass)) -#define E_IS_TABLE_SPECIFICATION(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), E_TYPE_TABLE_SPECIFICATION)) -#define E_IS_TABLE_SPECIFICATION_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), E_TYPE_TABLE_SPECIFICATION)) -#define E_TABLE_SPECIFICATION_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS((o), E_TYPE_TABLE_SPECIFICATION, ETableSpecificationClass)) +typedef struct _ETableSpecification ETableSpecification; +typedef struct _ETableSpecificationClass ETableSpecificationClass; -typedef struct { - GObject base; +struct _ETableSpecification { + GObject parent; ETableColumnSpecification **columns; ETableState *state; @@ -61,28 +75,36 @@ typedef struct { gchar *click_to_add_message; gchar *domain; -} ETableSpecification; +}; -typedef struct { +struct _ETableSpecificationClass { GObjectClass parent_class; -} ETableSpecificationClass; +}; -GType e_table_specification_get_type (void); -ETableSpecification *e_table_specification_new (void); +GType e_table_specification_get_type (void) G_GNUC_CONST; +ETableSpecification * + e_table_specification_new (void); -gboolean e_table_specification_load_from_file (ETableSpecification *specification, - const gchar *filename); -gboolean e_table_specification_load_from_string (ETableSpecification *specification, - const gchar *xml); -void e_table_specification_load_from_node (ETableSpecification *specification, - const xmlNode *node); +gboolean e_table_specification_load_from_file + (ETableSpecification *specification, + const gchar *filename); +gboolean e_table_specification_load_from_string + (ETableSpecification *specification, + const gchar *xml); +void e_table_specification_load_from_node + (ETableSpecification *specification, + const xmlNode *node); -gint e_table_specification_save_to_file (ETableSpecification *specification, - const gchar *filename); -gchar *e_table_specification_save_to_string (ETableSpecification *specification); -xmlNode *e_table_specification_save_to_node (ETableSpecification *specification, - xmlDoc *doc); -ETableSpecification *e_table_specification_duplicate (ETableSpecification *spec); +gint e_table_specification_save_to_file + (ETableSpecification *specification, + const gchar *filename); +gchar * e_table_specification_save_to_string + (ETableSpecification *specification); +xmlNode * e_table_specification_save_to_node + (ETableSpecification *specification, + xmlDoc *doc); +ETableSpecification * + e_table_specification_duplicate (ETableSpecification *specification); G_END_DECLS diff --git a/widgets/table/e-table-state.c b/widgets/table/e-table-state.c index 9844849818..536bf3c5c8 100644 --- a/widgets/table/e-table-state.c +++ b/widgets/table/e-table-state.c @@ -71,9 +71,9 @@ etst_finalize (GObject *object) } static void -e_table_state_class_init (ETableStateClass *klass) +e_table_state_class_init (ETableStateClass *class) { - GObjectClass *object_class = G_OBJECT_CLASS (klass); + GObjectClass *object_class = G_OBJECT_CLASS (class); object_class->dispose = etst_dispose; object_class->finalize = etst_finalize; @@ -90,7 +90,7 @@ e_table_state_init (ETableState *state) ETableState * e_table_state_new (void) { - return (ETableState *) g_object_new (E_TABLE_STATE_TYPE, NULL); + return g_object_new (E_TYPE_TABLE_STATE, NULL); } ETableState * diff --git a/widgets/table/e-table-state.h b/widgets/table/e-table-state.h index 082bb17ad7..23fc5b2fb2 100644 --- a/widgets/table/e-table-state.h +++ b/widgets/table/e-table-state.h @@ -23,50 +23,61 @@ #ifndef _E_TABLE_STATE_H_ #define _E_TABLE_STATE_H_ -#include <glib-object.h> #include <libxml/tree.h> #include <table/e-table-sort-info.h> +/* Standard GObject macros */ +#define E_TYPE_TABLE_STATE \ + (e_table_state_get_type ()) +#define E_TABLE_STATE(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST \ + ((obj), E_TYPE_TABLE_STATE, ETableState)) +#define E_TABLE_STATE_CLASS(cls) \ + (G_TYPE_CHECK_CLASS_CAST \ + ((cls), E_TYPE_TABLE_STATE, ETableStateClass)) +#define E_IS_TABLE_STATE(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE \ + ((obj), E_TYPE_TABLE_STATE)) +#define E_IS_TABLE_STATE_CLASS(cls) \ + (G_TYPE_CHECK_CLASS_TYPE \ + ((cls), E_TYPE_TABLE_STATE)) +#define E_TABLE_STATE_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS \ + ((obj), E_TYPE_TABLE_STATE, ETableStateClass)) + G_BEGIN_DECLS -#define E_TABLE_STATE_TYPE (e_table_state_get_type ()) -#define E_TABLE_STATE(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), E_TABLE_STATE_TYPE, ETableState)) -#define E_TABLE_STATE_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k), E_TABLE_STATE_TYPE, ETableStateClass)) -#define E_IS_TABLE_STATE(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), E_TABLE_STATE_TYPE)) -#define E_IS_TABLE_STATE_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), E_TABLE_STATE_TYPE)) -#define E_TABLE_STATE_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS((o), E_TABLE_STATE_TYPE, ETableStateClass)) +typedef struct _ETableState ETableState; +typedef struct _ETableStateClass ETableStateClass; -typedef struct { - GObject base; +struct _ETableState { + GObject parent; ETableSortInfo *sort_info; - gint col_count; - gint *columns; - gdouble *expansions; -} ETableState; + gint col_count; + gint *columns; + gdouble *expansions; +}; -typedef struct { +struct _ETableStateClass { GObjectClass parent_class; -} ETableStateClass; - -GType e_table_state_get_type (void); -ETableState *e_table_state_new (void); - -ETableState *e_table_state_vanilla (gint col_count); - -gboolean e_table_state_load_from_file (ETableState *state, - const gchar *filename); -void e_table_state_load_from_string (ETableState *state, - const gchar *xml); -void e_table_state_load_from_node (ETableState *state, - const xmlNode *node); +}; -void e_table_state_save_to_file (ETableState *state, - const gchar *filename); -gchar *e_table_state_save_to_string (ETableState *state); -xmlNode *e_table_state_save_to_node (ETableState *state, - xmlNode *parent); -ETableState *e_table_state_duplicate (ETableState *state); +GType e_table_state_get_type (void) G_GNUC_CONST; +ETableState * e_table_state_new (void); +ETableState * e_table_state_vanilla (gint col_count); +gboolean e_table_state_load_from_file (ETableState *state, + const gchar *filename); +void e_table_state_load_from_string (ETableState *state, + const gchar *xml); +void e_table_state_load_from_node (ETableState *state, + const xmlNode *node); +void e_table_state_save_to_file (ETableState *state, + const gchar *filename); +gchar * e_table_state_save_to_string (ETableState *state); +xmlNode * e_table_state_save_to_node (ETableState *state, + xmlNode *parent); +ETableState * e_table_state_duplicate (ETableState *state); G_END_DECLS diff --git a/widgets/table/e-table-subset-variable.c b/widgets/table/e-table-subset-variable.c index 07aaa18e10..0f9a58db31 100644 --- a/widgets/table/e-table-subset-variable.c +++ b/widgets/table/e-table-subset-variable.c @@ -33,7 +33,7 @@ /* workaround for avoiding API breakage */ #define etssv_get_type e_table_subset_variable_get_type -G_DEFINE_TYPE (ETableSubsetVariable, etssv, E_TABLE_SUBSET_TYPE) +G_DEFINE_TYPE (ETableSubsetVariable, etssv, E_TYPE_TABLE_SUBSET) #define INCREMENT_AMOUNT 10 @@ -120,12 +120,12 @@ etssv_remove (ETableSubsetVariable *etssv, } static void -etssv_class_init (ETableSubsetVariableClass *klass) +etssv_class_init (ETableSubsetVariableClass *class) { - klass->add = etssv_add; - klass->add_array = etssv_add_array; - klass->add_all = etssv_add_all; - klass->remove = etssv_remove; + class->add = etssv_add; + class->add_array = etssv_add_array; + class->add_all = etssv_add_all; + class->remove = etssv_remove; } static void @@ -148,7 +148,7 @@ e_table_subset_variable_construct (ETableSubsetVariable *etssv, ETableModel * e_table_subset_variable_new (ETableModel *source) { - ETableSubsetVariable *etssv = g_object_new (E_TABLE_SUBSET_VARIABLE_TYPE, NULL); + ETableSubsetVariable *etssv = g_object_new (E_TYPE_TABLE_SUBSET_VARIABLE, NULL); if (e_table_subset_variable_construct (etssv, source) == NULL) { g_object_unref (etssv); diff --git a/widgets/table/e-table-subset-variable.h b/widgets/table/e-table-subset-variable.h index 4654fb5d67..da8186a1df 100644 --- a/widgets/table/e-table-subset-variable.h +++ b/widgets/table/e-table-subset-variable.h @@ -23,58 +23,78 @@ #ifndef _E_TABLE_SUBSET_VARIABLE_H_ #define _E_TABLE_SUBSET_VARIABLE_H_ -#include <glib-object.h> #include <table/e-table-subset.h> -G_BEGIN_DECLS +/* Standard GObject macros */ +#define E_TYPE_TABLE_SUBSET_VARIABLE \ + (e_table_subset_variable_get_type ()) +#define E_TABLE_SUBSET_VARIABLE(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST \ + ((obj), E_TYPE_TABLE_SUBSET_VARIABLE, ETableSubsetVariable)) +#define E_TABLE_SUBSET_VARIABLE_CLASS(cls) \ + (G_TYPE_CHECK_CLASS_CAST \ + ((cls), E_TYPE_TABLE_SUBSET_VARIABLE, ETableSubsetVariableClass)) +#define E_IS_TABLE_SUBSET_VARIABLE(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE \ + ((obj), E_TYPE_TABLE_SUBSET_VARIABLE)) +#define E_IS_TABLE_SUBSET_VARIABLE_CLASS(cls) \ + (G_TYPE_CHECK_CLASS_TYPE \ + ((cls), E_TYPE_TABLE_SUBSET_VARIABLE)) +#define E_TABLE_SUBSET_VARIABLE_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS \ + ((obj), E_TYPE_TABLE_SUBSET_VARIABLE, ETableSubsetVariableClass)) -#define E_TABLE_SUBSET_VARIABLE_TYPE (e_table_subset_variable_get_type ()) -#define E_TABLE_SUBSET_VARIABLE(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), E_TABLE_SUBSET_VARIABLE_TYPE, ETableSubsetVariable)) -#define E_TABLE_SUBSET_VARIABLE_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k), E_TABLE_SUBSET_VARIABLE_TYPE, ETableSubsetVariableClass)) -#define E_IS_TABLE_SUBSET_VARIABLE(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), E_TABLE_SUBSET_VARIABLE_TYPE)) -#define E_IS_TABLE_SUBSET_VARIABLE_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), E_TABLE_SUBSET_VARIABLE_TYPE)) -#define E_TABLE_SUBSET_VARIABLE_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS((o), E_TABLE_SUBSET_VARIABLE_TYPE, ETableSubsetVariableClass)) +G_BEGIN_DECLS -typedef struct { - ETableSubset base; +typedef struct _ETableSubsetVariable ETableSubsetVariable; +typedef struct _ETableSubsetVariableClass ETableSubsetVariableClass; +struct _ETableSubsetVariable { + ETableSubset parent; gint n_vals_allocated; -} ETableSubsetVariable; +}; -typedef struct { +struct _ETableSubsetVariableClass { ETableSubsetClass parent_class; - void (*add) (ETableSubsetVariable *ets, - gint row); - void (*add_array) (ETableSubsetVariable *ets, - const gint *array, - gint count); - void (*add_all) (ETableSubsetVariable *ets); - gboolean (*remove) (ETableSubsetVariable *ets, - gint row); -} ETableSubsetVariableClass; + void (*add) (ETableSubsetVariable *ets, + gint row); + void (*add_array) (ETableSubsetVariable *ets, + const gint *array, + gint count); + void (*add_all) (ETableSubsetVariable *ets); + gboolean (*remove) (ETableSubsetVariable *ets, + gint row); +}; + +GType e_table_subset_variable_get_type + (void) G_GNUC_CONST; +ETableModel * e_table_subset_variable_new (ETableModel *etm); +ETableModel * e_table_subset_variable_construct + (ETableSubsetVariable *etssv, + ETableModel *source); +void e_table_subset_variable_add (ETableSubsetVariable *ets, + gint row); +void e_table_subset_variable_add_array + (ETableSubsetVariable *ets, + const gint *array, + gint count); +void e_table_subset_variable_add_all (ETableSubsetVariable *ets); +gboolean e_table_subset_variable_remove (ETableSubsetVariable *ets, + gint row); +void e_table_subset_variable_clear (ETableSubsetVariable *ets); +void e_table_subset_variable_increment + (ETableSubsetVariable *ets, + gint position, + gint amount); +void e_table_subset_variable_decrement + (ETableSubsetVariable *ets, + gint position, + gint amount); +void e_table_subset_variable_set_allocation + (ETableSubsetVariable *ets, + gint total); -GType e_table_subset_variable_get_type (void); -ETableModel *e_table_subset_variable_new (ETableModel *etm); -ETableModel *e_table_subset_variable_construct (ETableSubsetVariable *etssv, - ETableModel *source); -void e_table_subset_variable_add (ETableSubsetVariable *ets, - gint row); -void e_table_subset_variable_add_array (ETableSubsetVariable *ets, - const gint *array, - gint count); -void e_table_subset_variable_add_all (ETableSubsetVariable *ets); -gboolean e_table_subset_variable_remove (ETableSubsetVariable *ets, - gint row); -void e_table_subset_variable_clear (ETableSubsetVariable *ets); -void e_table_subset_variable_increment (ETableSubsetVariable *ets, - gint position, - gint amount); -void e_table_subset_variable_decrement (ETableSubsetVariable *ets, - gint position, - gint amount); -void e_table_subset_variable_set_allocation (ETableSubsetVariable *ets, - gint total); G_END_DECLS #endif /* _E_TABLE_SUBSET_VARIABLE_H_ */ diff --git a/widgets/table/e-table-subset.c b/widgets/table/e-table-subset.c index e9f048da06..7473099bf9 100644 --- a/widgets/table/e-table-subset.c +++ b/widgets/table/e-table-subset.c @@ -42,7 +42,7 @@ static void etss_proxy_model_rows_deleted_real (ETableSubset *etss, ETableModel /* workaround for avoding API breakage */ #define etss_get_type e_table_subset_get_type -G_DEFINE_TYPE (ETableSubset, etss, E_TABLE_MODEL_TYPE) +G_DEFINE_TYPE (ETableSubset, etss, E_TYPE_TABLE_MODEL) #define ETSS_CLASS(object) (E_TABLE_SUBSET_GET_CLASS(object)) @@ -248,10 +248,10 @@ etss_value_to_string (ETableModel *etm, gint col, gconstpointer value) } static void -etss_class_init (ETableSubsetClass *klass) +etss_class_init (ETableSubsetClass *class) { - ETableModelClass *table_class = E_TABLE_MODEL_CLASS (klass); - GObjectClass *object_class = G_OBJECT_CLASS (klass); + ETableModelClass *table_class = E_TABLE_MODEL_CLASS (class); + GObjectClass *object_class = G_OBJECT_CLASS (class); object_class->dispose = etss_dispose; object_class->finalize = etss_finalize; @@ -273,13 +273,13 @@ etss_class_init (ETableSubsetClass *klass) table_class->value_is_empty = etss_value_is_empty; table_class->value_to_string = etss_value_to_string; - klass->proxy_model_pre_change = etss_proxy_model_pre_change_real; - klass->proxy_model_no_change = etss_proxy_model_no_change_real; - klass->proxy_model_changed = etss_proxy_model_changed_real; - klass->proxy_model_row_changed = etss_proxy_model_row_changed_real; - klass->proxy_model_cell_changed = etss_proxy_model_cell_changed_real; - klass->proxy_model_rows_inserted = etss_proxy_model_rows_inserted_real; - klass->proxy_model_rows_deleted = etss_proxy_model_rows_deleted_real; + class->proxy_model_pre_change = etss_proxy_model_pre_change_real; + class->proxy_model_no_change = etss_proxy_model_no_change_real; + class->proxy_model_changed = etss_proxy_model_changed_real; + class->proxy_model_row_changed = etss_proxy_model_row_changed_real; + class->proxy_model_cell_changed = etss_proxy_model_cell_changed_real; + class->proxy_model_rows_inserted = etss_proxy_model_rows_inserted_real; + class->proxy_model_rows_deleted = etss_proxy_model_rows_deleted_real; } static void @@ -429,7 +429,7 @@ e_table_subset_construct (ETableSubset *etss, ETableModel *source, gint nvals) ETableModel * e_table_subset_new (ETableModel *source, const gint nvals) { - ETableSubset *etss = g_object_new (E_TABLE_SUBSET_TYPE, NULL); + ETableSubset *etss = g_object_new (E_TYPE_TABLE_SUBSET, NULL); if (e_table_subset_construct (etss, source, nvals) == NULL) { g_object_unref (etss); diff --git a/widgets/table/e-table-subset.h b/widgets/table/e-table-subset.h index dd345732e2..9729bdd6b0 100644 --- a/widgets/table/e-table-subset.h +++ b/widgets/table/e-table-subset.h @@ -25,63 +25,90 @@ #ifndef _E_TABLE_SUBSET_H_ #define _E_TABLE_SUBSET_H_ -#include <glib-object.h> #include <table/e-table-model.h> +/* Standard GObject macros */ +#define E_TYPE_TABLE_SUBSET \ + (e_table_subset_get_type ()) +#define E_TABLE_SUBSET(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST \ + ((obj), E_TYPE_TABLE_SUBSET, ETableSubset)) +#define E_TABLE_SUBSET_CLASS(cls) \ + (G_TYPE_CHECK_CLASS_CAST \ + ((cls), E_TYPE_TABLE_SUBSET, ETableSubsetClass)) +#define E_IS_TABLE_SUBSET(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE \ + ((obj), E_TYPE_TABLE_SUBSET)) +#define E_IS_TABLE_SUBSET_CLASS(cls) \ + (G_TYPE_CHECK_CLASS_TYPE \ + ((cls), E_TYPE_TABLE_SUBSET)) +#define E_TABLE_SUBSET_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS \ + ((obj), E_TYPE_TABLE_SUBSET, ETableSubsetClass)) + G_BEGIN_DECLS -#define E_TABLE_SUBSET_TYPE (e_table_subset_get_type ()) -#define E_TABLE_SUBSET(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), E_TABLE_SUBSET_TYPE, ETableSubset)) -#define E_TABLE_SUBSET_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k), E_TABLE_SUBSET_TYPE, ETableSubsetClass)) -#define E_IS_TABLE_SUBSET(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), E_TABLE_SUBSET_TYPE)) -#define E_IS_TABLE_SUBSET_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), E_TABLE_SUBSET_TYPE)) -#define E_TABLE_SUBSET_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), E_TABLE_SUBSET_TYPE, ETableSubsetClass)) +typedef struct _ETableSubset ETableSubset; +typedef struct _ETableSubsetClass ETableSubsetClass; -typedef struct { - ETableModel base; +struct _ETableSubset { + ETableModel parent; - ETableModel *source; - gint n_map; + ETableModel *source; + gint n_map; gint *map_table; gint last_access; - gint table_model_pre_change_id; - gint table_model_no_change_id; - gint table_model_changed_id; - gint table_model_row_changed_id; - gint table_model_cell_changed_id; - gint table_model_rows_inserted_id; - gint table_model_rows_deleted_id; -} ETableSubset; + gint table_model_pre_change_id; + gint table_model_no_change_id; + gint table_model_changed_id; + gint table_model_row_changed_id; + gint table_model_cell_changed_id; + gint table_model_rows_inserted_id; + gint table_model_rows_deleted_id; +}; -typedef struct { +struct _ETableSubsetClass { ETableModelClass parent_class; - void (*proxy_model_pre_change) (ETableSubset *etss, ETableModel *etm); - void (*proxy_model_no_change) (ETableSubset *etss, ETableModel *etm); - void (*proxy_model_changed) (ETableSubset *etss, ETableModel *etm); - void (*proxy_model_row_changed) (ETableSubset *etss, ETableModel *etm, gint row); - void (*proxy_model_cell_changed) (ETableSubset *etss, ETableModel *etm, gint col, gint row); - void (*proxy_model_rows_inserted) (ETableSubset *etss, ETableModel *etm, gint row, gint count); - void (*proxy_model_rows_deleted) (ETableSubset *etss, ETableModel *etm, gint row, gint count); -} ETableSubsetClass; - -GType e_table_subset_get_type (void); -ETableModel *e_table_subset_new (ETableModel *etm, - gint n_vals); -ETableModel *e_table_subset_construct (ETableSubset *ets, - ETableModel *source, - gint nvals); - -gint e_table_subset_model_to_view_row (ETableSubset *ets, - gint model_row); -gint e_table_subset_view_to_model_row (ETableSubset *ets, - gint view_row); - -ETableModel *e_table_subset_get_toplevel (ETableSubset *table_model); - -void e_table_subset_print_debugging (ETableSubset *table_model); + void (*proxy_model_pre_change) (ETableSubset *etss, + ETableModel *etm); + void (*proxy_model_no_change) (ETableSubset *etss, + ETableModel *etm); + void (*proxy_model_changed) (ETableSubset *etss, + ETableModel *etm); + void (*proxy_model_row_changed) (ETableSubset *etss, + ETableModel *etm, + gint row); + void (*proxy_model_cell_changed) (ETableSubset *etss, + ETableModel *etm, + gint col, + gint row); + void (*proxy_model_rows_inserted) (ETableSubset *etss, + ETableModel *etm, + gint row, + gint count); + void (*proxy_model_rows_deleted) (ETableSubset *etss, + ETableModel *etm, + gint row, + gint count); +}; + +GType e_table_subset_get_type (void) G_GNUC_CONST; +ETableModel * e_table_subset_new (ETableModel *etm, + gint n_vals); +ETableModel * e_table_subset_construct (ETableSubset *ets, + ETableModel *source, + gint nvals); +gint e_table_subset_model_to_view_row + (ETableSubset *ets, + gint model_row); +gint e_table_subset_view_to_model_row + (ETableSubset *ets, + gint view_row); +ETableModel * e_table_subset_get_toplevel (ETableSubset *table_model); +void e_table_subset_print_debugging (ETableSubset *table_model); G_END_DECLS diff --git a/widgets/table/e-table-utils.h b/widgets/table/e-table-utils.h index 2c725f4bf9..a53e7e4060 100644 --- a/widgets/table/e-table-utils.h +++ b/widgets/table/e-table-utils.h @@ -31,17 +31,18 @@ G_BEGIN_DECLS -ETableHeader *e_table_state_to_header (GtkWidget *widget, - ETableHeader *full_header, - ETableState *state); - -ETableHeader *e_table_spec_to_full_header (ETableSpecification *spec, - ETableExtras *ete); - -ETableCol *e_table_util_calculate_current_search_col (ETableHeader *header, - ETableHeader *full_header, - ETableSortInfo *sort_info, - gboolean always_search); +ETableHeader * e_table_state_to_header (GtkWidget *widget, + ETableHeader *full_header, + ETableState *state); + +ETableHeader * e_table_spec_to_full_header (ETableSpecification *spec, + ETableExtras *ete); + +ETableCol * e_table_util_calculate_current_search_col + (ETableHeader *header, + ETableHeader *full_header, + ETableSortInfo *sort_info, + gboolean always_search); G_END_DECLS diff --git a/widgets/table/e-table-without.c b/widgets/table/e-table-without.c index 5dacfb61cc..881c21bf16 100644 --- a/widgets/table/e-table-without.c +++ b/widgets/table/e-table-without.c @@ -30,9 +30,13 @@ #include "e-table-without.h" +#define E_TABLE_WITHOUT_GET_PRIVATE(obj) \ + (G_TYPE_INSTANCE_GET_PRIVATE \ + ((obj), E_TYPE_TABLE_WITHOUT, ETableWithoutPrivate)) + /* workaround for avoiding API breakage */ #define etw_get_type e_table_without_get_type -G_DEFINE_TYPE (ETableWithout, etw, E_TABLE_SUBSET_TYPE) +G_DEFINE_TYPE (ETableWithout, etw, E_TYPE_TABLE_SUBSET) #define INCREMENT_AMOUNT 10 @@ -135,20 +139,18 @@ delete_hash_element (gpointer key, static void etw_dispose (GObject *object) { - ETableWithout *etw = E_TABLE_WITHOUT (object); + ETableWithoutPrivate *priv; - if (etw->priv) { - if (etw->priv->hash) { - g_hash_table_foreach (etw->priv->hash, delete_hash_element, etw); - g_hash_table_destroy (etw->priv->hash); - etw->priv->hash = NULL; - } - g_free (etw->priv); - etw->priv = NULL; + priv = E_TABLE_WITHOUT_GET_PRIVATE (object); + + if (priv->hash != NULL) { + g_hash_table_foreach (priv->hash, delete_hash_element, object); + g_hash_table_destroy (priv->hash); + priv->hash = NULL; } - if (G_OBJECT_CLASS (etw_parent_class)->dispose) - (* G_OBJECT_CLASS (etw_parent_class)->dispose) (object); + /* Chain up to parent's dispose() method. */ + G_OBJECT_CLASS (etw_parent_class)->dispose (object); } static void @@ -231,28 +233,26 @@ etw_proxy_model_changed (ETableSubset *etss, ETableModel *etm) } static void -etw_class_init (ETableWithoutClass *klass) +etw_class_init (ETableWithoutClass *class) { - ETableSubsetClass *etss_class = E_TABLE_SUBSET_CLASS (klass); - GObjectClass *object_class = G_OBJECT_CLASS (klass); + GObjectClass *object_class; + ETableSubsetClass *etss_class; + + g_type_class_add_private (class, sizeof (ETableWithoutPrivate)); - object_class->dispose = etw_dispose; + object_class = G_OBJECT_CLASS (class); + object_class->dispose = etw_dispose; + etss_class = E_TABLE_SUBSET_CLASS (class); etss_class->proxy_model_rows_inserted = etw_proxy_model_rows_inserted; etss_class->proxy_model_rows_deleted = etw_proxy_model_rows_deleted; - etss_class->proxy_model_changed = etw_proxy_model_changed; + etss_class->proxy_model_changed = etw_proxy_model_changed; } static void etw_init (ETableWithout *etw) { - etw->priv = g_new (ETableWithoutPrivate, 1); - etw->priv->hash_func = NULL; - etw->priv->compare_func = NULL; - etw->priv->get_key_func = NULL; - etw->priv->duplicate_key_func = NULL; - etw->priv->free_gotten_key_func = NULL; - etw->priv->free_duplicated_key_func = NULL; + etw->priv = E_TABLE_WITHOUT_GET_PRIVATE (etw); } ETableModel * @@ -293,7 +293,7 @@ e_table_without_new (ETableModel *source, ETableWithoutFreeKeyFunc free_duplicated_key_func, void *closure) { - ETableWithout *etw = g_object_new (E_TABLE_WITHOUT_TYPE, NULL); + ETableWithout *etw = g_object_new (E_TYPE_TABLE_WITHOUT, NULL); if (e_table_without_construct (etw, source, diff --git a/widgets/table/e-table-without.h b/widgets/table/e-table-without.h index ce4745cff9..03e1db6702 100644 --- a/widgets/table/e-table-without.h +++ b/widgets/table/e-table-without.h @@ -24,62 +24,76 @@ #ifndef _E_TABLE_WITHOUT_H_ #define _E_TABLE_WITHOUT_H_ -#include <glib-object.h> #include <table/e-table-subset.h> -G_BEGIN_DECLS +/* Standard GObject macros */ +#define E_TYPE_TABLE_WITHOUT \ + (e_table_without_get_type ()) +#define E_TABLE_WITHOUT(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST \ + ((obj), E_TYPE_TABLE_WITHOUT, ETableWithout)) +#define E_TABLE_WITHOUT_CLASS(cls) \ + (G_TYPE_CHECK_CLASS_CAST \ + ((cls), E_TYPE_TABLE_WITHOUT, ETableWithoutClass)) +#define E_IS_TABLE_WITHOUT(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE \ + ((obj), E_TYPE_TABLE_WITHOUT)) +#define E_IS_TABLE_WITHOUT_CLASS(cls) \ + (G_TYPE_CHECK_CLASS_TYPE \ + ((cls), E_TYPE_TABLE_WITHOUT)) +#define E_TABLE_WITHOUT_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS \ + ((obj), E_TYPE_TABLE_WITHOUT, ETableWithoutClass)) -#define E_TABLE_WITHOUT_TYPE (e_table_without_get_type ()) -#define E_TABLE_WITHOUT(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), E_TABLE_WITHOUT_TYPE, ETableWithout)) -#define E_TABLE_WITHOUT_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k), E_TABLE_WITHOUT_TYPE, ETableWithoutClass)) -#define E_IS_TABLE_WITHOUT(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), E_TABLE_WITHOUT_TYPE)) -#define E_IS_TABLE_WITHOUT_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), E_TABLE_WITHOUT_TYPE)) +G_BEGIN_DECLS +typedef struct _ETableWithout ETableWithout; +typedef struct _ETableWithoutClass ETableWithoutClass; typedef struct _ETableWithoutPrivate ETableWithoutPrivate; -typedef gpointer (*ETableWithoutGetKeyFunc) (ETableModel *source, - gint row, - void *closure); -typedef gpointer (*ETableWithoutDuplicateKeyFunc) (const void *key, - void *closure); -typedef void (*ETableWithoutFreeKeyFunc) (void *key, - void *closure); -typedef struct { - ETableSubset base; +typedef gpointer (*ETableWithoutGetKeyFunc) (ETableModel *source, + gint row, + gpointer closure); +typedef gpointer (*ETableWithoutDuplicateKeyFunc)(gconstpointer key, + gpointer closure); +typedef void (*ETableWithoutFreeKeyFunc) (gpointer key, + gpointer closure); +struct _ETableWithout { + ETableSubset parent; ETableWithoutPrivate *priv; -} ETableWithout; +}; -typedef struct { +struct _ETableWithoutClass { ETableSubsetClass parent_class; +}; -} ETableWithoutClass; +GType e_table_without_get_type (void) G_GNUC_CONST; +ETableModel * e_table_without_new (ETableModel *source, + GHashFunc hash_func, + GCompareFunc compare_func, + ETableWithoutGetKeyFunc get_key_func, + ETableWithoutDuplicateKeyFunc duplicate_key_func, + ETableWithoutFreeKeyFunc free_gotten_key_func, + ETableWithoutFreeKeyFunc free_duplicated_key_func, + gpointer closure); +ETableModel * e_table_without_construct (ETableWithout *etw, + ETableModel *source, + GHashFunc hash_func, + GCompareFunc compare_func, + ETableWithoutGetKeyFunc get_key_func, + ETableWithoutDuplicateKeyFunc duplicate_key_func, + ETableWithoutFreeKeyFunc free_gotten_key_func, + ETableWithoutFreeKeyFunc free_duplicated_key_func, + gpointer closure); +void e_table_without_hide (ETableWithout *etw, + gpointer key); +void e_table_without_hide_adopt (ETableWithout *etw, + gpointer key); +void e_table_without_show (ETableWithout *etw, + gpointer key); +void e_table_without_show_all (ETableWithout *etw); -GType e_table_without_get_type (void); -ETableModel *e_table_without_new (ETableModel *source, - GHashFunc hash_func, - GCompareFunc compare_func, - ETableWithoutGetKeyFunc get_key_func, - ETableWithoutDuplicateKeyFunc duplicate_key_func, - ETableWithoutFreeKeyFunc free_gotten_key_func, - ETableWithoutFreeKeyFunc free_duplicated_key_func, - void *closure); -ETableModel *e_table_without_construct (ETableWithout *etw, - ETableModel *source, - GHashFunc hash_func, - GCompareFunc compare_func, - ETableWithoutGetKeyFunc get_key_func, - ETableWithoutDuplicateKeyFunc duplicate_key_func, - ETableWithoutFreeKeyFunc free_gotten_key_func, - ETableWithoutFreeKeyFunc free_duplicated_key_func, - void *closure); -void e_table_without_hide (ETableWithout *etw, - void *key); -void e_table_without_hide_adopt (ETableWithout *etw, - void *key); -void e_table_without_show (ETableWithout *etw, - void *key); -void e_table_without_show_all (ETableWithout *etw); G_END_DECLS #endif /* _E_TABLE_WITHOUT_H_ */ diff --git a/widgets/table/e-table.c b/widgets/table/e-table.c index 952bf900b8..aad7c9f729 100644 --- a/widgets/table/e-table.c +++ b/widgets/table/e-table.c @@ -1869,7 +1869,7 @@ e_table_new (ETableModel *etm, g_return_val_if_fail (ete == NULL || E_IS_TABLE_EXTRAS (ete), NULL); g_return_val_if_fail (spec != NULL, NULL); - e_table = g_object_new (E_TABLE_TYPE, NULL); + e_table = g_object_new (E_TYPE_TABLE, NULL); e_table = e_table_construct (e_table, etm, ete, spec, state); @@ -1909,7 +1909,7 @@ e_table_new_from_spec_file (ETableModel *etm, g_return_val_if_fail (ete == NULL || E_IS_TABLE_EXTRAS (ete), NULL); g_return_val_if_fail (spec_fn != NULL, NULL); - e_table = g_object_new (E_TABLE_TYPE, NULL); + e_table = g_object_new (E_TYPE_TABLE, NULL); e_table = e_table_construct_from_spec_file (e_table, etm, ete, spec_fn, state_fn); @@ -3510,7 +3510,7 @@ e_table_class_init (ETableClass *class) g_param_spec_object ("model", "Model", NULL, - E_TABLE_MODEL_TYPE, + E_TYPE_TABLE_MODEL, G_PARAM_READABLE)); gtk_widget_class_install_style_property ( diff --git a/widgets/table/e-table.h b/widgets/table/e-table.h index 1da89f9e2f..b95444d118 100644 --- a/widgets/table/e-table.h +++ b/widgets/table/e-table.h @@ -6,7 +6,7 @@ * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public @@ -40,13 +40,29 @@ #include <table/e-table-sorter.h> #include <table/e-table-search.h> +/* Standard GObject macros */ +#define E_TYPE_TABLE \ + (e_table_get_type ()) +#define E_TABLE(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST \ + ((obj), E_TYPE_TABLE, ETable)) +#define E_TABLE_CLASS(cls) \ + (G_TYPE_CHECK_CLASS_CAST \ + ((cls), E_TYPE_TABLE, ETableClass)) +#define E_IS_TABLE(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE \ + ((obj), E_TYPE_TABLE)) +#define E_IS_TABLE_CLASS(cls) \ + (G_TYPE_CHECK_CLASS_TYPE \ + ((cls), E_TYPE_TABLE)) +#define E_TABLE_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS \ + ((obj), E_TYPE_TABLE, ETableClass)) + G_BEGIN_DECLS -#define E_TABLE_TYPE (e_table_get_type ()) -#define E_TABLE(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), E_TABLE_TYPE, ETable)) -#define E_TABLE_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k), E_TABLE_TYPE, ETableClass)) -#define E_IS_TABLE(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), E_TABLE_TYPE)) -#define E_IS_TABLE_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), E_TABLE_TYPE)) +typedef struct _ETable ETable; +typedef struct _ETableClass ETableClass; typedef struct _ETableDragSourceSite ETableDragSourceSite; @@ -56,7 +72,7 @@ typedef enum { E_TABLE_CURSOR_LOC_TABLE = 1 << 1 } ETableCursorLoc; -typedef struct { +struct _ETable { GtkTable parent; ETableModel *model; @@ -64,21 +80,21 @@ typedef struct { ETableHeader *full_header, *header; GnomeCanvasItem *canvas_vbox; - ETableGroup *group; + ETableGroup *group; ETableSortInfo *sort_info; - ETableSorter *sorter; + ETableSorter *sorter; ETableSelectionModel *selection; ETableCursorLoc cursor_loc; ETableSpecification *spec; - ETableSearch *search; + ETableSearch *search; - ETableCol *current_search_col; + ETableCol *current_search_col; - guint search_search_id; - guint search_accept_id; + guint search_search_id; + guint search_accept_id; gint table_model_change_id; gint table_row_change_id; @@ -154,201 +170,226 @@ typedef struct { gint header_width; gchar *domain; -} ETable; +}; -typedef struct { +struct _ETableClass { GtkTableClass parent_class; - void (*cursor_change) (ETable *et, gint row); - void (*cursor_activated) (ETable *et, gint row); - void (*selection_change) (ETable *et); - void (*double_click) (ETable *et, gint row, gint col, GdkEvent *event); - gboolean (*right_click) (ETable *et, gint row, gint col, GdkEvent *event); - gboolean (*click) (ETable *et, gint row, gint col, GdkEvent *event); - gboolean (*key_press) (ETable *et, gint row, gint col, GdkEvent *event); - gboolean (*start_drag) (ETable *et, gint row, gint col, GdkEvent *event); - void (*state_change) (ETable *et); - gboolean (*white_space_event) (ETable *et, GdkEvent *event); - - void (*set_scroll_adjustments) (ETable *table, - GtkAdjustment *hadjustment, - GtkAdjustment *vadjustment); + void (*cursor_change) (ETable *et, + gint row); + void (*cursor_activated) (ETable *et, + gint row); + void (*selection_change) (ETable *et); + void (*double_click) (ETable *et, + gint row, + gint col, + GdkEvent *event); + gboolean (*right_click) (ETable *et, + gint row, + gint col, + GdkEvent *event); + gboolean (*click) (ETable *et, + gint row, + gint col, + GdkEvent *event); + gboolean (*key_press) (ETable *et, + gint row, + gint col, + GdkEvent *event); + gboolean (*start_drag) (ETable *et, + gint row, + gint col, + GdkEvent *event); + void (*state_change) (ETable *et); + gboolean (*white_space_event) (ETable *et, + GdkEvent *event); + + void (*set_scroll_adjustments) + (ETable *table, + GtkAdjustment *hadjustment, + GtkAdjustment *vadjustment); /* Source side drag signals */ - void (* table_drag_begin) (ETable *table, - gint row, - gint col, - GdkDragContext *context); - void (* table_drag_end) (ETable *table, - gint row, - gint col, - GdkDragContext *context); - void (* table_drag_data_get) (ETable *table, - gint row, - gint col, - GdkDragContext *context, - GtkSelectionData *selection_data, - guint info, - guint time); - void (* table_drag_data_delete) (ETable *table, - gint row, - gint col, - GdkDragContext *context); + void (*table_drag_begin) (ETable *table, + gint row, + gint col, + GdkDragContext *context); + void (*table_drag_end) (ETable *table, + gint row, + gint col, + GdkDragContext *context); + void (*table_drag_data_get) (ETable *table, + gint row, + gint col, + GdkDragContext *context, + GtkSelectionData *selection_data, + guint info, + guint time); + void (*table_drag_data_delete) + (ETable *table, + gint row, + gint col, + GdkDragContext *context); /* Target side drag signals */ - void (* table_drag_leave) (ETable *table, - gint row, - gint col, - GdkDragContext *context, - guint time); - gboolean (* table_drag_motion) (ETable *table, - gint row, - gint col, - GdkDragContext *context, - gint x, - gint y, - guint time); - gboolean (* table_drag_drop) (ETable *table, - gint row, - gint col, - GdkDragContext *context, - gint x, - gint y, - guint time); - void (* table_drag_data_received) (ETable *table, - gint row, - gint col, - GdkDragContext *context, - gint x, - gint y, - GtkSelectionData *selection_data, - guint info, - guint time); -} ETableClass; -GType e_table_get_type (void); -ETable *e_table_construct (ETable *e_table, - ETableModel *etm, - ETableExtras *ete, - const gchar *spec, - const gchar *state); -GtkWidget *e_table_new (ETableModel *etm, - ETableExtras *ete, - const gchar *spec, - const gchar *state); + void (*table_drag_leave) (ETable *table, + gint row, + gint col, + GdkDragContext *context, + guint time); + gboolean (*table_drag_motion) (ETable *table, + gint row, + gint col, + GdkDragContext *context, + gint x, + gint y, + guint time); + gboolean (*table_drag_drop) (ETable *table, + gint row, + gint col, + GdkDragContext *context, + gint x, + gint y, + guint time); + void (*table_drag_data_received) + (ETable *table, + gint row, + gint col, + GdkDragContext *context, + gint x, + gint y, + GtkSelectionData *selection_data, + guint info, + guint time); +}; + +GType e_table_get_type (void) G_GNUC_CONST; +ETable * e_table_construct (ETable *e_table, + ETableModel *etm, + ETableExtras *ete, + const gchar *spec, + const gchar *state); +GtkWidget * e_table_new (ETableModel *etm, + ETableExtras *ete, + const gchar *spec, + const gchar *state); /* Create an ETable using files. */ -ETable *e_table_construct_from_spec_file (ETable *e_table, - ETableModel *etm, - ETableExtras *ete, - const gchar *spec_fn, - const gchar *state_fn); -GtkWidget *e_table_new_from_spec_file (ETableModel *etm, - ETableExtras *ete, - const gchar *spec_fn, - const gchar *state_fn); +ETable * e_table_construct_from_spec_file + (ETable *e_table, + ETableModel *etm, + ETableExtras *ete, + const gchar *spec_fn, + const gchar *state_fn); +GtkWidget * e_table_new_from_spec_file (ETableModel *etm, + ETableExtras *ete, + const gchar *spec_fn, + const gchar *state_fn); /* To save the state */ -gchar *e_table_get_state (ETable *e_table); -void e_table_save_state (ETable *e_table, - const gchar *filename); -ETableState *e_table_get_state_object (ETable *e_table); +gchar * e_table_get_state (ETable *e_table); +void e_table_save_state (ETable *e_table, + const gchar *filename); +ETableState *e_table_get_state_object (ETable *e_table); /* note that it is more efficient to provide the state at creation time */ -void e_table_set_state (ETable *e_table, - const gchar *state); -void e_table_set_state_object (ETable *e_table, - ETableState *state); -void e_table_load_state (ETable *e_table, - const gchar *filename); -void e_table_set_cursor_row (ETable *e_table, - gint row); - -/* -1 means we don't have the cursor. This is in model rows. */ -gint e_table_get_cursor_row (ETable *e_table); -void e_table_selected_row_foreach (ETable *e_table, - EForeachFunc callback, - gpointer closure); -gint e_table_selected_count (ETable *e_table); -EPrintable *e_table_get_printable (ETable *e_table); -gint e_table_get_next_row (ETable *e_table, - gint model_row); -gint e_table_get_prev_row (ETable *e_table, - gint model_row); -gint e_table_model_to_view_row (ETable *e_table, - gint model_row); -gint e_table_view_to_model_row (ETable *e_table, - gint view_row); -void e_table_get_cell_at (ETable *table, - gint x, - gint y, - gint *row_return, - gint *col_return); -void e_table_get_mouse_over_cell (ETable *table, gint *row, gint *col); -void e_table_get_cell_geometry (ETable *table, - gint row, - gint col, - gint *x_return, - gint *y_return, - gint *width_return, - gint *height_return); +void e_table_set_state (ETable *e_table, + const gchar *state); +void e_table_set_state_object (ETable *e_table, + ETableState *state); +void e_table_load_state (ETable *e_table, + const gchar *filename); +void e_table_set_cursor_row (ETable *e_table, + gint row); + +/* -1 means we don't have the cursor. This is in model rows. */ +gint e_table_get_cursor_row (ETable *e_table); +void e_table_selected_row_foreach (ETable *e_table, + EForeachFunc callback, + gpointer closure); +gint e_table_selected_count (ETable *e_table); +EPrintable * e_table_get_printable (ETable *e_table); +gint e_table_get_next_row (ETable *e_table, + gint model_row); +gint e_table_get_prev_row (ETable *e_table, + gint model_row); +gint e_table_model_to_view_row (ETable *e_table, + gint model_row); +gint e_table_view_to_model_row (ETable *e_table, + gint view_row); +void e_table_get_cell_at (ETable *table, + gint x, + gint y, + gint *row_return, + gint *col_return); +void e_table_get_mouse_over_cell (ETable *table, + gint *row, + gint *col); +void e_table_get_cell_geometry (ETable *table, + gint row, + gint col, + gint *x_return, + gint *y_return, + gint *width_return, + gint *height_return); /* Useful accessor functions. */ -ESelectionModel *e_table_get_selection_model (ETable *table); +ESelectionModel *e_table_get_selection_model (ETable *table); /* Drag & drop stuff. */ /* Target */ -void e_table_drag_get_data (ETable *table, - gint row, - gint col, - GdkDragContext *context, - GdkAtom target, - guint32 time); -void e_table_drag_highlight (ETable *table, - gint row, - gint col); /* col == -1 to highlight entire row. */ -void e_table_drag_unhighlight (ETable *table); -void e_table_drag_dest_set (ETable *table, - GtkDestDefaults flags, - const GtkTargetEntry *targets, - gint n_targets, - GdkDragAction actions); -void e_table_drag_dest_set_proxy (ETable *table, - GdkWindow *proxy_window, - GdkDragProtocol protocol, - gboolean use_coordinates); +void e_table_drag_get_data (ETable *table, + gint row, + gint col, + GdkDragContext *context, + GdkAtom target, + guint32 time); +void e_table_drag_highlight (ETable *table, + gint row, + gint col); /* col == -1 to highlight entire row. */ +void e_table_drag_unhighlight (ETable *table); +void e_table_drag_dest_set (ETable *table, + GtkDestDefaults flags, + const GtkTargetEntry *targets, + gint n_targets, + GdkDragAction actions); +void e_table_drag_dest_set_proxy (ETable *table, + GdkWindow *proxy_window, + GdkDragProtocol protocol, + gboolean use_coordinates); /* There probably should be functions for setting the targets * as a GtkTargetList */ -void e_table_drag_dest_unset (GtkWidget *widget); +void e_table_drag_dest_unset (GtkWidget *widget); /* Source side */ -void e_table_drag_source_set (ETable *table, - GdkModifierType start_button_mask, - const GtkTargetEntry *targets, - gint n_targets, - GdkDragAction actions); -void e_table_drag_source_unset (ETable *table); +void e_table_drag_source_set (ETable *table, + GdkModifierType start_button_mask, + const GtkTargetEntry *targets, + gint n_targets, + GdkDragAction actions); +void e_table_drag_source_unset (ETable *table); /* There probably should be functions for setting the targets * as a GtkTargetList */ -GdkDragContext *e_table_drag_begin (ETable *table, - gint row, - gint col, - GtkTargetList *targets, - GdkDragAction actions, - gint button, - GdkEvent *event); +GdkDragContext *e_table_drag_begin (ETable *table, + gint row, + gint col, + GtkTargetList *targets, + GdkDragAction actions, + gint button, + GdkEvent *event); /* selection stuff */ -void e_table_select_all (ETable *table); -void e_table_invert_selection (ETable *table); +void e_table_select_all (ETable *table); +void e_table_invert_selection (ETable *table); /* This function is only needed in single_selection_mode. */ -void e_table_right_click_up (ETable *table); +void e_table_right_click_up (ETable *table); -void e_table_commit_click_to_add (ETable *table); +void e_table_commit_click_to_add (ETable *table); G_END_DECLS diff --git a/widgets/table/e-tree-memory-callbacks.c b/widgets/table/e-tree-memory-callbacks.c index daf3bc7c13..1edaa3e09d 100644 --- a/widgets/table/e-tree-memory-callbacks.c +++ b/widgets/table/e-tree-memory-callbacks.c @@ -29,7 +29,7 @@ #include "e-tree-memory-callbacks.h" -G_DEFINE_TYPE (ETreeMemoryCallbacks, e_tree_memory_callbacks, E_TREE_MEMORY_TYPE) +G_DEFINE_TYPE (ETreeMemoryCallbacks, e_tree_memory_callbacks, E_TYPE_TREE_MEMORY) static GdkPixbuf * etmc_icon_at (ETreeModel *etm, ETreePath node) @@ -184,9 +184,9 @@ etmc_value_to_string (ETreeModel *etm, gint col, gconstpointer value) } static void -e_tree_memory_callbacks_class_init (ETreeMemoryCallbacksClass *klass) +e_tree_memory_callbacks_class_init (ETreeMemoryCallbacksClass *class) { - ETreeModelClass *model_class = E_TREE_MODEL_CLASS (klass); + ETreeModelClass *model_class = E_TREE_MODEL_CLASS (class); model_class->icon_at = etmc_icon_at; @@ -263,7 +263,7 @@ e_tree_memory_callbacks_new (ETreeMemoryCallbacksIconAtFn icon_at, { ETreeMemoryCallbacks *etmc; - etmc = g_object_new (E_TREE_MEMORY_CALLBACKS_TYPE, NULL); + etmc = g_object_new (E_TYPE_TREE_MEMORY_CALLBACKS, NULL); etmc->icon_at = icon_at; diff --git a/widgets/table/e-tree-memory-callbacks.h b/widgets/table/e-tree-memory-callbacks.h index e37ef30d6c..f2e202bec3 100644 --- a/widgets/table/e-tree-memory-callbacks.h +++ b/widgets/table/e-tree-memory-callbacks.h @@ -25,35 +25,98 @@ #include <table/e-tree-memory.h> -G_BEGIN_DECLS - -#define E_TREE_MEMORY_CALLBACKS_TYPE (e_tree_memory_callbacks_get_type ()) -#define E_TREE_MEMORY_CALLBACKS(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), E_TREE_MEMORY_CALLBACKS_TYPE, ETreeMemoryCallbacks)) -#define E_TREE_MEMORY_CALLBACKS_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k), E_TREE_MEMORY_CALLBACKS_TYPE, ETreeMemoryCallbacksClass)) -#define E_IS_TREE_MEMORY_CALLBACKS(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), E_TREE_MEMORY_CALLBACKS_TYPE)) -#define E_IS_TREE_MEMORY_CALLBACKS_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), E_TREE_MEMORY_CALLBACKS_TYPE)) - -typedef GdkPixbuf* (*ETreeMemoryCallbacksIconAtFn) (ETreeModel *etree, ETreePath path, gpointer model_data); - -typedef gint (*ETreeMemoryCallbacksColumnCountFn) (ETreeModel *etree, gpointer model_data); - -typedef gboolean (*ETreeMemoryCallbacksHasSaveIdFn) (ETreeModel *etree, gpointer model_data); -typedef gchar *(*ETreeMemoryCallbacksGetSaveIdFn) (ETreeModel *etree, ETreePath path, gpointer model_data); +/* Standard GObject macros */ +#define E_TYPE_TREE_MEMORY_CALLBACKS \ + (e_tree_memory_callbacks_get_type ()) +#define E_TREE_MEMORY_CALLBACKS(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST \ + ((obj), E_TYPE_TREE_MEMORY_CALLBACKS, ETreeMemoryCallbacks)) +#define E_TREE_MEMORY_CALLBACKS_CLASS(cls) \ + (G_TYPE_CHECK_CLASS_CAST \ + ((cls), E_TYPE_TREE_MEMORY_CALLBACKS, ETreeMemoryCallbacksClass)) +#define E_IS_TREE_MEMORY_CALLBACKS(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE \ + ((obj), E_TYPE_TREE_MEMORY_CALLBACKS)) +#define E_IS_TREE_MEMORY_CALLBACKS_CLASS(cls) \ + (G_TYPE_CHECK_CLASS_TYPE \ + ((cls), E_TYPE_TREE_MEMORY_CALLBACKS)) +#define E_TREE_MEMORY_CALLBACKS_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS \ + ((obj), E_TYPE_TREE_MEMORY_CALLBACKS, ETreeMemoryCallbacksClass)) -typedef gboolean (*ETreeMemoryCallbacksHasGetNodeByIdFn) (ETreeModel *etree, gpointer model_data); -typedef ETreePath (*ETreeMemoryCallbacksGetNodeByIdFn) (ETreeModel *etree, const gchar *save_id, gpointer model_data); - -typedef gpointer (*ETreeMemoryCallbacksValueAtFn) (ETreeModel *etree, ETreePath path, gint col, gpointer model_data); -typedef void (*ETreeMemoryCallbacksSetValueAtFn) (ETreeModel *etree, ETreePath path, gint col, gconstpointer val, gpointer model_data); -typedef gboolean (*ETreeMemoryCallbacksIsEditableFn) (ETreeModel *etree, ETreePath path, gint col, gpointer model_data); - -typedef void *(*ETreeMemoryCallbacksDuplicateValueFn) (ETreeModel *etm, gint col, gconstpointer val, gpointer data); -typedef void (*ETreeMemoryCallbacksFreeValueFn) (ETreeModel *etm, gint col, gpointer val, gpointer data); -typedef void *(*ETreeMemoryCallbacksInitializeValueFn) (ETreeModel *etm, gint col, gpointer data); -typedef gboolean (*ETreeMemoryCallbacksValueIsEmptyFn) (ETreeModel *etm, gint col, gconstpointer val, gpointer data); -typedef gchar *(*ETreeMemoryCallbacksValueToStringFn) (ETreeModel *etm, gint col, gconstpointer val, gpointer data); +G_BEGIN_DECLS -typedef struct { +typedef struct _ETreeMemoryCallbacks ETreeMemoryCallbacks; +typedef struct _ETreeMemoryCallbacksClass ETreeMemoryCallbacksClass; + +typedef GdkPixbuf * (*ETreeMemoryCallbacksIconAtFn) + (ETreeModel *etree, + ETreePath path, + gpointer model_data); + +typedef gint (*ETreeMemoryCallbacksColumnCountFn) + (ETreeModel *etree, + gpointer model_data); + +typedef gboolean (*ETreeMemoryCallbacksHasSaveIdFn) + (ETreeModel *etree, + gpointer model_data); +typedef gchar * (*ETreeMemoryCallbacksGetSaveIdFn) + (ETreeModel *etree, + ETreePath path, + gpointer model_data); + +typedef gboolean (*ETreeMemoryCallbacksHasGetNodeByIdFn) + (ETreeModel *etree, + gpointer model_data); +typedef ETreePath (*ETreeMemoryCallbacksGetNodeByIdFn) + (ETreeModel *etree, + const gchar *save_id, + gpointer model_data); + +typedef gpointer (*ETreeMemoryCallbacksValueAtFn) + (ETreeModel *etree, + ETreePath path, + gint col, + gpointer model_data); +typedef void (*ETreeMemoryCallbacksSetValueAtFn) + (ETreeModel *etree, + ETreePath path, + gint col, + gconstpointer val, + gpointer model_data); +typedef gboolean (*ETreeMemoryCallbacksIsEditableFn) + (ETreeModel *etree, + ETreePath path, + gint col, + gpointer model_data); + +typedef gpointer (*ETreeMemoryCallbacksDuplicateValueFn) + (ETreeModel *etm, + gint col, + gconstpointer val, + gpointer data); +typedef void (*ETreeMemoryCallbacksFreeValueFn) + (ETreeModel *etm, + gint col, + gpointer val, + gpointer data); +typedef gpointer (*ETreeMemoryCallbacksInitializeValueFn) + (ETreeModel *etm, + gint col, + gpointer data); +typedef gboolean (*ETreeMemoryCallbacksValueIsEmptyFn) + (ETreeModel *etm, + gint col, + gconstpointer val, + gpointer data); +typedef gchar * (*ETreeMemoryCallbacksValueToStringFn) + (ETreeModel *etm, + gint col, + gconstpointer val, + gpointer data); + +struct _ETreeMemoryCallbacks { ETreeMemory parent; ETreeMemoryCallbacksIconAtFn icon_at; @@ -66,7 +129,7 @@ typedef struct { ETreeMemoryCallbacksHasGetNodeByIdFn has_get_node_by_id; ETreeMemoryCallbacksGetNodeByIdFn get_node_by_id; - ETreeMemoryCallbacksValueAtFn sort_value_at; + ETreeMemoryCallbacksValueAtFn sort_value_at; ETreeMemoryCallbacksValueAtFn value_at; ETreeMemoryCallbacksSetValueAtFn set_value_at; ETreeMemoryCallbacksIsEditableFn is_editable; @@ -78,36 +141,37 @@ typedef struct { ETreeMemoryCallbacksValueToStringFn value_to_string; gpointer model_data; -} ETreeMemoryCallbacks; +}; -typedef struct { +struct _ETreeMemoryCallbacksClass { ETreeMemoryClass parent_class; -} ETreeMemoryCallbacksClass; - -GType e_tree_memory_callbacks_get_type (void); +}; -ETreeModel *e_tree_memory_callbacks_new (ETreeMemoryCallbacksIconAtFn icon_at, +GType e_tree_memory_callbacks_get_type + (void) G_GNUC_CONST; +ETreeModel * e_tree_memory_callbacks_new + (ETreeMemoryCallbacksIconAtFn icon_at, - ETreeMemoryCallbacksColumnCountFn column_count, + ETreeMemoryCallbacksColumnCountFn column_count, - ETreeMemoryCallbacksHasSaveIdFn has_save_id, - ETreeMemoryCallbacksGetSaveIdFn get_save_id, + ETreeMemoryCallbacksHasSaveIdFn has_save_id, + ETreeMemoryCallbacksGetSaveIdFn get_save_id, - ETreeMemoryCallbacksHasGetNodeByIdFn has_get_node_by_id, - ETreeMemoryCallbacksGetNodeByIdFn get_node_by_id, + ETreeMemoryCallbacksHasGetNodeByIdFn has_get_node_by_id, + ETreeMemoryCallbacksGetNodeByIdFn get_node_by_id, - ETreeMemoryCallbacksValueAtFn sort_value_at, - ETreeMemoryCallbacksValueAtFn value_at, - ETreeMemoryCallbacksSetValueAtFn set_value_at, - ETreeMemoryCallbacksIsEditableFn is_editable, + ETreeMemoryCallbacksValueAtFn sort_value_at, + ETreeMemoryCallbacksValueAtFn value_at, + ETreeMemoryCallbacksSetValueAtFn set_value_at, + ETreeMemoryCallbacksIsEditableFn is_editable, - ETreeMemoryCallbacksDuplicateValueFn duplicate_value, - ETreeMemoryCallbacksFreeValueFn free_value, - ETreeMemoryCallbacksInitializeValueFn initialize_value, - ETreeMemoryCallbacksValueIsEmptyFn value_is_empty, - ETreeMemoryCallbacksValueToStringFn value_to_string, + ETreeMemoryCallbacksDuplicateValueFn duplicate_value, + ETreeMemoryCallbacksFreeValueFn free_value, + ETreeMemoryCallbacksInitializeValueFn initialize_value, + ETreeMemoryCallbacksValueIsEmptyFn value_is_empty, + ETreeMemoryCallbacksValueToStringFn value_to_string, - gpointer model_data); + gpointer model_data); G_END_DECLS diff --git a/widgets/table/e-tree-memory.c b/widgets/table/e-tree-memory.c index 71dc0cbae0..bb26fa773f 100644 --- a/widgets/table/e-tree-memory.c +++ b/widgets/table/e-tree-memory.c @@ -37,7 +37,11 @@ #include "e-tree-memory.h" -G_DEFINE_TYPE (ETreeMemory, e_tree_memory, E_TREE_MODEL_TYPE) +#define E_TREE_MEMORY_GET_PRIVATE(obj) \ + (G_TYPE_INSTANCE_GET_PRIVATE \ + ((obj), E_TYPE_TREE_MEMORY, ETreeMemoryPrivate)) + +G_DEFINE_TYPE (ETreeMemory, e_tree_memory, E_TYPE_TREE_MODEL) enum { FILL_IN_CHILDREN, @@ -63,7 +67,7 @@ struct ETreeMemoryPath { gint num_children; }; -struct ETreeMemoryPriv { +struct _ETreeMemoryPrivate { ETreeMemoryPath *root; /* whether nodes are created expanded @@ -180,7 +184,7 @@ e_tree_path_unlink (ETreeMemoryPath *path) void e_tree_memory_freeze (ETreeMemory *etmm) { - ETreeMemoryPriv *priv = etmm->priv; + ETreeMemoryPrivate *priv = etmm->priv; if (priv->frozen == 0) e_tree_model_pre_change (E_TREE_MODEL (etmm)); @@ -200,7 +204,7 @@ e_tree_memory_freeze (ETreeMemory *etmm) void e_tree_memory_thaw (ETreeMemory *etmm) { - ETreeMemoryPriv *priv = etmm->priv; + ETreeMemoryPrivate *priv = etmm->priv; if (priv->frozen > 0) priv->frozen--; @@ -215,18 +219,13 @@ e_tree_memory_thaw (ETreeMemory *etmm) static void etmm_dispose (GObject *object) { - ETreeMemory *etmm = E_TREE_MEMORY (object); - ETreeMemoryPriv *priv = etmm->priv; - - if (priv) { - /* XXX lots of stuff to free here */ + ETreeMemoryPrivate *priv; - if (priv->root) - e_tree_memory_node_remove (etmm, priv->root); + priv = E_TREE_MEMORY_GET_PRIVATE (object); - g_free (priv); - } - etmm->priv = NULL; + if (priv->root) + e_tree_memory_node_remove ( + E_TREE_MEMORY (object), priv->root); G_OBJECT_CLASS (e_tree_memory_parent_class)->dispose (object); } @@ -234,7 +233,7 @@ etmm_dispose (GObject *object) static ETreePath etmm_get_root (ETreeModel *etm) { - ETreeMemoryPriv *priv = E_TREE_MEMORY (etm)->priv; + ETreeMemoryPrivate *priv = E_TREE_MEMORY (etm)->priv; return priv->root; } @@ -326,7 +325,7 @@ static gboolean etmm_get_expanded_default (ETreeModel *etm) { ETreeMemory *etmm = E_TREE_MEMORY (etm); - ETreeMemoryPriv *priv = etmm->priv; + ETreeMemoryPrivate *priv = etmm->priv; return priv->expanded_default; } @@ -353,10 +352,33 @@ etmm_node_request_collapse (ETreeModel *etm, ETreePath node) static void -e_tree_memory_class_init (ETreeMemoryClass *klass) +e_tree_memory_class_init (ETreeMemoryClass *class) { - ETreeModelClass *tree_class = (ETreeModelClass *) klass; - GObjectClass *object_class = (GObjectClass *) klass; + GObjectClass *object_class; + ETreeModelClass *tree_model_class; + + g_type_class_add_private (class, sizeof (ETreeMemoryPrivate)); + + object_class = G_OBJECT_CLASS (class); + object_class->dispose = etmm_dispose; + + tree_model_class = E_TREE_MODEL_CLASS (class); + tree_model_class->get_root = etmm_get_root; + tree_model_class->get_prev = etmm_get_prev; + tree_model_class->get_next = etmm_get_next; + tree_model_class->get_first_child = etmm_get_first_child; + tree_model_class->get_last_child = etmm_get_last_child; + tree_model_class->get_parent = etmm_get_parent; + + tree_model_class->is_root = etmm_is_root; + tree_model_class->is_expandable = etmm_is_expandable; + tree_model_class->get_children = etmm_get_children; + tree_model_class->depth = etmm_depth; + tree_model_class->get_expanded_default = etmm_get_expanded_default; + + tree_model_class->node_request_collapse = etmm_node_request_collapse; + + class->fill_in_children = NULL; signals[FILL_IN_CHILDREN] = g_signal_new ("fill_in_children", @@ -366,40 +388,12 @@ e_tree_memory_class_init (ETreeMemoryClass *klass) (GSignalAccumulator) NULL, NULL, g_cclosure_marshal_VOID__POINTER, G_TYPE_NONE, 1, G_TYPE_POINTER); - - object_class->dispose = etmm_dispose; - - tree_class->get_root = etmm_get_root; - tree_class->get_prev = etmm_get_prev; - tree_class->get_next = etmm_get_next; - tree_class->get_first_child = etmm_get_first_child; - tree_class->get_last_child = etmm_get_last_child; - tree_class->get_parent = etmm_get_parent; - - tree_class->is_root = etmm_is_root; - tree_class->is_expandable = etmm_is_expandable; - tree_class->get_children = etmm_get_children; - tree_class->depth = etmm_depth; - tree_class->get_expanded_default = etmm_get_expanded_default; - - tree_class->node_request_collapse = etmm_node_request_collapse; - - klass->fill_in_children = NULL; } static void e_tree_memory_init (ETreeMemory *etmm) { - ETreeMemoryPriv *priv; - - priv = g_new0 (ETreeMemoryPriv, 1); - etmm->priv = priv; - - priv->root = NULL; - priv->frozen = 0; - priv->expanded_default = 0; - priv->destroy_func = NULL; - priv->destroy_user_data = NULL; + etmm->priv = E_TREE_MEMORY_GET_PRIVATE (etmm); } /** @@ -423,7 +417,7 @@ e_tree_memory_construct (ETreeMemory *etmm) ETreeMemory * e_tree_memory_new (void) { - return (ETreeMemory *) g_object_new (E_TREE_MEMORY_TYPE, NULL); + return g_object_new (E_TYPE_TREE_MEMORY, NULL); } /** @@ -495,7 +489,7 @@ e_tree_memory_node_insert (ETreeMemory *tree_model, gint position, gpointer node_data) { - ETreeMemoryPriv *priv; + ETreeMemoryPrivate *priv; ETreeMemoryPath *new_path; ETreeMemoryPath *parent_path = parent_node; diff --git a/widgets/table/e-tree-memory.h b/widgets/table/e-tree-memory.h index 824f0b1399..cff4811256 100644 --- a/widgets/table/e-tree-memory.h +++ b/widgets/table/e-tree-memory.h @@ -28,71 +28,90 @@ #include <gdk-pixbuf/gdk-pixbuf.h> #include <table/e-tree-model.h> -G_BEGIN_DECLS +/* Standard GObject macros */ +#define E_TYPE_TREE_MEMORY \ + (e_tree_memory_get_type ()) +#define E_TREE_MEMORY(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST \ + ((obj), E_TYPE_TREE_MEMORY, ETreeMemory)) +#define E_TREE_MEMORY_CLASS(cls) \ + (G_TYPE_CHECK_CLASS_CAST \ + ((cls), E_TYPE_TREE_MEMORY, ETreeMemoryClass)) +#define E_IS_TREE_MEMORY(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE \ + ((obj), E_TYPE_TREE_MEMORY)) +#define E_IS_TREE_MEMORY_CLASS(cls) \ + (G_TYPE_CHECK_CLASS_TYPE \ + ((cls), E_TYPE_TREE_MEMORY)) +#define E_TREE_MEMORY_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS \ + ((obj), E_TYPE_TREE_MEMORY, ETreeMemoryClass)) -#define E_TREE_MEMORY_TYPE (e_tree_memory_get_type ()) -#define E_TREE_MEMORY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), E_TREE_MEMORY_TYPE, ETreeMemory)) -#define E_TREE_MEMORY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k), E_TREE_MEMORY_TYPE, ETreeMemoryClass)) -#define E_IS_TREE_MEMORY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), E_TREE_MEMORY_TYPE)) -#define E_IS_TREE_MEMORY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), E_TREE_MEMORY_TYPE)) -#define E_TREE_MEMORY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS((o), E_TREE_MEMORY_TYPE, ETreeMemoryClass)) +G_BEGIN_DECLS -typedef struct ETreeMemory ETreeMemory; -typedef struct ETreeMemoryPriv ETreeMemoryPriv; -typedef struct ETreeMemoryClass ETreeMemoryClass; +typedef struct _ETreeMemory ETreeMemory; +typedef struct _ETreeMemoryClass ETreeMemoryClass; +typedef struct _ETreeMemoryPrivate ETreeMemoryPrivate; -typedef gint (*ETreeMemorySortCallback) (ETreeMemory *etmm, ETreePath path1, ETreePath path2, gpointer closure); +typedef gint (*ETreeMemorySortCallback) (ETreeMemory *etmm, + ETreePath path1, + ETreePath path2, + gpointer closure); -struct ETreeMemory { - ETreeModel base; - ETreeMemoryPriv *priv; +struct _ETreeMemory { + ETreeModel parent; + ETreeMemoryPrivate *priv; }; -struct ETreeMemoryClass { +struct _ETreeMemoryClass { ETreeModelClass parent_class; - /* signals */ - void (*fill_in_children) (ETreeMemory *model, ETreePath node); + /* Signals */ + void (*fill_in_children) (ETreeMemory *model, + ETreePath node); }; -GType e_tree_memory_get_type (void); -void e_tree_memory_construct (ETreeMemory *etree); -ETreeMemory *e_tree_memory_new (void); +GType e_tree_memory_get_type (void) G_GNUC_CONST; +void e_tree_memory_construct (ETreeMemory *etree); +ETreeMemory * e_tree_memory_new (void); /* node operations */ -ETreePath e_tree_memory_node_insert (ETreeMemory *etree, - ETreePath parent, - gint position, - gpointer node_data); -ETreePath e_tree_memory_node_insert_id (ETreeMemory *etree, - ETreePath parent, - gint position, - gpointer node_data, - gchar *id); -ETreePath e_tree_memory_node_insert_before (ETreeMemory *etree, - ETreePath parent, - ETreePath sibling, - gpointer node_data); -gpointer e_tree_memory_node_remove (ETreeMemory *etree, - ETreePath path); +ETreePath e_tree_memory_node_insert (ETreeMemory *etree, + ETreePath parent, + gint position, + gpointer node_data); +ETreePath e_tree_memory_node_insert_id (ETreeMemory *etree, + ETreePath parent, + gint position, + gpointer node_data, + gchar *id); +ETreePath e_tree_memory_node_insert_before + (ETreeMemory *etree, + ETreePath parent, + ETreePath sibling, + gpointer node_data); +gpointer e_tree_memory_node_remove (ETreeMemory *etree, + ETreePath path); /* Freeze and thaw */ -void e_tree_memory_freeze (ETreeMemory *etree); -void e_tree_memory_thaw (ETreeMemory *etree); -void e_tree_memory_set_expanded_default (ETreeMemory *etree, - gboolean expanded); -gpointer e_tree_memory_node_get_data (ETreeMemory *etm, - ETreePath node); -void e_tree_memory_node_set_data (ETreeMemory *etm, - ETreePath node, - gpointer node_data); -void e_tree_memory_sort_node (ETreeMemory *etm, - ETreePath node, - ETreeMemorySortCallback callback, - gpointer user_data); -void e_tree_memory_set_node_destroy_func (ETreeMemory *etmm, - GFunc destroy_func, - gpointer user_data); +void e_tree_memory_freeze (ETreeMemory *etree); +void e_tree_memory_thaw (ETreeMemory *etree); +void e_tree_memory_set_expanded_default + (ETreeMemory *etree, + gboolean expanded); +gpointer e_tree_memory_node_get_data (ETreeMemory *etm, + ETreePath node); +void e_tree_memory_node_set_data (ETreeMemory *etm, + ETreePath node, + gpointer node_data); +void e_tree_memory_sort_node (ETreeMemory *etm, + ETreePath node, + ETreeMemorySortCallback callback, + gpointer user_data); +void e_tree_memory_set_node_destroy_func + (ETreeMemory *etmm, + GFunc destroy_func, + gpointer user_data); G_END_DECLS diff --git a/widgets/table/e-tree-model.c b/widgets/table/e-tree-model.c index 2c90c6ae72..79197aade0 100644 --- a/widgets/table/e-tree-model.c +++ b/widgets/table/e-tree-model.c @@ -61,9 +61,9 @@ static guint e_tree_model_signals[LAST_SIGNAL] = {0, }; static void -e_tree_model_class_init (ETreeModelClass *klass) +e_tree_model_class_init (ETreeModelClass *class) { - GObjectClass *object_class = G_OBJECT_CLASS (klass); + GObjectClass *object_class = G_OBJECT_CLASS (class); e_tree_model_signals[PRE_CHANGE] = g_signal_new ("pre_change", @@ -155,52 +155,52 @@ e_tree_model_class_init (ETreeModelClass *klass) g_cclosure_marshal_VOID__POINTER, G_TYPE_NONE, 1, G_TYPE_POINTER); - klass->get_root = NULL; - - klass->get_parent = NULL; - klass->get_first_child = NULL; - klass->get_last_child = NULL; - klass->get_next = NULL; - klass->get_prev = NULL; - - klass->is_root = NULL; - klass->is_expandable = NULL; - klass->get_children = NULL; - klass->depth = NULL; - - klass->icon_at = NULL; - - klass->get_expanded_default = NULL; - klass->column_count = NULL; - - klass->has_save_id = NULL; - klass->get_save_id = NULL; - klass->has_get_node_by_id = NULL; - klass->get_node_by_id = NULL; - - klass->has_change_pending = NULL; - - klass->sort_value_at = NULL; - klass->value_at = NULL; - klass->set_value_at = NULL; - klass->is_editable = NULL; - - klass->duplicate_value = NULL; - klass->free_value = NULL; - klass->initialize_value = NULL; - klass->value_is_empty = NULL; - klass->value_to_string = NULL; - - klass->pre_change = NULL; - klass->no_change = NULL; - klass->rebuilt = NULL; - klass->node_changed = NULL; - klass->node_data_changed = NULL; - klass->node_col_changed = NULL; - klass->node_inserted = NULL; - klass->node_removed = NULL; - klass->node_deleted = NULL; - klass->node_request_collapse = NULL; + class->get_root = NULL; + + class->get_parent = NULL; + class->get_first_child = NULL; + class->get_last_child = NULL; + class->get_next = NULL; + class->get_prev = NULL; + + class->is_root = NULL; + class->is_expandable = NULL; + class->get_children = NULL; + class->depth = NULL; + + class->icon_at = NULL; + + class->get_expanded_default = NULL; + class->column_count = NULL; + + class->has_save_id = NULL; + class->get_save_id = NULL; + class->has_get_node_by_id = NULL; + class->get_node_by_id = NULL; + + class->has_change_pending = NULL; + + class->sort_value_at = NULL; + class->value_at = NULL; + class->set_value_at = NULL; + class->is_editable = NULL; + + class->duplicate_value = NULL; + class->free_value = NULL; + class->initialize_value = NULL; + class->value_is_empty = NULL; + class->value_to_string = NULL; + + class->pre_change = NULL; + class->no_change = NULL; + class->rebuilt = NULL; + class->node_changed = NULL; + class->node_data_changed = NULL; + class->node_col_changed = NULL; + class->node_inserted = NULL; + class->node_removed = NULL; + class->node_deleted = NULL; + class->node_request_collapse = NULL; } static void @@ -226,7 +226,7 @@ e_tree_model_pre_change (ETreeModel *tree_model) g_return_if_fail (tree_model != NULL); g_return_if_fail (E_IS_TREE_MODEL (tree_model)); - d(g_print("Emitting pre_change on model 0x%p, a %s.\n", tree_model, g_type_name (G_OBJECT(tree_model)->klass->type))); + d(g_print("Emitting pre_change on model 0x%p, a %s.\n", tree_model, g_type_name (G_OBJECT(tree_model)->class->type))); g_signal_emit (G_OBJECT (tree_model), e_tree_model_signals[PRE_CHANGE], 0); } @@ -246,7 +246,7 @@ e_tree_model_no_change (ETreeModel *tree_model) g_return_if_fail (tree_model != NULL); g_return_if_fail (E_IS_TREE_MODEL (tree_model)); - d(g_print("Emitting no_change on model 0x%p, a %s.\n", tree_model, g_type_name (G_OBJECT(tree_model)->klass->type))); + d(g_print("Emitting no_change on model 0x%p, a %s.\n", tree_model, g_type_name (G_OBJECT(tree_model)->class->type))); g_signal_emit (G_OBJECT (tree_model), e_tree_model_signals[NO_CHANGE], 0); } @@ -266,7 +266,7 @@ e_tree_model_rebuilt (ETreeModel *tree_model) g_return_if_fail (tree_model != NULL); g_return_if_fail (E_IS_TREE_MODEL (tree_model)); - d(g_print("Emitting rebuilt on model 0x%p, a %s.\n", tree_model, g_type_name (G_OBJECT(tree_model)->klass->type))); + d(g_print("Emitting rebuilt on model 0x%p, a %s.\n", tree_model, g_type_name (G_OBJECT(tree_model)->class->type))); g_signal_emit (G_OBJECT (tree_model), e_tree_model_signals[REBUILT], 0); } @@ -285,7 +285,7 @@ e_tree_model_node_changed (ETreeModel *tree_model, ETreePath node) g_return_if_fail (tree_model != NULL); g_return_if_fail (E_IS_TREE_MODEL (tree_model)); - d(g_print("Emitting node_changed on model 0x%p, a %s.\n", tree_model, g_type_name (G_OBJECT(tree_model)->klass->type))); + d(g_print("Emitting node_changed on model 0x%p, a %s.\n", tree_model, g_type_name (G_OBJECT(tree_model)->class->type))); g_signal_emit (G_OBJECT (tree_model), e_tree_model_signals[NODE_CHANGED], 0, node); } @@ -305,7 +305,7 @@ e_tree_model_node_data_changed (ETreeModel *tree_model, ETreePath node) g_return_if_fail (tree_model != NULL); g_return_if_fail (E_IS_TREE_MODEL (tree_model)); - d(g_print("Emitting node_data_changed on model 0x%p, a %s.\n", tree_model, g_type_name (G_OBJECT(tree_model)->klass->type))); + d(g_print("Emitting node_data_changed on model 0x%p, a %s.\n", tree_model, g_type_name (G_OBJECT(tree_model)->class->type))); g_signal_emit (G_OBJECT (tree_model), e_tree_model_signals[NODE_DATA_CHANGED], 0, node); } @@ -325,7 +325,7 @@ e_tree_model_node_col_changed (ETreeModel *tree_model, ETreePath node, gint col g_return_if_fail (tree_model != NULL); g_return_if_fail (E_IS_TREE_MODEL (tree_model)); - d(g_print("Emitting node_col_changed on model 0x%p, a %s.\n", tree_model, g_type_name (G_OBJECT(tree_model)->klass->type))); + d(g_print("Emitting node_col_changed on model 0x%p, a %s.\n", tree_model, g_type_name (G_OBJECT(tree_model)->class->type))); g_signal_emit (G_OBJECT (tree_model), e_tree_model_signals[NODE_COL_CHANGED], 0, node, col); } @@ -346,7 +346,7 @@ e_tree_model_node_inserted (ETreeModel *tree_model, g_return_if_fail (tree_model != NULL); g_return_if_fail (E_IS_TREE_MODEL (tree_model)); - d(g_print("Emitting node_inserted on model 0x%p, a %s.\n", tree_model, g_type_name (G_OBJECT(tree_model)->klass->type))); + d(g_print("Emitting node_inserted on model 0x%p, a %s.\n", tree_model, g_type_name (G_OBJECT(tree_model)->class->type))); g_signal_emit (G_OBJECT (tree_model), e_tree_model_signals[NODE_INSERTED], 0, parent_node, inserted_node); @@ -366,7 +366,7 @@ e_tree_model_node_removed (ETreeModel *tree_model, ETreePath parent_node, ETree g_return_if_fail (tree_model != NULL); g_return_if_fail (E_IS_TREE_MODEL (tree_model)); - d(g_print("Emitting node_removed on model 0x%p, a %s.\n", tree_model, g_type_name (G_OBJECT(tree_model)->klass->type))); + d(g_print("Emitting node_removed on model 0x%p, a %s.\n", tree_model, g_type_name (G_OBJECT(tree_model)->class->type))); g_signal_emit (G_OBJECT (tree_model), e_tree_model_signals[NODE_REMOVED], 0, parent_node, removed_node, old_position); @@ -385,7 +385,7 @@ e_tree_model_node_deleted (ETreeModel *tree_model, ETreePath deleted_node) g_return_if_fail (tree_model != NULL); g_return_if_fail (E_IS_TREE_MODEL (tree_model)); - d(g_print("Emitting node_deleted on model 0x%p, a %s.\n", tree_model, g_type_name (G_OBJECT(tree_model)->klass->type))); + d(g_print("Emitting node_deleted on model 0x%p, a %s.\n", tree_model, g_type_name (G_OBJECT(tree_model)->class->type))); g_signal_emit (G_OBJECT (tree_model), e_tree_model_signals[NODE_DELETED], 0, deleted_node); } @@ -403,7 +403,7 @@ e_tree_model_node_request_collapse (ETreeModel *tree_model, ETreePath collapsed g_return_if_fail (tree_model != NULL); g_return_if_fail (E_IS_TREE_MODEL (tree_model)); - d(g_print("Emitting node_request_collapse on model 0x%p, a %s.\n", tree_model, g_type_name (G_OBJECT(tree_model)->klass->type))); + d(g_print("Emitting node_request_collapse on model 0x%p, a %s.\n", tree_model, g_type_name (G_OBJECT(tree_model)->class->type))); g_signal_emit (G_OBJECT (tree_model), e_tree_model_signals[NODE_REQUEST_COLLAPSE], 0, collapsed_node); } @@ -420,7 +420,7 @@ e_tree_model_node_request_collapse (ETreeModel *tree_model, ETreePath collapsed ETreeModel * e_tree_model_new (void) { - return (ETreeModel *) g_object_new (E_TREE_MODEL_TYPE, NULL); + return g_object_new (E_TYPE_TREE_MODEL, NULL); } /** diff --git a/widgets/table/e-tree-model.h b/widgets/table/e-tree-model.h index c6600ddf83..01c4bf4180 100644 --- a/widgets/table/e-tree-model.h +++ b/widgets/table/e-tree-model.h @@ -26,72 +26,120 @@ #define _E_TREE_MODEL_H_ #include <gdk-pixbuf/gdk-pixbuf.h> -#include <glib-object.h> + +/* Standard GObject macros */ +#define E_TYPE_TREE_MODEL \ + (e_tree_model_get_type ()) +#define E_TREE_MODEL(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST \ + ((obj), E_TYPE_TREE_MODEL, ETreeModel)) +#define E_TREE_MODEL_CLASS(cls) \ + (G_TYPE_CHECK_CLASS_CAST \ + ((cls), E_TYPE_TREE_MODEL, ETreeModelClass)) +#define E_IS_TREE_MODEL(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE \ + ((obj), E_TYPE_TREE_MODEL)) +#define E_IS_TREE_MODEL_CLASS(cls) \ + (G_TYPE_CHECK_CLASS_TYPE \ + ((cls), E_TYPE_TREE_MODEL)) +#define E_TREE_MODEL_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS \ + ((obj), E_TYPE_TREE_MODEL, ETreeModelClass)) G_BEGIN_DECLS -#define E_TREE_MODEL_TYPE (e_tree_model_get_type ()) -#define E_TREE_MODEL(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), E_TREE_MODEL_TYPE, ETreeModel)) -#define E_TREE_MODEL_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k), E_TREE_MODEL_TYPE, ETreeModelClass)) -#define E_IS_TREE_MODEL(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), E_TREE_MODEL_TYPE)) -#define E_IS_TREE_MODEL_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), E_TREE_MODEL_TYPE)) -#define E_TREE_MODEL_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS((o), E_TREE_MODEL_TYPE, ETreeModelClass)) - -typedef gpointer ETreePath; -typedef struct ETreeModel ETreeModel; -typedef struct ETreeModelClass ETreeModelClass; -typedef gint (*ETreePathCompareFunc)(ETreeModel *model, ETreePath path1, ETreePath path2); -typedef gboolean (*ETreePathFunc)(ETreeModel *model, ETreePath path, gpointer data); - -struct ETreeModel { - GObject base; +typedef gpointer ETreePath; + +typedef struct _ETreeModel ETreeModel; +typedef struct _ETreeModelClass ETreeModelClass; + +typedef gint (*ETreePathCompareFunc) (ETreeModel *model, + ETreePath path1, + ETreePath path2); +typedef gboolean (*ETreePathFunc) (ETreeModel *model, + ETreePath path, + gpointer data); + +struct _ETreeModel { + GObject parent; }; -struct ETreeModelClass { +struct _ETreeModelClass { GObjectClass parent_class; /* * Virtual methods */ - ETreePath (*get_root) (ETreeModel *etm); + ETreePath (*get_root) (ETreeModel *etm); - ETreePath (*get_parent) (ETreeModel *etm, ETreePath node); - ETreePath (*get_first_child) (ETreeModel *etm, ETreePath node); - ETreePath (*get_last_child) (ETreeModel *etm, ETreePath node); - ETreePath (*get_next) (ETreeModel *etm, ETreePath node); - ETreePath (*get_prev) (ETreeModel *etm, ETreePath node); + ETreePath (*get_parent) (ETreeModel *etm, + ETreePath node); + ETreePath (*get_first_child) (ETreeModel *etm, + ETreePath node); + ETreePath (*get_last_child) (ETreeModel *etm, + ETreePath node); + ETreePath (*get_next) (ETreeModel *etm, + ETreePath node); + ETreePath (*get_prev) (ETreeModel *etm, + ETreePath node); - gboolean (*is_root) (ETreeModel *etm, ETreePath node); - gboolean (*is_expandable) (ETreeModel *etm, ETreePath node); - guint (*get_children) (ETreeModel *etm, ETreePath node, ETreePath **paths); - guint (*depth) (ETreeModel *etm, ETreePath node); + gboolean (*is_root) (ETreeModel *etm, + ETreePath node); + gboolean (*is_expandable) (ETreeModel *etm, + ETreePath node); + guint (*get_children) (ETreeModel *etm, + ETreePath node, + ETreePath **paths); + guint (*depth) (ETreeModel *etm, + ETreePath node); - GdkPixbuf *(*icon_at) (ETreeModel *etm, ETreePath node); + GdkPixbuf * (*icon_at) (ETreeModel *etm, + ETreePath node); - gboolean (*get_expanded_default) (ETreeModel *etm); - gint (*column_count) (ETreeModel *etm); + gboolean (*get_expanded_default) (ETreeModel *etm); + gint (*column_count) (ETreeModel *etm); - gboolean (*has_save_id) (ETreeModel *etm); - gchar *(*get_save_id) (ETreeModel *etm, ETreePath node); + gboolean (*has_save_id) (ETreeModel *etm); + gchar * (*get_save_id) (ETreeModel *etm, + ETreePath node); - gboolean (*has_get_node_by_id) (ETreeModel *etm); - ETreePath (*get_node_by_id) (ETreeModel *etm, const gchar *save_id); + gboolean (*has_get_node_by_id) (ETreeModel *etm); + ETreePath (*get_node_by_id) (ETreeModel *etm, + const gchar *save_id); - gboolean (*has_change_pending) (ETreeModel *etm); + gboolean (*has_change_pending) (ETreeModel *etm); /* * ETable analogs */ - void *(*sort_value_at) (ETreeModel *etm, ETreePath node, gint col); - void *(*value_at) (ETreeModel *etm, ETreePath node, gint col); - void (*set_value_at) (ETreeModel *etm, ETreePath node, gint col, gconstpointer val); - gboolean (*is_editable) (ETreeModel *etm, ETreePath node, gint col); + gpointer (*sort_value_at) (ETreeModel *etm, + ETreePath node, + gint col); + gpointer (*value_at) (ETreeModel *etm, + ETreePath node, + gint col); + void (*set_value_at) (ETreeModel *etm, + ETreePath node, + gint col, + gconstpointer val); + gboolean (*is_editable) (ETreeModel *etm, + ETreePath node, + gint col); - void *(*duplicate_value) (ETreeModel *etm, gint col, gconstpointer value); - void (*free_value) (ETreeModel *etm, gint col, gpointer value); - void *(*initialize_value) (ETreeModel *etm, gint col); - gboolean (*value_is_empty) (ETreeModel *etm, gint col, gconstpointer value); - gchar *(*value_to_string) (ETreeModel *etm, gint col, gconstpointer value); + gpointer (*duplicate_value) (ETreeModel *etm, + gint col, + gconstpointer value); + void (*free_value) (ETreeModel *etm, + gint col, + gpointer value); + gpointer (*initialize_value) (ETreeModel *etm, + gint col); + gboolean (*value_is_empty) (ETreeModel *etm, + gint col, + gconstpointer value); + gchar * (*value_to_string) (ETreeModel *etm, + gint col, + gconstpointer value); /* * Signals @@ -102,127 +150,144 @@ struct ETreeModelClass { * node_deleted, the ETreePath is no longer valid. */ - void (*pre_change) (ETreeModel *etm); - void (*no_change) (ETreeModel *etm); - void (*node_changed) (ETreeModel *etm, ETreePath node); - void (*node_data_changed) (ETreeModel *etm, ETreePath node); - void (*node_col_changed) (ETreeModel *etm, ETreePath node, gint col); - void (*node_inserted) (ETreeModel *etm, ETreePath parent, ETreePath inserted_node); - void (*node_removed) (ETreeModel *etm, ETreePath parent, ETreePath removed_node, gint old_position); - void (*node_deleted) (ETreeModel *etm, ETreePath deleted_node); - void (*rebuilt) (ETreeModel *etm); + void (*pre_change) (ETreeModel *etm); + void (*no_change) (ETreeModel *etm); + void (*node_changed) (ETreeModel *etm, + ETreePath node); + void (*node_data_changed) (ETreeModel *etm, + ETreePath node); + void (*node_col_changed) (ETreeModel *etm, + ETreePath node, + gint col); + void (*node_inserted) (ETreeModel *etm, + ETreePath parent, + ETreePath inserted_node); + void (*node_removed) (ETreeModel *etm, + ETreePath parent, + ETreePath removed_node, + gint old_position); + void (*node_deleted) (ETreeModel *etm, + ETreePath deleted_node); + void (*rebuilt) (ETreeModel *etm); /* This signal requests that any viewers of the tree that * collapse and expand nodes collapse this node. */ - void (*node_request_collapse) (ETreeModel *etm, ETreePath node); + void (*node_request_collapse) + (ETreeModel *etm, + ETreePath node); }; -GType e_tree_model_get_type (void); -ETreeModel *e_tree_model_new (void); +GType e_tree_model_get_type (void) G_GNUC_CONST; +ETreeModel * e_tree_model_new (void); /* tree traversal operations */ -ETreePath e_tree_model_get_root (ETreeModel *etree); -ETreePath e_tree_model_node_get_parent (ETreeModel *etree, - ETreePath path); -ETreePath e_tree_model_node_get_first_child (ETreeModel *etree, - ETreePath path); -ETreePath e_tree_model_node_get_last_child (ETreeModel *etree, - ETreePath path); -ETreePath e_tree_model_node_get_next (ETreeModel *etree, - ETreePath path); -ETreePath e_tree_model_node_get_prev (ETreeModel *etree, - ETreePath path); +ETreePath e_tree_model_get_root (ETreeModel *etree); +ETreePath e_tree_model_node_get_parent (ETreeModel *etree, + ETreePath path); +ETreePath e_tree_model_node_get_first_child + (ETreeModel *etree, + ETreePath path); +ETreePath e_tree_model_node_get_last_child + (ETreeModel *etree, + ETreePath path); +ETreePath e_tree_model_node_get_next (ETreeModel *etree, + ETreePath path); +ETreePath e_tree_model_node_get_prev (ETreeModel *etree, + ETreePath path); /* node accessors */ -gboolean e_tree_model_node_is_root (ETreeModel *etree, - ETreePath path); -gboolean e_tree_model_node_is_expandable (ETreeModel *etree, - ETreePath path); -guint e_tree_model_node_get_children (ETreeModel *etree, - ETreePath path, - ETreePath **paths); -guint e_tree_model_node_depth (ETreeModel *etree, - ETreePath path); -GdkPixbuf *e_tree_model_icon_at (ETreeModel *etree, - ETreePath path); -gboolean e_tree_model_get_expanded_default (ETreeModel *model); -gint e_tree_model_column_count (ETreeModel *model); -gboolean e_tree_model_has_save_id (ETreeModel *model); -gchar *e_tree_model_get_save_id (ETreeModel *model, - ETreePath node); -gboolean e_tree_model_has_get_node_by_id (ETreeModel *model); -ETreePath e_tree_model_get_node_by_id (ETreeModel *model, - const gchar *save_id); -gboolean e_tree_model_has_change_pending (ETreeModel *model); -void *e_tree_model_sort_value_at (ETreeModel *etree, - ETreePath node, - gint col); -void *e_tree_model_value_at (ETreeModel *etree, - ETreePath node, - gint col); -void e_tree_model_set_value_at (ETreeModel *etree, - ETreePath node, - gint col, - const void *val); -gboolean e_tree_model_node_is_editable (ETreeModel *etree, - ETreePath node, - gint col); -void *e_tree_model_duplicate_value (ETreeModel *etree, - gint col, - const void *value); -void e_tree_model_free_value (ETreeModel *etree, - gint col, - void *value); -void *e_tree_model_initialize_value (ETreeModel *etree, - gint col); -gboolean e_tree_model_value_is_empty (ETreeModel *etree, - gint col, - const void *value); -gchar *e_tree_model_value_to_string (ETreeModel *etree, - gint col, - const void *value); +gboolean e_tree_model_node_is_root (ETreeModel *etree, + ETreePath path); +gboolean e_tree_model_node_is_expandable (ETreeModel *etree, + ETreePath path); +guint e_tree_model_node_get_children (ETreeModel *etree, + ETreePath path, + ETreePath **paths); +guint e_tree_model_node_depth (ETreeModel *etree, + ETreePath path); +GdkPixbuf * e_tree_model_icon_at (ETreeModel *etree, + ETreePath path); +gboolean e_tree_model_get_expanded_default + (ETreeModel *model); +gint e_tree_model_column_count (ETreeModel *model); +gboolean e_tree_model_has_save_id (ETreeModel *model); +gchar * e_tree_model_get_save_id (ETreeModel *model, + ETreePath node); +gboolean e_tree_model_has_get_node_by_id (ETreeModel *model); +ETreePath e_tree_model_get_node_by_id (ETreeModel *model, + const gchar *save_id); +gboolean e_tree_model_has_change_pending (ETreeModel *model); +void *e_tree_model_sort_value_at (ETreeModel *etree, + ETreePath node, + gint col); +void *e_tree_model_value_at (ETreeModel *etree, + ETreePath node, + gint col); +void e_tree_model_set_value_at (ETreeModel *etree, + ETreePath node, + gint col, + const void *val); +gboolean e_tree_model_node_is_editable (ETreeModel *etree, + ETreePath node, + gint col); +void *e_tree_model_duplicate_value (ETreeModel *etree, + gint col, + const void *value); +void e_tree_model_free_value (ETreeModel *etree, + gint col, + void *value); +void *e_tree_model_initialize_value (ETreeModel *etree, + gint col); +gboolean e_tree_model_value_is_empty (ETreeModel *etree, + gint col, + const void *value); +gchar * e_tree_model_value_to_string (ETreeModel *etree, + gint col, + const void *value); /* depth first traversal of path's descendents, calling func on each one */ -void e_tree_model_node_traverse (ETreeModel *model, - ETreePath path, - ETreePathFunc func, - gpointer data); -void e_tree_model_node_traverse_preorder (ETreeModel *model, - ETreePath path, - ETreePathFunc func, - gpointer data); -ETreePath e_tree_model_node_find (ETreeModel *model, - ETreePath path, - ETreePath end_path, - gboolean forward_direction, - ETreePathFunc func, - gpointer data); +void e_tree_model_node_traverse (ETreeModel *model, + ETreePath path, + ETreePathFunc func, + gpointer data); +void e_tree_model_node_traverse_preorder + (ETreeModel *model, + ETreePath path, + ETreePathFunc func, + gpointer data); +ETreePath e_tree_model_node_find (ETreeModel *model, + ETreePath path, + ETreePath end_path, + gboolean forward_direction, + ETreePathFunc func, + gpointer data); /* ** Routines for emitting signals on the ETreeModel */ -void e_tree_model_pre_change (ETreeModel *tree_model); -void e_tree_model_no_change (ETreeModel *tree_model); -void e_tree_model_rebuilt (ETreeModel *tree_model); -void e_tree_model_node_changed (ETreeModel *tree_model, - ETreePath node); -void e_tree_model_node_data_changed (ETreeModel *tree_model, - ETreePath node); -void e_tree_model_node_col_changed (ETreeModel *tree_model, - ETreePath node, - gint col); -void e_tree_model_node_inserted (ETreeModel *tree_model, - ETreePath parent_node, - ETreePath inserted_node); -void e_tree_model_node_removed (ETreeModel *tree_model, - ETreePath parent_node, - ETreePath removed_node, - gint old_position); -void e_tree_model_node_deleted (ETreeModel *tree_model, - ETreePath deleted_node); -void e_tree_model_node_request_collapse (ETreeModel *tree_model, - ETreePath deleted_node); +void e_tree_model_pre_change (ETreeModel *tree_model); +void e_tree_model_no_change (ETreeModel *tree_model); +void e_tree_model_rebuilt (ETreeModel *tree_model); +void e_tree_model_node_changed (ETreeModel *tree_model, + ETreePath node); +void e_tree_model_node_data_changed (ETreeModel *tree_model, + ETreePath node); +void e_tree_model_node_col_changed (ETreeModel *tree_model, + ETreePath node, + gint col); +void e_tree_model_node_inserted (ETreeModel *tree_model, + ETreePath parent_node, + ETreePath inserted_node); +void e_tree_model_node_removed (ETreeModel *tree_model, + ETreePath parent_node, + ETreePath removed_node, + gint old_position); +void e_tree_model_node_deleted (ETreeModel *tree_model, + ETreePath deleted_node); +void e_tree_model_node_request_collapse + (ETreeModel *tree_model, + ETreePath deleted_node); G_END_DECLS diff --git a/widgets/table/e-tree-selection-model.c b/widgets/table/e-tree-selection-model.c index e734114f00..cc8a1fcd6a 100644 --- a/widgets/table/e-tree-selection-model.c +++ b/widgets/table/e-tree-selection-model.c @@ -29,6 +29,10 @@ #include "e-tree-selection-model.h" +#define E_TREE_SELECTION_MODEL_GET_PRIVATE(obj) \ + (G_TYPE_INSTANCE_GET_PRIVATE \ + ((obj), E_TYPE_TREE_SELECTION_MODEL, ETreeSelectionModelPrivate)) + G_DEFINE_TYPE ( ETreeSelectionModel, e_tree_selection_model, E_TYPE_SELECTION_MODEL) @@ -40,7 +44,7 @@ enum { PROP_ETTA }; -struct ETreeSelectionModelPriv { +struct _ETreeSelectionModelPrivate { ETreeTableAdapter *etta; ETreeModel *model; @@ -206,7 +210,7 @@ etsm_node_deleted (ETreeModel *etm, ETreePath child, ETreeSelectionModel *etsm) static void add_model (ETreeSelectionModel *etsm, ETreeModel *model) { - ETreeSelectionModelPriv *priv = etsm->priv; + ETreeSelectionModelPrivate *priv = etsm->priv; priv->model = model; @@ -235,7 +239,7 @@ add_model (ETreeSelectionModel *etsm, ETreeModel *model) static void drop_model (ETreeSelectionModel *etsm) { - ETreeSelectionModelPriv *priv = etsm->priv; + ETreeSelectionModelPrivate *priv = etsm->priv; if (!priv->model) return; @@ -277,24 +281,22 @@ etsm_dispose (GObject *object) drop_model (etsm); - if (G_OBJECT_CLASS (e_tree_selection_model_parent_class)->dispose) - (* G_OBJECT_CLASS (e_tree_selection_model_parent_class)->dispose) (object); + /* Chain up to parent's dispose() method. */ + G_OBJECT_CLASS (e_tree_selection_model_parent_class)->dispose (object); } static void etsm_finalize (GObject *object) { - ETreeSelectionModel *etsm = E_TREE_SELECTION_MODEL (object); + ETreeSelectionModelPrivate *priv; - if (etsm->priv) { - clear_selection (etsm); - g_hash_table_destroy (etsm->priv->paths); - g_free (etsm->priv); - etsm->priv = NULL; - } + priv = E_TREE_SELECTION_MODEL_GET_PRIVATE (object); - if (G_OBJECT_CLASS (e_tree_selection_model_parent_class)->finalize) - (* G_OBJECT_CLASS (e_tree_selection_model_parent_class)->finalize) (object); + clear_selection (E_TREE_SELECTION_MODEL (object)); + g_hash_table_destroy (priv->paths); + + /* Chain up to parent's finalize() method. */ + G_OBJECT_CLASS (e_tree_selection_model_parent_class)->finalize (object); } static void @@ -743,61 +745,44 @@ e_tree_selection_model_get_cursor (ETreeSelectionModel *etsm) static void e_tree_selection_model_init (ETreeSelectionModel *etsm) { - ETreeSelectionModelPriv *priv; - priv = g_new (ETreeSelectionModelPriv, 1); - etsm->priv = priv; - - priv->etta = NULL; - priv->model = NULL; + etsm->priv = E_TREE_SELECTION_MODEL_GET_PRIVATE (etsm); - priv->paths = g_hash_table_new (NULL, NULL); - - priv->cursor_path = NULL; - priv->start_path = NULL; - priv->cursor_col = -1; - priv->cursor_save_id = NULL; - - priv->tree_model_pre_change_id = 0; - priv->tree_model_no_change_id = 0; - priv->tree_model_node_changed_id = 0; - priv->tree_model_node_data_changed_id = 0; - priv->tree_model_node_col_changed_id = 0; - priv->tree_model_node_inserted_id = 0; - priv->tree_model_node_removed_id = 0; - priv->tree_model_node_deleted_id = 0; + etsm->priv->paths = g_hash_table_new (NULL, NULL); + etsm->priv->cursor_col = -1; } static void -e_tree_selection_model_class_init (ETreeSelectionModelClass *klass) +e_tree_selection_model_class_init (ETreeSelectionModelClass *class) { GObjectClass *object_class; ESelectionModelClass *esm_class; - object_class = G_OBJECT_CLASS (klass); - esm_class = E_SELECTION_MODEL_CLASS (klass); + g_type_class_add_private (class, sizeof (ETreeSelectionModelPrivate)); + object_class = G_OBJECT_CLASS (class); object_class->dispose = etsm_dispose; object_class->finalize = etsm_finalize; object_class->get_property = etsm_get_property; object_class->set_property = etsm_set_property; - esm_class->is_row_selected = etsm_is_row_selected; - esm_class->foreach = etsm_foreach; - esm_class->clear = etsm_clear; - esm_class->selected_count = etsm_selected_count; - esm_class->select_all = etsm_select_all; - esm_class->invert_selection = etsm_invert_selection; - esm_class->row_count = etsm_row_count; - - esm_class->change_one_row = etsm_change_one_row; - esm_class->change_cursor = etsm_change_cursor; - esm_class->cursor_row = etsm_cursor_row; - esm_class->cursor_col = etsm_cursor_col; - - esm_class->select_single_row = etsm_select_single_row; - esm_class->toggle_single_row = etsm_toggle_single_row; + esm_class = E_SELECTION_MODEL_CLASS (class); + esm_class->is_row_selected = etsm_is_row_selected; + esm_class->foreach = etsm_foreach; + esm_class->clear = etsm_clear; + esm_class->selected_count = etsm_selected_count; + esm_class->select_all = etsm_select_all; + esm_class->invert_selection = etsm_invert_selection; + esm_class->row_count = etsm_row_count; + + esm_class->change_one_row = etsm_change_one_row; + esm_class->change_cursor = etsm_change_cursor; + esm_class->cursor_row = etsm_cursor_row; + esm_class->cursor_col = etsm_cursor_col; + + esm_class->select_single_row = etsm_select_single_row; + esm_class->toggle_single_row = etsm_toggle_single_row; esm_class->move_selection_end = etsm_move_selection_end; - esm_class->set_selection_end = etsm_set_selection_end; + esm_class->set_selection_end = etsm_set_selection_end; g_object_class_install_property (object_class, PROP_CURSOR_ROW, g_param_spec_int ("cursor_row", @@ -817,14 +802,14 @@ e_tree_selection_model_class_init (ETreeSelectionModelClass *klass) g_param_spec_object ("model", "Model", NULL, - E_TREE_MODEL_TYPE, + E_TYPE_TREE_MODEL, G_PARAM_READWRITE)); g_object_class_install_property (object_class, PROP_ETTA, g_param_spec_object ("etta", "ETTA", NULL, - E_TREE_TABLE_ADAPTER_TYPE, + E_TYPE_TREE_TABLE_ADAPTER, G_PARAM_READWRITE)); } @@ -832,6 +817,6 @@ e_tree_selection_model_class_init (ETreeSelectionModelClass *klass) ESelectionModel * e_tree_selection_model_new (void) { - return g_object_new (E_TREE_SELECTION_MODEL_TYPE, NULL); + return g_object_new (E_TYPE_TREE_SELECTION_MODEL, NULL); } diff --git a/widgets/table/e-tree-selection-model.h b/widgets/table/e-tree-selection-model.h index e66abf3454..1541fcb95a 100644 --- a/widgets/table/e-tree-selection-model.h +++ b/widgets/table/e-tree-selection-model.h @@ -23,48 +23,68 @@ #ifndef _E_TREE_SELECTION_MODEL_H_ #define _E_TREE_SELECTION_MODEL_H_ -#include <glib-object.h> #include <e-util/e-sorter.h> #include <misc/e-selection-model.h> #include <table/e-tree-model.h> -G_BEGIN_DECLS - -typedef void (*ETreeForeachFunc) (ETreePath path, - gpointer closure); +/* Standard GObject macros */ +#define E_TYPE_TREE_SELECTION_MODEL \ + (e_tree_selection_model_get_type ()) +#define E_TREE_SELECTION_MODEL(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST \ + ((obj), E_TYPE_TREE_SELECTION_MODEL, ETreeSelectionModel)) +#define E_TREE_SELECTION_MODEL_CLASS(cls) \ + (G_TYPE_CHECK_CLASS_CAST \ + ((cls), E_TYPE_TREE_SELECTION_MODEL, ETreeSelectionModelClass)) +#define E_IS_TREE_SELECTION_MODEL(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE \ + ((obj), E_TYPE_TREE_SELECTION_MODEL)) +#define E_IS_TREE_SELECTION_MODEL_CLASS(cls) \ + (G_TYPE_CHECK_CLASS_TYPE \ + ((cls), E_TYPE_TREE_SELECTION_MODEL)) +#define E_TREE_SELECTION_MODEL_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS \ + ((obj), E_TYPE_TREE_SELECTION_MODEL, ETreeSelectionModelClass)) -typedef struct ETreeSelectionModelPriv ETreeSelectionModelPriv; +G_BEGIN_DECLS -#define E_TREE_SELECTION_MODEL_TYPE (e_tree_selection_model_get_type ()) -#define E_TREE_SELECTION_MODEL(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), E_TREE_SELECTION_MODEL_TYPE, ETreeSelectionModel)) -#define E_TREE_SELECTION_MODEL_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k), E_TREE_SELECTION_MODEL_TYPE, ETreeSelectionModelClass)) -#define E_IS_TREE_SELECTION_MODEL(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), E_TREE_SELECTION_MODEL_TYPE)) -#define E_IS_TREE_SELECTION_MODEL_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), E_TREE_SELECTION_MODEL_TYPE)) +typedef void (*ETreeForeachFunc) (ETreePath path, + gpointer closure); -typedef struct { - ESelectionModel base; +typedef struct _ETreeSelectionModel ETreeSelectionModel; +typedef struct _ETreeSelectionModelClass ETreeSelectionModelClass; +typedef struct _ETreeSelectionModelPrivate ETreeSelectionModelPrivate; - ETreeSelectionModelPriv *priv; -} ETreeSelectionModel; +struct _ETreeSelectionModel { + ESelectionModel parent; + ETreeSelectionModelPrivate *priv; +}; -typedef struct { +struct _ETreeSelectionModelClass { ESelectionModelClass parent_class; -} ETreeSelectionModelClass; +}; -GType e_tree_selection_model_get_type (void); -ESelectionModel *e_tree_selection_model_new (void); -void e_tree_selection_model_foreach (ETreeSelectionModel *etsm, - ETreeForeachFunc callback, - gpointer closure); -void e_tree_selection_model_select_single_path (ETreeSelectionModel *etsm, - ETreePath path); -void e_tree_selection_model_select_paths (ETreeSelectionModel *etsm, GPtrArray *paths); +GType e_tree_selection_model_get_type (void) G_GNUC_CONST; +ESelectionModel * + e_tree_selection_model_new (void); +void e_tree_selection_model_foreach (ETreeSelectionModel *etsm, + ETreeForeachFunc callback, + gpointer closure); +void e_tree_selection_model_select_single_path + (ETreeSelectionModel *etsm, + ETreePath path); +void e_tree_selection_model_select_paths + (ETreeSelectionModel *etsm, + GPtrArray *paths); -void e_tree_selection_model_add_to_selection (ETreeSelectionModel *etsm, - ETreePath path); -void e_tree_selection_model_change_cursor (ETreeSelectionModel *etsm, - ETreePath path); -ETreePath e_tree_selection_model_get_cursor (ETreeSelectionModel *etsm); +void e_tree_selection_model_add_to_selection + (ETreeSelectionModel *etsm, + ETreePath path); +void e_tree_selection_model_change_cursor + (ETreeSelectionModel *etsm, + ETreePath path); +ETreePath e_tree_selection_model_get_cursor + (ETreeSelectionModel *etsm); G_END_DECLS diff --git a/widgets/table/e-tree-sorted.c b/widgets/table/e-tree-sorted.c index e62ed66ffe..40b10c0dec 100644 --- a/widgets/table/e-tree-sorted.c +++ b/widgets/table/e-tree-sorted.c @@ -48,7 +48,11 @@ #define d(x) -G_DEFINE_TYPE (ETreeSorted, e_tree_sorted, E_TREE_MODEL_TYPE) +#define E_TREE_SORTED_GET_PRIVATE(obj) \ + (G_TYPE_INSTANCE_GET_PRIVATE \ + ((obj), E_TYPE_TREE_SORTED, ETreeSortedPrivate)) + +G_DEFINE_TYPE (ETreeSorted, e_tree_sorted, E_TYPE_TREE_MODEL) enum { NODE_RESORTED, @@ -75,7 +79,7 @@ struct ETreeSortedPath { guint needs_regen_to_sort : 1; }; -struct ETreeSortedPriv { +struct _ETreeSortedPrivate { ETreeModel *source; ETreeSortedPath *root; @@ -582,34 +586,29 @@ schedule_resort (ETreeSorted *ets, ETreeSortedPath *path, gboolean needs_regen, static void ets_dispose (GObject *object) { - ETreeSorted *ets = E_TREE_SORTED (object); - ETreeSortedPriv *priv = ets->priv; + ETreeSortedPrivate *priv; - /* FIXME lots of stuff to free here */ - if (!priv) { - G_OBJECT_CLASS (e_tree_sorted_parent_class)->dispose (object); - return; - } + priv = E_TREE_SORTED_GET_PRIVATE (object); if (priv->source) { - g_signal_handler_disconnect (G_OBJECT (priv->source), - priv->tree_model_pre_change_id); - g_signal_handler_disconnect (G_OBJECT (priv->source), - priv->tree_model_no_change_id); - g_signal_handler_disconnect (G_OBJECT (priv->source), - priv->tree_model_node_changed_id); - g_signal_handler_disconnect (G_OBJECT (priv->source), - priv->tree_model_node_data_changed_id); - g_signal_handler_disconnect (G_OBJECT (priv->source), - priv->tree_model_node_col_changed_id); - g_signal_handler_disconnect (G_OBJECT (priv->source), - priv->tree_model_node_inserted_id); - g_signal_handler_disconnect (G_OBJECT (priv->source), - priv->tree_model_node_removed_id); - g_signal_handler_disconnect (G_OBJECT (priv->source), - priv->tree_model_node_deleted_id); - g_signal_handler_disconnect (G_OBJECT (priv->source), - priv->tree_model_node_request_collapse_id); + g_signal_handler_disconnect ( + priv->source, priv->tree_model_pre_change_id); + g_signal_handler_disconnect ( + priv->source, priv->tree_model_no_change_id); + g_signal_handler_disconnect ( + priv->source, priv->tree_model_node_changed_id); + g_signal_handler_disconnect ( + priv->source, priv->tree_model_node_data_changed_id); + g_signal_handler_disconnect ( + priv->source, priv->tree_model_node_col_changed_id); + g_signal_handler_disconnect ( + priv->source, priv->tree_model_node_inserted_id); + g_signal_handler_disconnect ( + priv->source, priv->tree_model_node_removed_id); + g_signal_handler_disconnect ( + priv->source, priv->tree_model_node_deleted_id); + g_signal_handler_disconnect ( + priv->source, priv->tree_model_node_request_collapse_id); g_object_unref (priv->source); priv->source = NULL; @@ -626,43 +625,48 @@ ets_dispose (GObject *object) } if (priv->sort_info) { - g_signal_handler_disconnect (G_OBJECT (priv->sort_info), - priv->sort_info_changed_id); + g_signal_handler_disconnect ( + priv->sort_info, priv->sort_info_changed_id); priv->sort_info_changed_id = 0; g_object_unref (priv->sort_info); priv->sort_info = NULL; } - ets_stop_sort_idle (ets); - if (ets->priv->insert_idle_id) { - g_source_remove (ets->priv->insert_idle_id); - ets->priv->insert_idle_id = 0; + ets_stop_sort_idle (E_TREE_SORTED (object)); + + if (priv->insert_idle_id) { + g_source_remove (priv->insert_idle_id); + priv->insert_idle_id = 0; } - if (priv->full_header) + if (priv->full_header) { g_object_unref (priv->full_header); + priv->full_header = NULL; + } + /* Chain up to parent's dispose() method. */ + G_OBJECT_CLASS (e_tree_sorted_parent_class)->dispose (object); } static void ets_finalize (GObject *object) { - ETreeSorted *ets = (ETreeSorted *) object; + ETreeSortedPrivate *priv; - if (ets->priv->root) - free_path (ets->priv->root); + priv = E_TREE_SORTED_GET_PRIVATE (object); - g_free (ets->priv); - ets->priv = NULL; + if (priv->root) + free_path (priv->root); + /* Chain up to parent's finalize() method. */ G_OBJECT_CLASS (e_tree_sorted_parent_class)->finalize (object); } static ETreePath ets_get_root (ETreeModel *etm) { - ETreeSortedPriv *priv = E_TREE_SORTED (etm)->priv; + ETreeSortedPrivate *priv = E_TREE_SORTED (etm)->priv; if (priv->root == NULL) { ETreeSorted *ets = E_TREE_SORTED (etm); ETreePath corresponding = e_tree_model_get_root (ets->priv->source); @@ -1143,50 +1147,52 @@ ets_sort_info_changed (ETableSortInfo *sort_info, ETreeSorted *ets) /* Initialization and creation */ static void -e_tree_sorted_class_init (ETreeSortedClass *klass) +e_tree_sorted_class_init (ETreeSortedClass *class) { - ETreeModelClass *tree_class = E_TREE_MODEL_CLASS (klass); - GObjectClass *object_class = G_OBJECT_CLASS (klass); + GObjectClass *object_class; + ETreeModelClass *tree_model_class; - klass->node_resorted = NULL; + g_type_class_add_private (class, sizeof (ETreeSortedPrivate)); - object_class->dispose = ets_dispose; - object_class->finalize = ets_finalize; + object_class = G_OBJECT_CLASS (class); + object_class->dispose = ets_dispose; + object_class->finalize = ets_finalize; - tree_class->get_root = ets_get_root; - tree_class->get_parent = ets_get_parent; - tree_class->get_first_child = ets_get_first_child; - tree_class->get_last_child = ets_get_last_child; - tree_class->get_prev = ets_get_prev; - tree_class->get_next = ets_get_next; + tree_model_class = E_TREE_MODEL_CLASS (class); + tree_model_class->get_root = ets_get_root; + tree_model_class->get_parent = ets_get_parent; + tree_model_class->get_first_child = ets_get_first_child; + tree_model_class->get_last_child = ets_get_last_child; + tree_model_class->get_prev = ets_get_prev; + tree_model_class->get_next = ets_get_next; - tree_class->is_root = ets_is_root; - tree_class->is_expandable = ets_is_expandable; - tree_class->get_children = ets_get_children; - tree_class->depth = ets_depth; + tree_model_class->is_root = ets_is_root; + tree_model_class->is_expandable = ets_is_expandable; + tree_model_class->get_children = ets_get_children; + tree_model_class->depth = ets_depth; - tree_class->icon_at = ets_icon_at; + tree_model_class->icon_at = ets_icon_at; - tree_class->get_expanded_default = ets_get_expanded_default; - tree_class->column_count = ets_column_count; + tree_model_class->get_expanded_default = ets_get_expanded_default; + tree_model_class->column_count = ets_column_count; - tree_class->has_save_id = ets_has_save_id; - tree_class->get_save_id = ets_get_save_id; + tree_model_class->has_save_id = ets_has_save_id; + tree_model_class->get_save_id = ets_get_save_id; - tree_class->has_get_node_by_id = ets_has_get_node_by_id; - tree_class->get_node_by_id = ets_get_node_by_id; + tree_model_class->has_get_node_by_id = ets_has_get_node_by_id; + tree_model_class->get_node_by_id = ets_get_node_by_id; - tree_class->has_change_pending = ets_has_change_pending; + tree_model_class->has_change_pending = ets_has_change_pending; - tree_class->value_at = ets_value_at; - tree_class->set_value_at = ets_set_value_at; - tree_class->is_editable = ets_is_editable; + tree_model_class->value_at = ets_value_at; + tree_model_class->set_value_at = ets_set_value_at; + tree_model_class->is_editable = ets_is_editable; - tree_class->duplicate_value = ets_duplicate_value; - tree_class->free_value = ets_free_value; - tree_class->initialize_value = ets_initialize_value; - tree_class->value_is_empty = ets_value_is_empty; - tree_class->value_to_string = ets_value_to_string; + tree_model_class->duplicate_value = ets_duplicate_value; + tree_model_class->free_value = ets_free_value; + tree_model_class->initialize_value = ets_initialize_value; + tree_model_class->value_is_empty = ets_value_is_empty; + tree_model_class->value_to_string = ets_value_to_string; signals[NODE_RESORTED] = g_signal_new ("node_resorted", @@ -1201,36 +1207,7 @@ e_tree_sorted_class_init (ETreeSortedClass *klass) static void e_tree_sorted_init (ETreeSorted *ets) { - ETreeSortedPriv *priv; - - priv = g_new0 (ETreeSortedPriv, 1); - ets->priv = priv; - - priv->root = NULL; - priv->source = NULL; - - priv->sort_info = NULL; - priv->full_header = NULL; - - priv->last_access = NULL; - - priv->tree_model_pre_change_id = 0; - priv->tree_model_no_change_id = 0; - priv->tree_model_node_changed_id = 0; - priv->tree_model_node_data_changed_id = 0; - priv->tree_model_node_col_changed_id = 0; - priv->tree_model_node_inserted_id = 0; - priv->tree_model_node_removed_id = 0; - priv->tree_model_node_deleted_id = 0; - priv->tree_model_node_request_collapse_id = 0; - - priv->sort_info_changed_id = 0; - priv->sort_idle_id = 0; - priv->insert_idle_id = 0; - priv->insert_count = 0; - - priv->in_resort_idle = 0; - priv->nested_resort_idle = 0; + ets->priv = E_TREE_SORTED_GET_PRIVATE (ets); } /** @@ -1283,7 +1260,7 @@ e_tree_sorted_construct (ETreeSorted *ets, ETreeModel *source, ETableHeader *ful ETreeSorted * e_tree_sorted_new (ETreeModel *source, ETableHeader *full_header, ETableSortInfo *sort_info) { - ETreeSorted *ets = g_object_new (E_TREE_SORTED_TYPE, NULL); + ETreeSorted *ets = g_object_new (E_TYPE_TREE_SORTED, NULL); e_tree_sorted_construct (ets, source, full_header, sort_info); diff --git a/widgets/table/e-tree-sorted.h b/widgets/table/e-tree-sorted.h index 74d9a70a32..456ee15d14 100644 --- a/widgets/table/e-tree-sorted.h +++ b/widgets/table/e-tree-sorted.h @@ -29,56 +29,70 @@ #include <table/e-table-sort-info.h> #include <table/e-table-header.h> -G_BEGIN_DECLS - -#define E_TREE_SORTED_TYPE (e_tree_sorted_get_type ()) -#define E_TREE_SORTED(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), E_TREE_SORTED_TYPE, ETreeSorted)) -#define E_TREE_SORTED_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k), E_TREE_SORTED_TYPE, ETreeSortedClass)) -#define E_IS_TREE_SORTED(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), E_TREE_SORTED_TYPE)) -#define E_IS_TREE_SORTED_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), E_TREE_SORTED_TYPE)) -#define E_TREE_SORTED_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS((o), E_TREE_SORTED_TYPE, ETreeSortedClass)) +/* Standard GObject macros */ +#define E_TYPE_TREE_SORTED \ + (e_tree_sorted_get_type ()) +#define E_TREE_SORTED(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST \ + ((obj), E_TYPE_TREE_SORTED, ETreeSorted)) +#define E_TREE_SORTED_CLASS(cls) \ + (G_TYPE_CHECK_CLASS_CAST \ + ((cls), E_TYPE_TREE_SORTED, ETreeSortedClass)) +#define E_IS_TREE_SORTED(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE \ + ((obj), E_TYPE_TREE_SORTED)) +#define E_IS_TREE_SORTED_CLASS(cls) \ + (G_TYPE_CHECK_CLASS_TYPE \ + ((cls), E_TYPE_TREE_SORTED)) +#define E_TREE_SORTED_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS \ + ((obj), E_TYPE_TREE_SORTED, ETreeSortedClass)) -typedef struct ETreeSorted ETreeSorted; -typedef struct ETreeSortedPriv ETreeSortedPriv; -typedef struct ETreeSortedClass ETreeSortedClass; +G_BEGIN_DECLS -struct ETreeSorted { - ETreeModel base; +typedef struct _ETreeSorted ETreeSorted; +typedef struct _ETreeSortedClass ETreeSortedClass; +typedef struct _ETreeSortedPrivate ETreeSortedPrivate; - ETreeSortedPriv *priv; +struct _ETreeSorted { + ETreeModel parent; + ETreeSortedPrivate *priv; }; -struct ETreeSortedClass { +struct _ETreeSortedClass { ETreeModelClass parent_class; /* Signals */ - void (*node_resorted) (ETreeSorted *etm, ETreePath node); + void (*node_resorted) (ETreeSorted *etm, + ETreePath node); }; -GType e_tree_sorted_get_type (void); -void e_tree_sorted_construct (ETreeSorted *etree, - ETreeModel *source, - ETableHeader *full_header, - ETableSortInfo *sort_info); -ETreeSorted *e_tree_sorted_new (ETreeModel *source, - ETableHeader *full_header, - ETableSortInfo *sort_info); +GType e_tree_sorted_get_type (void) G_GNUC_CONST; +void e_tree_sorted_construct (ETreeSorted *etree, + ETreeModel *source, + ETableHeader *full_header, + ETableSortInfo *sort_info); +ETreeSorted * e_tree_sorted_new (ETreeModel *source, + ETableHeader *full_header, + ETableSortInfo *sort_info); -ETreePath e_tree_sorted_view_to_model_path (ETreeSorted *ets, - ETreePath view_path); -ETreePath e_tree_sorted_model_to_view_path (ETreeSorted *ets, - ETreePath model_path); -gint e_tree_sorted_orig_position (ETreeSorted *ets, - ETreePath path); -gint e_tree_sorted_node_num_children (ETreeSorted *ets, - ETreePath path); +ETreePath e_tree_sorted_view_to_model_path + (ETreeSorted *ets, + ETreePath view_path); +ETreePath e_tree_sorted_model_to_view_path + (ETreeSorted *ets, + ETreePath model_path); +gint e_tree_sorted_orig_position (ETreeSorted *ets, + ETreePath path); +gint e_tree_sorted_node_num_children (ETreeSorted *ets, + ETreePath path); -void e_tree_sorted_node_resorted (ETreeSorted *tree_model, - ETreePath node); +void e_tree_sorted_node_resorted (ETreeSorted *tree_model, + ETreePath node); -ETableSortInfo* e_tree_sorted_get_sort_info (ETreeSorted *tree_model); -void e_tree_sorted_set_sort_info (ETreeSorted *tree_model, - ETableSortInfo *sort_info); +ETableSortInfo *e_tree_sorted_get_sort_info (ETreeSorted *tree_model); +void e_tree_sorted_set_sort_info (ETreeSorted *tree_model, + ETableSortInfo *sort_info); G_END_DECLS diff --git a/widgets/table/e-tree-table-adapter.c b/widgets/table/e-tree-table-adapter.c index 63bd640a3c..d529a6e045 100644 --- a/widgets/table/e-tree-table-adapter.c +++ b/widgets/table/e-tree-table-adapter.c @@ -38,9 +38,13 @@ #include "e-table-sorting-utils.h" #include "e-tree-table-adapter.h" +#define E_TREE_TABLE_ADAPTER_GET_PRIVATE(obj) \ + (G_TYPE_INSTANCE_GET_PRIVATE \ + ((obj), E_TYPE_TREE_TABLE_ADAPTER, ETreeTableAdapterPrivate)) + /* workaround for avoiding API breakage */ #define etta_get_type e_tree_table_adapter_get_type -G_DEFINE_TYPE (ETreeTableAdapter, etta, E_TABLE_MODEL_TYPE) +G_DEFINE_TYPE (ETreeTableAdapter, etta, E_TYPE_TABLE_MODEL) #define d(x) #define INCREMENT_AMOUNT 100 @@ -62,7 +66,7 @@ typedef struct { guint expandable_set : 1; } node_t; -struct ETreeTableAdapterPriv { +struct _ETreeTableAdapterPrivate { ETreeModel *source; ETableSortInfo *sort_info; ETableHeader *header; @@ -508,68 +512,72 @@ update_node (ETreeTableAdapter *etta, ETreePath path) static void etta_finalize (GObject *object) { - ETreeTableAdapter *etta = E_TREE_TABLE_ADAPTER (object); + ETreeTableAdapterPrivate *priv; - if (etta->priv->resort_idle_id) { - g_source_remove (etta->priv->resort_idle_id); - etta->priv->resort_idle_id = 0; - } + priv = E_TREE_TABLE_ADAPTER_GET_PRIVATE (object); - if (etta->priv->root) { - kill_gnode (etta->priv->root, etta); - etta->priv->root = NULL; + if (priv->resort_idle_id) { + g_source_remove (priv->resort_idle_id); + priv->resort_idle_id = 0; } - g_hash_table_destroy (etta->priv->nodes); + if (priv->root) { + kill_gnode (priv->root, E_TREE_TABLE_ADAPTER (object)); + priv->root = NULL; + } - g_free (etta->priv->map_table); + g_hash_table_destroy (priv->nodes); - g_free (etta->priv); + g_free (priv->map_table); + /* Chain up to parent's finalize() method. */ G_OBJECT_CLASS (etta_parent_class)->finalize (object); } static void etta_dispose (GObject *object) { - ETreeTableAdapter *etta = E_TREE_TABLE_ADAPTER (object); + ETreeTableAdapterPrivate *priv; - if (etta->priv->sort_info) { - g_signal_handler_disconnect (G_OBJECT (etta->priv->sort_info), - etta->priv->sort_info_changed_id); - g_object_unref (etta->priv->sort_info); - etta->priv->sort_info = NULL; + priv = E_TREE_TABLE_ADAPTER_GET_PRIVATE (object); + + if (priv->sort_info) { + g_signal_handler_disconnect ( + priv->sort_info, priv->sort_info_changed_id); + g_object_unref (priv->sort_info); + priv->sort_info = NULL; } - if (etta->priv->header) { - g_object_unref (etta->priv->header); - etta->priv->header = NULL; + if (priv->header) { + g_object_unref (priv->header); + priv->header = NULL; } - if (etta->priv->source) { - g_signal_handler_disconnect (G_OBJECT (etta->priv->source), - etta->priv->pre_change_id); - g_signal_handler_disconnect (G_OBJECT (etta->priv->source), - etta->priv->no_change_id); - g_signal_handler_disconnect (G_OBJECT (etta->priv->source), - etta->priv->rebuilt_id); - g_signal_handler_disconnect (G_OBJECT (etta->priv->source), - etta->priv->node_changed_id); - g_signal_handler_disconnect (G_OBJECT (etta->priv->source), - etta->priv->node_data_changed_id); - g_signal_handler_disconnect (G_OBJECT (etta->priv->source), - etta->priv->node_col_changed_id); - g_signal_handler_disconnect (G_OBJECT (etta->priv->source), - etta->priv->node_inserted_id); - g_signal_handler_disconnect (G_OBJECT (etta->priv->source), - etta->priv->node_removed_id); - g_signal_handler_disconnect (G_OBJECT (etta->priv->source), - etta->priv->node_request_collapse_id); - - g_object_unref (etta->priv->source); - etta->priv->source = NULL; + if (priv->source) { + g_signal_handler_disconnect ( + priv->source, priv->pre_change_id); + g_signal_handler_disconnect ( + priv->source, priv->no_change_id); + g_signal_handler_disconnect ( + priv->source, priv->rebuilt_id); + g_signal_handler_disconnect ( + priv->source, priv->node_changed_id); + g_signal_handler_disconnect ( + priv->source, priv->node_data_changed_id); + g_signal_handler_disconnect ( + priv->source, priv->node_col_changed_id); + g_signal_handler_disconnect ( + priv->source, priv->node_inserted_id); + g_signal_handler_disconnect ( + priv->source, priv->node_removed_id); + g_signal_handler_disconnect ( + priv->source, priv->node_request_collapse_id); + + g_object_unref (priv->source); + priv->source = NULL; } + /* Chain up to parent's dispose() method. */ G_OBJECT_CLASS (etta_parent_class)->dispose (object); } @@ -694,33 +702,37 @@ etta_value_to_string (ETableModel *etm, gint col, gconstpointer value) } static void -etta_class_init (ETreeTableAdapterClass *klass) +etta_class_init (ETreeTableAdapterClass *class) { - ETableModelClass *table_class = (ETableModelClass *) klass; - GObjectClass *object_class = (GObjectClass *) klass; + GObjectClass *object_class; + ETableModelClass *table_model_class; - object_class->dispose = etta_dispose; - object_class->finalize = etta_finalize; + g_type_class_add_private (class, sizeof (ETreeTableAdapterPrivate)); - table_class->column_count = etta_column_count; - table_class->row_count = etta_row_count; - table_class->append_row = etta_append_row; + object_class = G_OBJECT_CLASS (class); + object_class->dispose = etta_dispose; + object_class->finalize = etta_finalize; - table_class->value_at = etta_value_at; - table_class->set_value_at = etta_set_value_at; - table_class->is_cell_editable = etta_is_cell_editable; + table_model_class = E_TABLE_MODEL_CLASS (class); + table_model_class->column_count = etta_column_count; + table_model_class->row_count = etta_row_count; + table_model_class->append_row = etta_append_row; - table_class->has_save_id = etta_has_save_id; - table_class->get_save_id = etta_get_save_id; + table_model_class->value_at = etta_value_at; + table_model_class->set_value_at = etta_set_value_at; + table_model_class->is_cell_editable = etta_is_cell_editable; - table_class->has_change_pending = etta_has_change_pending; - table_class->duplicate_value = etta_duplicate_value; - table_class->free_value = etta_free_value; - table_class->initialize_value = etta_initialize_value; - table_class->value_is_empty = etta_value_is_empty; - table_class->value_to_string = etta_value_to_string; + table_model_class->has_save_id = etta_has_save_id; + table_model_class->get_save_id = etta_get_save_id; - klass->sorting_changed = NULL; + table_model_class->has_change_pending = etta_has_change_pending; + table_model_class->duplicate_value = etta_duplicate_value; + table_model_class->free_value = etta_free_value; + table_model_class->initialize_value = etta_initialize_value; + table_model_class->value_is_empty = etta_value_is_empty; + table_model_class->value_to_string = etta_value_to_string; + + class->sorting_changed = NULL; signals[SORTING_CHANGED] = g_signal_new ("sorting_changed", @@ -735,32 +747,10 @@ etta_class_init (ETreeTableAdapterClass *klass) static void etta_init (ETreeTableAdapter *etta) { - etta->priv = g_new (ETreeTableAdapterPriv, 1); - - etta->priv->source = NULL; - etta->priv->sort_info = NULL; + etta->priv = E_TREE_TABLE_ADAPTER_GET_PRIVATE (etta); - etta->priv->n_map = 0; - etta->priv->n_vals_allocated = 0; - etta->priv->map_table = NULL; - etta->priv->nodes = NULL; - etta->priv->root = NULL; - - etta->priv->root_visible = TRUE; - etta->priv->remap_needed = TRUE; - - etta->priv->pre_change_id = 0; - etta->priv->no_change_id = 0; - etta->priv->rebuilt_id = 0; - etta->priv->node_changed_id = 0; - etta->priv->node_data_changed_id = 0; - etta->priv->node_col_changed_id = 0; - etta->priv->node_inserted_id = 0; - etta->priv->node_removed_id = 0; - etta->priv->node_request_collapse_id = 0; - - etta->priv->resort_idle_id = 0; - etta->priv->force_expanded_state = 0; + etta->priv->root_visible = TRUE; + etta->priv->remap_needed = TRUE; } static void @@ -931,7 +921,7 @@ e_tree_table_adapter_construct (ETreeTableAdapter *etta, ETreeModel *source, ETa ETableModel * e_tree_table_adapter_new (ETreeModel *source, ETableSortInfo *sort_info, ETableHeader *header) { - ETreeTableAdapter *etta = g_object_new (E_TREE_TABLE_ADAPTER_TYPE, NULL); + ETreeTableAdapter *etta = g_object_new (E_TYPE_TREE_TABLE_ADAPTER, NULL); e_tree_table_adapter_construct (etta, source, sort_info, header); diff --git a/widgets/table/e-tree-table-adapter.h b/widgets/table/e-tree-table-adapter.h index b5fc2c0422..ea7b86b21d 100644 --- a/widgets/table/e-tree-table-adapter.h +++ b/widgets/table/e-tree-table-adapter.h @@ -24,81 +24,109 @@ #ifndef _E_TREE_TABLE_ADAPTER_H_ #define _E_TREE_TABLE_ADAPTER_H_ -#include <glib-object.h> #include <table/e-table-model.h> #include <table/e-tree-model.h> #include <table/e-table-sort-info.h> #include <table/e-table-header.h> #include <libxml/tree.h> -G_BEGIN_DECLS - -#define E_TREE_TABLE_ADAPTER_TYPE (e_tree_table_adapter_get_type ()) -#define E_TREE_TABLE_ADAPTER(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), E_TREE_TABLE_ADAPTER_TYPE, ETreeTableAdapter)) -#define E_TREE_TABLE_ADAPTER_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k), E_TREE_TABLE_ADAPTER_TYPE, ETreeTableAdapterClass)) -#define E_IS_TREE_TABLE_ADAPTER(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), E_TREE_TABLE_ADAPTER_TYPE)) -#define E_IS_TREE_TABLE_ADAPTER_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), E_TREE_TABLE_ADAPTER_TYPE)) -#define E_TREE_TABLE_ADAPTER_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((obj), E_TREE_TABLE_ADAPTER_TYPE, ETreeTableAdapterClass)) +/* Standard GObject macros */ +#define E_TYPE_TREE_TABLE_ADAPTER \ + (e_tree_table_adapter_get_type ()) +#define E_TREE_TABLE_ADAPTER(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST \ + ((obj), E_TYPE_TREE_TABLE_ADAPTER, ETreeTableAdapter)) +#define E_TREE_TABLE_ADAPTER_CLASS(cls) \ + (G_TYPE_CHECK_CLASS_CAST \ + ((cls), E_TYPE_TREE_TABLE_ADAPTER, ETreeTableAdapterClass)) +#define E_IS_TREE_TABLE_ADAPTER(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE \ + ((obj), E_TYPE_TREE_TABLE_ADAPTER)) +#define E_IS_TREE_TABLE_ADAPTER_CLASS(cls) \ + (G_TYPE_CHECK_CLASS_TYPE \ + ((cls), E_TYPE_TREE_TABLE_ADAPTER)) +#define E_TREE_TABLE_ADAPTER_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS \ + ((obj), E_TYPE_TREE_TABLE_ADAPTER, ETreeTableAdapterClass)) -typedef struct ETreeTableAdapterPriv ETreeTableAdapterPriv; +G_BEGIN_DECLS -typedef struct { - ETableModel base; +typedef struct _ETreeTableAdapter ETreeTableAdapter; +typedef struct _ETreeTableAdapterClass ETreeTableAdapterClass; +typedef struct _ETreeTableAdapterPrivate ETreeTableAdapterPrivate; - ETreeTableAdapterPriv *priv; -} ETreeTableAdapter; +struct _ETreeTableAdapter { + ETableModel parent; + ETreeTableAdapterPrivate *priv; +}; -typedef struct { +struct _ETreeTableAdapterClass { ETableModelClass parent_class; /* Signals */ - gboolean (*sorting_changed) (ETreeTableAdapter *etta); -} ETreeTableAdapterClass; - -GType e_tree_table_adapter_get_type (void); -ETableModel *e_tree_table_adapter_new (ETreeModel *source, - ETableSortInfo *sort_info, - ETableHeader *header); -ETableModel *e_tree_table_adapter_construct (ETreeTableAdapter *ets, - ETreeModel *source, - ETableSortInfo *sort_info, - ETableHeader *header); - -ETreePath e_tree_table_adapter_node_get_next (ETreeTableAdapter *etta, - ETreePath path); -gboolean e_tree_table_adapter_node_is_expanded (ETreeTableAdapter *etta, - ETreePath path); -void e_tree_table_adapter_node_set_expanded (ETreeTableAdapter *etta, - ETreePath path, - gboolean expanded); -void e_tree_table_adapter_node_set_expanded_recurse (ETreeTableAdapter *etta, - ETreePath path, - gboolean expanded); -void e_tree_table_adapter_force_expanded_state (ETreeTableAdapter *etta, - gint state); -void e_tree_table_adapter_root_node_set_visible (ETreeTableAdapter *etta, - gboolean visible); -ETreePath e_tree_table_adapter_node_at_row (ETreeTableAdapter *etta, - gint row); -gint e_tree_table_adapter_row_of_node (ETreeTableAdapter *etta, - ETreePath path); -gboolean e_tree_table_adapter_root_node_is_visible (ETreeTableAdapter *etta); - -void e_tree_table_adapter_show_node (ETreeTableAdapter *etta, - ETreePath path); - -void e_tree_table_adapter_save_expanded_state (ETreeTableAdapter *etta, - const gchar *filename); -void e_tree_table_adapter_load_expanded_state (ETreeTableAdapter *etta, - const gchar *filename); - -xmlDoc *e_tree_table_adapter_save_expanded_state_xml (ETreeTableAdapter *etta); -void e_tree_table_adapter_load_expanded_state_xml (ETreeTableAdapter *etta, xmlDoc *doc); - -void e_tree_table_adapter_set_sort_info (ETreeTableAdapter *etta, - ETableSortInfo *sort_info); -ETableSortInfo *e_tree_table_adapter_get_sort_info (ETreeTableAdapter *etta); -ETableHeader *e_tree_table_adapter_get_header (ETreeTableAdapter *etta); + gboolean (*sorting_changed) (ETreeTableAdapter *etta); +}; + +GType e_tree_table_adapter_get_type (void) G_GNUC_CONST; +ETableModel * e_tree_table_adapter_new (ETreeModel *source, + ETableSortInfo *sort_info, + ETableHeader *header); +ETableModel * e_tree_table_adapter_construct (ETreeTableAdapter *ets, + ETreeModel *source, + ETableSortInfo *sort_info, + ETableHeader *header); + +ETreePath e_tree_table_adapter_node_get_next + (ETreeTableAdapter *etta, + ETreePath path); +gboolean e_tree_table_adapter_node_is_expanded + (ETreeTableAdapter *etta, + ETreePath path); +void e_tree_table_adapter_node_set_expanded + (ETreeTableAdapter *etta, + ETreePath path, + gboolean expanded); +void e_tree_table_adapter_node_set_expanded_recurse + (ETreeTableAdapter *etta, + ETreePath path, + gboolean expanded); +void e_tree_table_adapter_force_expanded_state + (ETreeTableAdapter *etta, + gint state); +void e_tree_table_adapter_root_node_set_visible + (ETreeTableAdapter *etta, + gboolean visible); +ETreePath e_tree_table_adapter_node_at_row + (ETreeTableAdapter *etta, + gint row); +gint e_tree_table_adapter_row_of_node + (ETreeTableAdapter *etta, + ETreePath path); +gboolean e_tree_table_adapter_root_node_is_visible + (ETreeTableAdapter *etta); + +void e_tree_table_adapter_show_node (ETreeTableAdapter *etta, + ETreePath path); + +void e_tree_table_adapter_save_expanded_state + (ETreeTableAdapter *etta, + const gchar *filename); +void e_tree_table_adapter_load_expanded_state + (ETreeTableAdapter *etta, + const gchar *filename); + +xmlDoc * e_tree_table_adapter_save_expanded_state_xml + (ETreeTableAdapter *etta); +void e_tree_table_adapter_load_expanded_state_xml + (ETreeTableAdapter *etta, + xmlDoc *doc); + +void e_tree_table_adapter_set_sort_info + (ETreeTableAdapter *etta, + ETableSortInfo *sort_info); +ETableSortInfo *e_tree_table_adapter_get_sort_info + (ETreeTableAdapter *etta); +ETableHeader * e_tree_table_adapter_get_header (ETreeTableAdapter *etta); G_END_DECLS diff --git a/widgets/table/e-tree.c b/widgets/table/e-tree.c index f19a9a7cfc..bcad41a797 100644 --- a/widgets/table/e-tree.c +++ b/widgets/table/e-tree.c @@ -59,6 +59,10 @@ #define d(x) +#define E_TREE_GET_PRIVATE(obj) \ + (G_TYPE_INSTANCE_GET_PRIVATE \ + ((obj), E_TYPE_TREE, ETreePrivate)) + enum { CURSOR_CHANGE, CURSOR_ACTIVATED, @@ -107,7 +111,7 @@ enum { ET_SCROLL_RIGHT = 1 << 3 }; -struct ETreePriv { +struct _ETreePrivate { ETreeModel *model; ETreeTableAdapter *etta; @@ -379,70 +383,94 @@ connect_header (ETree *e_tree, ETableState *state) static void et_dispose (GObject *object) { - ETree *et = E_TREE (object); + ETreePrivate *priv; - if (et->priv) { + priv = E_TREE_GET_PRIVATE (object); - if (et->priv->search) { - if (et->priv->search_search_id) - g_signal_handler_disconnect (et->priv->search, - et->priv->search_search_id); - if (et->priv->search_accept_id) - g_signal_handler_disconnect (et->priv->search, - et->priv->search_accept_id); - g_object_unref (et->priv->search); - } + if (priv->search != NULL) { + g_signal_handler_disconnect ( + priv->search, priv->search_search_id); + g_signal_handler_disconnect ( + priv->search, priv->search_accept_id); + g_object_unref (priv->search); + priv->search = NULL; + } - if (et->priv->reflow_idle_id) - g_source_remove (et->priv->reflow_idle_id); - et->priv->reflow_idle_id = 0; + if (priv->reflow_idle_id > 0) { + g_source_remove (priv->reflow_idle_id); + priv->reflow_idle_id = 0; + } - scroll_off (et); - hover_off (et); - g_list_foreach ( - et->priv->expanded_list, - (GFunc) g_free, NULL); - g_list_free (et->priv->expanded_list); - - et_disconnect_from_etta (et); - - g_object_unref (et->priv->etta); - g_object_unref (et->priv->model); - g_object_unref (et->priv->full_header); - disconnect_header (et); - g_object_unref (et->priv->selection); - if (et->priv->spec) - g_object_unref (et->priv->spec); - et->priv->spec = NULL; - - if (et->priv->sorter) - g_object_unref (et->priv->sorter); - et->priv->sorter = NULL; - - if (et->priv->header_canvas) - gtk_widget_destroy (GTK_WIDGET (et->priv->header_canvas)); - et->priv->header_canvas = NULL; - - if (et->priv->site) - e_tree_drag_source_unset (et); - - if (et->priv->last_drop_context) - g_object_weak_unref (G_OBJECT (et->priv->last_drop_context), context_destroyed, et); - et->priv->last_drop_context = NULL; + scroll_off (E_TREE (object)); + hover_off (E_TREE (object)); + g_list_foreach ( + priv->expanded_list, + (GFunc) g_free, NULL); + g_list_free (priv->expanded_list); + priv->expanded_list = NULL; + + et_disconnect_from_etta (E_TREE (object)); - if (et->priv->info_text) - g_object_run_dispose (G_OBJECT (et->priv->info_text)); - et->priv->info_text = NULL; - et->priv->info_text_resize_id = 0; + if (priv->etta != NULL) { + g_object_unref (priv->etta); + priv->etta = NULL; + } + + if (priv->model != NULL) { + g_object_unref (priv->model); + priv->model = NULL; + } + + if (priv->full_header != NULL) { + g_object_unref (priv->full_header); + priv->full_header = NULL; + } + + disconnect_header (E_TREE (object)); + + if (priv->selection != NULL) { + g_object_unref (priv->selection); + priv->selection = NULL; + } + + if (priv->spec != NULL) { + g_object_unref (priv->spec); + priv->spec = NULL; + } + + if (priv->sorter != NULL) { + g_object_unref (priv->sorter); + priv->sorter = NULL; + } + + if (priv->header_canvas != NULL) { + gtk_widget_destroy (GTK_WIDGET (priv->header_canvas)); + priv->header_canvas = NULL; + } - gtk_widget_destroy (GTK_WIDGET (et->priv->table_canvas)); + if (priv->site) + e_tree_drag_source_unset (E_TREE (object)); - g_free (et->priv); - et->priv = NULL; + if (priv->last_drop_context != NULL) { + g_object_weak_unref ( + G_OBJECT (priv->last_drop_context), + context_destroyed, object); + priv->last_drop_context = NULL; } - if (G_OBJECT_CLASS (e_tree_parent_class)->dispose) - G_OBJECT_CLASS (e_tree_parent_class)->dispose (object); + if (priv->info_text != NULL) { + g_object_run_dispose (G_OBJECT (priv->info_text)); + priv->info_text = NULL; + } + priv->info_text_resize_id = 0; + + if (priv->table_canvas != NULL) { + gtk_widget_destroy (GTK_WIDGET (priv->table_canvas)); + priv->table_canvas = NULL; + } + + /* Chain up to parent's dispose() method. */ + G_OBJECT_CLASS (e_tree_parent_class)->dispose (object); } static void @@ -555,65 +583,20 @@ e_tree_init (ETree *e_tree) gtk_table_set_homogeneous (GTK_TABLE (e_tree), FALSE); - e_tree->priv = g_new (ETreePriv, 1); - - e_tree->priv->model = NULL; - e_tree->priv->etta = NULL; - - e_tree->priv->full_header = NULL; - e_tree->priv->header = NULL; - - e_tree->priv->structure_change_id = 0; - e_tree->priv->expansion_change_id = 0; - e_tree->priv->sort_info_change_id = 0; - e_tree->priv->group_info_change_id = 0; - - e_tree->priv->sort_info = NULL; - e_tree->priv->sorter = NULL; - e_tree->priv->reflow_idle_id = 0; - e_tree->priv->scroll_idle_id = 0; - e_tree->priv->hover_idle_id = 0; - - e_tree->priv->show_cursor_after_reflow = FALSE; - - e_tree->priv->table_model_change_id = 0; - e_tree->priv->table_row_change_id = 0; - e_tree->priv->table_cell_change_id = 0; - e_tree->priv->table_rows_delete_id = 0; + e_tree->priv = E_TREE_GET_PRIVATE (e_tree); e_tree->priv->alternating_row_colors = 1; - e_tree->priv->horizontal_draw_grid = 1; - e_tree->priv->vertical_draw_grid = 1; - e_tree->priv->draw_focus = 1; - e_tree->priv->cursor_mode = E_CURSOR_SIMPLE; - e_tree->priv->length_threshold = 200; - e_tree->priv->uniform_row_height = FALSE; - - e_tree->priv->row_selection_active = FALSE; - e_tree->priv->horizontal_scrolling = FALSE; - e_tree->priv->scroll_direction = 0; + e_tree->priv->horizontal_draw_grid = 1; + e_tree->priv->vertical_draw_grid = 1; + e_tree->priv->draw_focus = 1; + e_tree->priv->cursor_mode = E_CURSOR_SIMPLE; + e_tree->priv->length_threshold = 200; - e_tree->priv->drop_row = -1; - e_tree->priv->drop_path = NULL; - e_tree->priv->drop_col = -1; - e_tree->priv->drop_highlight = NULL; + e_tree->priv->drop_row = -1; + e_tree->priv->drop_col = -1; - e_tree->priv->last_drop_x = 0; - e_tree->priv->last_drop_y = 0; - e_tree->priv->last_drop_time = 0; - e_tree->priv->last_drop_context = NULL; - - e_tree->priv->hover_x = 0; - e_tree->priv->hover_y = 0; - - e_tree->priv->drag_row = -1; - e_tree->priv->drag_path = NULL; - e_tree->priv->drag_col = -1; - - e_tree->priv->expanded_list = NULL; - - e_tree->priv->site = NULL; - e_tree->priv->do_drag = FALSE; + e_tree->priv->drag_row = -1; + e_tree->priv->drag_col = -1; #ifdef E_TREE_USE_TREE_SELECTION e_tree->priv->selection = @@ -622,32 +605,17 @@ e_tree_init (ETree *e_tree) e_tree->priv->selection = E_SELECTION_MODEL (e_table_selection_model_new ()); #endif - e_tree->priv->spec = NULL; - - e_tree->priv->info_text = NULL; - e_tree->priv->info_text_resize_id = 0; - - e_tree->priv->header_canvas = NULL; - e_tree->priv->table_canvas = NULL; - e_tree->priv->header_item = NULL; - e_tree->priv->root = NULL; + e_tree->priv->search = e_table_search_new (); - e_tree->priv->white_item = NULL; - e_tree->priv->item = NULL; - - e_tree->priv->search = e_table_search_new (); - - e_tree->priv->search_search_id = + e_tree->priv->search_search_id = g_signal_connect (G_OBJECT (e_tree->priv->search), "search", - G_CALLBACK (et_search_search), e_tree); - e_tree->priv->search_accept_id = + G_CALLBACK (et_search_search), e_tree); + e_tree->priv->search_accept_id = g_signal_connect (G_OBJECT (e_tree->priv->search), "accept", - G_CALLBACK (et_search_accept), e_tree); + G_CALLBACK (et_search_accept), e_tree); - e_tree->priv->current_search_col = NULL; - e_tree->priv->search_col_set = FALSE; - e_tree->priv->always_search = g_getenv ("GAL_ALWAYS_SEARCH") ? TRUE : FALSE; + e_tree->priv->always_search = g_getenv ("GAL_ALWAYS_SEARCH") ? TRUE : FALSE; } /* Grab_focus handler for the ETree */ @@ -1747,7 +1715,7 @@ e_tree_new (ETreeModel *etm, ETableExtras *ete, const gchar *spec, const gchar * g_return_val_if_fail (ete == NULL || E_IS_TABLE_EXTRAS (ete), NULL); g_return_val_if_fail (spec != NULL, NULL); - e_tree = g_object_new (E_TREE_TYPE, NULL); + e_tree = g_object_new (E_TYPE_TREE, NULL); if (!e_tree_construct (e_tree, etm, ete, spec, state)) { g_object_unref (e_tree); @@ -1790,7 +1758,7 @@ e_tree_new_from_spec_file (ETreeModel *etm, g_return_val_if_fail (ete == NULL || E_IS_TABLE_EXTRAS (ete), NULL); g_return_val_if_fail (spec_fn != NULL, NULL); - e_tree = g_object_new (E_TREE_TYPE, NULL); + e_tree = g_object_new (E_TYPE_TREE, NULL); if (!e_tree_construct_from_spec_file (e_tree, etm, ete, spec_fn, state_fn)) { g_object_unref (e_tree); @@ -2035,7 +2003,8 @@ set_scroll_adjustments (ETree *tree, if (hadjustment != NULL) gtk_adjustment_set_step_increment (hadjustment, 20); - if (tree->priv) { + /* XXX This can be called after our dispose() method has run. */ + if (tree->priv->table_canvas != NULL) { GtkScrollable *scrollable; scrollable = GTK_SCROLLABLE (tree->priv->table_canvas); @@ -3275,38 +3244,20 @@ e_tree_class_init (ETreeClass *class) GObjectClass *object_class; GtkWidgetClass *widget_class; - object_class = (GObjectClass *) class; - widget_class = (GtkWidgetClass *) class; - - object_class->dispose = et_dispose; - object_class->set_property = et_set_property; - object_class->get_property = et_get_property; - - widget_class->grab_focus = et_grab_focus; - widget_class->unrealize = et_unrealize; - widget_class->style_set = et_canvas_style_set; - widget_class->focus = et_focus; - - class->cursor_change = NULL; - class->cursor_activated = NULL; - class->selection_change = NULL; - class->double_click = NULL; - class->right_click = NULL; - class->click = NULL; - class->key_press = NULL; - class->start_drag = et_real_start_drag; - class->state_change = NULL; - class->white_space_event = NULL; - - class->tree_drag_begin = NULL; - class->tree_drag_end = NULL; - class->tree_drag_data_get = NULL; - class->tree_drag_data_delete = NULL; - - class->tree_drag_leave = NULL; - class->tree_drag_motion = NULL; - class->tree_drag_drop = NULL; - class->tree_drag_data_received = NULL; + g_type_class_add_private (class, sizeof (ETreePrivate)); + + object_class = G_OBJECT_CLASS (class); + object_class->dispose = et_dispose; + object_class->set_property = et_set_property; + object_class->get_property = et_get_property; + + widget_class = GTK_WIDGET_CLASS (class); + widget_class->grab_focus = et_grab_focus; + widget_class->unrealize = et_unrealize; + widget_class->style_set = et_canvas_style_set; + widget_class->focus = et_focus; + + class->start_drag = et_real_start_drag; et_signals[CURSOR_CHANGE] = g_signal_new ("cursor_change", @@ -3557,7 +3508,7 @@ e_tree_class_init (ETreeClass *class) g_param_spec_object ("ETreeTableAdapter", "ETree table adapter", "ETree table adapter", - E_TREE_TABLE_ADAPTER_TYPE, + E_TYPE_TREE_TABLE_ADAPTER, G_PARAM_READABLE)); g_object_class_install_property (object_class, PROP_UNIFORM_ROW_HEIGHT, diff --git a/widgets/table/e-tree.h b/widgets/table/e-tree.h index 345aa34336..533ab588f5 100644 --- a/widgets/table/e-tree.h +++ b/widgets/table/e-tree.h @@ -41,279 +41,331 @@ #include <table/e-tree-selection-model.h> #endif +/* Standard GObject macros */ +#define E_TYPE_TREE \ + (e_tree_get_type ()) +#define E_TREE(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST \ + ((obj), E_TYPE_TREE, ETree)) +#define E_TREE_CLASS(cls) \ + (G_TYPE_CHECK_CLASS_CAST \ + ((cls), E_TYPE_TREE, ETreeClass)) +#define E_IS_TREE(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE \ + ((obj), E_TYPE_TREE)) +#define E_IS_TREE_CLASS(cls) \ + (G_TYPE_CHECK_CLASS_TYPE \ + ((cls), E_TYPE_TREE)) +#define E_TREE_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS \ + ((obj), E_TYPE_TREE)) + G_BEGIN_DECLS -#define E_TREE_TYPE (e_tree_get_type ()) -#define E_TREE(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), E_TREE_TYPE, ETree)) -#define E_TREE_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k), E_TREE_TYPE, ETreeClass)) -#define E_IS_TREE(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), E_TREE_TYPE)) -#define E_IS_TREE_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), E_TREE_TYPE)) typedef struct _ETreeDragSourceSite ETreeDragSourceSite; -typedef struct ETreePriv ETreePriv; -typedef struct { - GtkTable parent; +typedef struct _ETree ETree; +typedef struct _ETreeClass ETreeClass; +typedef struct _ETreePrivate ETreePrivate; - ETreePriv *priv; -} ETree; +struct _ETree { + GtkTable parent; + ETreePrivate *priv; +}; -typedef struct { +struct _ETreeClass { GtkTableClass parent_class; - void (*cursor_change) (ETree *et, gint row, ETreePath path); - void (*cursor_activated) (ETree *et, gint row, ETreePath path); - void (*selection_change) (ETree *et); - void (*double_click) (ETree *et, gint row, ETreePath path, gint col, GdkEvent *event); - gboolean (*right_click) (ETree *et, gint row, ETreePath path, gint col, GdkEvent *event); - gboolean (*click) (ETree *et, gint row, ETreePath path, gint col, GdkEvent *event); - gboolean (*key_press) (ETree *et, gint row, ETreePath path, gint col, GdkEvent *event); - gboolean (*start_drag) (ETree *et, gint row, ETreePath path, gint col, GdkEvent *event); - void (*state_change) (ETree *et); - gboolean (*white_space_event) (ETree *et, GdkEvent *event); - - void (*set_scroll_adjustments) (ETree *tree, - GtkAdjustment *hadjustment, - GtkAdjustment *vadjustment); + void (*cursor_change) (ETree *et, + gint row, + ETreePath path); + void (*cursor_activated) (ETree *et, + gint row, + ETreePath path); + void (*selection_change) (ETree *et); + void (*double_click) (ETree *et, + gint row, + ETreePath path, + gint col, + GdkEvent *event); + gboolean (*right_click) (ETree *et, + gint row, + ETreePath path, + gint col, + GdkEvent *event); + gboolean (*click) (ETree *et, + gint row, + ETreePath path, + gint col, + GdkEvent *event); + gboolean (*key_press) (ETree *et, + gint row, + ETreePath path, + gint col, + GdkEvent *event); + gboolean (*start_drag) (ETree *et, + gint row, + ETreePath path, + gint col, + GdkEvent *event); + void (*state_change) (ETree *et); + gboolean (*white_space_event) (ETree *et, + GdkEvent *event); + + void (*set_scroll_adjustments) + (ETree *tree, + GtkAdjustment *hadjustment, + GtkAdjustment *vadjustment); /* Source side drag signals */ - void (* tree_drag_begin) (ETree *tree, - gint row, - ETreePath path, - gint col, - GdkDragContext *context); - void (* tree_drag_end) (ETree *tree, - gint row, - ETreePath path, - gint col, - GdkDragContext *context); - void (* tree_drag_data_get) (ETree *tree, - gint row, - ETreePath path, - gint col, - GdkDragContext *context, - GtkSelectionData *selection_data, - guint info, - guint time); - void (* tree_drag_data_delete) (ETree *tree, - gint row, - ETreePath path, - gint col, - GdkDragContext *context); + void (*tree_drag_begin) (ETree *tree, + gint row, + ETreePath path, + gint col, + GdkDragContext *context); + void (*tree_drag_end) (ETree *tree, + gint row, + ETreePath path, + gint col, + GdkDragContext *context); + void (*tree_drag_data_get) (ETree *tree, + gint row, + ETreePath path, + gint col, + GdkDragContext *context, + GtkSelectionData *selection_data, + guint info, + guint time); + void (*tree_drag_data_delete) + (ETree *tree, + gint row, + ETreePath path, + gint col, + GdkDragContext *context); /* Target side drag signals */ - void (* tree_drag_leave) (ETree *tree, - gint row, - ETreePath path, - gint col, - GdkDragContext *context, - guint time); - gboolean (* tree_drag_motion) (ETree *tree, - gint row, - ETreePath path, - gint col, - GdkDragContext *context, - gint x, - gint y, - guint time); - gboolean (* tree_drag_drop) (ETree *tree, - gint row, - ETreePath path, - gint col, - GdkDragContext *context, - gint x, - gint y, - guint time); - void (* tree_drag_data_received) (ETree *tree, - gint row, - ETreePath path, - gint col, - GdkDragContext *context, - gint x, - gint y, - GtkSelectionData *selection_data, - guint info, - guint time); -} ETreeClass; - -GType e_tree_get_type (void); -gboolean e_tree_construct (ETree *e_tree, - ETreeModel *etm, - ETableExtras *ete, - const gchar *spec, - const gchar *state); -GtkWidget *e_tree_new (ETreeModel *etm, - ETableExtras *ete, - const gchar *spec, - const gchar *state); + void (*tree_drag_leave) (ETree *tree, + gint row, + ETreePath path, + gint col, + GdkDragContext *context, + guint time); + gboolean (*tree_drag_motion) (ETree *tree, + gint row, + ETreePath path, + gint col, + GdkDragContext *context, + gint x, + gint y, + guint time); + gboolean (*tree_drag_drop) (ETree *tree, + gint row, + ETreePath path, + gint col, + GdkDragContext *context, + gint x, + gint y, + guint time); + void (*tree_drag_data_received) + (ETree *tree, + gint row, + ETreePath path, + gint col, + GdkDragContext *context, + gint x, + gint y, + GtkSelectionData *selection_data, + guint info, + guint time); +}; + +GType e_tree_get_type (void) G_GNUC_CONST; +gboolean e_tree_construct (ETree *e_tree, + ETreeModel *etm, + ETableExtras *ete, + const gchar *spec, + const gchar *state); +GtkWidget * e_tree_new (ETreeModel *etm, + ETableExtras *ete, + const gchar *spec, + const gchar *state); /* Create an ETree using files. */ -gboolean e_tree_construct_from_spec_file (ETree *e_tree, - ETreeModel *etm, - ETableExtras *ete, - const gchar *spec_fn, - const gchar *state_fn); -GtkWidget *e_tree_new_from_spec_file (ETreeModel *etm, - ETableExtras *ete, - const gchar *spec_fn, - const gchar *state_fn); +gboolean e_tree_construct_from_spec_file (ETree *e_tree, + ETreeModel *etm, + ETableExtras *ete, + const gchar *spec_fn, + const gchar *state_fn); +GtkWidget * e_tree_new_from_spec_file (ETreeModel *etm, + ETableExtras *ete, + const gchar *spec_fn, + const gchar *state_fn); /* To save the state */ -gchar *e_tree_get_state (ETree *e_tree); -void e_tree_save_state (ETree *e_tree, - const gchar *filename); -ETableState *e_tree_get_state_object (ETree *e_tree); -ETableSpecification *e_tree_get_spec (ETree *e_tree); +gchar * e_tree_get_state (ETree *e_tree); +void e_tree_save_state (ETree *e_tree, + const gchar *filename); +ETableState * e_tree_get_state_object (ETree *e_tree); +ETableSpecification * + e_tree_get_spec (ETree *e_tree); /* note that it is more efficient to provide the state at creation time */ -void e_tree_set_search_column (ETree *e_tree, - gint col); -void e_tree_set_state (ETree *e_tree, - const gchar *state); -void e_tree_set_state_object (ETree *e_tree, - ETableState *state); -void e_tree_load_state (ETree *e_tree, - const gchar *filename); -void e_tree_show_cursor_after_reflow (ETree *e_tree); - -void e_tree_set_cursor (ETree *e_tree, - ETreePath path); +void e_tree_set_search_column (ETree *e_tree, + gint col); +void e_tree_set_state (ETree *e_tree, + const gchar *state); +void e_tree_set_state_object (ETree *e_tree, + ETableState *state); +void e_tree_load_state (ETree *e_tree, + const gchar *filename); +void e_tree_show_cursor_after_reflow (ETree *e_tree); + +void e_tree_set_cursor (ETree *e_tree, + ETreePath path); /* NULL means we don't have the cursor. */ -ETreePath e_tree_get_cursor (ETree *e_tree); -void e_tree_selected_row_foreach (ETree *e_tree, - EForeachFunc callback, - gpointer closure); +ETreePath e_tree_get_cursor (ETree *e_tree); +void e_tree_selected_row_foreach (ETree *e_tree, + EForeachFunc callback, + gpointer closure); #ifdef E_TREE_USE_TREE_SELECTION -void e_tree_selected_path_foreach (ETree *e_tree, - ETreeForeachFunc callback, - gpointer closure); -void e_tree_path_foreach (ETree *e_tree, - ETreeForeachFunc callback, - gpointer closure); +void e_tree_selected_path_foreach (ETree *e_tree, + ETreeForeachFunc callback, + gpointer closure); +void e_tree_path_foreach (ETree *e_tree, + ETreeForeachFunc callback, + gpointer closure); #endif -gint e_tree_selected_count (ETree *e_tree); -EPrintable *e_tree_get_printable (ETree *e_tree); -gint e_tree_get_next_row (ETree *e_tree, - gint model_row); -gint e_tree_get_prev_row (ETree *e_tree, - gint model_row); -gint e_tree_model_to_view_row (ETree *e_tree, - gint model_row); -gint e_tree_view_to_model_row (ETree *e_tree, - gint view_row); -void e_tree_get_cell_at (ETree *tree, - gint x, - gint y, - gint *row_return, - gint *col_return); -void e_tree_get_cell_geometry (ETree *tree, - gint row, - gint col, - gint *x_return, - gint *y_return, - gint *width_return, - gint *height_return); +gint e_tree_selected_count (ETree *e_tree); +EPrintable *e_tree_get_printable (ETree *e_tree); +gint e_tree_get_next_row (ETree *e_tree, + gint model_row); +gint e_tree_get_prev_row (ETree *e_tree, + gint model_row); +gint e_tree_model_to_view_row (ETree *e_tree, + gint model_row); +gint e_tree_view_to_model_row (ETree *e_tree, + gint view_row); +void e_tree_get_cell_at (ETree *tree, + gint x, + gint y, + gint *row_return, + gint *col_return); +void e_tree_get_cell_geometry (ETree *tree, + gint row, + gint col, + gint *x_return, + gint *y_return, + gint *width_return, + gint *height_return); /* Useful accessors */ -ETreeModel * e_tree_get_model (ETree *et); -ESelectionModel *e_tree_get_selection_model (ETree *et); -ETreeTableAdapter *e_tree_get_table_adapter (ETree *et); +ETreeModel * e_tree_get_model (ETree *et); +ESelectionModel * + e_tree_get_selection_model (ETree *et); +ETreeTableAdapter * + e_tree_get_table_adapter (ETree *et); /* Drag & drop stuff. */ /* Target */ -void e_tree_drag_get_data (ETree *tree, - gint row, - gint col, - GdkDragContext *context, - GdkAtom target, - guint32 time); -void e_tree_drag_highlight (ETree *tree, - gint row, - gint col); /* col == -1 to highlight entire row. */ -void e_tree_drag_unhighlight (ETree *tree); -void e_tree_drag_dest_set (ETree *tree, - GtkDestDefaults flags, - const GtkTargetEntry *targets, - gint n_targets, - GdkDragAction actions); -void e_tree_drag_dest_set_proxy (ETree *tree, - GdkWindow *proxy_window, - GdkDragProtocol protocol, - gboolean use_coordinates); +void e_tree_drag_get_data (ETree *tree, + gint row, + gint col, + GdkDragContext *context, + GdkAtom target, + guint32 time); +void e_tree_drag_highlight (ETree *tree, + gint row, + gint col); /* col == -1 to highlight entire row. */ +void e_tree_drag_unhighlight (ETree *tree); +void e_tree_drag_dest_set (ETree *tree, + GtkDestDefaults flags, + const GtkTargetEntry *targets, + gint n_targets, + GdkDragAction actions); +void e_tree_drag_dest_set_proxy (ETree *tree, + GdkWindow *proxy_window, + GdkDragProtocol protocol, + gboolean use_coordinates); /* There probably should be functions for setting the targets * as a GtkTargetList */ -void e_tree_drag_dest_unset (GtkWidget *widget); +void e_tree_drag_dest_unset (GtkWidget *widget); /* Source side */ -void e_tree_drag_source_set (ETree *tree, - GdkModifierType start_button_mask, - const GtkTargetEntry *targets, - gint n_targets, - GdkDragAction actions); -void e_tree_drag_source_unset (ETree *tree); +void e_tree_drag_source_set (ETree *tree, + GdkModifierType start_button_mask, + const GtkTargetEntry *targets, + gint n_targets, + GdkDragAction actions); +void e_tree_drag_source_unset (ETree *tree); /* There probably should be functions for setting the targets * as a GtkTargetList */ -GdkDragContext *e_tree_drag_begin (ETree *tree, - gint row, - gint col, - GtkTargetList *targets, - GdkDragAction actions, - gint button, - GdkEvent *event); +GdkDragContext *e_tree_drag_begin (ETree *tree, + gint row, + gint col, + GtkTargetList *targets, + GdkDragAction actions, + gint button, + GdkEvent *event); /* Adapter functions */ -gboolean e_tree_node_is_expanded (ETree *et, - ETreePath path); -void e_tree_node_set_expanded (ETree *et, - ETreePath path, - gboolean expanded); -void e_tree_node_set_expanded_recurse (ETree *et, - ETreePath path, - gboolean expanded); -void e_tree_root_node_set_visible (ETree *et, - gboolean visible); -ETreePath e_tree_node_at_row (ETree *et, - gint row); -gint e_tree_row_of_node (ETree *et, - ETreePath path); -gboolean e_tree_root_node_is_visible (ETree *et); -void e_tree_show_node (ETree *et, - ETreePath path); -void e_tree_save_expanded_state (ETree *et, - gchar *filename); -void e_tree_load_expanded_state (ETree *et, - gchar *filename); - -xmlDoc *e_tree_save_expanded_state_xml (ETree *et); -void e_tree_load_expanded_state_xml (ETree *et, xmlDoc *doc); - -gint e_tree_row_count (ETree *et); -GtkWidget *e_tree_get_tooltip (ETree *et); -void e_tree_force_expanded_state (ETree *et, gint state); +gboolean e_tree_node_is_expanded (ETree *et, + ETreePath path); +void e_tree_node_set_expanded (ETree *et, + ETreePath path, + gboolean expanded); +void e_tree_node_set_expanded_recurse + (ETree *et, + ETreePath path, + gboolean expanded); +void e_tree_root_node_set_visible (ETree *et, + gboolean visible); +ETreePath e_tree_node_at_row (ETree *et, + gint row); +gint e_tree_row_of_node (ETree *et, + ETreePath path); +gboolean e_tree_root_node_is_visible (ETree *et); +void e_tree_show_node (ETree *et, + ETreePath path); +void e_tree_save_expanded_state (ETree *et, + gchar *filename); +void e_tree_load_expanded_state (ETree *et, + gchar *filename); + +xmlDoc * e_tree_save_expanded_state_xml (ETree *et); +void e_tree_load_expanded_state_xml (ETree *et, + xmlDoc *doc); + +gint e_tree_row_count (ETree *et); +GtkWidget * e_tree_get_tooltip (ETree *et); +void e_tree_force_expanded_state (ETree *et, + gint state); typedef enum { E_TREE_FIND_NEXT_BACKWARD = 0, - E_TREE_FIND_NEXT_FORWARD = 1 << 0, - E_TREE_FIND_NEXT_WRAP = 1 << 1 + E_TREE_FIND_NEXT_FORWARD = 1 << 0, + E_TREE_FIND_NEXT_WRAP = 1 << 1 } ETreeFindNextParams; -gboolean e_tree_find_next (ETree *et, - ETreeFindNextParams params, - ETreePathFunc func, - gpointer data); +gboolean e_tree_find_next (ETree *et, + ETreeFindNextParams params, + ETreePathFunc func, + gpointer data); /* This function is only needed in single_selection_mode. */ -void e_tree_right_click_up (ETree *et); +void e_tree_right_click_up (ETree *et); -ETableItem * e_tree_get_item (ETree * et); +ETableItem * e_tree_get_item (ETree *et); -GnomeCanvasItem * e_tree_get_header_item (ETree * et); +GnomeCanvasItem * + e_tree_get_header_item (ETree *et); -void e_tree_set_info_message (ETree *tree, const gchar *info_message); +void e_tree_set_info_message (ETree *tree, + const gchar *info_message); G_END_DECLS diff --git a/widgets/table/gal-a11y-e-cell-popup.c b/widgets/table/gal-a11y-e-cell-popup.c index 92ee3a8322..a282f862e3 100644 --- a/widgets/table/gal-a11y-e-cell-popup.c +++ b/widgets/table/gal-a11y-e-cell-popup.c @@ -38,7 +38,7 @@ static AtkObjectClass *parent_class = NULL; #define PARENT_TYPE (gal_a11y_e_cell_get_type ()) -static void gal_a11y_e_cell_popup_class_init (GalA11yECellPopupClass *klass); +static void gal_a11y_e_cell_popup_class_init (GalA11yECellPopupClass *class); static void popup_cell_action (GalA11yECell *cell); /** @@ -77,7 +77,7 @@ gal_a11y_e_cell_popup_get_type (void) } static void -gal_a11y_e_cell_popup_class_init (GalA11yECellPopupClass *klass) +gal_a11y_e_cell_popup_class_init (GalA11yECellPopupClass *class) { parent_class = g_type_class_ref (PARENT_TYPE); } diff --git a/widgets/table/gal-a11y-e-cell-popup.h b/widgets/table/gal-a11y-e-cell-popup.h index b96aa9392c..fdf20802a1 100644 --- a/widgets/table/gal-a11y-e-cell-popup.h +++ b/widgets/table/gal-a11y-e-cell-popup.h @@ -24,7 +24,6 @@ #ifndef __GAL_A11Y_E_CELL_POPUP_H__ #define __GAL_A11Y_E_CELL_POPUP_H__ -#include <glib-object.h> #include <table/e-table-item.h> #include <table/gal-a11y-e-cell.h> #include <atk/atkgobjectaccessible.h> diff --git a/widgets/table/gal-a11y-e-cell-registry.c b/widgets/table/gal-a11y-e-cell-registry.c index c1c3b441e7..863813348d 100644 --- a/widgets/table/gal-a11y-e-cell-registry.c +++ b/widgets/table/gal-a11y-e-cell-registry.c @@ -47,9 +47,9 @@ gal_a11y_e_cell_registry_finalize (GObject *obj) } static void -gal_a11y_e_cell_registry_class_init (GalA11yECellRegistryClass *klass) +gal_a11y_e_cell_registry_class_init (GalA11yECellRegistryClass *class) { - GObjectClass *object_class = G_OBJECT_CLASS (klass); + GObjectClass *object_class = G_OBJECT_CLASS (class); parent_class = g_type_class_ref (PARENT_TYPE); diff --git a/widgets/table/gal-a11y-e-cell-registry.h b/widgets/table/gal-a11y-e-cell-registry.h index 189da02b02..de8b21b701 100644 --- a/widgets/table/gal-a11y-e-cell-registry.h +++ b/widgets/table/gal-a11y-e-cell-registry.h @@ -23,7 +23,6 @@ #ifndef __GAL_A11Y_E_CELL_REGISTRY_H__ #define __GAL_A11Y_E_CELL_REGISTRY_H__ -#include <glib-object.h> #include <atk/atkobject.h> #include <table/e-table-item.h> #include <table/e-cell.h> diff --git a/widgets/table/gal-a11y-e-cell-toggle.c b/widgets/table/gal-a11y-e-cell-toggle.c index fcea3ec2a1..660a0ebd9a 100644 --- a/widgets/table/gal-a11y-e-cell-toggle.c +++ b/widgets/table/gal-a11y-e-cell-toggle.c @@ -30,7 +30,7 @@ #define PARENT_TYPE (gal_a11y_e_cell_get_type ()) static GObjectClass *parent_class; -static void gal_a11y_e_cell_toggle_class_init (GalA11yECellToggleClass *klass); +static void gal_a11y_e_cell_toggle_class_init (GalA11yECellToggleClass *class); static void gal_a11y_e_cell_toggle_dispose (GObject *object) @@ -78,9 +78,9 @@ gal_a11y_e_cell_toggle_get_type (void) } static void -gal_a11y_e_cell_toggle_class_init (GalA11yECellToggleClass *klass) +gal_a11y_e_cell_toggle_class_init (GalA11yECellToggleClass *class) { - GObjectClass *object_class = G_OBJECT_CLASS (klass); + GObjectClass *object_class = G_OBJECT_CLASS (class); object_class->dispose = gal_a11y_e_cell_toggle_dispose; parent_class = g_type_class_ref (PARENT_TYPE); diff --git a/widgets/table/gal-a11y-e-cell-tree.c b/widgets/table/gal-a11y-e-cell-tree.c index 776fc692c6..1a95c46a90 100644 --- a/widgets/table/gal-a11y-e-cell-tree.c +++ b/widgets/table/gal-a11y-e-cell-tree.c @@ -144,7 +144,7 @@ ectr_do_action_collapse (AtkAction *action) } static void -ectr_class_init (GalA11yECellTreeClass *klass) +ectr_class_init (GalA11yECellTreeClass *class) { a11y_parent_class = g_type_class_ref (A11Y_PARENT_TYPE); } diff --git a/widgets/table/gal-a11y-e-cell-tree.h b/widgets/table/gal-a11y-e-cell-tree.h index fedd9e5fbd..18ccf9c7bc 100644 --- a/widgets/table/gal-a11y-e-cell-tree.h +++ b/widgets/table/gal-a11y-e-cell-tree.h @@ -23,7 +23,6 @@ #ifndef __GAL_A11Y_E_CELL_TREE_H__ #define __GAL_A11Y_E_CELL_TREE_H__ -#include <glib-object.h> #include <table/e-table-item.h> #include <table/e-cell-tree.h> #include "gal-a11y-e-cell.h" diff --git a/widgets/table/gal-a11y-e-cell-vbox.c b/widgets/table/gal-a11y-e-cell-vbox.c index df3e00bff4..1fa24f821a 100644 --- a/widgets/table/gal-a11y-e-cell-vbox.c +++ b/widgets/table/gal-a11y-e-cell-vbox.c @@ -147,10 +147,10 @@ ecv_ref_accessible_at_point (AtkComponent *component, } static void -ecv_class_init (GalA11yECellVboxClass *klass) +ecv_class_init (GalA11yECellVboxClass *class) { - GObjectClass *object_class = G_OBJECT_CLASS (klass); - AtkObjectClass *a11y_class = ATK_OBJECT_CLASS (klass); + GObjectClass *object_class = G_OBJECT_CLASS (class); + AtkObjectClass *a11y_class = ATK_OBJECT_CLASS (class); parent_class = g_type_class_ref (PARENT_TYPE); object_class->dispose = ecv_dispose; diff --git a/widgets/table/gal-a11y-e-cell.c b/widgets/table/gal-a11y-e-cell.c index b2962ba96c..65a1fe9759 100644 --- a/widgets/table/gal-a11y-e-cell.c +++ b/widgets/table/gal-a11y-e-cell.c @@ -228,10 +228,10 @@ gal_a11y_e_cell_atk_component_iface_init (AtkComponentIface *iface) } static void -gal_a11y_e_cell_class_init (GalA11yECellClass *klass) +gal_a11y_e_cell_class_init (GalA11yECellClass *class) { - AtkObjectClass *atk_object_class = ATK_OBJECT_CLASS (klass); - GObjectClass *object_class = G_OBJECT_CLASS (klass); + AtkObjectClass *atk_object_class = ATK_OBJECT_CLASS (class); + GObjectClass *object_class = G_OBJECT_CLASS (class); parent_class = g_type_class_ref (PARENT_TYPE); diff --git a/widgets/table/gal-a11y-e-cell.h b/widgets/table/gal-a11y-e-cell.h index aa02aff79c..48c7d2bec8 100644 --- a/widgets/table/gal-a11y-e-cell.h +++ b/widgets/table/gal-a11y-e-cell.h @@ -23,7 +23,6 @@ #ifndef __GAL_A11Y_E_CELL_H__ #define __GAL_A11Y_E_CELL_H__ -#include <glib-object.h> #include <table/e-table-item.h> #include <table/e-cell.h> diff --git a/widgets/table/gal-a11y-e-table-click-to-add-factory.c b/widgets/table/gal-a11y-e-table-click-to-add-factory.c index 1208241179..e13e6599b4 100644 --- a/widgets/table/gal-a11y-e-table-click-to-add-factory.c +++ b/widgets/table/gal-a11y-e-table-click-to-add-factory.c @@ -56,9 +56,9 @@ gal_a11y_e_table_click_to_add_factory_create_accessible (GObject *obj) } static void -gal_a11y_e_table_click_to_add_factory_class_init (GalA11yETableClickToAddFactoryClass *klass) +gal_a11y_e_table_click_to_add_factory_class_init (GalA11yETableClickToAddFactoryClass *class) { - AtkObjectFactoryClass *factory_class = ATK_OBJECT_FACTORY_CLASS (klass); + AtkObjectFactoryClass *factory_class = ATK_OBJECT_FACTORY_CLASS (class); parent_class = g_type_class_ref (PARENT_TYPE); diff --git a/widgets/table/gal-a11y-e-table-click-to-add-factory.h b/widgets/table/gal-a11y-e-table-click-to-add-factory.h index 5321ccd241..c8f9782a7e 100644 --- a/widgets/table/gal-a11y-e-table-click-to-add-factory.h +++ b/widgets/table/gal-a11y-e-table-click-to-add-factory.h @@ -23,7 +23,6 @@ #ifndef __GAL_A11Y_E_TABLE_CLICK_TO_ADD_FACTORY_H__ #define __GAL_A11Y_E_TABLE_CLICK_TO_ADD_FACTORY_H__ -#include <glib-object.h> #include <atk/atkobjectfactory.h> #define GAL_A11Y_TYPE_E_TABLE_CLICK_TO_ADD_FACTORY (gal_a11y_e_table_item_factory_get_type ()) diff --git a/widgets/table/gal-a11y-e-table-click-to-add.c b/widgets/table/gal-a11y-e-table-click-to-add.c index 32bee99f07..05f145f6ed 100644 --- a/widgets/table/gal-a11y-e-table-click-to-add.c +++ b/widgets/table/gal-a11y-e-table-click-to-add.c @@ -181,9 +181,9 @@ etcta_ref_state_set (AtkObject *accessible) } static void -etcta_class_init (GalA11yETableClickToAddClass *klass) +etcta_class_init (GalA11yETableClickToAddClass *class) { - AtkObjectClass *atk_object_class = ATK_OBJECT_CLASS (klass); + AtkObjectClass *atk_object_class = ATK_OBJECT_CLASS (class); parent_class = g_type_class_ref (PARENT_TYPE); @@ -335,7 +335,7 @@ gal_a11y_e_table_click_to_add_init (void) { if (atk_get_root ()) atk_registry_set_factory_type (atk_get_default_registry (), - E_TABLE_CLICK_TO_ADD_TYPE, + E_TYPE_TABLE_CLICK_TO_ADD, gal_a11y_e_table_click_to_add_factory_get_type ()); } diff --git a/widgets/table/gal-a11y-e-table-click-to-add.h b/widgets/table/gal-a11y-e-table-click-to-add.h index 0d1507f79d..8d95a00baa 100644 --- a/widgets/table/gal-a11y-e-table-click-to-add.h +++ b/widgets/table/gal-a11y-e-table-click-to-add.h @@ -22,7 +22,6 @@ #ifndef __GAL_A11Y_E_TABLE_CLICK_TO_ADD_H__ #define __GAL_A11Y_E_TABLE_CLICK_TO_ADD_H__ -#include <glib-object.h> #include <table/e-table-item.h> #include <atk/atkgobjectaccessible.h> diff --git a/widgets/table/gal-a11y-e-table-column-header.c b/widgets/table/gal-a11y-e-table-column-header.c index c2f3abe91a..6eec994eb2 100644 --- a/widgets/table/gal-a11y-e-table-column-header.c +++ b/widgets/table/gal-a11y-e-table-column-header.c @@ -86,17 +86,17 @@ gal_a11y_e_table_column_header_dispose (GObject *object) } static void -etch_class_init (GalA11yETableColumnHeaderClass *klass) +etch_class_init (GalA11yETableColumnHeaderClass *class) { - AtkObjectClass *class = ATK_OBJECT_CLASS (klass); - GObjectClass *object_class = G_OBJECT_CLASS (klass); + AtkObjectClass *atk_object_class = ATK_OBJECT_CLASS (class); + GObjectClass *object_class = G_OBJECT_CLASS (class); parent_class = g_type_class_ref (PARENT_TYPE); object_class->dispose = gal_a11y_e_table_column_header_dispose; - class->ref_state_set = gal_a11y_e_table_column_header_ref_state_set; - class->initialize = gal_a11y_e_table_column_header_real_initialize; + atk_object_class->ref_state_set = gal_a11y_e_table_column_header_ref_state_set; + atk_object_class->initialize = gal_a11y_e_table_column_header_real_initialize; } inline static GObject * diff --git a/widgets/table/gal-a11y-e-table-column-header.h b/widgets/table/gal-a11y-e-table-column-header.h index ec9a74b868..20d41004f2 100644 --- a/widgets/table/gal-a11y-e-table-column-header.h +++ b/widgets/table/gal-a11y-e-table-column-header.h @@ -24,7 +24,6 @@ #ifndef __GAL_A11Y_E_TABLE_COLUMN_HEADER_H__ #define __GAL_A11Y_E_TABLE_COLUMN_HEADER_H__ -#include <glib-object.h> #include <atk/atkgobjectaccessible.h> #define GAL_A11Y_TYPE_E_TABLE_COLUMN_HEADER (gal_a11y_e_table_column_header_get_type ()) diff --git a/widgets/table/gal-a11y-e-table-factory.c b/widgets/table/gal-a11y-e-table-factory.c index 5e99c13bb9..face3ad06b 100644 --- a/widgets/table/gal-a11y-e-table-factory.c +++ b/widgets/table/gal-a11y-e-table-factory.c @@ -48,9 +48,9 @@ gal_a11y_e_table_factory_create_accessible (GObject *obj) } static void -gal_a11y_e_table_factory_class_init (GalA11yETableFactoryClass *klass) +gal_a11y_e_table_factory_class_init (GalA11yETableFactoryClass *class) { - AtkObjectFactoryClass *factory_class = ATK_OBJECT_FACTORY_CLASS (klass); + AtkObjectFactoryClass *factory_class = ATK_OBJECT_FACTORY_CLASS (class); parent_class = g_type_class_ref (PARENT_TYPE); diff --git a/widgets/table/gal-a11y-e-table-factory.h b/widgets/table/gal-a11y-e-table-factory.h index 6caf3d8beb..6f66e6b82a 100644 --- a/widgets/table/gal-a11y-e-table-factory.h +++ b/widgets/table/gal-a11y-e-table-factory.h @@ -24,7 +24,6 @@ #ifndef __GAL_A11Y_E_TABLE_FACTORY_H__ #define __GAL_A11Y_E_TABLE_FACTORY_H__ -#include <glib-object.h> #include <atk/atkobjectfactory.h> #define GAL_A11Y_TYPE_E_TABLE_FACTORY (gal_a11y_e_table_factory_get_type ()) diff --git a/widgets/table/gal-a11y-e-table-item-factory.c b/widgets/table/gal-a11y-e-table-item-factory.c index 0b58e29add..c987b0068a 100644 --- a/widgets/table/gal-a11y-e-table-item-factory.c +++ b/widgets/table/gal-a11y-e-table-item-factory.c @@ -55,9 +55,9 @@ gal_a11y_e_table_item_factory_create_accessible (GObject *obj) } static void -gal_a11y_e_table_item_factory_class_init (GalA11yETableItemFactoryClass *klass) +gal_a11y_e_table_item_factory_class_init (GalA11yETableItemFactoryClass *class) { - AtkObjectFactoryClass *factory_class = ATK_OBJECT_FACTORY_CLASS (klass); + AtkObjectFactoryClass *factory_class = ATK_OBJECT_FACTORY_CLASS (class); parent_class = g_type_class_ref (PARENT_TYPE); diff --git a/widgets/table/gal-a11y-e-table-item-factory.h b/widgets/table/gal-a11y-e-table-item-factory.h index a08cfeb84b..c2995eaaf0 100644 --- a/widgets/table/gal-a11y-e-table-item-factory.h +++ b/widgets/table/gal-a11y-e-table-item-factory.h @@ -23,7 +23,6 @@ #ifndef __GAL_A11Y_E_TABLE_ITEM_FACTORY_H__ #define __GAL_A11Y_E_TABLE_ITEM_FACTORY_H__ -#include <glib-object.h> #include <atk/atkobjectfactory.h> #define GAL_A11Y_TYPE_E_TABLE_ITEM_FACTORY (gal_a11y_e_table_item_factory_get_type ()) diff --git a/widgets/table/gal-a11y-e-table-item.c b/widgets/table/gal-a11y-e-table-item.c index 3938bd02ec..218265ecdd 100644 --- a/widgets/table/gal-a11y-e-table-item.c +++ b/widgets/table/gal-a11y-e-table-item.c @@ -917,10 +917,10 @@ eti_real_initialize (AtkObject *obj, } static void -eti_class_init (GalA11yETableItemClass *klass) +eti_class_init (GalA11yETableItemClass *class) { - AtkObjectClass *atk_object_class = ATK_OBJECT_CLASS (klass); - GObjectClass *object_class = G_OBJECT_CLASS (klass); + AtkObjectClass *atk_object_class = ATK_OBJECT_CLASS (class); + GObjectClass *object_class = G_OBJECT_CLASS (class); quark_accessible_object = g_quark_from_static_string ("gtk-accessible-object"); @@ -1341,7 +1341,7 @@ gal_a11y_e_table_item_init (void) { if (atk_get_root ()) atk_registry_set_factory_type (atk_get_default_registry (), - E_TABLE_ITEM_TYPE, + E_TYPE_TABLE_ITEM, gal_a11y_e_table_item_factory_get_type ()); } diff --git a/widgets/table/gal-a11y-e-table-item.h b/widgets/table/gal-a11y-e-table-item.h index 90861a14ec..b77c5c3e93 100644 --- a/widgets/table/gal-a11y-e-table-item.h +++ b/widgets/table/gal-a11y-e-table-item.h @@ -24,7 +24,6 @@ #ifndef __GAL_A11Y_E_TABLE_ITEM_H__ #define __GAL_A11Y_E_TABLE_ITEM_H__ -#include <glib-object.h> #include <table/e-table-item.h> #include <atk/atkgobjectaccessible.h> diff --git a/widgets/table/gal-a11y-e-table.c b/widgets/table/gal-a11y-e-table.c index 1bf522767b..7139b41fe3 100644 --- a/widgets/table/gal-a11y-e-table.c +++ b/widgets/table/gal-a11y-e-table.c @@ -200,9 +200,9 @@ et_get_layer (AtkComponent *component) } static void -et_class_init (GalA11yETableClass *klass) +et_class_init (GalA11yETableClass *class) { - AtkObjectClass *atk_object_class = ATK_OBJECT_CLASS (klass); + AtkObjectClass *atk_object_class = ATK_OBJECT_CLASS (class); parent_class = g_type_class_ref (PARENT_TYPE); @@ -305,7 +305,7 @@ gal_a11y_e_table_init (void) { if (atk_get_root ()) atk_registry_set_factory_type (atk_get_default_registry (), - E_TABLE_TYPE, + E_TYPE_TABLE, gal_a11y_e_table_factory_get_type ()); } diff --git a/widgets/table/gal-a11y-e-tree-factory.c b/widgets/table/gal-a11y-e-tree-factory.c index e3cf441974..cf864ca283 100644 --- a/widgets/table/gal-a11y-e-tree-factory.c +++ b/widgets/table/gal-a11y-e-tree-factory.c @@ -47,9 +47,9 @@ gal_a11y_e_tree_factory_create_accessible (GObject *obj) } static void -gal_a11y_e_tree_factory_class_init (GalA11yETreeFactoryClass *klass) +gal_a11y_e_tree_factory_class_init (GalA11yETreeFactoryClass *class) { - AtkObjectFactoryClass *factory_class = ATK_OBJECT_FACTORY_CLASS (klass); + AtkObjectFactoryClass *factory_class = ATK_OBJECT_FACTORY_CLASS (class); parent_class = g_type_class_ref (PARENT_TYPE); diff --git a/widgets/table/gal-a11y-e-tree-factory.h b/widgets/table/gal-a11y-e-tree-factory.h index 640261acf2..a2e44445a0 100644 --- a/widgets/table/gal-a11y-e-tree-factory.h +++ b/widgets/table/gal-a11y-e-tree-factory.h @@ -23,7 +23,6 @@ #ifndef __GAL_A11Y_E_TREE_FACTORY_H__ #define __GAL_A11Y_E_TREE_FACTORY_H__ -#include <glib-object.h> #include <atk/atkobjectfactory.h> #define GAL_A11Y_TYPE_E_TREE_FACTORY (gal_a11y_e_table_factory_get_type ()) diff --git a/widgets/table/gal-a11y-e-tree.c b/widgets/table/gal-a11y-e-tree.c index 87dc8f1618..193d3eb9d7 100644 --- a/widgets/table/gal-a11y-e-tree.c +++ b/widgets/table/gal-a11y-e-tree.c @@ -98,9 +98,9 @@ et_get_layer (AtkComponent *component) } static void -et_class_init (GalA11yETreeClass *klass) +et_class_init (GalA11yETreeClass *class) { - AtkObjectClass *atk_object_class = ATK_OBJECT_CLASS (klass); + AtkObjectClass *atk_object_class = ATK_OBJECT_CLASS (class); parent_class = g_type_class_ref (PARENT_TYPE); @@ -190,7 +190,7 @@ gal_a11y_e_tree_init (void) { if (atk_get_root ()) atk_registry_set_factory_type (atk_get_default_registry (), - E_TREE_TYPE, + E_TYPE_TREE, gal_a11y_e_tree_factory_get_type ()); } |