alx/mu4e
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

clang-format: update c/cc coding style

Browse Source 
Update all cc code using .clang-format; please do so as well for future PRs
etc.; emacs has a handy 'clang-format' mode to make this automatic.

For comparing old changes with git blame, we can disregard this one using
--ignore-rev

(see https://www.moxio.com/blog/43/ignoring-bulk-change-commits-with-git-blame )
This commit is contained in:
Dirk-Jan C. Binnema
2021-10-20 12:18:15 +03:00
parent 09935cc4b3
commit 3dd721d5a3
111 changed files with 13851 additions and 14579 deletions
Download Patch File Download Diff File Expand all files Collapse all files

258
toys/mug/mu-msg-attach-view.cc
View File

@ -32,11 +32,10 @@ enum {
NUM_COL
};
/* 'private'/'protected' functions */
static void mu_msg_attach_view_class_init (MuMsgAttachViewClass *klass);
static void mu_msg_attach_view_init (MuMsgAttachView *obj);
static void mu_msg_attach_view_finalize (GObject *obj);
static void mu_msg_attach_view_class_init(MuMsgAttachViewClass* klass);
static void mu_msg_attach_view_init(MuMsgAttachView* obj);
static void mu_msg_attach_view_finalize(GObject* obj);
/* list my signals */
enum {
@ -46,254 +45,247 @@ enum {
};
struct _MuMsgAttachViewPrivate {
MuMsg *_msg;
MuMsg* _msg;
};
#define MU_MSG_ATTACH_VIEW_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE((o), \
MU_TYPE_MSG_ATTACH_VIEW, \
MuMsgAttachViewPrivate))
#define MU_MSG_ATTACH_VIEW_GET_PRIVATE(o) \
(G_TYPE_INSTANCE_GET_PRIVATE((o), MU_TYPE_MSG_ATTACH_VIEW, MuMsgAttachViewPrivate))
/* globals */
static GtkIconViewClass *parent_class = NULL;
static GtkIconViewClass* parent_class = NULL;
static guint signals[LAST_SIGNAL] = {0};
G_DEFINE_TYPE (MuMsgAttachView, mu_msg_attach_view, GTK_TYPE_ICON_VIEW);
G_DEFINE_TYPE(MuMsgAttachView, mu_msg_attach_view, GTK_TYPE_ICON_VIEW);
static void
set_message (MuMsgAttachView *self, MuMsg *msg)
set_message(MuMsgAttachView* self, MuMsg* msg)
{
if (self->_priv->_msg == msg)
return; /* nothing to todo */
if (self->_priv->_msg) {
mu_msg_unref (self->_priv->_msg);
if (self->_priv->_msg) {
mu_msg_unref(self->_priv->_msg);
self->_priv->_msg = NULL;
}
if (msg)
self->_priv->_msg = mu_msg_ref (msg);
self->_priv->_msg = mu_msg_ref(msg);
}
static void
mu_msg_attach_view_class_init (MuMsgAttachViewClass *klass)
mu_msg_attach_view_class_init(MuMsgAttachViewClass* klass)
{
GObjectClass *gobject_class;
gobject_class = (GObjectClass*) klass;
GObjectClass* gobject_class;
gobject_class = (GObjectClass*)klass;
parent_class = (GtkIconViewClass*)g_type_class_peek_parent (klass);
parent_class = (GtkIconViewClass*)g_type_class_peek_parent(klass);
gobject_class->finalize = mu_msg_attach_view_finalize;
g_type_class_add_private (gobject_class, sizeof(MuMsgAttachViewPrivate));
g_type_class_add_private(gobject_class, sizeof(MuMsgAttachViewPrivate));
signals[ATTACH_ACTIVATED] =
g_signal_new ("attach-activated",
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (MuMsgAttachViewClass,
attach_activated),
NULL, NULL,
g_cclosure_marshal_VOID__UINT_POINTER,
G_TYPE_NONE, 2, G_TYPE_UINT, G_TYPE_POINTER);
g_signal_new("attach-activated",
G_TYPE_FROM_CLASS(gobject_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET(MuMsgAttachViewClass, attach_activated),
NULL,
NULL,
g_cclosure_marshal_VOID__UINT_POINTER,
G_TYPE_NONE,
2,
G_TYPE_UINT,
G_TYPE_POINTER);
}
static void
item_activated (MuMsgAttachView *self, GtkTreePath *tpath)
item_activated(MuMsgAttachView* self, GtkTreePath* tpath)
{
GtkTreeModel *model;
GtkTreeIter iter;
guint partnum;
GtkTreeModel* model;
GtkTreeIter iter;
guint partnum;
model = gtk_icon_view_get_model (GTK_ICON_VIEW(self));
if (!gtk_tree_model_get_iter (model, &iter, tpath)) {
g_warning ("could not find path");
model = gtk_icon_view_get_model(GTK_ICON_VIEW(self));
if (!gtk_tree_model_get_iter(model, &iter, tpath)) {
g_warning("could not find path");
}
gtk_tree_model_get (model, &iter,
PARTNUM_COL, &partnum,
-1);
gtk_tree_model_get(model, &iter, PARTNUM_COL, &partnum, -1);
g_signal_emit (G_OBJECT (self),
signals[ATTACH_ACTIVATED], 0,
partnum, self->_priv->_msg);
g_signal_emit(G_OBJECT(self), signals[ATTACH_ACTIVATED], 0, partnum, self->_priv->_msg);
}
static void
accumulate_parts (MuMsgAttachView *self, GtkTreePath *path, GSList **lst)
accumulate_parts(MuMsgAttachView* self, GtkTreePath* path, GSList** lst)
{
GtkTreeIter iter;
GtkTreeModel *model;
GtkTreeIter iter;
GtkTreeModel* model;
/* don't unref */
model = gtk_icon_view_get_model (GTK_ICON_VIEW(self));
model = gtk_icon_view_get_model(GTK_ICON_VIEW(self));
if (gtk_tree_model_get_iter (model, &iter, path)) {
gchar *filepath;
gint idx;
gtk_tree_model_get (model, &iter, PARTNUM_COL, &idx, -1);
filepath = mu_msg_part_get_cache_path (self->_priv->_msg,
MU_MSG_OPTION_NONE,
idx, NULL);
if (gtk_tree_model_get_iter(model, &iter, path)) {
gchar* filepath;
gint idx;
gtk_tree_model_get(model, &iter, PARTNUM_COL, &idx, -1);
filepath =
mu_msg_part_get_cache_path(self->_priv->_msg, MU_MSG_OPTION_NONE, idx, NULL);
if (filepath) {
if (mu_msg_part_save (self->_priv->_msg,
MU_MSG_OPTION_USE_EXISTING,
filepath,
idx, NULL)) {
GFile *file;
file = g_file_new_for_path (filepath);
*lst = g_slist_prepend (*lst, g_file_get_uri(file));
g_object_unref (file);
if (mu_msg_part_save(self->_priv->_msg,
MU_MSG_OPTION_USE_EXISTING,
filepath,
idx,
NULL)) {
GFile* file;
file = g_file_new_for_path(filepath);
*lst = g_slist_prepend(*lst, g_file_get_uri(file));
g_object_unref(file);
} else
g_warning ("error saving msg part");
g_free (filepath);
g_warning("error saving msg part");
g_free(filepath);
}
}
}
static void
on_drag_data_get (MuMsgAttachView *self, GdkDragContext *drag_context,
GtkSelectionData *data, guint info, guint time, gpointer user_data)
on_drag_data_get(MuMsgAttachView* self,
GdkDragContext* drag_context,
GtkSelectionData* data,
guint info,
guint time,
gpointer user_data)
{
GSList *lst, *cur;
char **uris;
int i;
char** uris;
int i;
lst = NULL;
gtk_icon_view_selected_foreach (GTK_ICON_VIEW(self),
(GtkIconViewForeachFunc)accumulate_parts,
&lst);
gtk_icon_view_selected_foreach(GTK_ICON_VIEW(self),
(GtkIconViewForeachFunc)accumulate_parts,
&lst);
uris = g_new(char*, g_slist_length(lst) + 1);
for (cur = lst, i = 0; cur; cur = g_slist_next(cur))
uris[i++] = (gchar*)cur->data;
uris[i] = NULL;
gtk_selection_data_set_uris (data, uris);
gtk_selection_data_set_uris(data, uris);
g_free (uris);
g_slist_free_full (lst, g_free);
g_free(uris);
g_slist_free_full(lst, g_free);
}
static void
mu_msg_attach_view_init (MuMsgAttachView *obj)
mu_msg_attach_view_init(MuMsgAttachView* obj)
{
GtkListStore *store;
GtkListStore* store;
obj->_priv = MU_MSG_ATTACH_VIEW_GET_PRIVATE(obj);
obj->_priv = MU_MSG_ATTACH_VIEW_GET_PRIVATE(obj);
obj->_priv->_msg = NULL;
store = gtk_list_store_new (NUM_COL,GDK_TYPE_PIXBUF,
G_TYPE_STRING, G_TYPE_UINT);
gtk_icon_view_set_model (GTK_ICON_VIEW(obj), GTK_TREE_MODEL(store));
g_object_unref (store);
store = gtk_list_store_new(NUM_COL, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_UINT);
gtk_icon_view_set_model(GTK_ICON_VIEW(obj), GTK_TREE_MODEL(store));
g_object_unref(store);
gtk_icon_view_set_pixbuf_column (GTK_ICON_VIEW(obj), ICON_COL);
gtk_icon_view_set_text_column (GTK_ICON_VIEW(obj), NAME_COL);
gtk_icon_view_set_pixbuf_column(GTK_ICON_VIEW(obj), ICON_COL);
gtk_icon_view_set_text_column(GTK_ICON_VIEW(obj), NAME_COL);
gtk_icon_view_set_margin (GTK_ICON_VIEW(obj), 0);
gtk_icon_view_set_spacing (GTK_ICON_VIEW(obj), 0);
gtk_icon_view_set_item_padding (GTK_ICON_VIEW(obj), 0);
gtk_icon_view_set_margin(GTK_ICON_VIEW(obj), 0);
gtk_icon_view_set_spacing(GTK_ICON_VIEW(obj), 0);
gtk_icon_view_set_item_padding(GTK_ICON_VIEW(obj), 0);
/* note: only since GTK+ 2.22 */
/* gtk_icon_view_set_item_orientation (GTK_ICON_VIEW(obj), */
/* GTK_ORIENTATION_HORIZONTAL); */
g_signal_connect (G_OBJECT(obj), "item-activated",
G_CALLBACK(item_activated), NULL);
g_signal_connect(G_OBJECT(obj), "item-activated", G_CALLBACK(item_activated), NULL);
gtk_icon_view_set_selection_mode (GTK_ICON_VIEW(obj),
GTK_SELECTION_MULTIPLE);
gtk_icon_view_set_selection_mode(GTK_ICON_VIEW(obj), GTK_SELECTION_MULTIPLE);
/* drag & drop */
gtk_icon_view_enable_model_drag_source (GTK_ICON_VIEW(obj),
(GdkModifierType)0, NULL, 0,
GDK_ACTION_COPY);
gtk_icon_view_enable_model_drag_source(GTK_ICON_VIEW(obj),
(GdkModifierType)0,
NULL,
0,
GDK_ACTION_COPY);
gtk_drag_source_add_uri_targets(GTK_WIDGET(obj));
g_signal_connect (obj, "drag-data-get", G_CALLBACK(on_drag_data_get), NULL);
g_signal_connect(obj, "drag-data-get", G_CALLBACK(on_drag_data_get), NULL);
}
static void
mu_msg_attach_view_finalize (GObject *obj)
mu_msg_attach_view_finalize(GObject* obj)
{
set_message (MU_MSG_ATTACH_VIEW(obj), NULL);
set_message(MU_MSG_ATTACH_VIEW(obj), NULL);
G_OBJECT_CLASS(parent_class)->finalize (obj);
G_OBJECT_CLASS(parent_class)->finalize(obj);
}
GtkWidget*
mu_msg_attach_view_new (void)
mu_msg_attach_view_new(void)
{
return GTK_WIDGET(g_object_new(MU_TYPE_MSG_ATTACH_VIEW, NULL));
}
struct _CBData {
GtkListStore *store;
guint count;
GtkListStore* store;
guint count;
};
typedef struct _CBData CBData;
static void
each_part (MuMsg *msg, MuMsgPart *part, CBData *cbdata)
each_part(MuMsg* msg, MuMsgPart* part, CBData* cbdata)
{
GtkTreeIter treeiter;
GdkPixbuf *pixbuf;
char ctype[128];
GdkPixbuf* pixbuf;
char ctype[128];
if (!mu_msg_part_maybe_attachment(part))
return;
if (!part->type || !part->subtype)
snprintf (ctype, sizeof(ctype), "%s",
"application/octet-stream");
snprintf(ctype, sizeof(ctype), "%s", "application/octet-stream");
else
snprintf (ctype, sizeof(ctype), "%s/%s",
part->type, part->subtype);
snprintf(ctype, sizeof(ctype), "%s/%s", part->type, part->subtype);
pixbuf = mu_widget_util_get_icon_pixbuf_for_content_type (ctype, 16);
pixbuf = mu_widget_util_get_icon_pixbuf_for_content_type(ctype, 16);
if (!pixbuf) {
g_debug ("%s: could not get icon pixbuf for '%s'",
__func__, ctype);
pixbuf = mu_widget_util_get_icon_pixbuf_for_content_type
("application/octet-stream", 16);
g_debug("%s: could not get icon pixbuf for '%s'", __func__, ctype);
pixbuf =
mu_widget_util_get_icon_pixbuf_for_content_type("application/octet-stream", 16);
}
gtk_list_store_append (cbdata->store, &treeiter);
gtk_list_store_set (cbdata->store, &treeiter,
NAME_COL, mu_msg_part_get_filename (part, TRUE),
ICON_COL, pixbuf,
PARTNUM_COL, part->index,
-1);
gtk_list_store_append(cbdata->store, &treeiter);
gtk_list_store_set(cbdata->store,
&treeiter,
NAME_COL,
mu_msg_part_get_filename(part, TRUE),
ICON_COL,
pixbuf,
PARTNUM_COL,
part->index,
-1);
if (pixbuf)
g_object_unref (pixbuf);
g_object_unref(pixbuf);
++cbdata->count;
}
gint
mu_msg_attach_view_set_message (MuMsgAttachView *self, MuMsg *msg)
mu_msg_attach_view_set_message(MuMsgAttachView* self, MuMsg* msg)
{
GtkListStore *store;
CBData cbdata;
GtkListStore* store;
CBData cbdata;
g_return_val_if_fail (MU_IS_MSG_ATTACH_VIEW(self), -1);
g_return_val_if_fail(MU_IS_MSG_ATTACH_VIEW(self), -1);
store = GTK_LIST_STORE (gtk_icon_view_get_model (GTK_ICON_VIEW(self)));
gtk_list_store_clear (store);
store = GTK_LIST_STORE(gtk_icon_view_get_model(GTK_ICON_VIEW(self)));
gtk_list_store_clear(store);
set_message (self, msg);
set_message(self, msg);
if (!msg)
return 0;
cbdata.store = store;
cbdata.count = 0;
mu_msg_part_foreach (msg, MU_MSG_OPTION_NONE,
(MuMsgPartForeachFunc)each_part, &cbdata);
mu_msg_part_foreach(msg, MU_MSG_OPTION_NONE, (MuMsgPartForeachFunc)each_part, &cbdata);
return cbdata.count;
}

36
toys/mug/mu-msg-attach-view.hh
View File

@ -17,7 +17,6 @@
**
*/
#ifndef MU_MSG_ATTACH_VIEW_HH__
#define MU_MSG_ATTACH_VIEW_HH__
@ -27,40 +26,43 @@
G_BEGIN_DECLS
/* convenience macros */
#define MU_TYPE_MSG_ATTACH_VIEW (mu_msg_attach_view_get_type())
#define MU_MSG_ATTACH_VIEW(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),MU_TYPE_MSG_ATTACH_VIEW,MuMsgAttachView))
#define MU_MSG_ATTACH_VIEW_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass),MU_TYPE_MSG_ATTACH_VIEW,MuMsgAttachViewClass))
#define MU_IS_MSG_ATTACH_VIEW(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj),MU_TYPE_MSG_ATTACH_VIEW))
#define MU_IS_MSG_ATTACH_VIEW_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass),MU_TYPE_MSG_ATTACH_VIEW))
#define MU_MSG_ATTACH_VIEW_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj),MU_TYPE_MSG_ATTACH_VIEW,MuMsgAttachViewClass))
#define MU_TYPE_MSG_ATTACH_VIEW (mu_msg_attach_view_get_type())
#define MU_MSG_ATTACH_VIEW(obj) \
(G_TYPE_CHECK_INSTANCE_CAST((obj), MU_TYPE_MSG_ATTACH_VIEW, MuMsgAttachView))
#define MU_MSG_ATTACH_VIEW_CLASS(klass) \
(G_TYPE_CHECK_CLASS_CAST((klass), MU_TYPE_MSG_ATTACH_VIEW, MuMsgAttachViewClass))
#define MU_IS_MSG_ATTACH_VIEW(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), MU_TYPE_MSG_ATTACH_VIEW))
#define MU_IS_MSG_ATTACH_VIEW_CLASS(klass) \
(G_TYPE_CHECK_CLASS_TYPE((klass), MU_TYPE_MSG_ATTACH_VIEW))
#define MU_MSG_ATTACH_VIEW_GET_CLASS(obj) \
(G_TYPE_INSTANCE_GET_CLASS((obj), MU_TYPE_MSG_ATTACH_VIEW, MuMsgAttachViewClass))
typedef struct _MuMsgAttachView MuMsgAttachView;
typedef struct _MuMsgAttachViewClass MuMsgAttachViewClass;
typedef struct _MuMsgAttachViewPrivate MuMsgAttachViewPrivate;
typedef struct _MuMsgAttachView MuMsgAttachView;
typedef struct _MuMsgAttachViewClass MuMsgAttachViewClass;
typedef struct _MuMsgAttachViewPrivate MuMsgAttachViewPrivate;
struct _MuMsgAttachView {
GtkIconView parent;
GtkIconView parent;
/* insert public members, if any */
/* private */
MuMsgAttachViewPrivate *_priv;
MuMsgAttachViewPrivate* _priv;
};
struct _MuMsgAttachViewClass {
GtkIconViewClass parent_class;
void (* attach_activated) (MuMsgAttachView* obj, guint partnum,
Mu::MuMsg *msg);
void (*attach_activated)(MuMsgAttachView* obj, guint partnum, Mu::MuMsg* msg);
};
/* member functions */
GType mu_msg_attach_view_get_type (void) G_GNUC_CONST;
GType mu_msg_attach_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* mu_msg_attach_view_new (void);
GtkWidget* mu_msg_attach_view_new(void);
/* returns # of attachments */
int mu_msg_attach_view_set_message (MuMsgAttachView *self, Mu::MuMsg *msg);
int mu_msg_attach_view_set_message(MuMsgAttachView* self, Mu::MuMsg* msg);
G_END_DECLS

266
toys/mug/mu-msg-body-view.cc
View File

@ -32,9 +32,9 @@ enum _ViewMode {
typedef enum _ViewMode ViewMode;
/* 'private'/'protected' functions */
static void mu_msg_body_view_class_init (MuMsgBodyViewClass *klass);
static void mu_msg_body_view_init (MuMsgBodyView *obj);
static void mu_msg_body_view_finalize (GObject *obj);
static void mu_msg_body_view_class_init(MuMsgBodyViewClass* klass);
static void mu_msg_body_view_init(MuMsgBodyView* obj);
static void mu_msg_body_view_finalize(GObject* obj);
/* list my signals */
enum {
@ -43,91 +43,92 @@ enum {
LAST_SIGNAL
};
struct _MuMsgBodyViewPrivate {
WebKitSettings *_settings;
MuMsg *_msg;
ViewMode _view_mode;
WebKitSettings* _settings;
MuMsg* _msg;
ViewMode _view_mode;
};
#define MU_MSG_BODY_VIEW_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE((o), \
MU_TYPE_MSG_BODY_VIEW, \
MuMsgBodyViewPrivate))
#define MU_MSG_BODY_VIEW_GET_PRIVATE(o) \
(G_TYPE_INSTANCE_GET_PRIVATE((o), MU_TYPE_MSG_BODY_VIEW, MuMsgBodyViewPrivate))
/* globals */
static WebKitWebViewClass *parent_class = NULL;
static WebKitWebViewClass* parent_class = NULL;
static guint signals[LAST_SIGNAL] = {0};
G_DEFINE_TYPE (MuMsgBodyView, mu_msg_body_view, WEBKIT_TYPE_WEB_VIEW);
G_DEFINE_TYPE(MuMsgBodyView, mu_msg_body_view, WEBKIT_TYPE_WEB_VIEW);
static void
set_message (MuMsgBodyView *self, MuMsg *msg)
set_message(MuMsgBodyView* self, MuMsg* msg)
{
if (self->_priv->_msg == msg)
return; /* nothing to todo */
if (self->_priv->_msg) {
mu_msg_unref (self->_priv->_msg);
if (self->_priv->_msg) {
mu_msg_unref(self->_priv->_msg);
self->_priv->_msg = NULL;
}
if (msg)
self->_priv->_msg = mu_msg_ref (msg);
self->_priv->_msg = mu_msg_ref(msg);
}
static void
mu_msg_body_view_class_init (MuMsgBodyViewClass *klass)
mu_msg_body_view_class_init(MuMsgBodyViewClass* klass)
{
GObjectClass *gobject_class;
gobject_class = (GObjectClass*) klass;
GObjectClass* gobject_class;
gobject_class = (GObjectClass*)klass;
parent_class = (WebKitWebViewClass*)g_type_class_peek_parent (klass);
parent_class = (WebKitWebViewClass*)g_type_class_peek_parent(klass);
gobject_class->finalize = mu_msg_body_view_finalize;
g_type_class_add_private (gobject_class, sizeof(MuMsgBodyViewPrivate));
g_type_class_add_private(gobject_class, sizeof(MuMsgBodyViewPrivate));
signals[ACTION_REQUESTED] =
g_signal_new ("action-requested",
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (MuMsgBodyViewClass,
action_requested),
NULL, NULL,
g_cclosure_marshal_VOID__STRING,
G_TYPE_NONE, 1, G_TYPE_STRING);
g_signal_new("action-requested",
G_TYPE_FROM_CLASS(gobject_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET(MuMsgBodyViewClass, action_requested),
NULL,
NULL,
g_cclosure_marshal_VOID__STRING,
G_TYPE_NONE,
1,
G_TYPE_STRING);
}
static char*
save_file_for_cid (MuMsg *msg, const char* cid)
save_file_for_cid(MuMsg* msg, const char* cid)
{
gint idx;
gchar *filepath;
gint idx;
gchar* filepath;
gboolean rv;
GError *err;
GError* err;
g_return_val_if_fail (msg, NULL);
g_return_val_if_fail (cid, NULL);
g_return_val_if_fail(msg, NULL);
g_return_val_if_fail(cid, NULL);
idx = mu_msg_find_index_for_cid (msg, MU_MSG_OPTION_NONE, cid);
idx = mu_msg_find_index_for_cid(msg, MU_MSG_OPTION_NONE, cid);
if (idx < 0) {
g_warning ("%s: cannot find %s", __func__, cid);
g_warning("%s: cannot find %s", __func__, cid);
return NULL;
}
filepath = mu_msg_part_get_cache_path (msg, MU_MSG_OPTION_NONE, idx, NULL);
filepath = mu_msg_part_get_cache_path(msg, MU_MSG_OPTION_NONE, idx, NULL);
if (!filepath) {
g_warning ("%s: cannot create filepath", filepath);
g_warning("%s: cannot create filepath", filepath);
return NULL;
}
err = NULL;
rv = mu_msg_part_save (msg, MU_MSG_OPTION_USE_EXISTING,
filepath, idx, &err);
rv = mu_msg_part_save(msg, MU_MSG_OPTION_USE_EXISTING, filepath, idx, &err);
if (!rv) {
g_warning ("%s: failed to save %s: %s", __func__, filepath,
err&&err->message?err->message:"error");
g_clear_error (&err);
g_free (filepath);
g_warning("%s: failed to save %s: %s",
__func__,
filepath,
err && err->message ? err->message : "error");
g_clear_error(&err);
g_free(filepath);
filepath = NULL;
}
@ -135,82 +136,82 @@ save_file_for_cid (MuMsg *msg, const char* cid)
}
static void
on_resource_load_started (MuMsgBodyView *self, WebKitWebResource *resource,
WebKitURIRequest *request, gpointer data)
on_resource_load_started(MuMsgBodyView* self,
WebKitWebResource* resource,
WebKitURIRequest* request,
gpointer data)
{
const char* uri;
MuMsg *msg;
const char* uri;
MuMsg* msg;
msg = self->_priv->_msg;
uri = webkit_uri_request_get_uri (request);
uri = webkit_uri_request_get_uri(request);
/* g_warning ("%s: %s", __func__, uri); */
if (g_ascii_strncasecmp (uri, "cid:", 4) == 0) {
gchar *filepath;
filepath = save_file_for_cid (msg, uri);
if (g_ascii_strncasecmp(uri, "cid:", 4) == 0) {
gchar* filepath;
filepath = save_file_for_cid(msg, uri);
if (filepath) {
gchar *fileuri;
fileuri = g_strdup_printf ("file://%s", filepath);
webkit_uri_request_set_uri (request, fileuri);
g_free (fileuri);
g_free (filepath);
gchar* fileuri;
fileuri = g_strdup_printf("file://%s", filepath);
webkit_uri_request_set_uri(request, fileuri);
g_free(fileuri);
g_free(filepath);
}
}
}
static void
on_menu_item_activate (GtkMenuItem *item, MuMsgBodyView *self)
on_menu_item_activate(GtkMenuItem* item, MuMsgBodyView* self)
{
g_signal_emit (G_OBJECT(self),
signals[ACTION_REQUESTED], 0,
g_object_get_data (G_OBJECT(item), "action"));
g_signal_emit(G_OBJECT(self),
signals[ACTION_REQUESTED],
0,
g_object_get_data(G_OBJECT(item), "action"));
}
static void
popup_menu (MuMsgBodyView *self, guint button, guint32 activate_time)
popup_menu(MuMsgBodyView* self, guint button, guint32 activate_time)
{
GtkWidget *menu;
int i;
GtkWidget* menu;
int i;
struct {
const char* title;
const char* action;
ViewMode mode;
ViewMode mode;
} actions[] = {
{ "View source...", "view-source", VIEW_MODE_MSG },
{ "View message...", "view-message", VIEW_MODE_SOURCE },
{"View source...", "view-source", VIEW_MODE_MSG},
{"View message...", "view-message", VIEW_MODE_SOURCE},
};
menu = gtk_menu_new ();
menu = gtk_menu_new();
for (i = 0; i != G_N_ELEMENTS(actions); ++i) {
GtkWidget *item;
GtkWidget* item;
if (self->_priv->_view_mode != actions[i].mode)
continue;
item = gtk_menu_item_new_with_label(actions[i].title);
g_object_set_data (G_OBJECT(item), "action", (gpointer)actions[i].action);
g_signal_connect (item, "activate", G_CALLBACK(on_menu_item_activate),
self);
gtk_menu_attach (GTK_MENU(menu), item, 0, 1, i, i+1);
gtk_widget_show (item);
g_object_set_data(G_OBJECT(item), "action", (gpointer)actions[i].action);
g_signal_connect(item, "activate", G_CALLBACK(on_menu_item_activate), self);
gtk_menu_attach(GTK_MENU(menu), item, 0, 1, i, i + 1);
gtk_widget_show(item);
}
gtk_menu_popup (GTK_MENU(menu), NULL, NULL, NULL, NULL, 0, 0);
gtk_menu_popup(GTK_MENU(menu), NULL, NULL, NULL, NULL, 0, 0);
}
static gboolean
on_button_press_event (MuMsgBodyView *self, GdkEventButton *event, gpointer data)
on_button_press_event(MuMsgBodyView* self, GdkEventButton* event, gpointer data)
{
/* ignore all but the first (typically, left) mouse button */
/* ignore all but the first (typically, left) mouse button */
switch (event->button) {
case 1: return FALSE; /* propagate, let widget handle it */
case 3:
/* no popup menus for notes */
if (self->_priv->_view_mode != VIEW_MODE_NOTE)
popup_menu (self, event->button, event->time);
popup_menu(self, event->button, event->time);
break;
default: return TRUE; /* ignore */
}
@ -218,123 +219,116 @@ on_button_press_event (MuMsgBodyView *self, GdkEventButton *event, gpointer data
return (event->button > 1) ? TRUE : FALSE;
}
static void
mu_msg_body_view_init (MuMsgBodyView *obj)
mu_msg_body_view_init(MuMsgBodyView* obj)
{
obj->_priv = MU_MSG_BODY_VIEW_GET_PRIVATE(obj);
obj->_priv->_msg = NULL;
obj->_priv->_msg = NULL;
obj->_priv->_view_mode = VIEW_MODE_NONE;
obj->_priv->_settings = webkit_settings_new ();
g_object_set (G_OBJECT(obj->_priv->_settings),
"enable-javascript", FALSE,
"auto-load-images", TRUE,
"enable-plugins", FALSE,
NULL);
obj->_priv->_settings = webkit_settings_new();
g_object_set(G_OBJECT(obj->_priv->_settings),
"enable-javascript",
FALSE,
"auto-load-images",
TRUE,
"enable-plugins",
FALSE,
NULL);
webkit_web_view_set_settings (WEBKIT_WEB_VIEW(obj), obj->_priv->_settings);
webkit_web_view_set_settings(WEBKIT_WEB_VIEW(obj), obj->_priv->_settings);
/* to support cid: */
g_signal_connect (obj, "resource-load-started",
G_CALLBACK (on_resource_load_started), NULL);
g_signal_connect (obj, "button-press-event",
G_CALLBACK(on_button_press_event), NULL);
g_signal_connect(obj, "resource-load-started", G_CALLBACK(on_resource_load_started), NULL);
g_signal_connect(obj, "button-press-event", G_CALLBACK(on_button_press_event), NULL);
}
static void
mu_msg_body_view_finalize (GObject *obj)
mu_msg_body_view_finalize(GObject* obj)
{
MuMsgBodyViewPrivate *priv;
MuMsgBodyViewPrivate* priv;
priv = MU_MSG_BODY_VIEW_GET_PRIVATE(obj);
if (priv && priv->_settings)
g_object_unref (priv->_settings);
g_object_unref(priv->_settings);
set_message (MU_MSG_BODY_VIEW(obj), NULL);
set_message(MU_MSG_BODY_VIEW(obj), NULL);
G_OBJECT_CLASS(parent_class)->finalize (obj);
G_OBJECT_CLASS(parent_class)->finalize(obj);
}
GtkWidget*
mu_msg_body_view_new (void)
mu_msg_body_view_new(void)
{
return GTK_WIDGET(g_object_new(MU_TYPE_MSG_BODY_VIEW, NULL));
}
static void
set_html (MuMsgBodyView *self, const char* html)
set_html(MuMsgBodyView* self, const char* html)
{
g_return_if_fail (MU_IS_MSG_BODY_VIEW(self));
g_return_if_fail(MU_IS_MSG_BODY_VIEW(self));
webkit_web_view_load_html (WEBKIT_WEB_VIEW(self),
html ? html : "",
NULL);
webkit_web_view_load_html(WEBKIT_WEB_VIEW(self), html ? html : "", NULL);
}
static void
set_text (MuMsgBodyView *self, const char* txt)
set_text(MuMsgBodyView* self, const char* txt)
{
g_return_if_fail (MU_IS_MSG_BODY_VIEW(self));
g_return_if_fail(MU_IS_MSG_BODY_VIEW(self));
webkit_web_view_load_plain_text (WEBKIT_WEB_VIEW(self), txt ? txt : "");
webkit_web_view_load_plain_text(WEBKIT_WEB_VIEW(self), txt ? txt : "");
}
void
mu_msg_body_view_set_message (MuMsgBodyView *self, MuMsg *msg)
mu_msg_body_view_set_message(MuMsgBodyView* self, MuMsg* msg)
{
const char* data;
g_return_if_fail (self);
g_return_if_fail(self);
set_message (self, msg);
set_message(self, msg);
data = msg ? mu_msg_get_body_html (msg, MU_MSG_OPTION_NONE) : "";
data = msg ? mu_msg_get_body_html(msg, MU_MSG_OPTION_NONE) : "";
if (data)
set_html (self, data);
set_html(self, data);
else
set_text (self,
mu_msg_get_body_text (msg, MU_MSG_OPTION_NONE));
set_text(self, mu_msg_get_body_text(msg, MU_MSG_OPTION_NONE));
self->_priv->_view_mode = VIEW_MODE_MSG;
}
void
mu_msg_body_view_set_message_source (MuMsgBodyView *self, MuMsg *msg)
mu_msg_body_view_set_message_source(MuMsgBodyView* self, MuMsg* msg)
{
const gchar *path;
gchar *data;
const gchar* path;
gchar* data;
g_return_if_fail (MU_IS_MSG_BODY_VIEW(self));
g_return_if_fail (msg);
g_return_if_fail(MU_IS_MSG_BODY_VIEW(self));
g_return_if_fail(msg);
set_message (self, NULL);
set_message(self, NULL);
path = msg ? mu_msg_get_path (msg) : NULL;
path = msg ? mu_msg_get_path(msg) : NULL;
if (path && g_file_get_contents (path, &data, NULL, NULL)) {
set_text (self, data);
g_free (data);
if (path && g_file_get_contents(path, &data, NULL, NULL)) {
set_text(self, data);
g_free(data);
} else
set_text (self, "");
set_text(self, "");
self->_priv->_view_mode = VIEW_MODE_SOURCE;
}
void
mu_msg_body_view_set_note (MuMsgBodyView *self, const gchar *html)
mu_msg_body_view_set_note(MuMsgBodyView* self, const gchar* html)
{
g_return_if_fail (self);
g_return_if_fail (html);
g_return_if_fail(self);
g_return_if_fail(html);
set_message (self, NULL);
set_message(self, NULL);
set_html (self, html);
set_html(self, html);
self->_priv->_view_mode = VIEW_MODE_NOTE;
}

38
toys/mug/mu-msg-body-view.hh
View File

@ -26,43 +26,45 @@
G_BEGIN_DECLS
/* convenience macros */
#define MU_TYPE_MSG_BODY_VIEW (mu_msg_body_view_get_type())
#define MU_MSG_BODY_VIEW(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),MU_TYPE_MSG_BODY_VIEW,MuMsgBodyView))
#define MU_MSG_BODY_VIEW_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass),MU_TYPE_MSG_BODY_VIEW,MuMsgBodyViewClass))
#define MU_IS_MSG_BODY_VIEW(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj),MU_TYPE_MSG_BODY_VIEW))
#define MU_IS_MSG_BODY_VIEW_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass),MU_TYPE_MSG_BODY_VIEW))
#define MU_MSG_BODY_VIEW_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj),MU_TYPE_MSG_BODY_VIEW,MuMsgBodyViewClass))
typedef struct _MuMsgBodyView MuMsgBodyView;
typedef struct _MuMsgBodyViewClass MuMsgBodyViewClass;
typedef struct _MuMsgBodyViewPrivate MuMsgBodyViewPrivate;
#define MU_TYPE_MSG_BODY_VIEW (mu_msg_body_view_get_type())
#define MU_MSG_BODY_VIEW(obj) \
(G_TYPE_CHECK_INSTANCE_CAST((obj), MU_TYPE_MSG_BODY_VIEW, MuMsgBodyView))
#define MU_MSG_BODY_VIEW_CLASS(klass) \
(G_TYPE_CHECK_CLASS_CAST((klass), MU_TYPE_MSG_BODY_VIEW, MuMsgBodyViewClass))
#define MU_IS_MSG_BODY_VIEW(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), MU_TYPE_MSG_BODY_VIEW))
#define MU_IS_MSG_BODY_VIEW_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), MU_TYPE_MSG_BODY_VIEW))
#define MU_MSG_BODY_VIEW_GET_CLASS(obj) \
(G_TYPE_INSTANCE_GET_CLASS((obj), MU_TYPE_MSG_BODY_VIEW, MuMsgBodyViewClass))
typedef struct _MuMsgBodyView MuMsgBodyView;
typedef struct _MuMsgBodyViewClass MuMsgBodyViewClass;
typedef struct _MuMsgBodyViewPrivate MuMsgBodyViewPrivate;
struct _MuMsgBodyView {
WebKitWebView parent;
WebKitWebView parent;
/* insert public members, if any */
/* private */
MuMsgBodyViewPrivate *_priv;
MuMsgBodyViewPrivate* _priv;
};
struct _MuMsgBodyViewClass {
WebKitWebViewClass parent_class;
/* supported actions: "reindex", "view-source" */
void (* action_requested) (MuMsgBodyView* self, const char* action);
void (*action_requested)(MuMsgBodyView* self, const char* action);
};
/* member functions */
GType mu_msg_body_view_get_type (void) G_GNUC_CONST;
GType mu_msg_body_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* mu_msg_body_view_new (void);
GtkWidget* mu_msg_body_view_new(void);
void mu_msg_body_view_set_message (MuMsgBodyView *self, Mu::MuMsg *msg);
void mu_msg_body_view_set_note (MuMsgBodyView *self, const gchar *html);
void mu_msg_body_view_set_message_source (MuMsgBodyView *self, Mu::MuMsg *msg);
void mu_msg_body_view_set_message(MuMsgBodyView* self, Mu::MuMsg* msg);
void mu_msg_body_view_set_note(MuMsgBodyView* self, const gchar* html);
void mu_msg_body_view_set_message_source(MuMsgBodyView* self, Mu::MuMsg* msg);
G_END_DECLS

132
toys/mug/mu-msg-header-view.cc
View File

@ -26,9 +26,9 @@
using namespace Mu;
/* 'private'/'protected' functions */
static void mu_msg_header_view_class_init (MuMsgHeaderViewClass *klass);
static void mu_msg_header_view_init (MuMsgHeaderView *obj);
static void mu_msg_header_view_finalize (GObject *obj);
static void mu_msg_header_view_class_init(MuMsgHeaderViewClass* klass);
static void mu_msg_header_view_init(MuMsgHeaderView* obj);
static void mu_msg_header_view_finalize(GObject* obj);
/* list my signals */
enum {
@ -38,150 +38,142 @@ enum {
};
struct _MuMsgHeaderViewPrivate {
GtkWidget *_grid;
GtkWidget* _grid;
};
#define MU_MSG_HEADER_VIEW_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE((o), \
MU_TYPE_MSG_HEADER_VIEW, \
MuMsgHeaderViewPrivate))
#define MU_MSG_HEADER_VIEW_GET_PRIVATE(o) \
(G_TYPE_INSTANCE_GET_PRIVATE((o), MU_TYPE_MSG_HEADER_VIEW, MuMsgHeaderViewPrivate))
/* globals */
static GtkBoxClass *parent_class = NULL;
static GtkBoxClass* parent_class = NULL;
/* uncomment the following if you have defined any signals */
/* static guint signals[LAST_SIGNAL] = {0}; */
G_DEFINE_TYPE (MuMsgHeaderView, mu_msg_header_view, GTK_TYPE_BOX);
G_DEFINE_TYPE(MuMsgHeaderView, mu_msg_header_view, GTK_TYPE_BOX);
static void
mu_msg_header_view_class_init (MuMsgHeaderViewClass *klass)
mu_msg_header_view_class_init(MuMsgHeaderViewClass* klass)
{
GObjectClass *gobject_class;
gobject_class = (GObjectClass*) klass;
GObjectClass* gobject_class;
gobject_class = (GObjectClass*)klass;
parent_class = (GtkBoxClass*)g_type_class_peek_parent (klass);
parent_class = (GtkBoxClass*)g_type_class_peek_parent(klass);
gobject_class->finalize = mu_msg_header_view_finalize;
g_type_class_add_private (gobject_class, sizeof(MuMsgHeaderViewPrivate));
g_type_class_add_private(gobject_class, sizeof(MuMsgHeaderViewPrivate));
/* signal definitions go here, e.g.: */
/* signals[MY_SIGNAL_1] = */
/* g_signal_new ("my_signal_1",....); */
/* signals[MY_SIGNAL_2] = */
/* g_signal_new ("my_signal_2",....); */
/* etc. */
/* signals[MY_SIGNAL_1] = */
/* g_signal_new ("my_signal_1",....); */
/* signals[MY_SIGNAL_2] = */
/* g_signal_new ("my_signal_2",....); */
/* etc. */
}
static void
mu_msg_header_view_init (MuMsgHeaderView *obj)
mu_msg_header_view_init(MuMsgHeaderView* obj)
{
/* static GtkBoxClass *parent_class = NULL; */
obj->_priv = MU_MSG_HEADER_VIEW_GET_PRIVATE(obj);
/* static GtkBoxClass *parent_class = NULL; */
obj->_priv = MU_MSG_HEADER_VIEW_GET_PRIVATE(obj);
obj->_priv->_grid = NULL;
}
static void
mu_msg_header_view_finalize (GObject *obj)
mu_msg_header_view_finalize(GObject* obj)
{
G_OBJECT_CLASS(parent_class)->finalize (obj);
G_OBJECT_CLASS(parent_class)->finalize(obj);
}
GtkWidget*
mu_msg_header_view_new (void)
mu_msg_header_view_new(void)
{
return GTK_WIDGET(g_object_new(MU_TYPE_MSG_HEADER_VIEW, NULL));
}
static GtkWidget*
get_label (const gchar *txt, gboolean istitle)
get_label(const gchar* txt, gboolean istitle)
{
GtkWidget *label;
GtkWidget* label;
label = gtk_label_new (NULL);
label = gtk_label_new(NULL);
if (istitle) {
char* markup;
markup = g_strdup_printf ("<b>%s</b>: ", txt);
gtk_label_set_markup (GTK_LABEL(label), markup);
gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_RIGHT);
g_free (markup);
markup = g_strdup_printf("<b>%s</b>: ", txt);
gtk_label_set_markup(GTK_LABEL(label), markup);
gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_RIGHT);
g_free(markup);
} else {
gtk_label_set_selectable (GTK_LABEL (label), TRUE);
gtk_label_set_text (GTK_LABEL(label), txt ? txt : "");
gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
gtk_label_set_selectable(GTK_LABEL(label), TRUE);
gtk_label_set_text(GTK_LABEL(label), txt ? txt : "");
gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_LEFT);
}
return label;
}
G_GNUC_UNUSED static gboolean
add_row (GtkWidget *grid, guint row, const char* fieldname, const char *value,
gboolean showempty)
add_row(GtkWidget* grid, guint row, const char* fieldname, const char* value, gboolean showempty)
{
GtkWidget *label, *al;
if (!value && !showempty)
return FALSE;
gtk_grid_insert_row (GTK_GRID(grid), row);
gtk_grid_insert_row(GTK_GRID(grid), row);
label = get_label (fieldname, TRUE);
al = gtk_alignment_new (0.0, 0.0, 0.0, 0.0);
gtk_container_add (GTK_CONTAINER (al), label);
label = get_label(fieldname, TRUE);
al = gtk_alignment_new(0.0, 0.0, 0.0, 0.0);
gtk_container_add(GTK_CONTAINER(al), label);
gtk_grid_attach (GTK_GRID(grid), al, 0, row, 1, 1);
gtk_grid_attach(GTK_GRID(grid), al, 0, row, 1, 1);
al = gtk_alignment_new (0.0, 1.0, 0.0, 0.0);
al = gtk_alignment_new(0.0, 1.0, 0.0, 0.0);
label = get_label (value, FALSE);
gtk_container_add (GTK_CONTAINER (al), label);
gtk_grid_attach (GTK_GRID(grid), al, 1, row, 1, 1);
label = get_label(value, FALSE);
gtk_container_add(GTK_CONTAINER(al), label);
gtk_grid_attach(GTK_GRID(grid), al, 1, row, 1, 1);
return TRUE;
}
static GtkWidget*
get_grid (Mu::MuMsg *msg)
get_grid(Mu::MuMsg* msg)
{
GtkWidget *grid;
int row;
GtkWidget* grid;
int row;
row = 0;
grid = gtk_grid_new (); /* 5 2 */
row = 0;
grid = gtk_grid_new(); /* 5 2 */
gtk_grid_insert_column (GTK_GRID(grid), 0);
gtk_grid_insert_column (GTK_GRID(grid), 1);
gtk_grid_insert_column(GTK_GRID(grid), 0);
gtk_grid_insert_column(GTK_GRID(grid), 1);
if (add_row (grid, row, "From", mu_msg_get_from (msg), TRUE))
if (add_row(grid, row, "From", mu_msg_get_from(msg), TRUE))
++row;
if (add_row (grid, row, "To", mu_msg_get_to (msg), FALSE))
if (add_row(grid, row, "To", mu_msg_get_to(msg), FALSE))
++row;
if (add_row (grid, row, "Cc", mu_msg_get_cc (msg), FALSE))
if (add_row(grid, row, "Cc", mu_msg_get_cc(msg), FALSE))
++row;
if (add_row (grid, row, "Subject", mu_msg_get_subject (msg), TRUE))
if (add_row(grid, row, "Subject", mu_msg_get_subject(msg), TRUE))
++row;
if (add_row (grid, row, "Date", mu_date_str_s
("%c", mu_msg_get_date (msg)),TRUE))
if (add_row(grid, row, "Date", mu_date_str_s("%c", mu_msg_get_date(msg)), TRUE))
++row;
return grid;
}
void
mu_msg_header_view_set_message (MuMsgHeaderView *self, Mu::MuMsg *msg)
mu_msg_header_view_set_message(MuMsgHeaderView* self, Mu::MuMsg* msg)
{
g_return_if_fail (MU_IS_MSG_HEADER_VIEW(self));
g_return_if_fail(MU_IS_MSG_HEADER_VIEW(self));
if (self->_priv->_grid) {
gtk_container_remove (GTK_CONTAINER(self), self->_priv->_grid);
gtk_container_remove(GTK_CONTAINER(self), self->_priv->_grid);
self->_priv->_grid = NULL;
}
if (msg) {
self->_priv->_grid = get_grid (msg);
gtk_box_pack_start (GTK_BOX(self), self->_priv->_grid,
TRUE, TRUE, 0);
gtk_widget_show_all (self->_priv->_grid);
self->_priv->_grid = get_grid(msg);
gtk_box_pack_start(GTK_BOX(self), self->_priv->_grid, TRUE, TRUE, 0);
gtk_widget_show_all(self->_priv->_grid);
}
}

31
toys/mug/mu-msg-header-view.hh
View File

@ -26,22 +26,26 @@
G_BEGIN_DECLS
/* convenience macros */
#define MU_TYPE_MSG_HEADER_VIEW (mu_msg_header_view_get_type())
#define MU_MSG_HEADER_VIEW(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),MU_TYPE_MSG_HEADER_VIEW,MuMsgHeaderView))
#define MU_MSG_HEADER_VIEW_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass),MU_TYPE_MSG_HEADER_VIEW,MuMsgHeaderViewClass))
#define MU_IS_MSG_HEADER_VIEW(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj),MU_TYPE_MSG_HEADER_VIEW))
#define MU_IS_MSG_HEADER_VIEW_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass),MU_TYPE_MSG_HEADER_VIEW))
#define MU_MSG_HEADER_VIEW_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj),MU_TYPE_MSG_HEADER_VIEW,MuMsgHeaderViewClass))
#define MU_TYPE_MSG_HEADER_VIEW (mu_msg_header_view_get_type())
#define MU_MSG_HEADER_VIEW(obj) \
(G_TYPE_CHECK_INSTANCE_CAST((obj), MU_TYPE_MSG_HEADER_VIEW, MuMsgHeaderView))
#define MU_MSG_HEADER_VIEW_CLASS(klass) \
(G_TYPE_CHECK_CLASS_CAST((klass), MU_TYPE_MSG_HEADER_VIEW, MuMsgHeaderViewClass))
#define MU_IS_MSG_HEADER_VIEW(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), MU_TYPE_MSG_HEADER_VIEW))
#define MU_IS_MSG_HEADER_VIEW_CLASS(klass) \
(G_TYPE_CHECK_CLASS_TYPE((klass), MU_TYPE_MSG_HEADER_VIEW))
#define MU_MSG_HEADER_VIEW_GET_CLASS(obj) \
(G_TYPE_INSTANCE_GET_CLASS((obj), MU_TYPE_MSG_HEADER_VIEW, MuMsgHeaderViewClass))
typedef struct _MuMsgHeaderView MuMsgHeaderView;
typedef struct _MuMsgHeaderViewClass MuMsgHeaderViewClass;
typedef struct _MuMsgHeaderViewPrivate MuMsgHeaderViewPrivate;
typedef struct _MuMsgHeaderView MuMsgHeaderView;
typedef struct _MuMsgHeaderViewClass MuMsgHeaderViewClass;
typedef struct _MuMsgHeaderViewPrivate MuMsgHeaderViewPrivate;
struct _MuMsgHeaderView {
GtkBox parent;
/* insert public members, if any */
/* private */
MuMsgHeaderViewPrivate *_priv;
MuMsgHeaderViewPrivate* _priv;
};
struct _MuMsgHeaderViewClass {
@ -51,15 +55,14 @@ struct _MuMsgHeaderViewClass {
};
/* member functions */
GType mu_msg_header_view_get_type (void) G_GNUC_CONST;
GType mu_msg_header_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* mu_msg_header_view_new (void);
GtkWidget* mu_msg_header_view_new(void);
struct MuMsg;
void mu_msg_header_view_set_message (MuMsgHeaderView *self, Mu::MuMsg *msg);
void mu_msg_header_view_set_message(MuMsgHeaderView* self, Mu::MuMsg* msg);
G_END_DECLS

201
toys/mug/mu-msg-view.cc
View File

@ -31,9 +31,9 @@
using namespace Mu;
/* 'private'/'protected' functions */
static void mu_msg_view_class_init (MuMsgViewClass *klass);
static void mu_msg_view_init (MuMsgView *obj);
static void mu_msg_view_finalize (GObject *obj);
static void mu_msg_view_class_init(MuMsgViewClass* klass);
static void mu_msg_view_init(MuMsgView* obj);
static void mu_msg_view_finalize(GObject* obj);
/* list my signals */
enum {
@ -44,202 +44,181 @@ enum {
struct _MuMsgViewPrivate {
GtkWidget *_headers, *_attach, *_attachexpander, *_body;
Mu::MuMsg *_msg;
Mu::MuMsg* _msg;
};
#define MU_MSG_VIEW_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE((o), \
MU_TYPE_MSG_VIEW, \
MuMsgViewPrivate))
#define MU_MSG_VIEW_GET_PRIVATE(o) \
(G_TYPE_INSTANCE_GET_PRIVATE((o), MU_TYPE_MSG_VIEW, MuMsgViewPrivate))
/* globals */
static GtkBoxClass *parent_class = NULL;
static GtkBoxClass* parent_class = NULL;
/* uncomment the following if you have defined any signals */
/* static guint signals[LAST_SIGNAL] = {0}; */
G_DEFINE_TYPE (MuMsgView, mu_msg_view, GTK_TYPE_BOX);
G_DEFINE_TYPE(MuMsgView, mu_msg_view, GTK_TYPE_BOX);
static void
set_message (MuMsgView *self, Mu::MuMsg *msg)
set_message(MuMsgView* self, Mu::MuMsg* msg)
{
if (self->_priv->_msg == msg)
return; /* nothing to todo */
if (self->_priv->_msg) {
mu_msg_unref (self->_priv->_msg);
if (self->_priv->_msg) {
mu_msg_unref(self->_priv->_msg);
self->_priv->_msg = NULL;
}
if (msg)
self->_priv->_msg = mu_msg_ref (msg);
self->_priv->_msg = mu_msg_ref(msg);
}
static void
mu_msg_view_class_init (MuMsgViewClass *klass)
mu_msg_view_class_init(MuMsgViewClass* klass)
{
GObjectClass *gobject_class;
gobject_class = (GObjectClass*) klass;
GObjectClass* gobject_class;
gobject_class = (GObjectClass*)klass;
parent_class = (GtkBoxClass*)g_type_class_peek_parent (klass);
parent_class = (GtkBoxClass*)g_type_class_peek_parent(klass);
gobject_class->finalize = mu_msg_view_finalize;
g_type_class_add_private (gobject_class, sizeof(MuMsgViewPrivate));
g_type_class_add_private(gobject_class, sizeof(MuMsgViewPrivate));
/* signal definitions go here, e.g.: */
/* signals[MY_SIGNAL_1] = */
/* g_signal_new ("my_signal_1",....); */
/* signals[MY_SIGNAL_2] = */
/* g_signal_new ("my_signal_2",....); */
/* etc. */
/* signals[MY_SIGNAL_1] = */
/* g_signal_new ("my_signal_1",....); */
/* signals[MY_SIGNAL_2] = */
/* g_signal_new ("my_signal_2",....); */
/* etc. */
}
static void
on_body_action_requested (GtkWidget *w, const char* action,
MuMsgView *self)
on_body_action_requested(GtkWidget* w, const char* action, MuMsgView* self)
{
if (g_strcmp0 (action, "view-source") == 0) {
if (g_strcmp0(action, "view-source") == 0) {
if (self->_priv->_msg)
mu_msg_view_set_message_source (self, self->_priv->_msg);
mu_msg_view_set_message_source(self, self->_priv->_msg);
} else if (g_strcmp0 (action, "view-message") == 0) {
} else if (g_strcmp0(action, "view-message") == 0) {
if (self->_priv->_msg)
mu_msg_view_set_message (self, self->_priv->_msg);
mu_msg_view_set_message(self, self->_priv->_msg);
} else if (g_strcmp0 (action, "reindex") == 0)
g_warning ("reindex");
} else if (g_strcmp0(action, "reindex") == 0)
g_warning("reindex");
else
g_warning ("unknown action '%s'", action);
g_warning("unknown action '%s'", action);
}
static void
on_attach_activated (GtkWidget *w, guint partnum, Mu::MuMsg *msg)
on_attach_activated(GtkWidget* w, guint partnum, Mu::MuMsg* msg)
{
gchar *filepath;
GError *err;
gchar* filepath;
GError* err;
err = NULL;
filepath = mu_msg_part_get_cache_path (msg, MU_MSG_OPTION_NONE, partnum,
&err);
err = NULL;
filepath = mu_msg_part_get_cache_path(msg, MU_MSG_OPTION_NONE, partnum, &err);
if (!filepath) {
g_warning ("failed to get cache path: %s",
err&&err->message?err->message:"error");
g_clear_error (&err);
g_warning("failed to get cache path: %s",
err && err->message ? err->message : "error");
g_clear_error(&err);
return;
}
if (!mu_msg_part_save (msg, MU_MSG_OPTION_USE_EXISTING,
filepath, partnum, &err)) {
g_warning ("failed to save %s: %s", filepath,
err&&err->message?err->message:"error");
g_clear_error (&err);
if (!mu_msg_part_save(msg, MU_MSG_OPTION_USE_EXISTING, filepath, partnum, &err)) {
g_warning("failed to save %s: %s",
filepath,
err && err->message ? err->message : "error");
g_clear_error(&err);
return;
} else
mu_util_play (filepath, TRUE, FALSE, NULL);
mu_util_play(filepath, TRUE, FALSE, NULL);
g_free (filepath);
g_free(filepath);
}
static void
mu_msg_view_init (MuMsgView *self)
mu_msg_view_init(MuMsgView* self)
{
gtk_orientable_set_orientation (GTK_ORIENTABLE(self),
GTK_ORIENTATION_VERTICAL);
gtk_orientable_set_orientation(GTK_ORIENTABLE(self), GTK_ORIENTATION_VERTICAL);
self->_priv = MU_MSG_VIEW_GET_PRIVATE(self);
self->_priv->_msg = NULL;
self->_priv->_headers = mu_msg_header_view_new ();
self->_priv->_attach = mu_msg_attach_view_new ();
self->_priv->_attachexpander = gtk_expander_new_with_mnemonic
("_Attachments");
self->_priv->_msg = NULL;
self->_priv->_headers = mu_msg_header_view_new();
self->_priv->_attach = mu_msg_attach_view_new();
self->_priv->_attachexpander = gtk_expander_new_with_mnemonic("_Attachments");
gtk_container_add (GTK_CONTAINER(self->_priv->_attachexpander),
self->_priv->_attach);
g_signal_connect (self->_priv->_attach, "attach-activated",
G_CALLBACK(on_attach_activated),
self);
gtk_container_add(GTK_CONTAINER(self->_priv->_attachexpander), self->_priv->_attach);
g_signal_connect(self->_priv->_attach,
"attach-activated",
G_CALLBACK(on_attach_activated),
self);
self->_priv->_body = mu_msg_body_view_new ();
g_signal_connect (self->_priv->_body,
"action-requested",
G_CALLBACK(on_body_action_requested),
self);
self->_priv->_body = mu_msg_body_view_new();
g_signal_connect(self->_priv->_body,
"action-requested",
G_CALLBACK(on_body_action_requested),
self);
gtk_box_pack_start (GTK_BOX(self), self->_priv->_headers,
FALSE, FALSE, 2);
gtk_box_pack_start (GTK_BOX(self), self->_priv->_attachexpander,
FALSE, FALSE, 2);
gtk_box_pack_start (GTK_BOX(self), self->_priv->_body,
TRUE, TRUE, 2);
gtk_box_pack_start(GTK_BOX(self), self->_priv->_headers, FALSE, FALSE, 2);
gtk_box_pack_start(GTK_BOX(self), self->_priv->_attachexpander, FALSE, FALSE, 2);
gtk_box_pack_start(GTK_BOX(self), self->_priv->_body, TRUE, TRUE, 2);
}
static void
mu_msg_view_finalize (GObject *obj)
mu_msg_view_finalize(GObject* obj)
{
set_message (MU_MSG_VIEW (obj), NULL);
set_message(MU_MSG_VIEW(obj), NULL);
G_OBJECT_CLASS(parent_class)->finalize (obj);
G_OBJECT_CLASS(parent_class)->finalize(obj);
}
GtkWidget*
mu_msg_view_new (void)
mu_msg_view_new(void)
{
return GTK_WIDGET(g_object_new(MU_TYPE_MSG_VIEW, NULL));
}
void
mu_msg_view_set_message (MuMsgView *self, Mu::MuMsg *msg)
mu_msg_view_set_message(MuMsgView* self, Mu::MuMsg* msg)
{
gint attachnum;
g_return_if_fail (MU_IS_MSG_VIEW(self));
g_return_if_fail(MU_IS_MSG_VIEW(self));
set_message (self, msg);
set_message(self, msg);
mu_msg_header_view_set_message (MU_MSG_HEADER_VIEW(self->_priv->_headers),
msg);
attachnum = mu_msg_attach_view_set_message (MU_MSG_ATTACH_VIEW(self->_priv->_attach),
msg);
mu_msg_header_view_set_message(MU_MSG_HEADER_VIEW(self->_priv->_headers), msg);
attachnum = mu_msg_attach_view_set_message(MU_MSG_ATTACH_VIEW(self->_priv->_attach), msg);
mu_msg_body_view_set_message (MU_MSG_BODY_VIEW(self->_priv->_body),
msg);
mu_msg_body_view_set_message(MU_MSG_BODY_VIEW(self->_priv->_body), msg);
gtk_widget_set_visible (self->_priv->_headers, TRUE);
gtk_widget_set_visible (self->_priv->_attachexpander, attachnum > 0);
gtk_widget_set_visible (self->_priv->_body, TRUE);
gtk_widget_set_visible(self->_priv->_headers, TRUE);
gtk_widget_set_visible(self->_priv->_attachexpander, attachnum > 0);
gtk_widget_set_visible(self->_priv->_body, TRUE);
}
void
mu_msg_view_set_message_source (MuMsgView *self,
Mu::MuMsg *msg)
mu_msg_view_set_message_source(MuMsgView* self, Mu::MuMsg* msg)
{
g_return_if_fail (MU_IS_MSG_VIEW(self));
g_return_if_fail(MU_IS_MSG_VIEW(self));
set_message (self, msg);
set_message(self, msg);
mu_msg_body_view_set_message_source (MU_MSG_BODY_VIEW(self->_priv->_body),
msg);
mu_msg_body_view_set_message_source(MU_MSG_BODY_VIEW(self->_priv->_body), msg);
gtk_widget_set_visible (self->_priv->_headers, FALSE);
gtk_widget_set_visible (self->_priv->_attachexpander, FALSE);
gtk_widget_set_visible (self->_priv->_body, TRUE);
gtk_widget_set_visible(self->_priv->_headers, FALSE);
gtk_widget_set_visible(self->_priv->_attachexpander, FALSE);
gtk_widget_set_visible(self->_priv->_body, TRUE);
}
void
mu_msg_view_set_note (MuMsgView *self, const gchar* html)
mu_msg_view_set_note(MuMsgView* self, const gchar* html)
{
g_return_if_fail (MU_IS_MSG_VIEW(self));
g_return_if_fail(MU_IS_MSG_VIEW(self));
gtk_widget_set_visible (self->_priv->_headers, FALSE);
gtk_widget_set_visible (self->_priv->_attachexpander, FALSE);
gtk_widget_set_visible (self->_priv->_body, TRUE);
gtk_widget_set_visible(self->_priv->_headers, FALSE);
gtk_widget_set_visible(self->_priv->_attachexpander, FALSE);
gtk_widget_set_visible(self->_priv->_body, TRUE);
mu_msg_body_view_set_note (MU_MSG_BODY_VIEW(self->_priv->_body),
html);
mu_msg_body_view_set_note(MU_MSG_BODY_VIEW(self->_priv->_body), html);
}

32
toys/mug/mu-msg-view.hh
View File

@ -26,21 +26,23 @@
G_BEGIN_DECLS
/* convenience macros */
#define MU_TYPE_MSG_VIEW (mu_msg_view_get_type())
#define MU_MSG_VIEW(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),MU_TYPE_MSG_VIEW,MuMsgView))
#define MU_MSG_VIEW_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass),MU_TYPE_MSG_VIEW,MuMsgViewClass))
#define MU_IS_MSG_VIEW(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj),MU_TYPE_MSG_VIEW))
#define MU_IS_MSG_VIEW_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass),MU_TYPE_MSG_VIEW))
#define MU_MSG_VIEW_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj),MU_TYPE_MSG_VIEW,MuMsgViewClass))
#define MU_TYPE_MSG_VIEW (mu_msg_view_get_type())
#define MU_MSG_VIEW(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), MU_TYPE_MSG_VIEW, MuMsgView))
#define MU_MSG_VIEW_CLASS(klass) \
(G_TYPE_CHECK_CLASS_CAST((klass), MU_TYPE_MSG_VIEW, MuMsgViewClass))
#define MU_IS_MSG_VIEW(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), MU_TYPE_MSG_VIEW))
#define MU_IS_MSG_VIEW_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), MU_TYPE_MSG_VIEW))
#define MU_MSG_VIEW_GET_CLASS(obj) \
(G_TYPE_INSTANCE_GET_CLASS((obj), MU_TYPE_MSG_VIEW, MuMsgViewClass))
typedef struct _MuMsgView MuMsgView;
typedef struct _MuMsgViewClass MuMsgViewClass;
typedef struct _MuMsgViewPrivate MuMsgViewPrivate;
typedef struct _MuMsgView MuMsgView;
typedef struct _MuMsgViewClass MuMsgViewClass;
typedef struct _MuMsgViewPrivate MuMsgViewPrivate;
struct _MuMsgView {
GtkBox parent;
/* private */
MuMsgViewPrivate *_priv;
MuMsgViewPrivate* _priv;
};
struct _MuMsgViewClass {
@ -49,17 +51,17 @@ struct _MuMsgViewClass {
};
/* member functions */
GType mu_msg_view_get_type (void) G_GNUC_CONST;
GType mu_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* mu_msg_view_new (void);
GtkWidget* mu_msg_view_new(void);
struct MuMsg;
void mu_msg_view_set_message (MuMsgView *self, Mu::MuMsg *msg);
void mu_msg_view_set_note (MuMsgView *self, const gchar* html);
void mu_msg_view_set_message_source (MuMsgView *self, Mu::MuMsg *msg);
void mu_msg_view_set_message(MuMsgView* self, Mu::MuMsg* msg);
void mu_msg_view_set_note(MuMsgView* self, const gchar* html);
void mu_msg_view_set_message_source(MuMsgView* self, Mu::MuMsg* msg);
G_END_DECLS

527
toys/mug/mug-msg-list-view.cc
View File

@ -25,397 +25,404 @@
using namespace Mu;
/* 'private'/'protected' functions */
static void mug_msg_list_view_finalize (GObject * obj);
static void mug_msg_list_view_finalize(GObject* obj);
/* list my signals */
enum {
MUG_MSG_SELECTED,
MUG_ERROR_OCCURED,
LAST_SIGNAL
};
enum { MUG_MSG_SELECTED, MUG_ERROR_OCCURED, LAST_SIGNAL };
enum {
MUG_COL_DATESTR,
MUG_COL_MAILDIR,
MUG_COL_FLAGSSTR,
MUG_COL_FROM,
MUG_COL_TO,
MUG_COL_SUBJECT,
MUG_COL_PATH,
MUG_COL_PRIO,
MUG_COL_FLAGS,
MUG_COL_TIME,
MUG_N_COLS
MUG_COL_DATESTR,
MUG_COL_MAILDIR,
MUG_COL_FLAGSSTR,
MUG_COL_FROM,
MUG_COL_TO,
MUG_COL_SUBJECT,
MUG_COL_PATH,
MUG_COL_PRIO,
MUG_COL_FLAGS,
MUG_COL_TIME,
MUG_N_COLS
};
typedef struct _MugMsgListViewPrivate MugMsgListViewPrivate;
struct _MugMsgListViewPrivate {
GtkTreeStore *_store;
char *_xpath;
char *_query;
GtkTreeStore* _store;
char* _xpath;
char* _query;
};
#define MUG_MSG_LIST_VIEW_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE((o), \
MUG_TYPE_MSG_LIST_VIEW, \
MugMsgListViewPrivate))
#define MUG_MSG_LIST_VIEW_GET_PRIVATE(o) \
(G_TYPE_INSTANCE_GET_PRIVATE((o), MUG_TYPE_MSG_LIST_VIEW, MugMsgListViewPrivate))
/* globals */
static GtkTreeViewClass *parent_class = NULL;
static GtkTreeViewClass* parent_class = NULL;
/* uncomment the following if you have defined any signals */
static guint signals[LAST_SIGNAL] = { 0 };
static guint signals[LAST_SIGNAL] = {0};
G_DEFINE_TYPE (MugMsgListView, mug_msg_list_view, GTK_TYPE_TREE_VIEW);
G_DEFINE_TYPE(MugMsgListView, mug_msg_list_view, GTK_TYPE_TREE_VIEW);
static void
mug_msg_list_view_class_init (MugMsgListViewClass * klass)
mug_msg_list_view_class_init(MugMsgListViewClass* klass)
{
GObjectClass *gobject_class;
gobject_class = (GObjectClass *) klass;
GObjectClass* gobject_class;
gobject_class = (GObjectClass*)klass;
parent_class = (GtkTreeViewClass*)g_type_class_peek_parent (klass);
gobject_class->finalize = mug_msg_list_view_finalize;
parent_class = (GtkTreeViewClass*)g_type_class_peek_parent(klass);
gobject_class->finalize = mug_msg_list_view_finalize;
g_type_class_add_private (gobject_class,
sizeof (MugMsgListViewPrivate));
g_type_class_add_private(gobject_class, sizeof(MugMsgListViewPrivate));
signals[MUG_MSG_SELECTED] =
g_signal_new ("msg-selected",
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (MugMsgListViewClass,
msg_selected),
NULL, NULL,
g_cclosure_marshal_VOID__STRING,
G_TYPE_NONE, 1, G_TYPE_STRING);
signals[MUG_ERROR_OCCURED] =
g_signal_new ("error-occured",
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (MugMsgListViewClass,
error_occured),
NULL, NULL,
g_cclosure_marshal_VOID__UINT,
G_TYPE_NONE, 1, G_TYPE_UINT);
signals[MUG_MSG_SELECTED] = g_signal_new("msg-selected",
G_TYPE_FROM_CLASS(gobject_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET(MugMsgListViewClass, msg_selected),
NULL,
NULL,
g_cclosure_marshal_VOID__STRING,
G_TYPE_NONE,
1,
G_TYPE_STRING);
signals[MUG_ERROR_OCCURED] =
g_signal_new("error-occured",
G_TYPE_FROM_CLASS(gobject_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET(MugMsgListViewClass, error_occured),
NULL,
NULL,
g_cclosure_marshal_VOID__UINT,
G_TYPE_NONE,
1,
G_TYPE_UINT);
}
static void
on_cursor_changed (GtkTreeView * tview, MugMsgListView * lst)
on_cursor_changed(GtkTreeView* tview, MugMsgListView* lst)
{
GtkTreeSelection *sel;
GtkTreeIter iter;
MugMsgListViewPrivate *priv;
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);
if (!sel)
return; /* hmmm */
if (gtk_tree_selection_get_selected (sel, NULL, &iter)) {
char *path;
gtk_tree_model_get (GTK_TREE_MODEL (priv->_store), &iter,
MUG_COL_PATH, &path, -1);
g_signal_emit (G_OBJECT (lst),
signals[MUG_MSG_SELECTED], 0, path);
g_free (path);
}
sel = gtk_tree_view_get_selection(tview);
if (!sel)
return; /* hmmm */
if (gtk_tree_selection_get_selected(sel, NULL, &iter)) {
char* path;
gtk_tree_model_get(GTK_TREE_MODEL(priv->_store), &iter, MUG_COL_PATH, &path, -1);
g_signal_emit(G_OBJECT(lst), signals[MUG_MSG_SELECTED], 0, path);
g_free(path);
}
}
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)
{
MuFlags flags;
MuMsgPrio prio;
MuFlags 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_FLAG_NEW) ? 800 : 400,
"weight", (flags & MU_FLAG_SEEN) ? 400 : 800,
"foreground", prio == MU_MSG_PRIO_HIGH ? "red" : NULL,
NULL);
g_object_set(G_OBJECT(renderer),
"weight",
(flags & MU_FLAG_NEW) ? 800 : 400,
"weight",
(flags & MU_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;
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_sizing (col, GTK_TREE_VIEW_COLUMN_FIXED);
if (sortcolidx == -1)
sortcolidx = colidx;
gtk_tree_view_column_set_sort_column_id(col, sortcolidx);
gtk_tree_view_column_set_sizing(col, GTK_TREE_VIEW_COLUMN_FIXED);
if (maxwidth) {
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);
if (maxwidth) {
gtk_tree_view_column_set_fixed_width(col, maxwidth);
gtk_tree_view_column_set_expand(col, FALSE);
} else
gtk_tree_view_column_set_expand(col, TRUE);
gtk_tree_view_column_set_cell_data_func (col, renderer,
(GtkTreeCellDataFunc)
treecell_func, NULL, NULL);
gtk_tree_view_column_set_cell_data_func(col,
renderer,
(GtkTreeCellDataFunc)treecell_func,
NULL,
NULL);
gtk_tree_view_append_column (treeview, col);
gtk_tree_view_append_column(treeview, col);
gtk_tree_view_columns_autosize (treeview);
gtk_tree_view_set_fixed_height_mode (treeview, TRUE);
gtk_tree_view_columns_autosize(treeview);
gtk_tree_view_set_fixed_height_mode(treeview, TRUE);
}
static void
mug_msg_list_view_init (MugMsgListView * obj)
mug_msg_list_view_init(MugMsgListView* obj)
{
MugMsgListViewPrivate *priv;
GtkTreeView *tview;
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_tree_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->_xpath = priv->_query = NULL;
priv->_store = gtk_tree_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)
mug_msg_list_view_finalize(GObject* obj)
{
MugMsgListViewPrivate *priv;
priv = MUG_MSG_LIST_VIEW_GET_PRIVATE (obj);
MugMsgListViewPrivate* priv;
priv = MUG_MSG_LIST_VIEW_GET_PRIVATE(obj);
if (priv->_store)
g_object_unref (priv->_store);
if (priv->_store)
g_object_unref(priv->_store);
g_free (priv->_xpath);
g_free (priv->_query);
g_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)
mug_msg_list_view_move_first(MugMsgListView* self)
{
GtkTreePath *path;
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)
msg_list_view_move(MugMsgListView* self, gboolean next)
{
GtkTreePath *path;
GtkTreePath* path;
gtk_tree_view_get_cursor (GTK_TREE_VIEW (self), &path, NULL);
if (!path)
return FALSE;
gtk_tree_view_get_cursor(GTK_TREE_VIEW(self), &path, NULL);
if (!path)
return FALSE;
if (next)
gtk_tree_path_next (path);
else
gtk_tree_path_prev (path);
if (next)
gtk_tree_path_next(path);
else
gtk_tree_path_prev(path);
gtk_tree_view_set_cursor (GTK_TREE_VIEW (self), path, NULL, FALSE);
gtk_tree_path_free (path);
gtk_tree_view_set_cursor(GTK_TREE_VIEW(self), path, NULL, FALSE);
gtk_tree_path_free(path);
return TRUE;
return TRUE;
}
gboolean
mug_msg_list_view_move_next (MugMsgListView * self)
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)
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;
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;
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 ("-");
else
return mu_str_display_contact (str);
if (!str || *str == '\0')
return g_strdup("-");
else
return mu_str_display_contact(str);
}
static Mu::Option<Mu::QueryResults>
run_query (const char *xpath, const char *expr, MugMsgListView * self)
run_query(const char* xpath, const char* expr, MugMsgListView* self)
{
Mu::Store store{xpath};
Mu::Query query{store};
Mu::Store store{xpath};
Mu::Query query{store};
return query.run(expr, MU_MSG_FIELD_ID_DATE,
Mu::QueryFlags::Descending |
Mu::QueryFlags::SkipUnreadable |
Mu::QueryFlags::SkipDuplicates |
Mu::QueryFlags::IncludeRelated |
Mu::QueryFlags::Threading);
return query.run(expr,
MU_MSG_FIELD_ID_DATE,
Mu::QueryFlags::Descending | Mu::QueryFlags::SkipUnreadable |
Mu::QueryFlags::SkipDuplicates | Mu::QueryFlags::IncludeRelated |
Mu::QueryFlags::Threading);
}
static void
add_row (GtkTreeStore * store, MuMsg *msg, GtkTreeIter *treeiter)
add_row(GtkTreeStore* store, MuMsg* msg, GtkTreeIter* treeiter)
{
const gchar *datestr, *flagstr;
gchar *from, *to;
time_t timeval;
const gchar *datestr, *flagstr;
gchar * from, *to;
time_t timeval;
timeval = mu_msg_get_date (msg);
datestr = timeval == 0 ? "-" : mu_date_display_s (timeval);
from = empty_or_display_contact (mu_msg_get_from (msg));
to = empty_or_display_contact (mu_msg_get_to (msg));
flagstr = mu_flags_to_str_s (mu_msg_get_flags (msg), MU_FLAG_TYPE_ANY);
timeval = mu_msg_get_date(msg);
datestr = timeval == 0 ? "-" : mu_date_display_s(timeval);
from = empty_or_display_contact(mu_msg_get_from(msg));
to = empty_or_display_contact(mu_msg_get_to(msg));
flagstr = mu_flags_to_str_s(mu_msg_get_flags(msg), MU_FLAG_TYPE_ANY);
/* if (0) { */
/* GtkTreeIter myiter; */
/* if (!gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL(store), */
/* &myiter, path)) */
/* g_warning ("%s: cannot get iter for %s",
* __func__, path); */
/* } */
/* if (0) { */
/* GtkTreeIter myiter; */
/* if (!gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL(store), */
/* &myiter, path)) */
/* g_warning ("%s: cannot get iter for %s",
* __func__, path); */
/* } */
gtk_tree_store_set (store, treeiter,
MUG_COL_DATESTR, datestr,
MUG_COL_MAILDIR, mu_msg_get_maildir (msg),
MUG_COL_FLAGSSTR, flagstr,
MUG_COL_FROM, from,
MUG_COL_TO, to,
MUG_COL_SUBJECT, mu_msg_get_subject (msg),
MUG_COL_PATH, mu_msg_get_path (msg),
MUG_COL_PRIO, mu_msg_get_prio (msg),
MUG_COL_FLAGS, mu_msg_get_flags (msg),
MUG_COL_TIME, timeval, -1);
g_free (from);
g_free (to);
gtk_tree_store_set(store,
treeiter,
MUG_COL_DATESTR,
datestr,
MUG_COL_MAILDIR,
mu_msg_get_maildir(msg),
MUG_COL_FLAGSSTR,
flagstr,
MUG_COL_FROM,
from,
MUG_COL_TO,
to,
MUG_COL_SUBJECT,
mu_msg_get_subject(msg),
MUG_COL_PATH,
mu_msg_get_path(msg),
MUG_COL_PRIO,
mu_msg_get_prio(msg),
MUG_COL_FLAGS,
mu_msg_get_flags(msg),
MUG_COL_TIME,
timeval,
-1);
g_free(from);
g_free(to);
}
static int
update_model (GtkTreeStore *store, const char *xpath, const char *query,
MugMsgListView *self)
update_model(GtkTreeStore* store, const char* xpath, const char* query, MugMsgListView* self)
{
const auto res{run_query (xpath, query, self)};
if (!res) {
g_warning ("error: running query failed");
return -1;
}
const auto res{run_query(xpath, query, self)};
if (!res) {
g_warning("error: running query failed");
return -1;
}
auto count{0};
auto count{0};
std::string prev_thread_path;
for (auto&& it: *res) {
GtkTreeIter treeiter, prev_treeiter;
std::string prev_thread_path;
for (auto&& it : *res) {
GtkTreeIter treeiter, prev_treeiter;
const auto thread_path{it.query_match().thread_path};
const auto thread_path{it.query_match().thread_path};
if (prev_thread_path.find(thread_path) == 0)
gtk_tree_store_append (store, &treeiter, &prev_treeiter);
else
gtk_tree_store_append (store, &treeiter, NULL);
if (prev_thread_path.find(thread_path) == 0)
gtk_tree_store_append(store, &treeiter, &prev_treeiter);
else
gtk_tree_store_append(store, &treeiter, NULL);
/* don't unref msg */
add_row (store, it.floating_msg(), &treeiter);
/* don't unref msg */
add_row(store, it.floating_msg(), &treeiter);
//prev_ti = ti;
prev_treeiter = treeiter;
prev_thread_path = thread_path;
++count;
}
// prev_ti = ti;
prev_treeiter = treeiter;
prev_thread_path = thread_path;
++count;
}
return count;
return count;
}
int
mug_msg_list_view_query (MugMsgListView * self, const char *query)
mug_msg_list_view_query(MugMsgListView* self, const char* query)
{
MugMsgListViewPrivate *priv;
gboolean rv;
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_tree_store_clear (priv->_store);
priv = MUG_MSG_LIST_VIEW_GET_PRIVATE(self);
gtk_tree_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;
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_expand_all (GTK_TREE_VIEW(self));
gtk_tree_view_expand_all(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;
}

120
toys/mug/mug-msg-view.cc
View File

@ -27,9 +27,9 @@
using namespace Mu;
/* '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 {
@ -38,115 +38,111 @@ enum {
LAST_SIGNAL
};
typedef struct _MugMsgViewPrivate MugMsgViewPrivate;
struct _MugMsgViewPrivate {
GtkWidget *_view;
GtkWidget* _view;
};
#define MUG_MSG_VIEW_GET_PRIVATE(o)(G_TYPE_INSTANCE_GET_PRIVATE((o),MUG_TYPE_MSG_VIEW, MugMsgViewPrivate))
#define MUG_MSG_VIEW_GET_PRIVATE(o) \
(G_TYPE_INSTANCE_GET_PRIVATE((o), MUG_TYPE_MSG_VIEW, MugMsgViewPrivate))
/* globals */
static GtkBoxClass *parent_class = NULL;
G_DEFINE_TYPE (MugMsgView, mug_msg_view, GTK_TYPE_BOX);
static GtkBoxClass* parent_class = NULL;
G_DEFINE_TYPE(MugMsgView, mug_msg_view, GTK_TYPE_BOX);
/* uncomment the following if you have defined any signals */
/* static guint signals[LAST_SIGNAL] = {0}; */
static void
mug_msg_view_class_init (MugMsgViewClass * klass)
mug_msg_view_class_init(MugMsgViewClass* klass)
{
GObjectClass *gobject_class;
gobject_class = (GObjectClass *) klass;
GObjectClass* gobject_class;
gobject_class = (GObjectClass*)klass;
parent_class = (GtkBoxClass*)g_type_class_peek_parent (klass);
parent_class = (GtkBoxClass*)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] = */
/* g_signal_new ("my_signal_1",....); */
/* signals[MY_SIGNAL_2] = */
/* g_signal_new ("my_signal_2",....); */
/* etc. */
/* signals[MY_SIGNAL_1] = */
/* g_signal_new ("my_signal_1",....); */
/* signals[MY_SIGNAL_2] = */
/* g_signal_new ("my_signal_2",....); */
/* etc. */
}
static void
mug_msg_view_init (MugMsgView * obj)
mug_msg_view_init(MugMsgView* obj)
{
MugMsgViewPrivate *priv;
GtkWidget *scrolled;
MugMsgViewPrivate* priv;
GtkWidget* scrolled;
priv = MUG_MSG_VIEW_GET_PRIVATE (obj);
priv = MUG_MSG_VIEW_GET_PRIVATE(obj);
priv->_view = mu_msg_view_new ();
priv->_view = mu_msg_view_new();
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), scrolled, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(obj), scrolled, TRUE, TRUE, 0);
}
static void
mug_msg_view_finalize (GObject * obj)
mug_msg_view_finalize(GObject* obj)
{
/* free/unref instance resources here */
G_OBJECT_CLASS (parent_class)->finalize (obj);
/* free/unref instance resources here */
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));
}
gboolean
mug_msg_view_set_msg (MugMsgView * self, const char *msgpath)
mug_msg_view_set_msg(MugMsgView* self, const char* msgpath)
{
MugMsgViewPrivate *priv;
g_return_val_if_fail (MUG_IS_MSG_VIEW (self), FALSE);
MugMsgViewPrivate* priv;
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)
mu_msg_view_set_message (MU_MSG_VIEW(priv->_view), NULL);
mu_msg_view_set_message(MU_MSG_VIEW(priv->_view), NULL);
else {
Mu::MuMsg *msg;
Mu::MuMsg* msg;
if (access (msgpath, R_OK) == 0) {
msg = mu_msg_new_from_file (msgpath, NULL, NULL);
mu_msg_view_set_message (MU_MSG_VIEW(priv->_view), msg);
if (access(msgpath, R_OK) == 0) {
msg = mu_msg_new_from_file(msgpath, NULL, NULL);
mu_msg_view_set_message(MU_MSG_VIEW(priv->_view), msg);
if (msg)
mu_msg_unref (msg);
mu_msg_unref(msg);
} else {
gchar *note;
note = g_strdup_printf (
"<h1>Note</h1><hr>"
"<p>Message <tt>%s</tt> does not seem to be present "
"on the file system."
"<p>Maybe you need to run <tt>mu index</tt>?",
msgpath);
mu_msg_view_set_note (MU_MSG_VIEW (priv->_view), note);
g_free (note);
gchar* note;
note = g_strdup_printf("<h1>Note</h1><hr>"
"<p>Message <tt>%s</tt> does not seem to be present "
"on the file system."
"<p>Maybe you need to run <tt>mu index</tt>?",
msgpath);
mu_msg_view_set_note(MU_MSG_VIEW(priv->_view), note);
g_free(note);
}
}
return TRUE;
}
void
mug_msg_view_set_note (MugMsgView * self, const char* html)
mug_msg_view_set_note(MugMsgView* self, const char* html)
{
MugMsgViewPrivate *priv;
g_return_if_fail (MUG_IS_MSG_VIEW (self));
MugMsgViewPrivate* priv;
g_return_if_fail(MUG_IS_MSG_VIEW(self));
priv = MUG_MSG_VIEW_GET_PRIVATE (self);
priv = MUG_MSG_VIEW_GET_PRIVATE(self);
mu_msg_view_set_note (MU_MSG_VIEW (priv->_view), html);
mu_msg_view_set_note(MU_MSG_VIEW(priv->_view), html);
}

121
toys/mug/mug-shortcuts.cc
View File

@ -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"
@ -38,115 +38,110 @@ enum {
};
struct _MugShortcutsPrivate {
GtkWidget *_bbox;
GtkWidget* _bbox;
};
#define MUG_SHORTCUTS_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE((o), \
MUG_TYPE_SHORTCUTS, \
MugShortcutsPrivate))
#define MUG_SHORTCUTS_GET_PRIVATE(o) \
(G_TYPE_INSTANCE_GET_PRIVATE((o), MUG_TYPE_SHORTCUTS, MugShortcutsPrivate))
/* globals */
static guint signals[LAST_SIGNAL] = { 0 };
static guint signals[LAST_SIGNAL] = {0};
static GtkBoxClass *parent_class = NULL;
G_DEFINE_TYPE (MugShortcuts, mug_shortcuts, GTK_TYPE_BOX);
static GtkBoxClass* parent_class = NULL;
G_DEFINE_TYPE(MugShortcuts, mug_shortcuts, GTK_TYPE_BOX);
static void
mug_shortcuts_class_init (MugShortcutsClass * klass)
mug_shortcuts_class_init(MugShortcutsClass* klass)
{
GObjectClass *gobject_class;
gobject_class = (GObjectClass *) klass;
GObjectClass* gobject_class;
gobject_class = (GObjectClass*)klass;
parent_class = (GtkBoxClass*)g_type_class_peek_parent (klass);
parent_class = (GtkBoxClass*)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);
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);
/* signals[MY_SIGNAL_2] = */
/* g_signal_new ("my_signal_2",....); */
/* etc. */
/* signals[MY_SIGNAL_2] = */
/* g_signal_new ("my_signal_2",....); */
/* etc. */
}
static void
mug_shortcuts_init (MugShortcuts * obj)
mug_shortcuts_init(MugShortcuts* obj)
{
obj->_priv = MUG_SHORTCUTS_GET_PRIVATE (obj);
obj->_priv->_bbox = gtk_button_box_new (GTK_ORIENTATION_VERTICAL);
obj->_priv = MUG_SHORTCUTS_GET_PRIVATE(obj);
obj->_priv->_bbox = gtk_button_box_new(GTK_ORIENTATION_VERTICAL);
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);
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)
mug_shortcuts_finalize(GObject* obj)
{
/* free/unref instance resources here */
G_OBJECT_CLASS (parent_class)->finalize (obj);
/* free/unref instance resources here */
G_OBJECT_CLASS(parent_class)->finalize(obj);
}
static void
on_button_clicked (GtkWidget * button, MugShortcuts * self)
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)
each_bookmark(const char* key, const char* val, MugShortcuts* self)
{
GtkWidget *button;
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)
init_shortcuts(MugShortcuts* self, const char* bmpath)
{
MuBookmarks *bookmarks;
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;
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 */

432
toys/mug/mug.cc
View File

@ -21,7 +21,7 @@
#include <gtk/gtk.h>
#include <gdk/gdkkeysyms.h>
#include <string.h> /* for memset */
#include <string.h> /* for memset */
#include <utils/mu-util.h>
#include <mu-store.hh>
@ -33,32 +33,33 @@
#include "mug-shortcuts.h"
struct _MugData {
GtkWidget *win;
GtkWidget *statusbar;
GtkWidget *mlist;
GtkWidget *toolbar;
GtkWidget *msgview;
GtkWidget *querybar;
GtkWidget *shortcuts;
gchar *muhome;
GtkWidget* win;
GtkWidget* statusbar;
GtkWidget* mlist;
GtkWidget* toolbar;
GtkWidget* msgview;
GtkWidget* querybar;
GtkWidget* shortcuts;
gchar* muhome;
};
typedef struct _MugData MugData;
static void
about_mug (MugData * mugdata)
about_mug(MugData* mugdata)
{
GtkWidget *about;
about = gtk_message_dialog_new
(GTK_WINDOW (mugdata->win), GTK_DIALOG_MODAL,
GTK_MESSAGE_INFO, GTK_BUTTONS_OK,
"Mug version %s\n"
"A graphical frontend to the 'mu' e-mail search engine\n\n"
"(c) 2010-2013 Dirk-Jan C. Binnema\n"
"Released under the terms of the GPLv3+", VERSION);
GtkWidget* about;
about = gtk_message_dialog_new(GTK_WINDOW(mugdata->win),
GTK_DIALOG_MODAL,
GTK_MESSAGE_INFO,
GTK_BUTTONS_OK,
"Mug version %s\n"
"A graphical frontend to the 'mu' e-mail search engine\n\n"
"(c) 2010-2013 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 {
@ -67,353 +68,334 @@ enum _ToolAction {
ACTION_REINDEX,
ACTION_DO_QUIT,
ACTION_ABOUT,
ACTION_SEPARATOR /* pseudo action */
ACTION_SEPARATOR /* pseudo action */
};
typedef enum _ToolAction ToolAction;
static void
on_tool_button_clicked (GtkToolButton * btn, MugData * mugdata)
on_tool_button_clicked(GtkToolButton* btn, MugData* mugdata)
{
ToolAction action;
action = (ToolAction)
GPOINTER_TO_UINT (g_object_get_data (G_OBJECT (btn), "action"));
action = (ToolAction)GPOINTER_TO_UINT(g_object_get_data(G_OBJECT(btn), "action"));
switch (action) {
case ACTION_DO_QUIT:
gtk_main_quit ();
break;
case ACTION_NEXT_MSG:
mug_msg_list_view_move_next (MUG_MSG_LIST_VIEW
(mugdata->mlist));
break;
case ACTION_PREV_MSG:
mug_msg_list_view_move_prev (MUG_MSG_LIST_VIEW
(mugdata->mlist));
break;
case ACTION_ABOUT:
about_mug (mugdata);
break;
default:
g_print ("%u\n", action);
case ACTION_DO_QUIT: gtk_main_quit(); break;
case ACTION_NEXT_MSG: mug_msg_list_view_move_next(MUG_MSG_LIST_VIEW(mugdata->mlist)); break;
case ACTION_PREV_MSG: mug_msg_list_view_move_prev(MUG_MSG_LIST_VIEW(mugdata->mlist)); break;
case ACTION_ABOUT: about_mug(mugdata); break;
default: g_print("%u\n", action);
}
}
static GtkToolItem*
tool_button (const char *name)
tool_button(const char* name)
{
GtkWidget *icon;
GtkWidget* icon;
icon = gtk_image_new_from_icon_name
(name, GTK_ICON_SIZE_SMALL_TOOLBAR);
icon = gtk_image_new_from_icon_name(name, GTK_ICON_SIZE_SMALL_TOOLBAR);
return gtk_menu_tool_button_new (icon, NULL);
return gtk_menu_tool_button_new(icon, NULL);
}
static GtkToolItem*
get_connected_tool_button (const char* stock_id, ToolAction action,
MugData *mugdata)
get_connected_tool_button(const char* stock_id, ToolAction action, MugData* mugdata)
{
GtkToolItem *btn;
GtkToolItem* btn;
btn = tool_button (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);
btn = tool_button(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)
static GtkWidget*
mug_toolbar(MugData* mugdata)
{
GtkWidget *toolbar;
int i;
GtkWidget* toolbar;
int i;
struct {
const char *stock_id;
ToolAction action;
} tools[] = {
{"go-up", ACTION_PREV_MSG},
{"go-down", ACTION_NEXT_MSG},
{NULL, ACTION_SEPARATOR},
{"view-refresh", ACTION_REINDEX},
{NULL, ACTION_SEPARATOR},
{"help-about", ACTION_ABOUT},
{NULL, ACTION_SEPARATOR},
{"application-exit", ACTION_DO_QUIT}};
const char* stock_id;
ToolAction action;
} tools[] = {{"go-up", ACTION_PREV_MSG},
{"go-down", ACTION_NEXT_MSG},
{NULL, ACTION_SEPARATOR},
{"view-refresh", ACTION_REINDEX},
{NULL, ACTION_SEPARATOR},
{"help-about", ACTION_ABOUT},
{NULL, ACTION_SEPARATOR},
{"application-exit", ACTION_DO_QUIT}};
toolbar = gtk_toolbar_new ();
for (i = 0; i != G_N_ELEMENTS (tools); ++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);
gtk_toolbar_insert(GTK_TOOLBAR(toolbar), gtk_separator_tool_item_new(), i);
continue;
} else /* nope: a real item */
gtk_toolbar_insert (GTK_TOOLBAR (toolbar),
get_connected_tool_button
(tools[i].stock_id, tools[i].action,
mugdata), i);
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_path(MU_RUNTIME_PATH_BOOKMARKS));
data->shortcuts = mug_shortcuts_new(mu_runtime_path(MU_RUNTIME_PATH_BOOKMARKS));
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;
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_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));
if (count == 0) /* nothing found */
mug_query_bar_grab_focus(MUG_QUERY_BAR(bar));
}
static void
on_msg_selected (MugMsgListView * mlist, const char *mpath, MugData * mugdata)
on_msg_selected(MugMsgListView* mlist, const char* mpath, MugData* mugdata)
{
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;
GtkWidget* errdialog;
const char* msg;
switch (err) {
case MUG_ERROR_XAPIAN_NOT_UPTODATE:
msg = "The Xapian Database has the wrong version\n"
"Please run 'mu index --rebuild'";
"Please run 'mu index --rebuild'";
break;
case MUG_ERROR_XAPIAN_DIR:
msg = "Cannot find the Xapian database dir\n"
"Please restart mug with --muhome=... pointing\n"
"to your mu home directory";
break;
case MUG_ERROR_QUERY:
msg = "Error in query";
break;
default:
msg = "Some error occurred";
"Please restart mug with --muhome=... pointing\n"
"to your mu home directory";
break;
case MUG_ERROR_QUERY: msg = "Error in query"; break;
default: msg = "Some error occurred"; break;
}
errdialog = gtk_message_dialog_new
(GTK_WINDOW (mugdata->win), GTK_DIALOG_MODAL,
GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, "%s", msg);
errdialog = gtk_message_dialog_new(GTK_WINDOW(mugdata->win),
GTK_DIALOG_MODAL,
GTK_MESSAGE_ERROR,
GTK_BUTTONS_OK,
"%s",
msg);
gtk_dialog_run (GTK_DIALOG (errdialog));
gtk_widget_destroy (errdialog);
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;
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, *paned, *scrolled;
queryarea = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2);
paned = gtk_paned_new (GTK_ORIENTATION_VERTICAL);
queryarea = gtk_box_new(GTK_ORIENTATION_VERTICAL, 2);
paned = gtk_paned_new(GTK_ORIENTATION_VERTICAL);
mugdata->mlist = mug_msg_list_view_new
(mu_runtime_path(MU_RUNTIME_PATH_XAPIANDB));
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_path(MU_RUNTIME_PATH_XAPIANDB));
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 ();
mug_msg_view_set_note (MUG_MSG_VIEW(mugdata->msgview),
"<h1>Welcome to <i>mug</i>!</h1><hr>"
"<tt>mug</tt> is an experimental UI for <tt>mu</tt>, which will "
"slowly evolve into something useful.<br><br>Enjoy the ride.");
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->msgview = mug_msg_view_new();
mug_msg_view_set_note(MUG_MSG_VIEW(mugdata->msgview),
"<h1>Welcome to <i>mug</i>!</h1><hr>"
"<tt>mug</tt> is an experimental UI for <tt>mu</tt>, which will "
"slowly evolve into something useful.<br><br>Enjoy the ride.");
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_box_new (GTK_ORIENTATION_HORIZONTAL, 5);
mainarea = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 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;
}
static GtkWidget*
mug_shell (MugData *mugdata)
mug_shell(MugData* mugdata)
{
GtkWidget *vbox;
GtkWidget* vbox;
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_box_new (GTK_ORIENTATION_VERTICAL, 2);
vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 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->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);
{
gchar *icon;
icon = g_strdup_printf ("%s%cmug.svg",
MUGDIR, G_DIR_SEPARATOR);
gtk_window_set_icon_from_file (GTK_WINDOW (mugdata->win), icon, NULL);
g_free (icon);
gchar* icon;
icon = g_strdup_printf("%s%cmug.svg", MUGDIR, G_DIR_SEPARATOR);
gtk_window_set_icon_from_file(GTK_WINDOW(mugdata->win), icon, NULL);
g_free(icon);
}
return mugdata->win;
}
static gint
on_focus_query_bar (GtkWidget* ignored, GdkEventKey *event, MugData* mugdata)
on_focus_query_bar(GtkWidget* ignored, GdkEventKey* event, MugData* mugdata)
{
if (event->type==GDK_KEY_RELEASE && event->keyval==GDK_KEY_Escape) {
mug_query_bar_grab_focus (MUG_QUERY_BAR (mugdata->querybar));
if (event->type == GDK_KEY_RELEASE && event->keyval == GDK_KEY_Escape) {
mug_query_bar_grab_focus(MUG_QUERY_BAR(mugdata->querybar));
return 1;
}
return 0;
}
int
main (int argc, char *argv[])
main(int argc, char* argv[])
{
MugData mugdata;
GtkWidget *mugshell;
GOptionContext *octx;
GOptionEntry entries[] = {
{"muhome", 0, 0, G_OPTION_ARG_FILENAME, &mugdata.muhome,
"specify an alternative mu directory", NULL},
{NULL, 0, 0, G_OPTION_ARG_NONE, NULL, NULL, NULL} /* sentinel */
};
MugData mugdata;
GtkWidget* mugshell;
GOptionContext* octx;
GOptionEntry entries[] = {
{"muhome",
0,
0,
G_OPTION_ARG_FILENAME,
&mugdata.muhome,
"specify an alternative mu directory",
NULL},
{NULL, 0, 0, G_OPTION_ARG_NONE, NULL, NULL, NULL} /* sentinel */
};
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_option_context_free (octx);
g_printerr ("mug: error in options\n");
memset(&mugdata, 0, sizeof(MugData));
if (!g_option_context_parse(octx, &argc, &argv, NULL)) {
g_option_context_free(octx);
g_printerr("mug: error in options\n");
return 1;
}
g_option_context_free (octx);
mu_runtime_init (mugdata.muhome, "mug", FALSE);
g_option_context_free(octx);
mu_runtime_init(mugdata.muhome, "mug", FALSE);
mugshell = mug_shell (&mugdata);
g_signal_connect (G_OBJECT (mugshell), "destroy",
G_CALLBACK (gtk_main_quit), NULL);
g_signal_connect (G_OBJECT (mugshell), "key_release_event",
G_CALLBACK ( on_focus_query_bar ), (gpointer)&mugdata );
mugshell = mug_shell(&mugdata);
g_signal_connect(G_OBJECT(mugshell), "destroy", G_CALLBACK(gtk_main_quit), NULL);
g_signal_connect(G_OBJECT(mugshell),
"key_release_event",
G_CALLBACK(on_focus_query_bar),
(gpointer)&mugdata);
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;
}