From ac1b942dd83034c5656b2e4dbf039c975b130047 Mon Sep 17 00:00:00 2001 From: "Dirk-Jan C. Binnema" Date: Sat, 27 Nov 2010 13:31:26 +0200 Subject: [PATCH] * mug: fix header clearing + code reindentation --- toys/mug/mug-msg-list-view.c | 447 ++++++++++++++++------------------- toys/mug/mug-msg-list-view.h | 30 +-- toys/mug/mug-msg-view.c | 307 ++++++++++++------------ toys/mug/mug-msg-view.h | 18 +- toys/mug/mug-query-bar.c | 104 ++++---- toys/mug/mug-query-bar.h | 21 +- toys/mug/mug-shortcuts.c | 104 ++++---- toys/mug/mug-shortcuts.h | 20 +- toys/mug/mug.cc | 369 ++++++++++++++--------------- 9 files changed, 664 insertions(+), 756 deletions(-) diff --git a/toys/mug/mug-msg-list-view.c b/toys/mug/mug-msg-list-view.c index 10ef478e..b2dfa0ae 100644 --- a/toys/mug/mug-msg-list-view.c +++ b/toys/mug/mug-msg-list-view.c @@ -23,9 +23,9 @@ /* include other impl specific header files */ /* 'private'/'protected' functions */ -static void mug_msg_list_view_class_init (MugMsgListViewClass *klass); -static void mug_msg_list_view_init (MugMsgListView *obj); -static void mug_msg_list_view_finalize (GObject *obj); +static void mug_msg_list_view_class_init(MugMsgListViewClass * klass); +static void mug_msg_list_view_init(MugMsgListView * obj); +static void mug_msg_list_view_finalize(GObject * obj); /* list my signals */ enum { @@ -34,7 +34,6 @@ enum { LAST_SIGNAL }; - enum { MUG_COL_DATESTR, MUG_COL_MAILDIR, @@ -62,262 +61,236 @@ struct _MugMsgListViewPrivate { static GtkTreeViewClass *parent_class = NULL; /* uncomment the following if you have defined any signals */ -static guint signals[LAST_SIGNAL] = {0}; +static guint signals[LAST_SIGNAL] = { 0 }; -G_DEFINE_TYPE (MugMsgListView, mug_msg_list_view, GTK_TYPE_TREE_VIEW); +G_DEFINE_TYPE(MugMsgListView, mug_msg_list_view, GTK_TYPE_TREE_VIEW); - -static void -mug_msg_list_view_class_init (MugMsgListViewClass *klass) +static void mug_msg_list_view_class_init(MugMsgListViewClass * klass) { GObjectClass *gobject_class; - gobject_class = (GObjectClass*) klass; + gobject_class = (GObjectClass *) klass; - parent_class = g_type_class_peek_parent (klass); + parent_class = g_type_class_peek_parent(klass); gobject_class->finalize = mug_msg_list_view_finalize; - g_type_class_add_private (gobject_class, - sizeof(MugMsgListViewPrivate)); + g_type_class_add_private(gobject_class, sizeof(MugMsgListViewPrivate)); - signals[MUG_MSG_SELECTED] = - g_signal_new ("msg-selected", - G_TYPE_FROM_CLASS(gobject_class), - G_SIGNAL_RUN_FIRST, - G_STRUCT_OFFSET(MugMsgListViewClass, - msg_selected), - NULL, NULL, - g_cclosure_marshal_VOID__STRING, - G_TYPE_NONE, 1, G_TYPE_STRING); - signals[MUG_ERROR_OCCURED] = - g_signal_new ("error-occured", - G_TYPE_FROM_CLASS(gobject_class), - G_SIGNAL_RUN_FIRST, - G_STRUCT_OFFSET(MugMsgListViewClass, - error_occured), - NULL, NULL, - g_cclosure_marshal_VOID__UINT, - G_TYPE_NONE, 1, G_TYPE_UINT); + signals[MUG_MSG_SELECTED] = + g_signal_new("msg-selected", + G_TYPE_FROM_CLASS(gobject_class), + G_SIGNAL_RUN_FIRST, + G_STRUCT_OFFSET(MugMsgListViewClass, + msg_selected), + NULL, NULL, + g_cclosure_marshal_VOID__STRING, + G_TYPE_NONE, 1, G_TYPE_STRING); + signals[MUG_ERROR_OCCURED] = + g_signal_new("error-occured", + G_TYPE_FROM_CLASS(gobject_class), + G_SIGNAL_RUN_FIRST, + G_STRUCT_OFFSET(MugMsgListViewClass, + error_occured), + NULL, NULL, + g_cclosure_marshal_VOID__UINT, + G_TYPE_NONE, 1, G_TYPE_UINT); } - -static void -on_cursor_changed (GtkTreeView *tview, MugMsgListView *lst) +static void on_cursor_changed(GtkTreeView * tview, MugMsgListView * lst) { GtkTreeSelection *sel; GtkTreeIter iter; MugMsgListViewPrivate *priv; priv = MUG_MSG_LIST_VIEW_GET_PRIVATE(tview); - - sel = gtk_tree_view_get_selection (tview); + + sel = gtk_tree_view_get_selection(tview); if (!sel) - return; /* hmmm */ - if (gtk_tree_selection_get_selected (sel, NULL, &iter)) { + return; /* hmmm */ + if (gtk_tree_selection_get_selected(sel, NULL, &iter)) { char *path; - gtk_tree_model_get (GTK_TREE_MODEL(priv->_store), &iter, - MUG_COL_PATH, &path, -1); - g_signal_emit (G_OBJECT(lst), - signals[MUG_MSG_SELECTED], 0, - path); - g_free (path); + gtk_tree_model_get(GTK_TREE_MODEL(priv->_store), &iter, + MUG_COL_PATH, &path, -1); + g_signal_emit(G_OBJECT(lst), + signals[MUG_MSG_SELECTED], 0, path); + g_free(path); } } - static void -treecell_func (GtkTreeViewColumn *tree_column, GtkCellRenderer *renderer, - GtkTreeModel *tree_model, GtkTreeIter *iter, gpointer data) +treecell_func(GtkTreeViewColumn * tree_column, GtkCellRenderer * renderer, + GtkTreeModel * tree_model, GtkTreeIter * iter, gpointer data) { MuMsgFlags flags; MuMsgPrio prio; - - gtk_tree_model_get (tree_model, iter, - MUG_COL_FLAGS, &flags, - MUG_COL_PRIO, &prio, - -1); - - g_object_set (G_OBJECT(renderer), - "weight", (flags & MU_MSG_FLAG_NEW) ? 800 : 400, - "weight", (flags & MU_MSG_FLAG_SEEN) ? 400 : 800, - "foreground", prio == MU_MSG_PRIO_HIGH ? "red" : NULL, - NULL); -} + gtk_tree_model_get(tree_model, iter, + MUG_COL_FLAGS, &flags, MUG_COL_PRIO, &prio, -1); + + g_object_set(G_OBJECT(renderer), + "weight", (flags & MU_MSG_FLAG_NEW) ? 800 : 400, + "weight", (flags & MU_MSG_FLAG_SEEN) ? 400 : 800, + "foreground", prio == MU_MSG_PRIO_HIGH ? "red" : NULL, + NULL); +} /* sortcolidx == -1 means 'sortcolidx = colidx' */ static void -append_col (GtkTreeView *treeview, const char* label, int colidx, int sortcolidx, - gint maxwidth) +append_col(GtkTreeView * treeview, const char *label, int colidx, + int sortcolidx, gint maxwidth) { GtkTreeViewColumn *col; GtkCellRenderer *renderer; - - renderer = gtk_cell_renderer_text_new (); - g_object_set (G_OBJECT(renderer),"ellipsize", PANGO_ELLIPSIZE_END, NULL); - - col = gtk_tree_view_column_new_with_attributes (label, renderer, "text", - colidx, NULL); - g_object_set (G_OBJECT(col), "resizable", TRUE, NULL); - gtk_tree_view_column_set_sort_indicator (col, TRUE); + renderer = gtk_cell_renderer_text_new(); + g_object_set(G_OBJECT(renderer), "ellipsize", PANGO_ELLIPSIZE_END, + NULL); + + col = gtk_tree_view_column_new_with_attributes(label, renderer, "text", + colidx, NULL); + g_object_set(G_OBJECT(col), "resizable", TRUE, NULL); + + gtk_tree_view_column_set_sort_indicator(col, TRUE); if (sortcolidx == -1) sortcolidx = colidx; - gtk_tree_view_column_set_sort_column_id (col, sortcolidx); - + gtk_tree_view_column_set_sort_column_id(col, sortcolidx); + if (maxwidth) { - gtk_tree_view_column_set_sizing (col, GTK_TREE_VIEW_COLUMN_FIXED); - gtk_tree_view_column_set_fixed_width (col, maxwidth); - gtk_tree_view_column_set_expand (col, FALSE); - } else { - //gtk_tree_view_column_set_sizing (col, GTK_TREE_VIEW_COLUMN_GROW_ONLY); - gtk_tree_view_column_set_expand (col, TRUE); - } + gtk_tree_view_column_set_sizing(col, + GTK_TREE_VIEW_COLUMN_FIXED); + gtk_tree_view_column_set_fixed_width(col, maxwidth); + gtk_tree_view_column_set_expand(col, FALSE); + } else + gtk_tree_view_column_set_expand(col, TRUE); - gtk_tree_view_column_set_cell_data_func (col, renderer, - (GtkTreeCellDataFunc) treecell_func, - NULL, NULL); + gtk_tree_view_column_set_cell_data_func(col, renderer, + (GtkTreeCellDataFunc) + treecell_func, NULL, NULL); - gtk_tree_view_append_column (treeview, col); + gtk_tree_view_append_column(treeview, col); } -static void -mug_msg_list_view_init (MugMsgListView *obj) +static void mug_msg_list_view_init(MugMsgListView * obj) { MugMsgListViewPrivate *priv; GtkTreeView *tview; - - priv = MUG_MSG_LIST_VIEW_GET_PRIVATE(obj); - - priv->_xpath = priv->_query = NULL; - priv->_store = gtk_list_store_new (MUG_N_COLS, - G_TYPE_STRING, /* date */ - G_TYPE_STRING, /* folder */ - G_TYPE_STRING, /* flagstr */ - G_TYPE_STRING, /* from */ - G_TYPE_STRING, /* to */ - G_TYPE_STRING, /* subject */ - G_TYPE_STRING, /* path */ - G_TYPE_UINT, /* prio */ - G_TYPE_UINT, /* flags */ - G_TYPE_INT); /* timeval */ - tview = GTK_TREE_VIEW (obj); - gtk_tree_view_set_model (tview, GTK_TREE_MODEL(priv->_store)); - gtk_tree_view_set_headers_clickable (GTK_TREE_VIEW(obj), TRUE); - gtk_tree_view_set_grid_lines (GTK_TREE_VIEW(obj), - GTK_TREE_VIEW_GRID_LINES_VERTICAL); - gtk_tree_view_set_rules_hint (GTK_TREE_VIEW(obj), TRUE); - - append_col (tview, "Date", MUG_COL_DATESTR, MUG_COL_TIME, 80); - append_col (tview, "Folder", MUG_COL_MAILDIR, -1, 60); - append_col (tview, "F", MUG_COL_FLAGSSTR, -1, 25); - append_col (tview, "From", MUG_COL_FROM, -1, 0); - append_col (tview, "To", MUG_COL_TO, -1, 0); - append_col (tview, "Subject", MUG_COL_SUBJECT, -1, 0); - - g_signal_connect (G_OBJECT(obj), "cursor-changed", - G_CALLBACK(on_cursor_changed), obj); + priv = MUG_MSG_LIST_VIEW_GET_PRIVATE(obj); + + priv->_xpath = priv->_query = NULL; + priv->_store = gtk_list_store_new(MUG_N_COLS, G_TYPE_STRING, /* date */ + G_TYPE_STRING, /* folder */ + G_TYPE_STRING, /* flagstr */ + G_TYPE_STRING, /* from */ + G_TYPE_STRING, /* to */ + G_TYPE_STRING, /* subject */ + G_TYPE_STRING, /* path */ + G_TYPE_UINT, /* prio */ + G_TYPE_UINT, /* flags */ + G_TYPE_INT); /* timeval */ + + tview = GTK_TREE_VIEW(obj); + gtk_tree_view_set_model(tview, GTK_TREE_MODEL(priv->_store)); + gtk_tree_view_set_headers_clickable(GTK_TREE_VIEW(obj), TRUE); + gtk_tree_view_set_grid_lines(GTK_TREE_VIEW(obj), + GTK_TREE_VIEW_GRID_LINES_VERTICAL); + gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(obj), TRUE); + + append_col(tview, "Date", MUG_COL_DATESTR, MUG_COL_TIME, 80); + append_col(tview, "Folder", MUG_COL_MAILDIR, -1, 60); + append_col(tview, "F", MUG_COL_FLAGSSTR, -1, 25); + append_col(tview, "From", MUG_COL_FROM, -1, 0); + append_col(tview, "To", MUG_COL_TO, -1, 0); + append_col(tview, "Subject", MUG_COL_SUBJECT, -1, 0); + + g_signal_connect(G_OBJECT(obj), "cursor-changed", + G_CALLBACK(on_cursor_changed), obj); } -static void -mug_msg_list_view_finalize (GObject *obj) -{ +static void mug_msg_list_view_finalize(GObject * obj) +{ MugMsgListViewPrivate *priv; priv = MUG_MSG_LIST_VIEW_GET_PRIVATE(obj); - if (priv->_store) - g_object_unref (priv->_store); + if (priv->_store) + g_object_unref(priv->_store); - g_free (priv->_xpath); - g_free (priv->_query); - - G_OBJECT_CLASS(parent_class)->finalize (obj); + g_free(priv->_xpath); + g_free(priv->_query); + + G_OBJECT_CLASS(parent_class)->finalize(obj); } -void -mug_msg_list_view_move_first (MugMsgListView *self) +void mug_msg_list_view_move_first(MugMsgListView * self) { GtkTreePath *path; - - g_return_if_fail (MUG_IS_MSG_LIST_VIEW(self)); - path = gtk_tree_path_new_first (); - gtk_tree_view_set_cursor (GTK_TREE_VIEW(self), path, - NULL, FALSE); - - gtk_tree_path_free (path); + g_return_if_fail(MUG_IS_MSG_LIST_VIEW(self)); + + path = gtk_tree_path_new_first(); + gtk_tree_view_set_cursor(GTK_TREE_VIEW(self), path, NULL, FALSE); + + gtk_tree_path_free(path); } - -static gboolean -msg_list_view_move (MugMsgListView *self, gboolean next) +static gboolean msg_list_view_move(MugMsgListView * self, gboolean next) { GtkTreePath *path; - - gtk_tree_view_get_cursor (GTK_TREE_VIEW(self), &path, NULL); + + gtk_tree_view_get_cursor(GTK_TREE_VIEW(self), &path, NULL); if (!path) return FALSE; if (next) - gtk_tree_path_next (path); + gtk_tree_path_next(path); else - gtk_tree_path_prev (path); - - gtk_tree_view_set_cursor (GTK_TREE_VIEW(self), path, - NULL, FALSE); - gtk_tree_path_free (path); - + gtk_tree_path_prev(path); + + gtk_tree_view_set_cursor(GTK_TREE_VIEW(self), path, NULL, FALSE); + gtk_tree_path_free(path); + return TRUE; } - -gboolean -mug_msg_list_view_move_next (MugMsgListView *self) +gboolean mug_msg_list_view_move_next(MugMsgListView * self) { - g_return_val_if_fail (MUG_IS_MSG_LIST_VIEW(self), FALSE); + g_return_val_if_fail(MUG_IS_MSG_LIST_VIEW(self), FALSE); - return msg_list_view_move (self, TRUE); + return msg_list_view_move(self, TRUE); } - -gboolean -mug_msg_list_view_move_prev (MugMsgListView *self) +gboolean mug_msg_list_view_move_prev(MugMsgListView * self) { - g_return_val_if_fail (MUG_IS_MSG_LIST_VIEW(self), FALSE); + g_return_val_if_fail(MUG_IS_MSG_LIST_VIEW(self), FALSE); - return msg_list_view_move (self, FALSE); + return msg_list_view_move(self, FALSE); } -GtkWidget* -mug_msg_list_view_new (const char *xpath) +GtkWidget *mug_msg_list_view_new(const char *xpath) { GtkWidget *w; MugMsgListViewPrivate *priv; - g_return_val_if_fail (xpath, NULL); - - w = GTK_WIDGET(g_object_new(MUG_TYPE_MSG_LIST_VIEW, NULL)); + g_return_val_if_fail(xpath, NULL); + + w = GTK_WIDGET(g_object_new(MUG_TYPE_MSG_LIST_VIEW, NULL)); priv = MUG_MSG_LIST_VIEW_GET_PRIVATE(w); - priv->_xpath = g_strdup (xpath); + priv->_xpath = g_strdup(xpath); return w; } - -static gchar* -empty_or_display_contact (const gchar* str) +static gchar *empty_or_display_contact(const gchar * str) { if (!str || *str == '\0') - return g_strdup ("-"); + return g_strdup("-"); else - return mu_str_display_contact (str); - + return mu_str_display_contact(str); + } -static MugError -mu_result_to_mug_error (MuResult r) +static MugError mu_result_to_mug_error(MuResult r) { switch (r) { case MU_ERROR_XAPIAN_DIR: @@ -331,127 +304,115 @@ mu_result_to_mug_error (MuResult r) } } - -static MuMsgIter * -run_query (const char *xpath, const char *query, - MugMsgListView *self) +static MuMsgIter *run_query(const char *xpath, const char *query, + MugMsgListView * self) { GError *err; MuQuery *xapian; MuMsgIter *iter; err = NULL; - xapian = mu_query_new (xpath, &err); + xapian = mu_query_new(xpath, &err); if (!xapian) { - g_warning ("Error: %s", err->message); - g_signal_emit (G_OBJECT(self), - signals[MUG_ERROR_OCCURED], 0, - mu_result_to_mug_error (err->code)); - g_error_free (err); + g_warning("Error: %s", err->message); + g_signal_emit(G_OBJECT(self), + signals[MUG_ERROR_OCCURED], 0, + mu_result_to_mug_error(err->code)); + g_error_free(err); return NULL; } - iter = mu_query_run (xapian, query, - MU_MSG_FIELD_ID_DATE, - TRUE, 0, &err); - mu_query_destroy (xapian); + iter = mu_query_run(xapian, query, MU_MSG_FIELD_ID_DATE, TRUE, 0, &err); + mu_query_destroy(xapian); if (!iter) { - g_warning ("Error: %s", err->message); - g_signal_emit (G_OBJECT(self), - signals[MUG_ERROR_OCCURED], 0, - mu_result_to_mug_error (err->code)); - g_error_free (err); + g_warning("Error: %s", err->message); + g_signal_emit(G_OBJECT(self), + signals[MUG_ERROR_OCCURED], 0, + mu_result_to_mug_error(err->code)); + g_error_free(err); return NULL; } - + return iter; } -static void -add_row (GtkListStore *store, MuMsgIter *iter) +static void add_row(GtkListStore * store, MuMsgIter * iter) { GtkTreeIter treeiter; const gchar *datestr, *flagstr; gchar *from, *to; time_t timeval; - - timeval = mu_msg_iter_get_date (iter); - datestr = timeval == 0 ? "-" : mu_str_display_date_s (timeval); - from = empty_or_display_contact (mu_msg_iter_get_from(iter)); - to = empty_or_display_contact (mu_msg_iter_get_to(iter)); - flagstr = mu_msg_flags_str_s(mu_msg_iter_get_flags (iter)); - - gtk_list_store_append (store, &treeiter); - gtk_list_store_set (store, &treeiter, - MUG_COL_DATESTR, datestr, - MUG_COL_MAILDIR, mu_msg_iter_get_maildir (iter), - MUG_COL_FLAGSSTR, flagstr, - MUG_COL_FROM, from, - MUG_COL_TO, to, - MUG_COL_SUBJECT,mu_msg_iter_get_subject (iter), - MUG_COL_PATH, mu_msg_iter_get_path (iter), - MUG_COL_PRIO, mu_msg_iter_get_prio(iter), - MUG_COL_FLAGS, mu_msg_iter_get_flags(iter), - MUG_COL_TIME, timeval, - -1); - g_free (from); - g_free (to); + + timeval = mu_msg_iter_get_date(iter); + datestr = timeval == 0 ? "-" : mu_str_display_date_s(timeval); + from = empty_or_display_contact(mu_msg_iter_get_from(iter)); + to = empty_or_display_contact(mu_msg_iter_get_to(iter)); + flagstr = mu_msg_flags_str_s(mu_msg_iter_get_flags(iter)); + + gtk_list_store_append(store, &treeiter); + gtk_list_store_set(store, &treeiter, + MUG_COL_DATESTR, datestr, + MUG_COL_MAILDIR, mu_msg_iter_get_maildir(iter), + MUG_COL_FLAGSSTR, flagstr, + MUG_COL_FROM, from, + MUG_COL_TO, to, + MUG_COL_SUBJECT, mu_msg_iter_get_subject(iter), + MUG_COL_PATH, mu_msg_iter_get_path(iter), + MUG_COL_PRIO, mu_msg_iter_get_prio(iter), + MUG_COL_FLAGS, mu_msg_iter_get_flags(iter), + MUG_COL_TIME, timeval, -1); + g_free(from); + g_free(to); } - static int -update_model (GtkListStore *store, const char *xpath, const char *query, - MugMsgListView *self) +update_model(GtkListStore * store, const char *xpath, const char *query, + MugMsgListView * self) { MuMsgIter *iter; int count; - iter = run_query (xpath, query, self); + iter = run_query(xpath, query, self); if (!iter) { - g_warning ("error: running query failed\n"); + g_warning("error: running query failed\n"); return -1; } - for (count = 0; !mu_msg_iter_is_done (iter); - mu_msg_iter_next (iter), ++count) - add_row (store, iter); - - mu_msg_iter_destroy (iter); + for (count = 0; !mu_msg_iter_is_done(iter); + mu_msg_iter_next(iter), ++count) + add_row(store, iter); + + mu_msg_iter_destroy(iter); return count; } - -int -mug_msg_list_view_query (MugMsgListView *self, const char *query) +int mug_msg_list_view_query(MugMsgListView * self, const char *query) { MugMsgListViewPrivate *priv; gboolean rv; - - g_return_val_if_fail (MUG_IS_MSG_LIST_VIEW(self), FALSE); - - priv = MUG_MSG_LIST_VIEW_GET_PRIVATE(self); - gtk_list_store_clear (priv->_store); - g_free (priv->_query); + g_return_val_if_fail(MUG_IS_MSG_LIST_VIEW(self), FALSE); + + priv = MUG_MSG_LIST_VIEW_GET_PRIVATE(self); + gtk_list_store_clear(priv->_store); + + g_free(priv->_query); priv->_query = query ? g_strdup(query) : NULL; - + if (!query) return TRUE; - - rv = update_model (priv->_store, priv->_xpath, query, - self); - gtk_tree_view_columns_autosize (GTK_TREE_VIEW(self)); - + rv = update_model(priv->_store, priv->_xpath, query, self); + + gtk_tree_view_columns_autosize(GTK_TREE_VIEW(self)); + return rv; } - -const gchar* -mug_msg_list_view_get_query (MugMsgListView *self) +const gchar *mug_msg_list_view_get_query(MugMsgListView * self) { - g_return_val_if_fail (MUG_IS_MSG_LIST_VIEW(self), NULL); - + g_return_val_if_fail(MUG_IS_MSG_LIST_VIEW(self), NULL); + return MUG_MSG_LIST_VIEW_GET_PRIVATE(self)->_query; } diff --git a/toys/mug/mug-msg-list-view.h b/toys/mug/mug-msg-list-view.h index 8d97d4c0..52b2df5a 100644 --- a/toys/mug/mug-msg-list-view.h +++ b/toys/mug/mug-msg-list-view.h @@ -24,7 +24,6 @@ #include G_BEGIN_DECLS - /* convenience macros */ #define MUG_TYPE_MSG_LIST_VIEW (mug_msg_list_view_get_type()) #define MUG_MSG_LIST_VIEW(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),MUG_TYPE_MSG_LIST_VIEW,MugMsgListView)) @@ -32,12 +31,11 @@ G_BEGIN_DECLS #define MUG_IS_MSG_LIST_VIEW(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj),MUG_TYPE_MSG_LIST_VIEW)) #define MUG_IS_MSG_LIST_VIEW_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass),MUG_TYPE_MSG_LIST_VIEW)) #define MUG_MSG_LIST_VIEW_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj),MUG_TYPE_MSG_LIST_VIEW,MugMsgListViewClass)) - -typedef struct _MugMsgListView MugMsgListView; +typedef struct _MugMsgListView MugMsgListView; typedef struct _MugMsgListViewClass MugMsgListViewClass; struct _MugMsgListView { - GtkTreeView parent; + GtkTreeView parent; /* insert public members, if any */ }; @@ -49,32 +47,28 @@ enum _MugError { }; typedef enum _MugError MugError; - struct _MugMsgListViewClass { GtkTreeViewClass parent_class; /* insert signal callback declarations, e.g. */ - void (* msg_selected) (MugMsgListView* obj, const char* msgpath); - void (* error_occured) (MugMsgListView* obj, MugError err); + void (*msg_selected) (MugMsgListView * obj, const char *msgpath); + void (*error_occured) (MugMsgListView * obj, MugError err); }; /* member functions */ -GType mug_msg_list_view_get_type (void) G_GNUC_CONST; +GType mug_msg_list_view_get_type(void) G_GNUC_CONST; /* parameter-less _new function (constructor) */ /* if this is a kind of GtkWidget, it should probably return at GtkWidget* */ -GtkWidget* mug_msg_list_view_new (const char *xpath); +GtkWidget *mug_msg_list_view_new(const char *xpath); -int mug_msg_list_view_query (MugMsgListView *self, const char *query); +int mug_msg_list_view_query(MugMsgListView * self, const char *query); +void mug_msg_list_view_move_first(MugMsgListView * self); -void mug_msg_list_view_move_first (MugMsgListView *self); +gboolean mug_msg_list_view_move_prev(MugMsgListView * self); +gboolean mug_msg_list_view_move_next(MugMsgListView * self); -gboolean mug_msg_list_view_move_prev (MugMsgListView *self); -gboolean mug_msg_list_view_move_next (MugMsgListView *self); - -const gchar* mug_msg_list_view_get_query (MugMsgListView *self); +const gchar *mug_msg_list_view_get_query(MugMsgListView * self); G_END_DECLS - -#endif /* __MUG_MSG_LIST_VIEW_H__ */ - +#endif /* __MUG_MSG_LIST_VIEW_H__ */ diff --git a/toys/mug/mug-msg-view.c b/toys/mug/mug-msg-view.c index 8667653f..c18cd5cb 100644 --- a/toys/mug/mug-msg-view.c +++ b/toys/mug/mug-msg-view.c @@ -17,15 +17,14 @@ ** */ - #include "mug-msg-view.h" #include "mu-msg.h" #include "mu-str.h" /* 'private'/'protected' functions */ -static void mug_msg_view_class_init (MugMsgViewClass *klass); -static void mug_msg_view_init (MugMsgView *obj); -static void mug_msg_view_finalize (GObject *obj); +static void mug_msg_view_class_init(MugMsgViewClass * klass); +static void mug_msg_view_init(MugMsgView * obj); +static void mug_msg_view_finalize(GObject * obj); /* list my signals */ enum { @@ -47,24 +46,24 @@ enum _HeaderRow { }; typedef enum _HeaderRow HeaderRow; -struct _HeaderInfo { - HeaderRow row; - const char *title; +struct _HeaderInfo { + HeaderRow row; + const char *title; }; typedef struct _HeaderInfo HeaderInfo; static const HeaderInfo HEADER_INFO[] = { - {HEADER_ROW_CC, "Cc"}, + {HEADER_ROW_CC, "Cc"}, {HEADER_ROW_SUBJECT, "Subject"}, - {HEADER_ROW_DATE, "Date"} + {HEADER_ROW_DATE, "Date"} }; static const HeaderInfo HEADER_INFO_EXPANDER[] = { - {HEADER_ROW_FROM, "From"}, - {HEADER_ROW_TO, "To"}, - {HEADER_ROW_PATH, "Path"}, - {HEADER_ROW_MSGID, "Message-Id" }, - {HEADER_ROW_SIZE, "Size"} + {HEADER_ROW_FROM, "From"}, + {HEADER_ROW_TO, "To"}, + {HEADER_ROW_PATH, "Path"}, + {HEADER_ROW_MSGID, "Message-Id"}, + {HEADER_ROW_SIZE, "Size"} }; typedef struct _MugMsgViewPrivate MugMsgViewPrivate; @@ -72,32 +71,29 @@ struct _MugMsgViewPrivate { GtkWidget *_headers_area; GtkWidget *_tablemain, *_tableexpander; - GtkWidget *_headervals [HEADER_ROW_NUM]; - + GtkWidget *_headervals[HEADER_ROW_NUM]; + GtkWidget *_expander_header, *_expander; GtkWidget *_view; }; -#define MUG_MSG_VIEW_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE((o), \ - MUG_TYPE_MSG_VIEW, MugMsgViewPrivate)) +#define MUG_MSG_VIEW_GET_PRIVATE(o)(G_TYPE_INSTANCE_GET_PRIVATE((o),MUG_TYPE_MSG_VIEW, MugMsgViewPrivate)) /* globals */ static GtkVBoxClass *parent_class = NULL; /* uncomment the following if you have defined any signals */ /* static guint signals[LAST_SIGNAL] = {0}; */ +G_DEFINE_TYPE(MugMsgView, mug_msg_view, GTK_TYPE_VBOX); -G_DEFINE_TYPE (MugMsgView, mug_msg_view, GTK_TYPE_VBOX); - -static void -mug_msg_view_class_init (MugMsgViewClass *klass) +static void mug_msg_view_class_init(MugMsgViewClass * klass) { GObjectClass *gobject_class; - gobject_class = (GObjectClass*) klass; + gobject_class = (GObjectClass *) klass; - parent_class = g_type_class_peek_parent (klass); + parent_class = g_type_class_peek_parent(klass); gobject_class->finalize = mug_msg_view_finalize; - g_type_class_add_private (gobject_class, sizeof(MugMsgViewPrivate)); + g_type_class_add_private(gobject_class, sizeof(MugMsgViewPrivate)); /* signal definitions go here, e.g.: */ /* signals[MY_SIGNAL_1] = */ @@ -107,198 +103,207 @@ mug_msg_view_class_init (MugMsgViewClass *klass) /* etc. */ } - -static GtkWidget* -create_table (MugMsgViewPrivate *priv, const HeaderInfo *hinfo, guint num) +static GtkWidget *create_table(MugMsgViewPrivate * priv, + const HeaderInfo * hinfo, guint num) { guint i; GtkWidget *table; - - table = gtk_table_new (num, 2, FALSE); - gtk_table_set_col_spacings (GTK_TABLE(table), 5); - + + table = gtk_table_new(num, 2, FALSE); + gtk_table_set_col_spacings(GTK_TABLE(table), 5); + for (i = 0; i < num; ++i) { char *str; GtkWidget *l, *al; - - l = gtk_label_new(NULL); - gtk_misc_set_alignment (GTK_MISC(l), 0.0, 0.5); - - gtk_label_set_justify (GTK_LABEL(l), GTK_JUSTIFY_LEFT); - str = g_strdup_printf ("%s:", hinfo[i].title); - gtk_label_set_markup (GTK_LABEL(l), str); - g_free (str); - al = gtk_alignment_new (0.0, 0.0, 0.0, 0.0); - gtk_container_add (GTK_CONTAINER(al), l); - gtk_table_attach (GTK_TABLE(table), al, 0, 1, i, i+1, - GTK_FILL, 0, 0, 0); - - l = priv->_headervals[hinfo[i].row] = gtk_label_new (NULL); + l = gtk_label_new(NULL); + gtk_misc_set_alignment(GTK_MISC(l), 0.0, 0.5); + + gtk_label_set_justify(GTK_LABEL(l), GTK_JUSTIFY_LEFT); + str = g_strdup_printf("%s:", hinfo[i].title); + gtk_label_set_markup(GTK_LABEL(l), str); + g_free(str); + al = gtk_alignment_new(0.0, 0.0, 0.0, 0.0); - gtk_label_set_selectable (GTK_LABEL(l), TRUE); - - gtk_container_add (GTK_CONTAINER(al), l); - gtk_label_set_justify (GTK_LABEL(l), GTK_JUSTIFY_LEFT); - gtk_label_set_line_wrap_mode (GTK_LABEL(l), PANGO_WRAP_WORD_CHAR); - gtk_label_set_line_wrap (GTK_LABEL(l), FALSE); - gtk_table_attach (GTK_TABLE(table), al, - 1, 2, i, i+1, - GTK_FILL, - 0, 0, 0); + gtk_container_add(GTK_CONTAINER(al), l); + gtk_table_attach(GTK_TABLE(table), al, 0, 1, i, i + 1, + GTK_FILL, 0, 0, 0); + + l = priv->_headervals[hinfo[i].row] = gtk_label_new(NULL); + al = gtk_alignment_new(0.0, 0.0, 0.0, 0.0); + gtk_label_set_selectable(GTK_LABEL(l), TRUE); + + gtk_container_add(GTK_CONTAINER(al), l); + gtk_label_set_justify(GTK_LABEL(l), GTK_JUSTIFY_LEFT); + gtk_label_set_line_wrap_mode(GTK_LABEL(l), + PANGO_WRAP_WORD_CHAR); + gtk_label_set_line_wrap(GTK_LABEL(l), FALSE); + gtk_table_attach(GTK_TABLE(table), al, + 1, 2, i, i + 1, GTK_FILL, 0, 0, 0); } return table; } -static GtkWidget* -headers_area (MugMsgViewPrivate *priv) +static GtkWidget *headers_area(MugMsgViewPrivate * priv) { GtkWidget *scrolled, *vbox; - - priv->_tablemain = create_table (priv, HEADER_INFO, - G_N_ELEMENTS(HEADER_INFO)); - priv->_tableexpander = create_table (priv, HEADER_INFO_EXPANDER, - G_N_ELEMENTS(HEADER_INFO_EXPANDER)); - priv->_expander = gtk_expander_new ("Details"); - gtk_container_add (GTK_CONTAINER(priv->_expander), - priv->_tableexpander); - - vbox = gtk_vbox_new (FALSE, FALSE); - gtk_box_pack_start (GTK_BOX(vbox), priv->_tablemain, FALSE, FALSE, 0); - gtk_box_pack_start (GTK_BOX(vbox), priv->_expander, FALSE, FALSE, 0); - scrolled = gtk_scrolled_window_new (NULL, NULL); - gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW(scrolled), - GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); - gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW(scrolled), vbox); + priv->_tablemain = create_table(priv, HEADER_INFO, + G_N_ELEMENTS(HEADER_INFO)); + priv->_tableexpander = create_table + (priv, HEADER_INFO_EXPANDER, G_N_ELEMENTS(HEADER_INFO_EXPANDER)); + priv->_expander = gtk_expander_new("Details"); + gtk_container_add(GTK_CONTAINER(priv->_expander), priv->_tableexpander); + + vbox = gtk_vbox_new(FALSE, FALSE); + gtk_box_pack_start(GTK_BOX(vbox), priv->_tablemain, FALSE, FALSE, 0); + gtk_box_pack_start(GTK_BOX(vbox), priv->_expander, FALSE, FALSE, 0); + + scrolled = gtk_scrolled_window_new(NULL, NULL); + gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled), + GTK_POLICY_AUTOMATIC, + GTK_POLICY_AUTOMATIC); + gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scrolled), + vbox); return priv->_headers_area = scrolled; } - -static void -mug_msg_view_init (MugMsgView *obj) +static void mug_msg_view_init(MugMsgView * obj) { MugMsgViewPrivate *priv; GtkWidget *scrolled; - + priv = MUG_MSG_VIEW_GET_PRIVATE(obj); - - priv->_view = gtk_text_view_new (); - gtk_text_view_set_editable (GTK_TEXT_VIEW(priv->_view), FALSE); - gtk_text_view_set_left_margin (GTK_TEXT_VIEW(priv->_view), 10); - gtk_text_view_set_right_margin (GTK_TEXT_VIEW(priv->_view), 10); - scrolled = gtk_scrolled_window_new (NULL, NULL); - gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW(scrolled), - GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); - gtk_container_add (GTK_CONTAINER (scrolled), priv->_view); - - gtk_box_pack_start (GTK_BOX(obj), headers_area(priv), FALSE, FALSE, 0); - gtk_box_pack_start (GTK_BOX(obj), scrolled, TRUE, TRUE, 0); + priv->_view = gtk_text_view_new(); + gtk_text_view_set_editable(GTK_TEXT_VIEW(priv->_view), FALSE); + gtk_text_view_set_left_margin(GTK_TEXT_VIEW(priv->_view), 10); + gtk_text_view_set_right_margin(GTK_TEXT_VIEW(priv->_view), 10); - gtk_widget_hide (priv->_headers_area); + scrolled = gtk_scrolled_window_new(NULL, NULL); + gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled), + GTK_POLICY_AUTOMATIC, + GTK_POLICY_AUTOMATIC); + gtk_container_add(GTK_CONTAINER(scrolled), priv->_view); + + gtk_box_pack_start(GTK_BOX(obj), headers_area(priv), FALSE, FALSE, 0); + gtk_box_pack_start(GTK_BOX(obj), scrolled, TRUE, TRUE, 0); } -static void -mug_msg_view_finalize (GObject *obj) +static void mug_msg_view_finalize(GObject * obj) { /* free/unref instance resources here */ - G_OBJECT_CLASS(parent_class)->finalize (obj); + G_OBJECT_CLASS(parent_class)->finalize(obj); } -GtkWidget* -mug_msg_view_new (void) +GtkWidget *mug_msg_view_new(void) { return GTK_WIDGET(g_object_new(MUG_TYPE_MSG_VIEW, NULL)); } - +static void empty_message(MugMsgView * self) +{ + int i; + MugMsgViewPrivate *priv; + GtkTextBuffer *buf; -gboolean -mug_msg_view_set_text (MugMsgView *self, const char* txt) + priv = MUG_MSG_VIEW_GET_PRIVATE(self); + + for (i = 0; i != HEADER_ROW_NUM; ++i) + gtk_label_set_markup(GTK_LABEL(priv->_headervals[i]), ""); + + buf = gtk_text_view_get_buffer(GTK_TEXT_VIEW(priv->_view)); + gtk_text_buffer_set_text(buf, "", -1); +} + +static gboolean set_text(MugMsgView * self, const char *txt) { MugMsgViewPrivate *priv; GtkTextBuffer *buf; - - g_return_val_if_fail (MUG_IS_MSG_VIEW(self), FALSE); + + g_return_val_if_fail(MUG_IS_MSG_VIEW(self), FALSE); priv = MUG_MSG_VIEW_GET_PRIVATE(self); - buf = gtk_text_view_get_buffer (GTK_TEXT_VIEW(priv->_view)); - gtk_text_buffer_set_text (buf, txt ? txt : "", -1); - + buf = gtk_text_view_get_buffer(GTK_TEXT_VIEW(priv->_view)); + gtk_text_buffer_set_text(buf, txt ? txt : "", -1); + return TRUE; } - -static void -fill_header (MugMsgViewPrivate *priv, MuMsg* msg) +static void fill_header(MugMsgViewPrivate * priv, MuMsg * msg) { - int i; + int i; + for (i = 0; i != HEADER_ROW_NUM; ++i) { - const gchar* val; + const gchar *val; switch (i) { - case HEADER_ROW_FROM: val = mu_msg_get_from(msg); break; - case HEADER_ROW_TO: val = mu_msg_get_to(msg); break; - case HEADER_ROW_SUBJECT: val = mu_msg_get_subject(msg); break; - case HEADER_ROW_MSGID: val = mu_msg_get_msgid(msg); break; - case HEADER_ROW_CC: val = mu_msg_get_cc (msg); break; - case HEADER_ROW_PATH: val = mu_msg_get_path (msg); break; - case HEADER_ROW_DATE: val = mu_str_date_s( - "%c", mu_msg_get_date (msg)); + case HEADER_ROW_FROM: + val = mu_msg_get_from(msg); break; - case HEADER_ROW_SIZE: val = mu_str_size_s (mu_msg_get_size(msg)); + case HEADER_ROW_TO: + val = mu_msg_get_to(msg); break; - default: val = NULL; + case HEADER_ROW_SUBJECT: + val = mu_msg_get_subject(msg); + break; + case HEADER_ROW_MSGID: + val = mu_msg_get_msgid(msg); + break; + case HEADER_ROW_CC: + val = mu_msg_get_cc(msg); + break; + case HEADER_ROW_PATH: + val = mu_msg_get_path(msg); + break; + case HEADER_ROW_DATE: + val = mu_str_date_s("%c", mu_msg_get_date(msg)); + break; + case HEADER_ROW_SIZE: + val = mu_str_size_s(mu_msg_get_size(msg)); + break; + default: + val = NULL; } - { - gchar *str; - str = g_markup_escape_text (val ? val : "", -1); - gtk_label_set_markup (GTK_LABEL(priv->_headervals[i]), str); - g_free (str); - } + { + gchar *str; + str = g_markup_escape_text(val ? val : "", -1); + gtk_label_set_markup + (GTK_LABEL(priv->_headervals[i]), str); + g_free(str); + } } - - gtk_widget_show (priv->_tablemain); - gtk_widget_show (priv->_expander); } - -gboolean -mug_msg_view_set_msg (MugMsgView *self, const char* msgpath) +gboolean mug_msg_view_set_msg(MugMsgView * self, const char *msgpath) { MugMsgViewPrivate *priv; - MuMsg* msg; + MuMsg *msg; gboolean rv; - - g_return_val_if_fail (MUG_IS_MSG_VIEW(self), FALSE); + + g_return_val_if_fail(MUG_IS_MSG_VIEW(self), FALSE); priv = MUG_MSG_VIEW_GET_PRIVATE(self); if (!msgpath) { - mug_msg_view_set_text (self, ""); - gtk_widget_hide (priv->_headers_area); + empty_message(self); return TRUE; } - - msg = mu_msg_new (msgpath, NULL, NULL); + + msg = mu_msg_new(msgpath, NULL, NULL); if (!msg) { - gtk_widget_hide (priv->_tablemain); - gtk_widget_hide (priv->_expander); - mug_msg_view_set_text (self, - "Message not found; " - "please run 'mu index'"); - return FALSE; + empty_message(self); + set_text(self, "Message not found; " "please run 'mu index'"); + return FALSE; } - - rv = mug_msg_view_set_text (self, mu_msg_get_body_text(msg)); - fill_header (priv, msg); - gtk_widget_show (priv->_headers_area); - - mu_msg_destroy (msg); - + + rv = set_text(self, mu_msg_get_body_text(msg)); + fill_header(priv, msg); + + mu_msg_destroy(msg); + return rv; } diff --git a/toys/mug/mug-msg-view.h b/toys/mug/mug-msg-view.h index 88380ffa..884c6173 100644 --- a/toys/mug/mug-msg-view.h +++ b/toys/mug/mug-msg-view.h @@ -17,7 +17,6 @@ ** */ - #ifndef __MUG_MSG_VIEW_H__ #define __MUG_MSG_VIEW_H__ @@ -25,7 +24,6 @@ /* other include files */ G_BEGIN_DECLS - /* convenience macros */ #define MUG_TYPE_MSG_VIEW (mug_msg_view_get_type()) #define MUG_MSG_VIEW(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),MUG_TYPE_MSG_VIEW,MugMsgView)) @@ -33,12 +31,11 @@ G_BEGIN_DECLS #define MUG_IS_MSG_VIEW(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj),MUG_TYPE_MSG_VIEW)) #define MUG_IS_MSG_VIEW_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass),MUG_TYPE_MSG_VIEW)) #define MUG_MSG_VIEW_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj),MUG_TYPE_MSG_VIEW,MugMsgViewClass)) - -typedef struct _MugMsgView MugMsgView; +typedef struct _MugMsgView MugMsgView; typedef struct _MugMsgViewClass MugMsgViewClass; struct _MugMsgView { - GtkVBox parent; + GtkVBox parent; /* insert public members, if any */ }; @@ -49,15 +46,12 @@ struct _MugMsgViewClass { }; /* member functions */ -GType mug_msg_view_get_type (void) G_GNUC_CONST; +GType mug_msg_view_get_type(void) G_GNUC_CONST; /* parameter-less _new function (constructor) */ /* if this is a kind of GtkWidget, it should probably return at GtkWidget* */ -GtkWidget* mug_msg_view_new (void); -gboolean mug_msg_view_set_msg (MugMsgView *self, const char* msgpath); -gboolean mug_msg_view_set_text (MugMsgView *self, const char* txt); +GtkWidget *mug_msg_view_new(void); +gboolean mug_msg_view_set_msg(MugMsgView * self, const char *msgpath); G_END_DECLS - -#endif /* __MUG_MSG_VIEW_H__ */ - +#endif /* __MUG_MSG_VIEW_H__ */ diff --git a/toys/mug/mug-query-bar.c b/toys/mug/mug-query-bar.c index f925c736..95ab72ab 100644 --- a/toys/mug/mug-query-bar.c +++ b/toys/mug/mug-query-bar.c @@ -6,9 +6,9 @@ /* include other impl specific header files */ /* 'private'/'protected' functions */ -static void mug_query_bar_class_init (MugQueryBarClass *klass); -static void mug_query_bar_init (MugQueryBar *obj); -static void mug_query_bar_finalize (GObject *obj); +static void mug_query_bar_class_init(MugQueryBarClass * klass); +static void mug_query_bar_init(MugQueryBar * obj); +static void mug_query_bar_finalize(GObject * obj); /* list my signals */ enum { @@ -26,116 +26,104 @@ struct _MugQueryBarPrivate { /* globals */ static GtkContainerClass *parent_class = NULL; -static guint signals[LAST_SIGNAL] = {0}; +static guint signals[LAST_SIGNAL] = { 0 }; -GType -mug_query_bar_get_type (void) +GType mug_query_bar_get_type(void) { static GType my_type = 0; if (!my_type) { static const GTypeInfo my_info = { sizeof(MugQueryBarClass), - NULL, /* base init */ - NULL, /* base finalize */ + NULL, /* base init */ + NULL, /* base finalize */ (GClassInitFunc) mug_query_bar_class_init, - NULL, /* class finalize */ - NULL, /* class data */ + NULL, /* class finalize */ + NULL, /* class data */ sizeof(MugQueryBar), - 0, /* n_preallocs, ignored since 2.10 */ + 0, /* n_preallocs, ignored since 2.10 */ (GInstanceInitFunc) mug_query_bar_init, NULL }; - my_type = g_type_register_static (GTK_TYPE_HBOX, - "MugQueryBar", - &my_info, 0); + my_type = g_type_register_static(GTK_TYPE_HBOX, + "MugQueryBar", &my_info, 0); } return my_type; } -static void -mug_query_bar_class_init (MugQueryBarClass *klass) +static void mug_query_bar_class_init(MugQueryBarClass * klass) { GObjectClass *gobject_class; - gobject_class = (GObjectClass*) klass; + gobject_class = (GObjectClass *) klass; - parent_class = g_type_class_peek_parent (klass); + parent_class = g_type_class_peek_parent(klass); gobject_class->finalize = mug_query_bar_finalize; - g_type_class_add_private (gobject_class, sizeof(MugQueryBarPrivate)); + g_type_class_add_private(gobject_class, sizeof(MugQueryBarPrivate)); /* signal definitions go here, e.g.: */ signals[MUG_QUERY_CHANGED] = - g_signal_new ("query_changed", - G_TYPE_FROM_CLASS(gobject_class), - G_SIGNAL_RUN_FIRST, - G_STRUCT_OFFSET(MugQueryBarClass, query_changed), - NULL, NULL, - g_cclosure_marshal_VOID__STRING, - G_TYPE_NONE, 1, G_TYPE_STRING); + g_signal_new("query_changed", + G_TYPE_FROM_CLASS(gobject_class), + G_SIGNAL_RUN_FIRST, + G_STRUCT_OFFSET(MugQueryBarClass, query_changed), + NULL, NULL, + g_cclosure_marshal_VOID__STRING, + G_TYPE_NONE, 1, G_TYPE_STRING); } - -static void -on_entry_activated (GtkWidget *w, MugQueryBar *bar) -{ - MugQueryBarPrivate *priv; +static void on_entry_activated(GtkWidget * w, MugQueryBar * bar) +{ + MugQueryBarPrivate *priv; priv = MUG_QUERY_BAR_GET_PRIVATE(bar); - g_signal_emit (G_OBJECT(bar), signals[MUG_QUERY_CHANGED], 0, - gtk_entry_get_text(GTK_ENTRY(w))); + g_signal_emit(G_OBJECT(bar), signals[MUG_QUERY_CHANGED], 0, + gtk_entry_get_text(GTK_ENTRY(w))); } -static void -mug_query_bar_init (MugQueryBar *obj) +static void mug_query_bar_init(MugQueryBar * obj) { - MugQueryBarPrivate *priv; + MugQueryBarPrivate *priv; priv = MUG_QUERY_BAR_GET_PRIVATE(obj); - priv->_entry = gtk_entry_new (); + priv->_entry = gtk_entry_new(); - g_signal_connect (priv->_entry, "activate", G_CALLBACK(on_entry_activated), - obj); - - gtk_box_pack_start (GTK_BOX(obj), priv->_entry, TRUE, TRUE, 0); + g_signal_connect(priv->_entry, "activate", + G_CALLBACK(on_entry_activated), obj); + + gtk_box_pack_start(GTK_BOX(obj), priv->_entry, TRUE, TRUE, 0); } -static void -mug_query_bar_finalize (GObject *obj) +static void mug_query_bar_finalize(GObject * obj) { /* free/unref instance resources here */ - G_OBJECT_CLASS(parent_class)->finalize (obj); + G_OBJECT_CLASS(parent_class)->finalize(obj); } -GtkWidget* -mug_query_bar_new (void) +GtkWidget *mug_query_bar_new(void) { return GTK_WIDGET(g_object_new(MUG_TYPE_QUERY_BAR, NULL)); } - void -mug_query_bar_set_query (MugQueryBar *self, const char *query, gboolean run) +mug_query_bar_set_query(MugQueryBar * self, const char *query, gboolean run) { MugQueryBarPrivate *priv; - - g_return_if_fail (MUG_IS_QUERY_BAR(self)); + + g_return_if_fail(MUG_IS_QUERY_BAR(self)); priv = MUG_QUERY_BAR_GET_PRIVATE(self); - gtk_entry_set_text (GTK_ENTRY(priv->_entry), query ? query : ""); + gtk_entry_set_text(GTK_ENTRY(priv->_entry), query ? query : ""); if (run) - on_entry_activated (priv->_entry, self); + on_entry_activated(priv->_entry, self); } - -void -mug_query_bar_grab_focus (MugQueryBar *self) +void mug_query_bar_grab_focus(MugQueryBar * self) { - g_return_if_fail (MUG_IS_QUERY_BAR(self)); + g_return_if_fail(MUG_IS_QUERY_BAR(self)); gtk_widget_grab_focus - (GTK_WIDGET(MUG_QUERY_BAR_GET_PRIVATE(self)->_entry)); + (GTK_WIDGET(MUG_QUERY_BAR_GET_PRIVATE(self)->_entry)); } - diff --git a/toys/mug/mug-query-bar.h b/toys/mug/mug-query-bar.h index 2c954cf3..a3763b82 100644 --- a/toys/mug/mug-query-bar.h +++ b/toys/mug/mug-query-bar.h @@ -8,7 +8,6 @@ /* other include files */ G_BEGIN_DECLS - /* convenience macros */ #define MUG_TYPE_QUERY_BAR (mug_query_bar_get_type()) #define MUG_QUERY_BAR(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),MUG_TYPE_QUERY_BAR,MugQueryBar)) @@ -16,33 +15,31 @@ G_BEGIN_DECLS #define MUG_IS_QUERY_BAR(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj),MUG_TYPE_QUERY_BAR)) #define MUG_IS_QUERY_BAR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass),MUG_TYPE_QUERY_BAR)) #define MUG_QUERY_BAR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj),MUG_TYPE_QUERY_BAR,MugQueryBarClass)) - -typedef struct _MugQueryBar MugQueryBar; +typedef struct _MugQueryBar MugQueryBar; typedef struct _MugQueryBarClass MugQueryBarClass; struct _MugQueryBar { - GtkHBox parent; + GtkHBox parent; /* insert public members, if any */ }; struct _MugQueryBarClass { GtkHBoxClass parent_class; /* insert signal callback declarations, e.g. */ - void (* query_changed) (MugQueryBar* obj, const char *query); + void (*query_changed) (MugQueryBar * obj, const char *query); }; /* member functions */ -GType mug_query_bar_get_type (void) G_GNUC_CONST; +GType mug_query_bar_get_type(void) G_GNUC_CONST; /* parameter-less _new function (constructor) */ /* if this is a kind of GtkWidget, it should probably return at GtkWidget* */ -GtkWidget* mug_query_bar_new (void); +GtkWidget *mug_query_bar_new(void); -void mug_query_bar_grab_focus (MugQueryBar *self); +void mug_query_bar_grab_focus(MugQueryBar * self); -void mug_query_bar_set_query (MugQueryBar *self, const char *query, gboolean run); +void mug_query_bar_set_query(MugQueryBar * self, const char *query, + gboolean run); G_END_DECLS - -#endif /* __MUG_QUERY_BAR_H__ */ - +#endif /* __MUG_QUERY_BAR_H__ */ diff --git a/toys/mug/mug-shortcuts.c b/toys/mug/mug-shortcuts.c index 808b2fc1..fc0082b2 100644 --- a/toys/mug/mug-shortcuts.c +++ b/toys/mug/mug-shortcuts.c @@ -23,9 +23,9 @@ /* include other impl specific header files */ /* 'private'/'protected' functions */ -static void mug_shortcuts_class_init (MugShortcutsClass *klass); -static void mug_shortcuts_init (MugShortcuts *obj); -static void mug_shortcuts_finalize (GObject *obj); +static void mug_shortcuts_class_init(MugShortcutsClass * klass); +static void mug_shortcuts_init(MugShortcuts * obj); +static void mug_shortcuts_finalize(GObject * obj); #define MUG_SHORTCUT_BOOKMARK "bookmark" @@ -39,7 +39,7 @@ enum { struct _MugShortcutsPrivate { GtkWidget *_bbox; - + }; #define MUG_SHORTCUTS_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE((o), \ MUG_TYPE_SHORTCUTS, \ @@ -47,109 +47,99 @@ struct _MugShortcutsPrivate { /* globals */ static GtkVBoxClass *parent_class = NULL; -static guint signals[LAST_SIGNAL] = {0}; +static guint signals[LAST_SIGNAL] = { 0 }; -G_DEFINE_TYPE (MugShortcuts, mug_shortcuts, GTK_TYPE_VBOX); +G_DEFINE_TYPE(MugShortcuts, mug_shortcuts, GTK_TYPE_VBOX); -static void -mug_shortcuts_class_init (MugShortcutsClass *klass) +static void mug_shortcuts_class_init(MugShortcutsClass * klass) { GObjectClass *gobject_class; - gobject_class = (GObjectClass*) klass; + gobject_class = (GObjectClass *) klass; - parent_class = g_type_class_peek_parent (klass); + parent_class = g_type_class_peek_parent(klass); gobject_class->finalize = mug_shortcuts_finalize; - g_type_class_add_private (gobject_class, sizeof(MugShortcutsPrivate)); + g_type_class_add_private(gobject_class, sizeof(MugShortcutsPrivate)); /* signal definitions go here, e.g.: */ signals[SHORTCUT_CLICKED] = - g_signal_new ("clicked", - G_TYPE_FROM_CLASS(gobject_class), - G_SIGNAL_RUN_FIRST, - G_STRUCT_OFFSET(MugShortcutsClass, clicked), - NULL, NULL, - g_cclosure_marshal_VOID__STRING, - G_TYPE_NONE, 1, G_TYPE_STRING); + g_signal_new("clicked", + G_TYPE_FROM_CLASS(gobject_class), + G_SIGNAL_RUN_FIRST, + G_STRUCT_OFFSET(MugShortcutsClass, clicked), + NULL, NULL, + g_cclosure_marshal_VOID__STRING, + G_TYPE_NONE, 1, G_TYPE_STRING); - /* signals[MY_SIGNAL_2] = */ /* g_signal_new ("my_signal_2",....); */ /* etc. */ } -static void -mug_shortcuts_init (MugShortcuts *obj) +static void mug_shortcuts_init(MugShortcuts * obj) { obj->_priv = MUG_SHORTCUTS_GET_PRIVATE(obj); - obj->_priv->_bbox = gtk_vbutton_box_new (); - gtk_button_box_set_layout (GTK_BUTTON_BOX(obj->_priv->_bbox), - GTK_BUTTONBOX_START); - gtk_box_pack_start (GTK_BOX(obj), obj->_priv->_bbox, TRUE, TRUE, 0); + obj->_priv->_bbox = gtk_vbutton_box_new(); + gtk_button_box_set_layout(GTK_BUTTON_BOX(obj->_priv->_bbox), + GTK_BUTTONBOX_START); + gtk_box_pack_start(GTK_BOX(obj), obj->_priv->_bbox, TRUE, TRUE, 0); } -static void -mug_shortcuts_finalize (GObject *obj) +static void mug_shortcuts_finalize(GObject * obj) { /* free/unref instance resources here */ - G_OBJECT_CLASS(parent_class)->finalize (obj); + G_OBJECT_CLASS(parent_class)->finalize(obj); } -static void -on_button_clicked (GtkWidget *button, MugShortcuts *self) +static void on_button_clicked(GtkWidget * button, MugShortcuts * self) { - g_signal_emit (G_OBJECT(self), - signals[SHORTCUT_CLICKED], 0, - (const gchar*)g_object_get_data (G_OBJECT(button), - MUG_SHORTCUT_BOOKMARK)); + g_signal_emit(G_OBJECT(self), + signals[SHORTCUT_CLICKED], 0, + (const gchar *)g_object_get_data(G_OBJECT(button), + MUG_SHORTCUT_BOOKMARK)); } - -static void -each_bookmark (const char* key, const char* val, MugShortcuts *self) +static void each_bookmark(const char *key, const char *val, MugShortcuts * self) { GtkWidget *button; - button = gtk_button_new_with_label (key); - g_object_set_data_full (G_OBJECT(button), MUG_SHORTCUT_BOOKMARK, - g_strdup(val), g_free); - g_signal_connect (G_OBJECT(button), "clicked", G_CALLBACK(on_button_clicked), - self); - - gtk_container_add (GTK_CONTAINER(self->_priv->_bbox), button); + button = gtk_button_new_with_label(key); + g_object_set_data_full(G_OBJECT(button), MUG_SHORTCUT_BOOKMARK, + g_strdup(val), g_free); + g_signal_connect(G_OBJECT(button), "clicked", + G_CALLBACK(on_button_clicked), self); + + gtk_container_add(GTK_CONTAINER(self->_priv->_bbox), button); } -static gboolean -init_shortcuts (MugShortcuts *self, const char* bmpath) +static gboolean init_shortcuts(MugShortcuts * self, const char *bmpath) { MuBookmarks *bookmarks; - bookmarks = mu_bookmarks_new (bmpath); + bookmarks = mu_bookmarks_new(bmpath); if (!bookmarks) return TRUE; - mu_bookmarks_foreach (bookmarks, (MuBookmarksForeachFunc)each_bookmark, - self); - - mu_bookmarks_destroy (bookmarks); + mu_bookmarks_foreach(bookmarks, (MuBookmarksForeachFunc) each_bookmark, + self); + + mu_bookmarks_destroy(bookmarks); return TRUE; } -GtkWidget* -mug_shortcuts_new (const char *bmpath) +GtkWidget *mug_shortcuts_new(const char *bmpath) { MugShortcuts *self; self = MUG_SHORTCUTS(g_object_new(MUG_TYPE_SHORTCUTS, NULL)); - if (!init_shortcuts (self, bmpath)) { - g_object_unref (self); + if (!init_shortcuts(self, bmpath)) { + g_object_unref(self); return NULL; } - + return GTK_WIDGET(self); } /* following: other function implementations */ /* such as mug_shortcuts_do_something, or mug_shortcuts_has_foo */ - diff --git a/toys/mug/mug-shortcuts.h b/toys/mug/mug-shortcuts.h index 16970fc9..935da486 100644 --- a/toys/mug/mug-shortcuts.h +++ b/toys/mug/mug-shortcuts.h @@ -17,7 +17,6 @@ ** */ - #ifndef __MUG_SHORTCUTS_H__ #define __MUG_SHORTCUTS_H__ @@ -25,7 +24,6 @@ /* other include files */ G_BEGIN_DECLS - /* convenience macros */ #define MUG_TYPE_SHORTCUTS (mug_shortcuts_get_type()) #define MUG_SHORTCUTS(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),MUG_TYPE_SHORTCUTS,MugShortcuts)) @@ -33,13 +31,12 @@ G_BEGIN_DECLS #define MUG_IS_SHORTCUTS(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj),MUG_TYPE_SHORTCUTS)) #define MUG_IS_SHORTCUTS_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass),MUG_TYPE_SHORTCUTS)) #define MUG_SHORTCUTS_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj),MUG_TYPE_SHORTCUTS,MugShortcutsClass)) - -typedef struct _MugShortcuts MugShortcuts; +typedef struct _MugShortcuts MugShortcuts; typedef struct _MugShortcutsClass MugShortcutsClass; -typedef struct _MugShortcutsPrivate MugShortcutsPrivate; +typedef struct _MugShortcutsPrivate MugShortcutsPrivate; struct _MugShortcuts { - GtkVBox parent; + GtkVBox parent; /* insert public members, if any */ /* private */ @@ -48,22 +45,19 @@ struct _MugShortcuts { struct _MugShortcutsClass { GtkVBoxClass parent_class; - void (*clicked) (MugShortcuts* obj, const char* query); + void (*clicked) (MugShortcuts * obj, const char *query); }; /* member functions */ -GType mug_shortcuts_get_type (void) G_GNUC_CONST; +GType mug_shortcuts_get_type(void) G_GNUC_CONST; /* parameter-less _new function (constructor) */ /* if this is a kind of GtkWidget, it should probably return at GtkWidget* */ -GtkWidget* mug_shortcuts_new (const char *bmpath); +GtkWidget *mug_shortcuts_new(const char *bmpath); /* fill in other public functions, e.g.: */ /* void mug_shortcuts_do_something (MugShortcuts *self, const gchar* param); */ /* gboolean mug_shortcuts_has_foo (MugShortcuts *self, gint value); */ - G_END_DECLS - -#endif /* __MUG_SHORTCUTS_H__ */ - +#endif /* __MUG_SHORTCUTS_H__ */ diff --git a/toys/mug/mug.cc b/toys/mug/mug.cc index d201eb9b..74ba1b31 100644 --- a/toys/mug/mug.cc +++ b/toys/mug/mug.cc @@ -19,10 +19,10 @@ #if HAVE_CONFIG_H #include "config.h" -#endif /*HAVE_CONFIG*/ +#endif /*HAVE_CONFIG */ #include -#include /* for memset */ +#include /* for memset */ #include "mu-util.h" #include "mu-runtime.h" @@ -43,22 +43,20 @@ struct _MugData { gchar *muhome; }; typedef struct _MugData MugData; - -static void -about_mug (MugData *mugdata) +static void about_mug(MugData * mugdata) { GtkWidget *about; about = gtk_message_dialog_new - (GTK_WINDOW(mugdata->win), GTK_DIALOG_MODAL, - GTK_MESSAGE_INFO,GTK_BUTTONS_OK, - "Mug version %s\n" - "A graphical frontend to the 'mu' e-mail search engine\n\n" - "(c) 2010 Dirk-Jan C. Binnema\n" - "Released under the terms of the GPLv3+", VERSION); - - gtk_dialog_run (GTK_DIALOG(about)); - gtk_widget_destroy (about); + (GTK_WINDOW(mugdata->win), GTK_DIALOG_MODAL, + GTK_MESSAGE_INFO, GTK_BUTTONS_OK, + "Mug version %s\n" + "A graphical frontend to the 'mu' e-mail search engine\n\n" + "(c) 2010 Dirk-Jan C. Binnema\n" + "Released under the terms of the GPLv3+", VERSION); + + gtk_dialog_run(GTK_DIALOG(about)); + gtk_widget_destroy(about); } enum _ToolAction { @@ -66,278 +64,265 @@ enum _ToolAction { ACTION_NEXT_MSG, ACTION_DO_QUIT, ACTION_ABOUT, - ACTION_SEPARATOR /* pseudo action */ + ACTION_SEPARATOR /* pseudo action */ }; typedef enum _ToolAction ToolAction; -static void -on_tool_button_clicked (GtkToolButton *btn, MugData *mugdata) +static void on_tool_button_clicked(GtkToolButton * btn, MugData * mugdata) { ToolAction action; - action = (ToolAction)GPOINTER_TO_UINT( - g_object_get_data(G_OBJECT(btn),"action")); + action = + (ToolAction) + GPOINTER_TO_UINT(g_object_get_data(G_OBJECT(btn), "action")); switch (action) { - + case ACTION_DO_QUIT: gtk_main_quit(); break; case ACTION_NEXT_MSG: - mug_msg_list_view_move_next - (MUG_MSG_LIST_VIEW(mugdata->mlist)); + mug_msg_list_view_move_next(MUG_MSG_LIST_VIEW(mugdata->mlist)); break; case ACTION_PREV_MSG: - mug_msg_list_view_move_prev - (MUG_MSG_LIST_VIEW(mugdata->mlist)); + mug_msg_list_view_move_prev(MUG_MSG_LIST_VIEW(mugdata->mlist)); break; case ACTION_ABOUT: - about_mug (mugdata); + about_mug(mugdata); break; default: - g_print ("%u\n", action); + g_print("%u\n", action); } } -static GtkWidget* -mug_toolbar (MugData *mugdata) +static GtkWidget *mug_toolbar(MugData * mugdata) { GtkWidget *toolbar; int i; struct { - const char* stock_id; + const char *stock_id; ToolAction action; } tools[] = { - { GTK_STOCK_GO_UP, ACTION_PREV_MSG }, - { GTK_STOCK_GO_DOWN, ACTION_NEXT_MSG }, - { NULL, ACTION_SEPARATOR }, - { GTK_STOCK_ABOUT, ACTION_ABOUT }, - { NULL, ACTION_SEPARATOR }, - { GTK_STOCK_QUIT, ACTION_DO_QUIT }, - }; - - for (toolbar = gtk_toolbar_new(), i = 0; i != G_N_ELEMENTS(tools); ++i) { - GtkToolItem *btn; + { + GTK_STOCK_GO_UP, ACTION_PREV_MSG}, { + GTK_STOCK_GO_DOWN, ACTION_NEXT_MSG}, { + NULL, ACTION_SEPARATOR}, { + GTK_STOCK_ABOUT, ACTION_ABOUT}, { + NULL, ACTION_SEPARATOR}, { + GTK_STOCK_QUIT, ACTION_DO_QUIT},}; - /* separator item ? */ - if (tools[i].action == ACTION_SEPARATOR) { - gtk_toolbar_insert (GTK_TOOLBAR(toolbar), - gtk_separator_tool_item_new(), i); + toolbar = gtk_toolbar_new(); + for (i = 0; i != G_N_ELEMENTS(tools); ++i) { + GtkToolItem *btn; + if (tools[i].action == ACTION_SEPARATOR) { /* separator */ + gtk_toolbar_insert(GTK_TOOLBAR(toolbar), + gtk_separator_tool_item_new(), i); continue; } /* nope: a real item */ - btn = gtk_tool_button_new_from_stock (tools[i].stock_id); - g_object_set_data (G_OBJECT(btn), "action", - GUINT_TO_POINTER(tools[i].action)); - g_signal_connect (G_OBJECT(btn), "clicked", - G_CALLBACK(on_tool_button_clicked), - mugdata); - gtk_toolbar_insert (GTK_TOOLBAR(toolbar), btn, i); + btn = gtk_tool_button_new_from_stock(tools[i].stock_id); + g_object_set_data(G_OBJECT(btn), "action", + GUINT_TO_POINTER(tools[i].action)); + g_signal_connect(G_OBJECT(btn), "clicked", + G_CALLBACK(on_tool_button_clicked), mugdata); + gtk_toolbar_insert(GTK_TOOLBAR(toolbar), btn, i); + gtk_widget_show(GTK_WIDGET(btn)); } - + return toolbar; } static void -on_shortcut_clicked (GtkWidget *w, const gchar *query, MugData *mdata) +on_shortcut_clicked(GtkWidget * w, const gchar * query, MugData * mdata) { - mug_query_bar_set_query (MUG_QUERY_BAR(mdata->querybar), - query, TRUE); + mug_query_bar_set_query(MUG_QUERY_BAR(mdata->querybar), query, TRUE); } - -static GtkWidget* -mug_shortcuts_bar (MugData *data) +static GtkWidget *mug_shortcuts_bar(MugData * data) { - data->shortcuts = mug_shortcuts_new (mu_runtime_bookmarks_file()); - - g_signal_connect (G_OBJECT(data->shortcuts), "clicked", - G_CALLBACK(on_shortcut_clicked), data); - + data->shortcuts = mug_shortcuts_new(mu_runtime_bookmarks_file()); + + g_signal_connect(G_OBJECT(data->shortcuts), "clicked", + G_CALLBACK(on_shortcut_clicked), data); + return data->shortcuts; } - -static GtkWidget* -mug_statusbar (void) +static GtkWidget *mug_statusbar(void) { GtkWidget *statusbar; - statusbar = gtk_statusbar_new (); + statusbar = gtk_statusbar_new(); return statusbar; } static void -on_query_changed (MugQueryBar *bar, const char* query, MugData *mugdata) +on_query_changed(MugQueryBar * bar, const char *query, MugData * mugdata) { int count; /* clear the old message */ - mug_msg_view_set_text (MUG_MSG_VIEW(mugdata->msgview), NULL); - - count = mug_msg_list_view_query (MUG_MSG_LIST_VIEW(mugdata->mlist), - query); + //mug_msg_view_set_text (MUG_MSG_VIEW(mugdata->msgview), NULL); + mug_msg_view_set_msg(MUG_MSG_VIEW(mugdata->msgview), NULL); + + count = mug_msg_list_view_query(MUG_MSG_LIST_VIEW(mugdata->mlist), + query); if (count >= 0) { - gchar *msg = - g_strdup_printf ("%d message%s found matching '%s'", - count, - count > 1 ? "s" : "", - mug_msg_list_view_get_query - (MUG_MSG_LIST_VIEW(mugdata->mlist))); - gtk_statusbar_push (GTK_STATUSBAR(mugdata->statusbar), 0, msg); - g_free (msg); - - mug_msg_list_view_move_first (MUG_MSG_LIST_VIEW(mugdata->mlist)); - gtk_widget_grab_focus (GTK_WIDGET(mugdata->mlist)); - } + gchar *msg = g_strdup_printf("%d message%s found matching '%s'", + count, + count > 1 ? "s" : "", + mug_msg_list_view_get_query + (MUG_MSG_LIST_VIEW + (mugdata->mlist))); + gtk_statusbar_push(GTK_STATUSBAR(mugdata->statusbar), 0, msg); + g_free(msg); + + mug_msg_list_view_move_first(MUG_MSG_LIST_VIEW(mugdata->mlist)); + gtk_widget_grab_focus(GTK_WIDGET(mugdata->mlist)); + } + + if (count == 0) /* nothing found */ + mug_query_bar_grab_focus(MUG_QUERY_BAR(bar)); } - static void -on_msg_selected (MugMsgListView *mlist, const char* mpath, MugData *mugdata) +on_msg_selected(MugMsgListView * mlist, const char *mpath, MugData * mugdata) { // g_warning ("msg selected: %s", mpath); - mug_msg_view_set_msg (MUG_MSG_VIEW(mugdata->msgview), mpath); + mug_msg_view_set_msg(MUG_MSG_VIEW(mugdata->msgview), mpath); } - static void -on_list_view_error (MugMsgListView *mlist, MugError err, - MugData *mugdata) +on_list_view_error(MugMsgListView * mlist, MugError err, MugData * mugdata) { GtkWidget *errdialog; - const char* msg; + const char *msg; switch (err) { case MUG_ERROR_XAPIAN_NOT_UPTODATE: - msg = "The Xapian Database has the wrong version\n" - "Please run 'mu index --rebuild'"; break; + msg = "The Xapian Database has the wrong version\n" + "Please run 'mu index --rebuild'"; + break; case MUG_ERROR_XAPIAN_DIR: - msg = "Cannot find the Xapian database dir\n" - "Please restart mug with --muhome=... pointing\n" - "to your mu home directory"; break; + msg = "Cannot find the Xapian database dir\n" + "Please restart mug with --muhome=... pointing\n" + "to your mu home directory"; + break; case MUG_ERROR_QUERY: - msg = "Error in query"; break; + msg = "Error in query"; + break; default: - msg = "Some error occured"; break; + msg = "Some error occured"; + break; } - - errdialog = gtk_message_dialog_new - (GTK_WINDOW(mugdata->win), GTK_DIALOG_MODAL, - GTK_MESSAGE_ERROR,GTK_BUTTONS_OK, "%s", msg); - gtk_dialog_run (GTK_DIALOG(errdialog)); - gtk_widget_destroy (errdialog); + errdialog = gtk_message_dialog_new + (GTK_WINDOW(mugdata->win), GTK_DIALOG_MODAL, + GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, "%s", msg); + + gtk_dialog_run(GTK_DIALOG(errdialog)); + gtk_widget_destroy(errdialog); if (err == MUG_ERROR_QUERY) { - mug_query_bar_grab_focus - (MUG_QUERY_BAR(mugdata->querybar)); + mug_query_bar_grab_focus(MUG_QUERY_BAR(mugdata->querybar)); } } - - -static GtkWidget* -mug_querybar (void) +static GtkWidget *mug_querybar(void) { GtkWidget *querybar; - querybar = mug_query_bar_new (); - + querybar = mug_query_bar_new(); + return querybar; } - -static GtkWidget* -mug_query_area (MugData *mugdata) +static GtkWidget *mug_query_area(MugData * mugdata) { GtkWidget *queryarea; GtkWidget *paned; GtkWidget *scrolled; - queryarea = gtk_vbox_new (FALSE, 2); - paned = gtk_vpaned_new (); + queryarea = gtk_vbox_new(FALSE, 2); + paned = gtk_vpaned_new(); mugdata->mlist = mug_msg_list_view_new(mu_runtime_xapian_dir()); - - scrolled = gtk_scrolled_window_new (NULL, NULL); - gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW(scrolled), - GTK_POLICY_AUTOMATIC, - GTK_POLICY_AUTOMATIC); - - gtk_container_add (GTK_CONTAINER(scrolled), mugdata->mlist); - gtk_paned_add1 (GTK_PANED (paned), scrolled); + scrolled = gtk_scrolled_window_new(NULL, NULL); + gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled), + GTK_POLICY_AUTOMATIC, + GTK_POLICY_AUTOMATIC); - mugdata->msgview = mug_msg_view_new (); - mug_msg_view_set_msg (MUG_MSG_VIEW(mugdata->msgview), NULL); - g_signal_connect (G_OBJECT(mugdata->mlist), "msg-selected", - G_CALLBACK(on_msg_selected), mugdata); - g_signal_connect (G_OBJECT(mugdata->mlist), "error-occured", - G_CALLBACK(on_list_view_error), mugdata); - gtk_paned_add2 (GTK_PANED (paned), mugdata->msgview); + gtk_container_add(GTK_CONTAINER(scrolled), mugdata->mlist); + gtk_paned_add1(GTK_PANED(paned), scrolled); - mugdata->querybar = mug_querybar(); - g_signal_connect (G_OBJECT(mugdata->querybar), "query-changed", - G_CALLBACK(on_query_changed), - mugdata); - - gtk_box_pack_start (GTK_BOX(queryarea), - mugdata->querybar, FALSE, FALSE, 2); - gtk_box_pack_start (GTK_BOX(queryarea), - paned, TRUE, TRUE, 2); - + mugdata->msgview = mug_msg_view_new(); + + mug_msg_view_set_msg(MUG_MSG_VIEW(mugdata->msgview), NULL); + g_signal_connect(G_OBJECT(mugdata->mlist), "msg-selected", + G_CALLBACK(on_msg_selected), mugdata); + g_signal_connect(G_OBJECT(mugdata->mlist), "error-occured", + G_CALLBACK(on_list_view_error), mugdata); + gtk_paned_add2(GTK_PANED(paned), mugdata->msgview); + + mugdata->querybar = mug_querybar(); + g_signal_connect(G_OBJECT(mugdata->querybar), "query-changed", + G_CALLBACK(on_query_changed), mugdata); + + gtk_box_pack_start(GTK_BOX(queryarea), + mugdata->querybar, FALSE, FALSE, 2); + gtk_box_pack_start(GTK_BOX(queryarea), paned, TRUE, TRUE, 2); + + gtk_widget_show_all(queryarea); return queryarea; } - -static GtkWidget* -mug_main_area (MugData *mugdata) +static GtkWidget *mug_main_area(MugData * mugdata) { - GtkWidget *mainarea; + GtkWidget *mainarea, *w; + mainarea = gtk_hbox_new(FALSE, 5); - mainarea = gtk_hbox_new (FALSE, 5); + w = mug_shortcuts_bar(mugdata); + gtk_box_pack_start(GTK_BOX(mainarea), w, FALSE, FALSE, 0); + gtk_widget_show(w); - gtk_box_pack_start (GTK_BOX(mainarea), mug_shortcuts_bar(mugdata), - FALSE, FALSE, 0); - gtk_box_pack_start (GTK_BOX(mainarea), mug_query_area(mugdata), - TRUE, TRUE, 0); + w = mug_query_area(mugdata); + gtk_box_pack_start(GTK_BOX(mainarea), w, TRUE, TRUE, 0); + gtk_widget_show(w); return mainarea; } - -GtkWidget* -mug_shell (MugData *mugdata) +GtkWidget *mug_shell(MugData * mugdata) { GtkWidget *vbox; gchar *icon; - - mugdata->win = gtk_window_new (GTK_WINDOW_TOPLEVEL); - gtk_window_set_title (GTK_WINDOW(mugdata->win), "Mug Mail Search"); - vbox = gtk_vbox_new (FALSE, 2); + mugdata->win = gtk_window_new(GTK_WINDOW_TOPLEVEL); + gtk_window_set_title(GTK_WINDOW(mugdata->win), "Mug Mail Search"); + + vbox = gtk_vbox_new(FALSE, 2); mugdata->toolbar = mug_toolbar(mugdata); - gtk_box_pack_start (GTK_BOX(vbox), mugdata->toolbar, FALSE, FALSE, 2); - gtk_box_pack_start (GTK_BOX(vbox), mug_main_area(mugdata), TRUE, TRUE, 2); - + gtk_box_pack_start(GTK_BOX(vbox), mugdata->toolbar, FALSE, FALSE, 2); + gtk_box_pack_start(GTK_BOX(vbox), mug_main_area(mugdata), TRUE, + TRUE, 2); + mugdata->statusbar = mug_statusbar(); - gtk_box_pack_start (GTK_BOX(vbox), mugdata->statusbar, FALSE, FALSE, 2); - - gtk_container_add (GTK_CONTAINER(mugdata->win), vbox); - gtk_widget_show_all (vbox); + gtk_box_pack_start(GTK_BOX(vbox), mugdata->statusbar, FALSE, FALSE, 2); - gtk_window_set_default_size (GTK_WINDOW(mugdata->win), 700, 500); - gtk_window_set_resizable (GTK_WINDOW(mugdata->win), TRUE); + gtk_container_add(GTK_CONTAINER(mugdata->win), vbox); + gtk_widget_show_all(vbox); + + gtk_window_set_default_size(GTK_WINDOW(mugdata->win), 700, 500); + gtk_window_set_resizable(GTK_WINDOW(mugdata->win), TRUE); + + icon = g_strdup_printf("%s%cmug.svg", ICONDIR, G_DIR_SEPARATOR); + gtk_window_set_icon_from_file(GTK_WINDOW(mugdata->win), icon, NULL); + g_free(icon); - icon = g_strdup_printf ("%s%cmug.svg", ICONDIR, G_DIR_SEPARATOR); - gtk_window_set_icon_from_file (GTK_WINDOW(mugdata->win), icon, NULL); - g_free (icon); - return mugdata->win; } -int -main (int argc, char *argv[]) +int main(int argc, char *argv[]) { MugData mugdata; GtkWidget *mugshell; @@ -345,33 +330,33 @@ main (int argc, char *argv[]) GOptionEntry entries[] = { {"muhome", 0, 0, G_OPTION_ARG_FILENAME, &mugdata.muhome, "specify an alternative mu directory", NULL}, - {NULL, 0, 0, G_OPTION_ARG_NONE, NULL, NULL, NULL} /* sentinel */ + {NULL, 0, 0, G_OPTION_ARG_NONE, NULL, NULL, NULL} /* sentinel */ }; - gtk_init (&argc, &argv); + gtk_init(&argc, &argv); - octx = g_option_context_new ("- mug options"); - g_option_context_add_main_entries (octx, entries, "Mug"); + octx = g_option_context_new("- mug options"); + g_option_context_add_main_entries(octx, entries, "Mug"); - memset (&mugdata, 0, sizeof(MugData)); - if (!g_option_context_parse (octx, &argc, &argv, NULL)) { - g_printerr ("mug: error in options\n"); + memset(&mugdata, 0, sizeof(MugData)); + if (!g_option_context_parse(octx, &argc, &argv, NULL)) { + g_printerr("mug: error in options\n"); return 1; } - mu_runtime_init (mugdata.muhome); - - mugshell = mug_shell (&mugdata); - g_signal_connect(G_OBJECT(mugshell), "destroy", - G_CALLBACK(gtk_main_quit), NULL); - - gtk_widget_show (mugshell); - mug_query_bar_grab_focus (MUG_QUERY_BAR(mugdata.querybar)); - - gtk_main (); - g_free (mugdata.muhome); + mu_runtime_init(mugdata.muhome); + + mugshell = mug_shell(&mugdata); + g_signal_connect(G_OBJECT(mugshell), "destroy", + G_CALLBACK(gtk_main_quit), NULL); + + gtk_widget_show(mugshell); + mug_query_bar_grab_focus(MUG_QUERY_BAR(mugdata.querybar)); + + gtk_main(); + g_free(mugdata.muhome); + + mu_runtime_uninit(); - mu_runtime_uninit (); - return 0; }