diff --git a/toys/mug/mug-msg-list-view.c b/toys/mug/mug-msg-list-view.c index b2dfa0ae..f78a249d 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 { @@ -63,234 +63,246 @@ static GtkTreeViewClass *parent_class = NULL; /* uncomment the following if you have defined any signals */ 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; - 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); + 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); + 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); + 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)) { + 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); + 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); + 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); + 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); + 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); + 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); + 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_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 = 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 */ + 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); + 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); + 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); + 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); + priv = MUG_MSG_LIST_VIEW_GET_PRIVATE (obj); if (priv->_store) - g_object_unref(priv->_store); + g_object_unref (priv->_store); - g_free(priv->_xpath); - g_free(priv->_query); + g_free (priv->_xpath); + g_free (priv->_query); - G_OBJECT_CLASS(parent_class)->finalize(obj); + 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)); + 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); + path = gtk_tree_path_new_first (); + gtk_tree_view_set_cursor (GTK_TREE_VIEW (self), path, NULL, FALSE); - gtk_tree_path_free(path); + 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_path_prev (path); - gtk_tree_view_set_cursor(GTK_TREE_VIEW(self), path, NULL, FALSE); - gtk_tree_path_free(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); + g_return_val_if_fail (xpath, NULL); - w = GTK_WIDGET(g_object_new(MUG_TYPE_MSG_LIST_VIEW, 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 = MUG_MSG_LIST_VIEW_GET_PRIVATE (w); + 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: @@ -304,115 +316,119 @@ static MugError 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)); + 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); + 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); + for (count = 0; !mu_msg_iter_is_done (iter); + mu_msg_iter_next (iter), ++count) + add_row (store, iter); - mu_msg_iter_destroy(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); + 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); + 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; + g_free (priv->_query); + priv->_query = query ? g_strdup (query) : NULL; if (!query) return TRUE; - rv = update_model(priv->_store, priv->_xpath, query, self); + rv = update_model (priv->_store, priv->_xpath, query, self); - gtk_tree_view_columns_autosize(GTK_TREE_VIEW(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; + 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 52b2df5a..147fe850 100644 --- a/toys/mug/mug-msg-list-view.h +++ b/toys/mug/mug-msg-list-view.h @@ -55,20 +55,28 @@ struct _MugMsgListViewClass { }; /* 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__ */ diff --git a/toys/mug/mug-msg-view.c b/toys/mug/mug-msg-view.c index c18cd5cb..2f3f5779 100644 --- a/toys/mug/mug-msg-view.c +++ b/toys/mug/mug-msg-view.c @@ -22,9 +22,9 @@ #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 { @@ -83,17 +83,18 @@ 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; - 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] = */ @@ -103,166 +104,163 @@ static void 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); + 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); + 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); + 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); - al = gtk_alignment_new(0.0, 0.0, 0.0, 0.0); - gtk_label_set_selectable(GTK_LABEL(l), TRUE); + 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); + 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->_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); + (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); + 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); + 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 = 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); + 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); + 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); + 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)); + return GTK_WIDGET (g_object_new (MUG_TYPE_MSG_VIEW, NULL)); } -static void empty_message(MugMsgView * self) +static void +empty_message (MugMsgView * self) { int i; MugMsgViewPrivate *priv; GtkTextBuffer *buf; - priv = MUG_MSG_VIEW_GET_PRIVATE(self); + priv = MUG_MSG_VIEW_GET_PRIVATE (self); for (i = 0; i != HEADER_ROW_NUM; ++i) - gtk_label_set_markup(GTK_LABEL(priv->_headervals[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); + 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) +static gboolean +set_text (MugMsgView * self, const char *txt) { MugMsgViewPrivate *priv; GtkTextBuffer *buf; - g_return_val_if_fail(MUG_IS_MSG_VIEW(self), FALSE); - priv = MUG_MSG_VIEW_GET_PRIVATE(self); + 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; for (i = 0; i != HEADER_ROW_NUM; ++i) { 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_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)); + 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)); + val = mu_str_size_s (mu_msg_get_size (msg)); break; default: val = NULL; @@ -270,40 +268,41 @@ static void fill_header(MugMsgViewPrivate * priv, MuMsg * msg) { gchar *str; - str = g_markup_escape_text(val ? val : "", -1); + str = g_markup_escape_text (val ? val : "", -1); gtk_label_set_markup - (GTK_LABEL(priv->_headervals[i]), str); - g_free(str); + (GTK_LABEL (priv->_headervals[i]), str); + g_free (str); } } } -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; 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); + priv = MUG_MSG_VIEW_GET_PRIVATE (self); if (!msgpath) { - empty_message(self); + empty_message (self); return TRUE; } - msg = mu_msg_new(msgpath, NULL, NULL); + msg = mu_msg_new (msgpath, NULL, NULL); if (!msg) { - empty_message(self); - set_text(self, "Message not found; " "please run 'mu index'"); + empty_message (self); + set_text (self, "Message not found; " "please run 'mu index'"); return FALSE; } - rv = set_text(self, mu_msg_get_body_text(msg)); - fill_header(priv, msg); + rv = set_text (self, mu_msg_get_body_text (msg)); + fill_header (priv, msg); - mu_msg_destroy(msg); + mu_msg_destroy (msg); return rv; } diff --git a/toys/mug/mug-msg-view.h b/toys/mug/mug-msg-view.h index 884c6173..dd45cec6 100644 --- a/toys/mug/mug-msg-view.h +++ b/toys/mug/mug-msg-view.h @@ -46,12 +46,16 @@ 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); +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__ */ diff --git a/toys/mug/mug-query-bar.c b/toys/mug/mug-query-bar.c index 95ab72ab..66666c22 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 { @@ -28,102 +28,109 @@ static GtkContainerClass *parent_class = NULL; 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), + sizeof (MugQueryBarClass), NULL, /* base init */ NULL, /* base finalize */ (GClassInitFunc) mug_query_bar_class_init, NULL, /* class finalize */ NULL, /* class data */ - sizeof(MugQueryBar), + sizeof (MugQueryBar), 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; - 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) +static void +on_entry_activated (GtkWidget * w, MugQueryBar * bar) { MugQueryBarPrivate *priv; - priv = MUG_QUERY_BAR_GET_PRIVATE(bar); + 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; - priv = MUG_QUERY_BAR_GET_PRIVATE(obj); + 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); + g_signal_connect (priv->_entry, "activate", + G_CALLBACK (on_entry_activated), obj); - gtk_box_pack_start(GTK_BOX(obj), priv->_entry, TRUE, TRUE, 0); + 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)); + 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)); - priv = MUG_QUERY_BAR_GET_PRIVATE(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 a3763b82..97cdd2a5 100644 --- a/toys/mug/mug-query-bar.h +++ b/toys/mug/mug-query-bar.h @@ -30,16 +30,20 @@ struct _MugQueryBarClass { }; /* 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__ */ diff --git a/toys/mug/mug-shortcuts.c b/toys/mug/mug-shortcuts.c index fc0082b2..0b39832f 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" @@ -49,96 +49,103 @@ static GtkVBoxClass *parent_class = NULL; 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; - 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 = 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); + 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); + 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_foreach (bookmarks, (MuBookmarksForeachFunc) each_bookmark, + self); - mu_bookmarks_destroy(bookmarks); + 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); + self = MUG_SHORTCUTS (g_object_new (MUG_TYPE_SHORTCUTS, NULL)); + if (!init_shortcuts (self, bmpath)) { + g_object_unref (self); return NULL; } - return GTK_WIDGET(self); + return GTK_WIDGET (self); } /* following: other function implementations */ diff --git a/toys/mug/mug-shortcuts.h b/toys/mug/mug-shortcuts.h index 935da486..d98b0aa2 100644 --- a/toys/mug/mug-shortcuts.h +++ b/toys/mug/mug-shortcuts.h @@ -49,11 +49,14 @@ struct _MugShortcutsClass { }; /* 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); */ diff --git a/toys/mug/mug.cc b/toys/mug/mug.cc index 74ba1b31..565ccabe 100644 --- a/toys/mug/mug.cc +++ b/toys/mug/mug.cc @@ -44,19 +44,20 @@ struct _MugData { }; 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_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_dialog_run (GTK_DIALOG (about)); + gtk_widget_destroy (about); } enum _ToolAction { @@ -68,32 +69,50 @@ enum _ToolAction { }; 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(); + 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 GtkToolItem* +get_connected_tool_button (const char* stock_id, ToolAction action, + MugData *mugdata) +{ + GtkToolItem *btn; + + btn = gtk_tool_button_new_from_stock (stock_id); + g_object_set_data (G_OBJECT (btn), "action", + GUINT_TO_POINTER (action)); + g_signal_connect (G_OBJECT (btn), "clicked", + G_CALLBACK (on_tool_button_clicked), + mugdata); + return btn; +} + +static GtkWidget * +mug_toolbar (MugData * mugdata) { GtkWidget *toolbar; int i; @@ -101,99 +120,95 @@ static GtkWidget *mug_toolbar(MugData * mugdata) 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},}; + {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}}; - 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); + toolbar = gtk_toolbar_new (); + for (i = 0; i != G_N_ELEMENTS (tools); ++i) { + 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); - gtk_widget_show(GTK_WIDGET(btn)); + } else /* nope: a real item */ + gtk_toolbar_insert (GTK_TOOLBAR (toolbar), + get_connected_tool_button + (tools[i].stock_id, tools[i].action, + mugdata), i); } - + 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()); + data->shortcuts = mug_shortcuts_new (mu_runtime_bookmarks_file ()); - g_signal_connect(G_OBJECT(data->shortcuts), "clicked", - G_CALLBACK(on_shortcut_clicked), data); + 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); - mug_msg_view_set_msg(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); + 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); + 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)); + 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)); + 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; @@ -217,112 +232,118 @@ on_list_view_error(MugMsgListView * mlist, MugError err, MugData * mugdata) } errdialog = gtk_message_dialog_new - (GTK_WINDOW(mugdata->win), GTK_DIALOG_MODAL, + (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); + 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); + 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); + gtk_container_add (GTK_CONTAINER (scrolled), mugdata->mlist); + gtk_paned_add1 (GTK_PANED (paned), scrolled); - mugdata->msgview = mug_msg_view_new(); + 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); + 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); + 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_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); + gtk_widget_show_all (queryarea); return queryarea; } -static GtkWidget *mug_main_area(MugData * mugdata) +static GtkWidget * +mug_main_area (MugData * mugdata) { 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); + w = mug_shortcuts_bar (mugdata); + gtk_box_pack_start (GTK_BOX (mainarea), w, FALSE, FALSE, 0); + gtk_widget_show (w); - w = mug_query_area(mugdata); - gtk_box_pack_start(GTK_BOX(mainarea), w, TRUE, TRUE, 0); - gtk_widget_show(w); + 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"); + 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); + 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); - mugdata->statusbar = mug_statusbar(); - gtk_box_pack_start(GTK_BOX(vbox), mugdata->statusbar, FALSE, FALSE, 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_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); + 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; @@ -333,30 +354,30 @@ int main(int argc, char *argv[]) {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); + mu_runtime_init (mugdata.muhome); - mugshell = mug_shell(&mugdata); - g_signal_connect(G_OBJECT(mugshell), "destroy", - G_CALLBACK(gtk_main_quit), NULL); + 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_widget_show (mugshell); + mug_query_bar_grab_focus (MUG_QUERY_BAR (mugdata.querybar)); - gtk_main(); - g_free(mugdata.muhome); + gtk_main (); + g_free (mugdata.muhome); - mu_runtime_uninit(); + mu_runtime_uninit (); return 0; }