emacs
/
mu
mirror of https://github.com/djcb/mu.git
1
0
Fork 0
Code Issues Releases Wiki Activity

* mug: fix header clearing + code reindentation

This commit is contained in:
Dirk-Jan C. Binnema 2010-11-27 13:31:26 +02:00
parent 2fabf5b564
commit ac1b942dd8
9 changed files with 664 additions and 756 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

447
toys/mug/mug-msg-list-view.c
View File

@ -23,9 +23,9 @@
/* include other impl specific header files */ /* include other impl specific header files */
/* 'private'/'protected' functions */ /* 'private'/'protected' functions */
static void mug_msg_list_view_class_init (MugMsgListViewClass *klass); 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_init(MugMsgListView * obj);
static void mug_msg_list_view_finalize (GObject *obj); static void mug_msg_list_view_finalize(GObject * obj);
/* list my signals */ /* list my signals */
enum { enum {
@ -34,7 +34,6 @@ enum {
LAST_SIGNAL LAST_SIGNAL
}; };
enum { enum {
MUG_COL_DATESTR, MUG_COL_DATESTR,
MUG_COL_MAILDIR, MUG_COL_MAILDIR,
@ -62,262 +61,236 @@ struct _MugMsgListViewPrivate {
static GtkTreeViewClass *parent_class = NULL; static GtkTreeViewClass *parent_class = NULL;
/* uncomment the following if you have defined any signals */ /* 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; 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; gobject_class->finalize = mug_msg_list_view_finalize;
g_type_class_add_private (gobject_class, g_type_class_add_private(gobject_class, sizeof(MugMsgListViewPrivate));
sizeof(MugMsgListViewPrivate));
signals[MUG_MSG_SELECTED] = signals[MUG_MSG_SELECTED] =
g_signal_new ("msg-selected", g_signal_new("msg-selected",
G_TYPE_FROM_CLASS(gobject_class), G_TYPE_FROM_CLASS(gobject_class),
G_SIGNAL_RUN_FIRST, G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET(MugMsgListViewClass, G_STRUCT_OFFSET(MugMsgListViewClass,
msg_selected), msg_selected),
NULL, NULL, NULL, NULL,
g_cclosure_marshal_VOID__STRING, g_cclosure_marshal_VOID__STRING,
G_TYPE_NONE, 1, G_TYPE_STRING); G_TYPE_NONE, 1, G_TYPE_STRING);
signals[MUG_ERROR_OCCURED] = signals[MUG_ERROR_OCCURED] =
g_signal_new ("error-occured", g_signal_new("error-occured",
G_TYPE_FROM_CLASS(gobject_class), G_TYPE_FROM_CLASS(gobject_class),
G_SIGNAL_RUN_FIRST, G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET(MugMsgListViewClass, G_STRUCT_OFFSET(MugMsgListViewClass,
error_occured), error_occured),
NULL, NULL, NULL, NULL,
g_cclosure_marshal_VOID__UINT, g_cclosure_marshal_VOID__UINT,
G_TYPE_NONE, 1, G_TYPE_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; GtkTreeSelection *sel;
GtkTreeIter iter; GtkTreeIter iter;
MugMsgListViewPrivate *priv; 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) if (!sel)
return; /* hmmm */ return; /* hmmm */
if (gtk_tree_selection_get_selected (sel, NULL, &iter)) { if (gtk_tree_selection_get_selected(sel, NULL, &iter)) {
char *path; char *path;
gtk_tree_model_get (GTK_TREE_MODEL(priv->_store), &iter, gtk_tree_model_get(GTK_TREE_MODEL(priv->_store), &iter,
MUG_COL_PATH, &path, -1); MUG_COL_PATH, &path, -1);
g_signal_emit (G_OBJECT(lst), g_signal_emit(G_OBJECT(lst),
signals[MUG_MSG_SELECTED], 0, signals[MUG_MSG_SELECTED], 0, path);
path); g_free(path);
g_free (path);
} }
} }
static void static void
treecell_func (GtkTreeViewColumn *tree_column, GtkCellRenderer *renderer, treecell_func(GtkTreeViewColumn * tree_column, GtkCellRenderer * renderer,
GtkTreeModel *tree_model, GtkTreeIter *iter, gpointer data) GtkTreeModel * tree_model, GtkTreeIter * iter, gpointer data)
{ {
MuMsgFlags flags; MuMsgFlags flags;
MuMsgPrio prio; 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' */ /* sortcolidx == -1 means 'sortcolidx = colidx' */
static void static void
append_col (GtkTreeView *treeview, const char* label, int colidx, int sortcolidx, append_col(GtkTreeView * treeview, const char *label, int colidx,
gint maxwidth) int sortcolidx, gint maxwidth)
{ {
GtkTreeViewColumn *col; GtkTreeViewColumn *col;
GtkCellRenderer *renderer; 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) if (sortcolidx == -1)
sortcolidx = colidx; sortcolidx = colidx;
gtk_tree_view_column_set_sort_column_id (col, sortcolidx); gtk_tree_view_column_set_sort_column_id(col, sortcolidx);
if (maxwidth) { if (maxwidth) {
gtk_tree_view_column_set_sizing (col, GTK_TREE_VIEW_COLUMN_FIXED); gtk_tree_view_column_set_sizing(col,
gtk_tree_view_column_set_fixed_width (col, maxwidth); GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_column_set_expand (col, FALSE); gtk_tree_view_column_set_fixed_width(col, maxwidth);
} else { gtk_tree_view_column_set_expand(col, FALSE);
//gtk_tree_view_column_set_sizing (col, GTK_TREE_VIEW_COLUMN_GROW_ONLY); } 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, gtk_tree_view_column_set_cell_data_func(col, renderer,
(GtkTreeCellDataFunc) treecell_func, (GtkTreeCellDataFunc)
NULL, NULL); treecell_func, NULL, NULL);
gtk_tree_view_append_column (treeview, col); gtk_tree_view_append_column(treeview, col);
} }
static void static void mug_msg_list_view_init(MugMsgListView * obj)
mug_msg_list_view_init (MugMsgListView *obj)
{ {
MugMsgListViewPrivate *priv; MugMsgListViewPrivate *priv;
GtkTreeView *tview; 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); priv = MUG_MSG_LIST_VIEW_GET_PRIVATE(obj);
gtk_tree_view_set_model (tview, GTK_TREE_MODEL(priv->_store));
gtk_tree_view_set_headers_clickable (GTK_TREE_VIEW(obj), TRUE); priv->_xpath = priv->_query = NULL;
gtk_tree_view_set_grid_lines (GTK_TREE_VIEW(obj), priv->_store = gtk_list_store_new(MUG_N_COLS, G_TYPE_STRING, /* date */
GTK_TREE_VIEW_GRID_LINES_VERTICAL); G_TYPE_STRING, /* folder */
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW(obj), TRUE); G_TYPE_STRING, /* flagstr */
G_TYPE_STRING, /* from */
append_col (tview, "Date", MUG_COL_DATESTR, MUG_COL_TIME, 80); G_TYPE_STRING, /* to */
append_col (tview, "Folder", MUG_COL_MAILDIR, -1, 60); G_TYPE_STRING, /* subject */
append_col (tview, "F", MUG_COL_FLAGSSTR, -1, 25); G_TYPE_STRING, /* path */
append_col (tview, "From", MUG_COL_FROM, -1, 0); G_TYPE_UINT, /* prio */
append_col (tview, "To", MUG_COL_TO, -1, 0); G_TYPE_UINT, /* flags */
append_col (tview, "Subject", MUG_COL_SUBJECT, -1, 0); G_TYPE_INT); /* timeval */
g_signal_connect (G_OBJECT(obj), "cursor-changed", tview = GTK_TREE_VIEW(obj);
G_CALLBACK(on_cursor_changed), 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 static void mug_msg_list_view_finalize(GObject * obj)
mug_msg_list_view_finalize (GObject *obj) {
{
MugMsgListViewPrivate *priv; MugMsgListViewPrivate *priv;
priv = MUG_MSG_LIST_VIEW_GET_PRIVATE(obj); priv = MUG_MSG_LIST_VIEW_GET_PRIVATE(obj);
if (priv->_store) if (priv->_store)
g_object_unref (priv->_store); g_object_unref(priv->_store);
g_free (priv->_xpath); g_free(priv->_xpath);
g_free (priv->_query); g_free(priv->_query);
G_OBJECT_CLASS(parent_class)->finalize (obj); G_OBJECT_CLASS(parent_class)->finalize(obj);
} }
void void mug_msg_list_view_move_first(MugMsgListView * self)
mug_msg_list_view_move_first (MugMsgListView *self)
{ {
GtkTreePath *path; GtkTreePath *path;
g_return_if_fail (MUG_IS_MSG_LIST_VIEW(self));
path = gtk_tree_path_new_first (); g_return_if_fail(MUG_IS_MSG_LIST_VIEW(self));
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; 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) if (!path)
return FALSE; return FALSE;
if (next) if (next)
gtk_tree_path_next (path); gtk_tree_path_next(path);
else else
gtk_tree_path_prev (path); gtk_tree_path_prev(path);
gtk_tree_view_set_cursor (GTK_TREE_VIEW(self), path, gtk_tree_view_set_cursor(GTK_TREE_VIEW(self), path, NULL, FALSE);
NULL, FALSE); gtk_tree_path_free(path);
gtk_tree_path_free (path);
return TRUE; 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* GtkWidget *mug_msg_list_view_new(const char *xpath)
mug_msg_list_view_new (const char *xpath)
{ {
GtkWidget *w; GtkWidget *w;
MugMsgListViewPrivate *priv; 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 = MUG_MSG_LIST_VIEW_GET_PRIVATE(w);
priv->_xpath = g_strdup (xpath); priv->_xpath = g_strdup(xpath);
return w; return w;
} }
static gchar *empty_or_display_contact(const gchar * str)
static gchar*
empty_or_display_contact (const gchar* str)
{ {
if (!str || *str == '\0') if (!str || *str == '\0')
return g_strdup ("-"); return g_strdup("-");
else else
return mu_str_display_contact (str); return mu_str_display_contact(str);
} }
static MugError static MugError mu_result_to_mug_error(MuResult r)
mu_result_to_mug_error (MuResult r)
{ {
switch (r) { switch (r) {
case MU_ERROR_XAPIAN_DIR: 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,
static MuMsgIter * MugMsgListView * self)
run_query (const char *xpath, const char *query,
MugMsgListView *self)
{ {
GError *err; GError *err;
MuQuery *xapian; MuQuery *xapian;
MuMsgIter *iter; MuMsgIter *iter;
err = NULL; err = NULL;
xapian = mu_query_new (xpath, &err); xapian = mu_query_new(xpath, &err);
if (!xapian) { if (!xapian) {
g_warning ("Error: %s", err->message); g_warning("Error: %s", err->message);
g_signal_emit (G_OBJECT(self), g_signal_emit(G_OBJECT(self),
signals[MUG_ERROR_OCCURED], 0, signals[MUG_ERROR_OCCURED], 0,
mu_result_to_mug_error (err->code)); mu_result_to_mug_error(err->code));
g_error_free (err); g_error_free(err);
return NULL; return NULL;
} }
iter = mu_query_run (xapian, query, iter = mu_query_run(xapian, query, MU_MSG_FIELD_ID_DATE, TRUE, 0, &err);
MU_MSG_FIELD_ID_DATE, mu_query_destroy(xapian);
TRUE, 0, &err);
mu_query_destroy (xapian);
if (!iter) { if (!iter) {
g_warning ("Error: %s", err->message); g_warning("Error: %s", err->message);
g_signal_emit (G_OBJECT(self), g_signal_emit(G_OBJECT(self),
signals[MUG_ERROR_OCCURED], 0, signals[MUG_ERROR_OCCURED], 0,
mu_result_to_mug_error (err->code)); mu_result_to_mug_error(err->code));
g_error_free (err); g_error_free(err);
return NULL; return NULL;
} }
return iter; return iter;
} }
static void static void add_row(GtkListStore * store, MuMsgIter * iter)
add_row (GtkListStore *store, MuMsgIter *iter)
{ {
GtkTreeIter treeiter; GtkTreeIter treeiter;
const gchar *datestr, *flagstr; const gchar *datestr, *flagstr;
gchar *from, *to; gchar *from, *to;
time_t timeval; time_t timeval;
timeval = mu_msg_iter_get_date (iter); timeval = mu_msg_iter_get_date(iter);
datestr = timeval == 0 ? "-" : mu_str_display_date_s (timeval); datestr = timeval == 0 ? "-" : mu_str_display_date_s(timeval);
from = empty_or_display_contact (mu_msg_iter_get_from(iter)); from = empty_or_display_contact(mu_msg_iter_get_from(iter));
to = empty_or_display_contact (mu_msg_iter_get_to(iter)); to = empty_or_display_contact(mu_msg_iter_get_to(iter));
flagstr = mu_msg_flags_str_s(mu_msg_iter_get_flags (iter)); flagstr = mu_msg_flags_str_s(mu_msg_iter_get_flags(iter));
gtk_list_store_append (store, &treeiter); gtk_list_store_append(store, &treeiter);
gtk_list_store_set (store, &treeiter, gtk_list_store_set(store, &treeiter,
MUG_COL_DATESTR, datestr, MUG_COL_DATESTR, datestr,
MUG_COL_MAILDIR, mu_msg_iter_get_maildir (iter), MUG_COL_MAILDIR, mu_msg_iter_get_maildir(iter),
MUG_COL_FLAGSSTR, flagstr, MUG_COL_FLAGSSTR, flagstr,
MUG_COL_FROM, from, MUG_COL_FROM, from,
MUG_COL_TO, to, MUG_COL_TO, to,
MUG_COL_SUBJECT,mu_msg_iter_get_subject (iter), MUG_COL_SUBJECT, mu_msg_iter_get_subject(iter),
MUG_COL_PATH, mu_msg_iter_get_path (iter), MUG_COL_PATH, mu_msg_iter_get_path(iter),
MUG_COL_PRIO, mu_msg_iter_get_prio(iter), MUG_COL_PRIO, mu_msg_iter_get_prio(iter),
MUG_COL_FLAGS, mu_msg_iter_get_flags(iter), MUG_COL_FLAGS, mu_msg_iter_get_flags(iter),
MUG_COL_TIME, timeval, MUG_COL_TIME, timeval, -1);
-1); g_free(from);
g_free (from); g_free(to);
g_free (to);
} }
static int static int
update_model (GtkListStore *store, const char *xpath, const char *query, update_model(GtkListStore * store, const char *xpath, const char *query,
MugMsgListView *self) MugMsgListView * self)
{ {
MuMsgIter *iter; MuMsgIter *iter;
int count; int count;
iter = run_query (xpath, query, self); iter = run_query(xpath, query, self);
if (!iter) { if (!iter) {
g_warning ("error: running query failed\n"); g_warning("error: running query failed\n");
return -1; return -1;
} }
for (count = 0; !mu_msg_iter_is_done (iter); for (count = 0; !mu_msg_iter_is_done(iter);
mu_msg_iter_next (iter), ++count) mu_msg_iter_next(iter), ++count)
add_row (store, iter); add_row(store, iter);
mu_msg_iter_destroy (iter); mu_msg_iter_destroy(iter);
return count; 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; MugMsgListViewPrivate *priv;
gboolean rv; 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; priv->_query = query ? g_strdup(query) : NULL;
if (!query) if (!query)
return TRUE; 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; 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;
} }

30
toys/mug/mug-msg-list-view.h
View File

@ -24,7 +24,6 @@
#include <mu-result.h> #include <mu-result.h>
G_BEGIN_DECLS G_BEGIN_DECLS
/* convenience macros */ /* convenience macros */
#define MUG_TYPE_MSG_LIST_VIEW (mug_msg_list_view_get_type()) #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)) #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(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_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)) #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; typedef struct _MugMsgListViewClass MugMsgListViewClass;
struct _MugMsgListView { struct _MugMsgListView {
GtkTreeView parent; GtkTreeView parent;
/* insert public members, if any */ /* insert public members, if any */
}; };
@ -49,32 +47,28 @@ enum _MugError {
}; };
typedef enum _MugError MugError; typedef enum _MugError MugError;
struct _MugMsgListViewClass { struct _MugMsgListViewClass {
GtkTreeViewClass parent_class; GtkTreeViewClass parent_class;
/* insert signal callback declarations, e.g. */ /* insert signal callback declarations, e.g. */
void (* msg_selected) (MugMsgListView* obj, const char* msgpath); void (*msg_selected) (MugMsgListView * obj, const char *msgpath);
void (* error_occured) (MugMsgListView* obj, MugError err); void (*error_occured) (MugMsgListView * obj, MugError err);
}; };
/* member functions */ /* 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) */ /* parameter-less _new function (constructor) */
/* if this is a kind of GtkWidget, it should probably return at GtkWidget* */ /* 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); const gchar *mug_msg_list_view_get_query(MugMsgListView * self);
gboolean mug_msg_list_view_move_next (MugMsgListView *self);
const gchar* mug_msg_list_view_get_query (MugMsgListView *self);
G_END_DECLS G_END_DECLS
#endif /* __MUG_MSG_LIST_VIEW_H__ */
#endif /* __MUG_MSG_LIST_VIEW_H__ */

307
toys/mug/mug-msg-view.c
View File

@ -17,15 +17,14 @@
** **
*/ */
#include "mug-msg-view.h" #include "mug-msg-view.h"
#include "mu-msg.h" #include "mu-msg.h"
#include "mu-str.h" #include "mu-str.h"
/* 'private'/'protected' functions */ /* 'private'/'protected' functions */
static void mug_msg_view_class_init (MugMsgViewClass *klass); static void mug_msg_view_class_init(MugMsgViewClass * klass);
static void mug_msg_view_init (MugMsgView *obj); static void mug_msg_view_init(MugMsgView * obj);
static void mug_msg_view_finalize (GObject *obj); static void mug_msg_view_finalize(GObject * obj);
/* list my signals */ /* list my signals */
enum { enum {
@ -47,24 +46,24 @@ enum _HeaderRow {
}; };
typedef enum _HeaderRow HeaderRow; typedef enum _HeaderRow HeaderRow;
struct _HeaderInfo { struct _HeaderInfo {
HeaderRow row; HeaderRow row;
const char *title; const char *title;
}; };
typedef struct _HeaderInfo HeaderInfo; typedef struct _HeaderInfo HeaderInfo;
static const HeaderInfo HEADER_INFO[] = { static const HeaderInfo HEADER_INFO[] = {
{HEADER_ROW_CC, "Cc"}, {HEADER_ROW_CC, "Cc"},
{HEADER_ROW_SUBJECT, "Subject"}, {HEADER_ROW_SUBJECT, "Subject"},
{HEADER_ROW_DATE, "Date"} {HEADER_ROW_DATE, "Date"}
}; };
static const HeaderInfo HEADER_INFO_EXPANDER[] = { static const HeaderInfo HEADER_INFO_EXPANDER[] = {
{HEADER_ROW_FROM, "From"}, {HEADER_ROW_FROM, "From"},
{HEADER_ROW_TO, "To"}, {HEADER_ROW_TO, "To"},
{HEADER_ROW_PATH, "Path"}, {HEADER_ROW_PATH, "Path"},
{HEADER_ROW_MSGID, "Message-Id" }, {HEADER_ROW_MSGID, "Message-Id"},
{HEADER_ROW_SIZE, "Size"} {HEADER_ROW_SIZE, "Size"}
}; };
typedef struct _MugMsgViewPrivate MugMsgViewPrivate; typedef struct _MugMsgViewPrivate MugMsgViewPrivate;
@ -72,32 +71,29 @@ struct _MugMsgViewPrivate {
GtkWidget *_headers_area; GtkWidget *_headers_area;
GtkWidget *_tablemain, *_tableexpander; GtkWidget *_tablemain, *_tableexpander;
GtkWidget *_headervals [HEADER_ROW_NUM]; GtkWidget *_headervals[HEADER_ROW_NUM];
GtkWidget *_expander_header, *_expander; GtkWidget *_expander_header, *_expander;
GtkWidget *_view; GtkWidget *_view;
}; };
#define MUG_MSG_VIEW_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE((o), \ #define MUG_MSG_VIEW_GET_PRIVATE(o)(G_TYPE_INSTANCE_GET_PRIVATE((o),MUG_TYPE_MSG_VIEW, MugMsgViewPrivate))
MUG_TYPE_MSG_VIEW, MugMsgViewPrivate))
/* globals */ /* globals */
static GtkVBoxClass *parent_class = NULL; static GtkVBoxClass *parent_class = NULL;
/* uncomment the following if you have defined any signals */ /* uncomment the following if you have defined any signals */
/* static guint signals[LAST_SIGNAL] = {0}; */ /* 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; 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; 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.: */ /* signal definitions go here, e.g.: */
/* signals[MY_SIGNAL_1] = */ /* signals[MY_SIGNAL_1] = */
@ -107,198 +103,207 @@ mug_msg_view_class_init (MugMsgViewClass *klass)
/* etc. */ /* etc. */
} }
static GtkWidget *create_table(MugMsgViewPrivate * priv,
static GtkWidget* const HeaderInfo * hinfo, guint num)
create_table (MugMsgViewPrivate *priv, const HeaderInfo *hinfo, guint num)
{ {
guint i; guint i;
GtkWidget *table; GtkWidget *table;
table = gtk_table_new (num, 2, FALSE); table = gtk_table_new(num, 2, FALSE);
gtk_table_set_col_spacings (GTK_TABLE(table), 5); gtk_table_set_col_spacings(GTK_TABLE(table), 5);
for (i = 0; i < num; ++i) { for (i = 0; i < num; ++i) {
char *str; char *str;
GtkWidget *l, *al; 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 ("<b>%s</b>:", 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); l = gtk_label_new(NULL);
gtk_container_add (GTK_CONTAINER(al), l); gtk_misc_set_alignment(GTK_MISC(l), 0.0, 0.5);
gtk_table_attach (GTK_TABLE(table), al, 0, 1, i, i+1,
GTK_FILL, 0, 0, 0); gtk_label_set_justify(GTK_LABEL(l), GTK_JUSTIFY_LEFT);
str = g_strdup_printf("<b>%s</b>:", hinfo[i].title);
l = priv->_headervals[hinfo[i].row] = gtk_label_new (NULL); gtk_label_set_markup(GTK_LABEL(l), str);
g_free(str);
al = gtk_alignment_new(0.0, 0.0, 0.0, 0.0); 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_table_attach(GTK_TABLE(table), al, 0, 1, i, i + 1,
gtk_container_add (GTK_CONTAINER(al), l); GTK_FILL, 0, 0, 0);
gtk_label_set_justify (GTK_LABEL(l), GTK_JUSTIFY_LEFT);
gtk_label_set_line_wrap_mode (GTK_LABEL(l), PANGO_WRAP_WORD_CHAR); l = priv->_headervals[hinfo[i].row] = gtk_label_new(NULL);
gtk_label_set_line_wrap (GTK_LABEL(l), FALSE); al = gtk_alignment_new(0.0, 0.0, 0.0, 0.0);
gtk_table_attach (GTK_TABLE(table), al, gtk_label_set_selectable(GTK_LABEL(l), TRUE);
1, 2, i, i+1,
GTK_FILL, gtk_container_add(GTK_CONTAINER(al), l);
0, 0, 0); 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; return table;
} }
static GtkWidget* static GtkWidget *headers_area(MugMsgViewPrivate * priv)
headers_area (MugMsgViewPrivate *priv)
{ {
GtkWidget *scrolled, *vbox; 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); priv->_tablemain = create_table(priv, HEADER_INFO,
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW(scrolled), G_N_ELEMENTS(HEADER_INFO));
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); priv->_tableexpander = create_table
gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW(scrolled), vbox); (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; return priv->_headers_area = scrolled;
} }
static void mug_msg_view_init(MugMsgView * obj)
static void
mug_msg_view_init (MugMsgView *obj)
{ {
MugMsgViewPrivate *priv; MugMsgViewPrivate *priv;
GtkWidget *scrolled; 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);
scrolled = gtk_scrolled_window_new (NULL, NULL); priv->_view = gtk_text_view_new();
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW(scrolled), gtk_text_view_set_editable(GTK_TEXT_VIEW(priv->_view), FALSE);
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_text_view_set_left_margin(GTK_TEXT_VIEW(priv->_view), 10);
gtk_container_add (GTK_CONTAINER (scrolled), priv->_view); gtk_text_view_set_right_margin(GTK_TEXT_VIEW(priv->_view), 10);
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_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 static void mug_msg_view_finalize(GObject * obj)
mug_msg_view_finalize (GObject *obj)
{ {
/* free/unref instance resources here */ /* free/unref instance resources here */
G_OBJECT_CLASS(parent_class)->finalize (obj); G_OBJECT_CLASS(parent_class)->finalize(obj);
} }
GtkWidget* GtkWidget *mug_msg_view_new(void)
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)
{
int i;
MugMsgViewPrivate *priv;
GtkTextBuffer *buf;
gboolean priv = MUG_MSG_VIEW_GET_PRIVATE(self);
mug_msg_view_set_text (MugMsgView *self, const char* txt)
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; MugMsgViewPrivate *priv;
GtkTextBuffer *buf; 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); priv = MUG_MSG_VIEW_GET_PRIVATE(self);
buf = gtk_text_view_get_buffer (GTK_TEXT_VIEW(priv->_view)); buf = gtk_text_view_get_buffer(GTK_TEXT_VIEW(priv->_view));
gtk_text_buffer_set_text (buf, txt ? txt : "", -1); gtk_text_buffer_set_text(buf, txt ? txt : "", -1);
return TRUE; 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) { for (i = 0; i != HEADER_ROW_NUM; ++i) {
const gchar* val; const gchar *val;
switch (i) { switch (i) {
case HEADER_ROW_FROM: val = mu_msg_get_from(msg); break; case HEADER_ROW_FROM:
case HEADER_ROW_TO: val = mu_msg_get_to(msg); break; val = mu_msg_get_from(msg);
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; 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; 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; 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); gtk_label_set_markup
g_free (str); (GTK_LABEL(priv->_headervals[i]), str);
} g_free(str);
}
} }
gtk_widget_show (priv->_tablemain);
gtk_widget_show (priv->_expander);
} }
gboolean gboolean mug_msg_view_set_msg(MugMsgView * self, const char *msgpath)
mug_msg_view_set_msg (MugMsgView *self, const char* msgpath)
{ {
MugMsgViewPrivate *priv; MugMsgViewPrivate *priv;
MuMsg* msg; MuMsg *msg;
gboolean rv; 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) { if (!msgpath) {
mug_msg_view_set_text (self, ""); empty_message(self);
gtk_widget_hide (priv->_headers_area);
return TRUE; return TRUE;
} }
msg = mu_msg_new (msgpath, NULL, NULL); msg = mu_msg_new(msgpath, NULL, NULL);
if (!msg) { if (!msg) {
gtk_widget_hide (priv->_tablemain); empty_message(self);
gtk_widget_hide (priv->_expander); set_text(self, "Message not found; " "please run 'mu index'");
mug_msg_view_set_text (self, return FALSE;
"Message not found; "
"please run 'mu index'");
return FALSE;
} }
rv = mug_msg_view_set_text (self, mu_msg_get_body_text(msg)); rv = set_text(self, mu_msg_get_body_text(msg));
fill_header (priv, msg); fill_header(priv, msg);
gtk_widget_show (priv->_headers_area);
mu_msg_destroy(msg);
mu_msg_destroy (msg);
return rv; return rv;
} }

18
toys/mug/mug-msg-view.h
View File

@ -17,7 +17,6 @@
** **
*/ */
#ifndef __MUG_MSG_VIEW_H__ #ifndef __MUG_MSG_VIEW_H__
#define __MUG_MSG_VIEW_H__ #define __MUG_MSG_VIEW_H__
@ -25,7 +24,6 @@
/* other include files */ /* other include files */
G_BEGIN_DECLS G_BEGIN_DECLS
/* convenience macros */ /* convenience macros */
#define MUG_TYPE_MSG_VIEW (mug_msg_view_get_type()) #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)) #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(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_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)) #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; typedef struct _MugMsgViewClass MugMsgViewClass;
struct _MugMsgView { struct _MugMsgView {
GtkVBox parent; GtkVBox parent;
/* insert public members, if any */ /* insert public members, if any */
}; };
@ -49,15 +46,12 @@ struct _MugMsgViewClass {
}; };
/* member functions */ /* 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) */ /* parameter-less _new function (constructor) */
/* if this is a kind of GtkWidget, it should probably return at GtkWidget* */ /* if this is a kind of GtkWidget, it should probably return at GtkWidget* */
GtkWidget* mug_msg_view_new (void); GtkWidget *mug_msg_view_new(void);
gboolean mug_msg_view_set_msg (MugMsgView *self, const char* msgpath); gboolean mug_msg_view_set_msg(MugMsgView * self, const char *msgpath);
gboolean mug_msg_view_set_text (MugMsgView *self, const char* txt);
G_END_DECLS G_END_DECLS
#endif /* __MUG_MSG_VIEW_H__ */
#endif /* __MUG_MSG_VIEW_H__ */

104
toys/mug/mug-query-bar.c
View File

@ -6,9 +6,9 @@
/* include other impl specific header files */ /* include other impl specific header files */
/* 'private'/'protected' functions */ /* 'private'/'protected' functions */
static void mug_query_bar_class_init (MugQueryBarClass *klass); static void mug_query_bar_class_init(MugQueryBarClass * klass);
static void mug_query_bar_init (MugQueryBar *obj); static void mug_query_bar_init(MugQueryBar * obj);
static void mug_query_bar_finalize (GObject *obj); static void mug_query_bar_finalize(GObject * obj);
/* list my signals */ /* list my signals */
enum { enum {
@ -26,116 +26,104 @@ struct _MugQueryBarPrivate {
/* globals */ /* globals */
static GtkContainerClass *parent_class = NULL; static GtkContainerClass *parent_class = NULL;
static guint signals[LAST_SIGNAL] = {0}; static guint signals[LAST_SIGNAL] = { 0 };
GType GType mug_query_bar_get_type(void)
mug_query_bar_get_type (void)
{ {
static GType my_type = 0; static GType my_type = 0;
if (!my_type) { if (!my_type) {
static const GTypeInfo my_info = { static const GTypeInfo my_info = {
sizeof(MugQueryBarClass), sizeof(MugQueryBarClass),
NULL, /* base init */ NULL, /* base init */
NULL, /* base finalize */ NULL, /* base finalize */
(GClassInitFunc) mug_query_bar_class_init, (GClassInitFunc) mug_query_bar_class_init,
NULL, /* class finalize */ NULL, /* class finalize */
NULL, /* class data */ NULL, /* class data */
sizeof(MugQueryBar), sizeof(MugQueryBar),
0, /* n_preallocs, ignored since 2.10 */ 0, /* n_preallocs, ignored since 2.10 */
(GInstanceInitFunc) mug_query_bar_init, (GInstanceInitFunc) mug_query_bar_init,
NULL NULL
}; };
my_type = g_type_register_static (GTK_TYPE_HBOX, my_type = g_type_register_static(GTK_TYPE_HBOX,
"MugQueryBar", "MugQueryBar", &my_info, 0);
&my_info, 0);
} }
return my_type; return my_type;
} }
static void static void mug_query_bar_class_init(MugQueryBarClass * klass)
mug_query_bar_class_init (MugQueryBarClass *klass)
{ {
GObjectClass *gobject_class; 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; 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.: */ /* signal definitions go here, e.g.: */
signals[MUG_QUERY_CHANGED] = signals[MUG_QUERY_CHANGED] =
g_signal_new ("query_changed", g_signal_new("query_changed",
G_TYPE_FROM_CLASS(gobject_class), G_TYPE_FROM_CLASS(gobject_class),
G_SIGNAL_RUN_FIRST, G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET(MugQueryBarClass, query_changed), G_STRUCT_OFFSET(MugQueryBarClass, query_changed),
NULL, NULL, NULL, NULL,
g_cclosure_marshal_VOID__STRING, g_cclosure_marshal_VOID__STRING,
G_TYPE_NONE, 1, G_TYPE_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;
{
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, g_signal_emit(G_OBJECT(bar), signals[MUG_QUERY_CHANGED], 0,
gtk_entry_get_text(GTK_ENTRY(w))); gtk_entry_get_text(GTK_ENTRY(w)));
} }
static void static void mug_query_bar_init(MugQueryBar * obj)
mug_query_bar_init (MugQueryBar *obj)
{ {
MugQueryBarPrivate *priv; 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), g_signal_connect(priv->_entry, "activate",
obj); 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 static void mug_query_bar_finalize(GObject * obj)
mug_query_bar_finalize (GObject *obj)
{ {
/* free/unref instance resources here */ /* free/unref instance resources here */
G_OBJECT_CLASS(parent_class)->finalize (obj); G_OBJECT_CLASS(parent_class)->finalize(obj);
} }
GtkWidget* GtkWidget *mug_query_bar_new(void)
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 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; 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); 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) 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_grab_focus
(GTK_WIDGET(MUG_QUERY_BAR_GET_PRIVATE(self)->_entry)); (GTK_WIDGET(MUG_QUERY_BAR_GET_PRIVATE(self)->_entry));
} }

21
toys/mug/mug-query-bar.h
View File

@ -8,7 +8,6 @@
/* other include files */ /* other include files */
G_BEGIN_DECLS G_BEGIN_DECLS
/* convenience macros */ /* convenience macros */
#define MUG_TYPE_QUERY_BAR (mug_query_bar_get_type()) #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)) #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(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_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)) #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; typedef struct _MugQueryBarClass MugQueryBarClass;
struct _MugQueryBar { struct _MugQueryBar {
GtkHBox parent; GtkHBox parent;
/* insert public members, if any */ /* insert public members, if any */
}; };
struct _MugQueryBarClass { struct _MugQueryBarClass {
GtkHBoxClass parent_class; GtkHBoxClass parent_class;
/* insert signal callback declarations, e.g. */ /* insert signal callback declarations, e.g. */
void (* query_changed) (MugQueryBar* obj, const char *query); void (*query_changed) (MugQueryBar * obj, const char *query);
}; };
/* member functions */ /* 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) */ /* parameter-less _new function (constructor) */
/* if this is a kind of GtkWidget, it should probably return at GtkWidget* */ /* 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 G_END_DECLS
#endif /* __MUG_QUERY_BAR_H__ */
#endif /* __MUG_QUERY_BAR_H__ */

104
toys/mug/mug-shortcuts.c
View File

@ -23,9 +23,9 @@
/* include other impl specific header files */ /* include other impl specific header files */
/* 'private'/'protected' functions */ /* 'private'/'protected' functions */
static void mug_shortcuts_class_init (MugShortcutsClass *klass); static void mug_shortcuts_class_init(MugShortcutsClass * klass);
static void mug_shortcuts_init (MugShortcuts *obj); static void mug_shortcuts_init(MugShortcuts * obj);
static void mug_shortcuts_finalize (GObject *obj); static void mug_shortcuts_finalize(GObject * obj);
#define MUG_SHORTCUT_BOOKMARK "bookmark" #define MUG_SHORTCUT_BOOKMARK "bookmark"
@ -39,7 +39,7 @@ enum {
struct _MugShortcutsPrivate { struct _MugShortcutsPrivate {
GtkWidget *_bbox; GtkWidget *_bbox;
}; };
#define MUG_SHORTCUTS_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE((o), \ #define MUG_SHORTCUTS_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE((o), \
MUG_TYPE_SHORTCUTS, \ MUG_TYPE_SHORTCUTS, \
@ -47,109 +47,99 @@ struct _MugShortcutsPrivate {
/* globals */ /* globals */
static GtkVBoxClass *parent_class = NULL; 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 static void mug_shortcuts_class_init(MugShortcutsClass * klass)
mug_shortcuts_class_init (MugShortcutsClass *klass)
{ {
GObjectClass *gobject_class; 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; 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.: */ /* signal definitions go here, e.g.: */
signals[SHORTCUT_CLICKED] = signals[SHORTCUT_CLICKED] =
g_signal_new ("clicked", g_signal_new("clicked",
G_TYPE_FROM_CLASS(gobject_class), G_TYPE_FROM_CLASS(gobject_class),
G_SIGNAL_RUN_FIRST, G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET(MugShortcutsClass, clicked), G_STRUCT_OFFSET(MugShortcutsClass, clicked),
NULL, NULL, NULL, NULL,
g_cclosure_marshal_VOID__STRING, g_cclosure_marshal_VOID__STRING,
G_TYPE_NONE, 1, G_TYPE_STRING); G_TYPE_NONE, 1, G_TYPE_STRING);
/* signals[MY_SIGNAL_2] = */ /* signals[MY_SIGNAL_2] = */
/* g_signal_new ("my_signal_2",....); */ /* g_signal_new ("my_signal_2",....); */
/* etc. */ /* etc. */
} }
static void static void mug_shortcuts_init(MugShortcuts * obj)
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 (); obj->_priv->_bbox = gtk_vbutton_box_new();
gtk_button_box_set_layout (GTK_BUTTON_BOX(obj->_priv->_bbox), gtk_button_box_set_layout(GTK_BUTTON_BOX(obj->_priv->_bbox),
GTK_BUTTONBOX_START); GTK_BUTTONBOX_START);
gtk_box_pack_start (GTK_BOX(obj), obj->_priv->_bbox, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(obj), obj->_priv->_bbox, TRUE, TRUE, 0);
} }
static void static void mug_shortcuts_finalize(GObject * obj)
mug_shortcuts_finalize (GObject *obj)
{ {
/* free/unref instance resources here */ /* free/unref instance resources here */
G_OBJECT_CLASS(parent_class)->finalize (obj); G_OBJECT_CLASS(parent_class)->finalize(obj);
} }
static void static void on_button_clicked(GtkWidget * button, MugShortcuts * self)
on_button_clicked (GtkWidget *button, MugShortcuts *self)
{ {
g_signal_emit (G_OBJECT(self), g_signal_emit(G_OBJECT(self),
signals[SHORTCUT_CLICKED], 0, signals[SHORTCUT_CLICKED], 0,
(const gchar*)g_object_get_data (G_OBJECT(button), (const gchar *)g_object_get_data(G_OBJECT(button),
MUG_SHORTCUT_BOOKMARK)); 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; GtkWidget *button;
button = gtk_button_new_with_label (key); button = gtk_button_new_with_label(key);
g_object_set_data_full (G_OBJECT(button), MUG_SHORTCUT_BOOKMARK, g_object_set_data_full(G_OBJECT(button), MUG_SHORTCUT_BOOKMARK,
g_strdup(val), g_free); g_strdup(val), g_free);
g_signal_connect (G_OBJECT(button), "clicked", G_CALLBACK(on_button_clicked), g_signal_connect(G_OBJECT(button), "clicked",
self); 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 static gboolean init_shortcuts(MugShortcuts * self, const char *bmpath)
init_shortcuts (MugShortcuts *self, const char* bmpath)
{ {
MuBookmarks *bookmarks; MuBookmarks *bookmarks;
bookmarks = mu_bookmarks_new (bmpath); bookmarks = mu_bookmarks_new(bmpath);
if (!bookmarks) if (!bookmarks)
return TRUE; return TRUE;
mu_bookmarks_foreach (bookmarks, (MuBookmarksForeachFunc)each_bookmark, mu_bookmarks_foreach(bookmarks, (MuBookmarksForeachFunc) each_bookmark,
self); self);
mu_bookmarks_destroy (bookmarks); mu_bookmarks_destroy(bookmarks);
return TRUE; return TRUE;
} }
GtkWidget* GtkWidget *mug_shortcuts_new(const char *bmpath)
mug_shortcuts_new (const char *bmpath)
{ {
MugShortcuts *self; MugShortcuts *self;
self = MUG_SHORTCUTS(g_object_new(MUG_TYPE_SHORTCUTS, NULL)); self = MUG_SHORTCUTS(g_object_new(MUG_TYPE_SHORTCUTS, NULL));
if (!init_shortcuts (self, bmpath)) { if (!init_shortcuts(self, bmpath)) {
g_object_unref (self); g_object_unref(self);
return NULL; return NULL;
} }
return GTK_WIDGET(self); return GTK_WIDGET(self);
} }
/* following: other function implementations */ /* following: other function implementations */
/* such as mug_shortcuts_do_something, or mug_shortcuts_has_foo */ /* such as mug_shortcuts_do_something, or mug_shortcuts_has_foo */

20
toys/mug/mug-shortcuts.h
View File

@ -17,7 +17,6 @@
** **
*/ */
#ifndef __MUG_SHORTCUTS_H__ #ifndef __MUG_SHORTCUTS_H__
#define __MUG_SHORTCUTS_H__ #define __MUG_SHORTCUTS_H__
@ -25,7 +24,6 @@
/* other include files */ /* other include files */
G_BEGIN_DECLS G_BEGIN_DECLS
/* convenience macros */ /* convenience macros */
#define MUG_TYPE_SHORTCUTS (mug_shortcuts_get_type()) #define MUG_TYPE_SHORTCUTS (mug_shortcuts_get_type())
#define MUG_SHORTCUTS(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),MUG_TYPE_SHORTCUTS,MugShortcuts)) #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(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_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)) #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 _MugShortcutsClass MugShortcutsClass;
typedef struct _MugShortcutsPrivate MugShortcutsPrivate; typedef struct _MugShortcutsPrivate MugShortcutsPrivate;
struct _MugShortcuts { struct _MugShortcuts {
GtkVBox parent; GtkVBox parent;
/* insert public members, if any */ /* insert public members, if any */
/* private */ /* private */
@ -48,22 +45,19 @@ struct _MugShortcuts {
struct _MugShortcutsClass { struct _MugShortcutsClass {
GtkVBoxClass parent_class; GtkVBoxClass parent_class;
void (*clicked) (MugShortcuts* obj, const char* query); void (*clicked) (MugShortcuts * obj, const char *query);
}; };
/* member functions */ /* 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) */ /* parameter-less _new function (constructor) */
/* if this is a kind of GtkWidget, it should probably return at GtkWidget* */ /* 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.: */ /* fill in other public functions, e.g.: */
/* void mug_shortcuts_do_something (MugShortcuts *self, const gchar* param); */ /* void mug_shortcuts_do_something (MugShortcuts *self, const gchar* param); */
/* gboolean mug_shortcuts_has_foo (MugShortcuts *self, gint value); */ /* gboolean mug_shortcuts_has_foo (MugShortcuts *self, gint value); */
G_END_DECLS G_END_DECLS
#endif /* __MUG_SHORTCUTS_H__ */
#endif /* __MUG_SHORTCUTS_H__ */

369
toys/mug/mug.cc
View File

@ -19,10 +19,10 @@
#if HAVE_CONFIG_H #if HAVE_CONFIG_H
#include "config.h" #include "config.h"
#endif /*HAVE_CONFIG*/ #endif /*HAVE_CONFIG */
#include <gtk/gtk.h> #include <gtk/gtk.h>
#include <string.h> /* for memset */ #include <string.h> /* for memset */
#include "mu-util.h" #include "mu-util.h"
#include "mu-runtime.h" #include "mu-runtime.h"
@ -43,22 +43,20 @@ struct _MugData {
gchar *muhome; gchar *muhome;
}; };
typedef struct _MugData MugData; typedef struct _MugData MugData;
static void static void about_mug(MugData * mugdata)
about_mug (MugData *mugdata)
{ {
GtkWidget *about; GtkWidget *about;
about = gtk_message_dialog_new 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, GTK_MESSAGE_INFO, GTK_BUTTONS_OK,
"Mug version %s\n" "Mug version %s\n"
"A graphical frontend to the 'mu' e-mail search engine\n\n" "A graphical frontend to the 'mu' e-mail search engine\n\n"
"(c) 2010 Dirk-Jan C. Binnema\n" "(c) 2010 Dirk-Jan C. Binnema\n"
"Released under the terms of the GPLv3+", VERSION); "Released under the terms of the GPLv3+", VERSION);
gtk_dialog_run (GTK_DIALOG(about)); gtk_dialog_run(GTK_DIALOG(about));
gtk_widget_destroy (about); gtk_widget_destroy(about);
} }
enum _ToolAction { enum _ToolAction {
@ -66,278 +64,265 @@ enum _ToolAction {
ACTION_NEXT_MSG, ACTION_NEXT_MSG,
ACTION_DO_QUIT, ACTION_DO_QUIT,
ACTION_ABOUT, ACTION_ABOUT,
ACTION_SEPARATOR /* pseudo action */ ACTION_SEPARATOR /* pseudo action */
}; };
typedef enum _ToolAction ToolAction; typedef enum _ToolAction ToolAction;
static void static void on_tool_button_clicked(GtkToolButton * btn, MugData * mugdata)
on_tool_button_clicked (GtkToolButton *btn, MugData *mugdata)
{ {
ToolAction action; ToolAction action;
action = (ToolAction)GPOINTER_TO_UINT( action =
g_object_get_data(G_OBJECT(btn),"action")); (ToolAction)
GPOINTER_TO_UINT(g_object_get_data(G_OBJECT(btn), "action"));
switch (action) { switch (action) {
case ACTION_DO_QUIT: case ACTION_DO_QUIT:
gtk_main_quit(); gtk_main_quit();
break; break;
case ACTION_NEXT_MSG: case ACTION_NEXT_MSG:
mug_msg_list_view_move_next mug_msg_list_view_move_next(MUG_MSG_LIST_VIEW(mugdata->mlist));
(MUG_MSG_LIST_VIEW(mugdata->mlist));
break; break;
case ACTION_PREV_MSG: case ACTION_PREV_MSG:
mug_msg_list_view_move_prev mug_msg_list_view_move_prev(MUG_MSG_LIST_VIEW(mugdata->mlist));
(MUG_MSG_LIST_VIEW(mugdata->mlist));
break; break;
case ACTION_ABOUT: case ACTION_ABOUT:
about_mug (mugdata); about_mug(mugdata);
break; break;
default: default:
g_print ("%u\n", action); g_print("%u\n", action);
} }
} }
static GtkWidget* static GtkWidget *mug_toolbar(MugData * mugdata)
mug_toolbar (MugData *mugdata)
{ {
GtkWidget *toolbar; GtkWidget *toolbar;
int i; int i;
struct { struct {
const char* stock_id; const char *stock_id;
ToolAction action; ToolAction action;
} tools[] = { } tools[] = {
{ GTK_STOCK_GO_UP, ACTION_PREV_MSG }, {
{ GTK_STOCK_GO_DOWN, ACTION_NEXT_MSG }, GTK_STOCK_GO_UP, ACTION_PREV_MSG}, {
{ NULL, ACTION_SEPARATOR }, GTK_STOCK_GO_DOWN, ACTION_NEXT_MSG}, {
{ GTK_STOCK_ABOUT, ACTION_ABOUT }, NULL, ACTION_SEPARATOR}, {
{ NULL, ACTION_SEPARATOR }, GTK_STOCK_ABOUT, ACTION_ABOUT}, {
{ GTK_STOCK_QUIT, ACTION_DO_QUIT }, NULL, ACTION_SEPARATOR}, {
}; GTK_STOCK_QUIT, ACTION_DO_QUIT},};
for (toolbar = gtk_toolbar_new(), i = 0; i != G_N_ELEMENTS(tools); ++i) {
GtkToolItem *btn;
/* separator item ? */ toolbar = gtk_toolbar_new();
if (tools[i].action == ACTION_SEPARATOR) { for (i = 0; i != G_N_ELEMENTS(tools); ++i) {
gtk_toolbar_insert (GTK_TOOLBAR(toolbar), GtkToolItem *btn;
gtk_separator_tool_item_new(), i); if (tools[i].action == ACTION_SEPARATOR) { /* separator */
gtk_toolbar_insert(GTK_TOOLBAR(toolbar),
gtk_separator_tool_item_new(), i);
continue; continue;
} }
/* nope: a real item */ /* nope: a real item */
btn = gtk_tool_button_new_from_stock (tools[i].stock_id); btn = gtk_tool_button_new_from_stock(tools[i].stock_id);
g_object_set_data (G_OBJECT(btn), "action", g_object_set_data(G_OBJECT(btn), "action",
GUINT_TO_POINTER(tools[i].action)); GUINT_TO_POINTER(tools[i].action));
g_signal_connect (G_OBJECT(btn), "clicked", g_signal_connect(G_OBJECT(btn), "clicked",
G_CALLBACK(on_tool_button_clicked), G_CALLBACK(on_tool_button_clicked), mugdata);
mugdata); gtk_toolbar_insert(GTK_TOOLBAR(toolbar), btn, i);
gtk_toolbar_insert (GTK_TOOLBAR(toolbar), btn, i); gtk_widget_show(GTK_WIDGET(btn));
} }
return toolbar; return toolbar;
} }
static void 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), mug_query_bar_set_query(MUG_QUERY_BAR(mdata->querybar), query, TRUE);
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_signal_connect(G_OBJECT(data->shortcuts), "clicked",
G_CALLBACK(on_shortcut_clicked), data); G_CALLBACK(on_shortcut_clicked), data);
return data->shortcuts; return data->shortcuts;
} }
static GtkWidget *mug_statusbar(void)
static GtkWidget*
mug_statusbar (void)
{ {
GtkWidget *statusbar; GtkWidget *statusbar;
statusbar = gtk_statusbar_new (); statusbar = gtk_statusbar_new();
return statusbar; return statusbar;
} }
static void static void
on_query_changed (MugQueryBar *bar, const char* query, MugData *mugdata) on_query_changed(MugQueryBar * bar, const char *query, MugData * mugdata)
{ {
int count; int count;
/* clear the old message */ /* clear the old message */
mug_msg_view_set_text (MUG_MSG_VIEW(mugdata->msgview), NULL); //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); count = mug_msg_list_view_query(MUG_MSG_LIST_VIEW(mugdata->mlist),
query);
if (count >= 0) { if (count >= 0) {
gchar *msg = gchar *msg = g_strdup_printf("%d message%s found matching '%s'",
g_strdup_printf ("%d message%s found matching '%s'", count,
count, count > 1 ? "s" : "",
count > 1 ? "s" : "", mug_msg_list_view_get_query
mug_msg_list_view_get_query (MUG_MSG_LIST_VIEW
(MUG_MSG_LIST_VIEW(mugdata->mlist))); (mugdata->mlist)));
gtk_statusbar_push (GTK_STATUSBAR(mugdata->statusbar), 0, msg); gtk_statusbar_push(GTK_STATUSBAR(mugdata->statusbar), 0, msg);
g_free (msg); g_free(msg);
mug_msg_list_view_move_first (MUG_MSG_LIST_VIEW(mugdata->mlist)); mug_msg_list_view_move_first(MUG_MSG_LIST_VIEW(mugdata->mlist));
gtk_widget_grab_focus (GTK_WIDGET(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 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); // 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 static void
on_list_view_error (MugMsgListView *mlist, MugError err, on_list_view_error(MugMsgListView * mlist, MugError err, MugData * mugdata)
MugData *mugdata)
{ {
GtkWidget *errdialog; GtkWidget *errdialog;
const char* msg; const char *msg;
switch (err) { switch (err) {
case MUG_ERROR_XAPIAN_NOT_UPTODATE: case MUG_ERROR_XAPIAN_NOT_UPTODATE:
msg = "The Xapian Database has the wrong version\n" msg = "The Xapian Database has the wrong version\n"
"Please run 'mu index --rebuild'"; break; "Please run 'mu index --rebuild'";
break;
case MUG_ERROR_XAPIAN_DIR: case MUG_ERROR_XAPIAN_DIR:
msg = "Cannot find the Xapian database dir\n" msg = "Cannot find the Xapian database dir\n"
"Please restart mug with --muhome=... pointing\n" "Please restart mug with --muhome=... pointing\n"
"to your mu home directory"; break; "to your mu home directory";
break;
case MUG_ERROR_QUERY: case MUG_ERROR_QUERY:
msg = "Error in query"; break; msg = "Error in query";
break;
default: 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)); errdialog = gtk_message_dialog_new
gtk_widget_destroy (errdialog); (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) { if (err == MUG_ERROR_QUERY) {
mug_query_bar_grab_focus mug_query_bar_grab_focus(MUG_QUERY_BAR(mugdata->querybar));
(MUG_QUERY_BAR(mugdata->querybar));
} }
} }
static GtkWidget *mug_querybar(void)
static GtkWidget*
mug_querybar (void)
{ {
GtkWidget *querybar; GtkWidget *querybar;
querybar = mug_query_bar_new (); querybar = mug_query_bar_new();
return querybar; return querybar;
} }
static GtkWidget *mug_query_area(MugData * mugdata)
static GtkWidget*
mug_query_area (MugData *mugdata)
{ {
GtkWidget *queryarea; GtkWidget *queryarea;
GtkWidget *paned; GtkWidget *paned;
GtkWidget *scrolled; GtkWidget *scrolled;
queryarea = gtk_vbox_new (FALSE, 2); queryarea = gtk_vbox_new(FALSE, 2);
paned = gtk_vpaned_new (); paned = gtk_vpaned_new();
mugdata->mlist = mug_msg_list_view_new(mu_runtime_xapian_dir()); mugdata->mlist = mug_msg_list_view_new(mu_runtime_xapian_dir());
scrolled = gtk_scrolled_window_new(NULL, NULL);
scrolled = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled),
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW(scrolled), GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
GTK_POLICY_AUTOMATIC);
gtk_container_add (GTK_CONTAINER(scrolled), mugdata->mlist);
gtk_paned_add1 (GTK_PANED (paned), scrolled);
mugdata->msgview = mug_msg_view_new (); gtk_container_add(GTK_CONTAINER(scrolled), mugdata->mlist);
mug_msg_view_set_msg (MUG_MSG_VIEW(mugdata->msgview), NULL); gtk_paned_add1(GTK_PANED(paned), scrolled);
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(); mugdata->msgview = mug_msg_view_new();
g_signal_connect (G_OBJECT(mugdata->querybar), "query-changed",
G_CALLBACK(on_query_changed), mug_msg_view_set_msg(MUG_MSG_VIEW(mugdata->msgview), NULL);
mugdata); g_signal_connect(G_OBJECT(mugdata->mlist), "msg-selected",
G_CALLBACK(on_msg_selected), mugdata);
gtk_box_pack_start (GTK_BOX(queryarea), g_signal_connect(G_OBJECT(mugdata->mlist), "error-occured",
mugdata->querybar, FALSE, FALSE, 2); G_CALLBACK(on_list_view_error), mugdata);
gtk_box_pack_start (GTK_BOX(queryarea), gtk_paned_add2(GTK_PANED(paned), mugdata->msgview);
paned, TRUE, TRUE, 2);
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; 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), w = mug_query_area(mugdata);
FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(mainarea), w, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX(mainarea), mug_query_area(mugdata), gtk_widget_show(w);
TRUE, TRUE, 0);
return mainarea; return mainarea;
} }
GtkWidget *mug_shell(MugData * mugdata)
GtkWidget*
mug_shell (MugData *mugdata)
{ {
GtkWidget *vbox; GtkWidget *vbox;
gchar *icon; 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); mugdata->toolbar = mug_toolbar(mugdata);
gtk_box_pack_start (GTK_BOX(vbox), mugdata->toolbar, FALSE, FALSE, 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); gtk_box_pack_start(GTK_BOX(vbox), mug_main_area(mugdata), TRUE,
TRUE, 2);
mugdata->statusbar = mug_statusbar(); mugdata->statusbar = mug_statusbar();
gtk_box_pack_start (GTK_BOX(vbox), mugdata->statusbar, FALSE, FALSE, 2); 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_window_set_default_size (GTK_WINDOW(mugdata->win), 700, 500); gtk_container_add(GTK_CONTAINER(mugdata->win), vbox);
gtk_window_set_resizable (GTK_WINDOW(mugdata->win), TRUE); 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; return mugdata->win;
} }
int int main(int argc, char *argv[])
main (int argc, char *argv[])
{ {
MugData mugdata; MugData mugdata;
GtkWidget *mugshell; GtkWidget *mugshell;
@ -345,33 +330,33 @@ main (int argc, char *argv[])
GOptionEntry entries[] = { GOptionEntry entries[] = {
{"muhome", 0, 0, G_OPTION_ARG_FILENAME, &mugdata.muhome, {"muhome", 0, 0, G_OPTION_ARG_FILENAME, &mugdata.muhome,
"specify an alternative mu directory", NULL}, "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"); octx = g_option_context_new("- mug options");
g_option_context_add_main_entries (octx, entries, "Mug"); g_option_context_add_main_entries(octx, entries, "Mug");
memset (&mugdata, 0, sizeof(MugData)); memset(&mugdata, 0, sizeof(MugData));
if (!g_option_context_parse (octx, &argc, &argv, NULL)) { if (!g_option_context_parse(octx, &argc, &argv, NULL)) {
g_printerr ("mug: error in options\n"); g_printerr("mug: error in options\n");
return 1; return 1;
} }
mu_runtime_init (mugdata.muhome); mu_runtime_init(mugdata.muhome);
mugshell = mug_shell (&mugdata); mugshell = mug_shell(&mugdata);
g_signal_connect(G_OBJECT(mugshell), "destroy", g_signal_connect(G_OBJECT(mugshell), "destroy",
G_CALLBACK(gtk_main_quit), NULL); G_CALLBACK(gtk_main_quit), NULL);
gtk_widget_show (mugshell); gtk_widget_show(mugshell);
mug_query_bar_grab_focus (MUG_QUERY_BAR(mugdata.querybar)); mug_query_bar_grab_focus(MUG_QUERY_BAR(mugdata.querybar));
gtk_main (); gtk_main();
g_free (mugdata.muhome); g_free(mugdata.muhome);
mu_runtime_uninit();
mu_runtime_uninit ();
return 0; return 0;
} }