modest-tny-account-store.c\
modest-tny-msg-actions.h\
modest-tny-msg-actions.c\
+ modest-tny-store-actions.c\
+ modest-tny-store-actions.h\
modest-protocol-mgr.h\
modest-protocol-mgr.c\
modest-ui.h\
modest-tny-platform-factory.c \
modest-tny-platform-factory.h
-
modest_LDADD = \
$(MODEST_GSTUFF_LIBS) \
$(MODEST_LIBTINYMAIL_GNOME_DESKTOP_LIBS) \
static void
send_mail (ModestEditMsgWindow *self)
{
- const gchar *from, *to, *cc, *bcc, *subject;
- gchar *body;
+ const gchar *to, *cc, *bcc, *subject;
+ gchar *body, *from;
ModestEditMsgWindowPrivate *priv;
TnyTransportAccount *transport_account;
ModestMailOperation *mail_operation;
+ ModestAccountData *data;
GtkTextBuffer *buf;
GtkTextIter b, e;
priv = MODEST_EDIT_MSG_WINDOW_GET_PRIVATE(self);
+ data = modest_combo_box_get_active_id (MODEST_COMBO_BOX (priv->from_field));
- /* don't free these */
- from = "djcb@djcbsoftware.nl";
+ /* don't free these (except from) */
+ from = g_strdup_printf ("%s <%s>", data->full_name, data->email) ;
to = gtk_entry_get_text (GTK_ENTRY(priv->to_field));
cc = gtk_entry_get_text (GTK_ENTRY(priv->cc_field));
bcc = gtk_entry_get_text (GTK_ENTRY(priv->bcc_field));
subject, body, NULL);
/* Clean up */
g_object_unref (mail_operation);
+ g_free (from);
g_free (body);
}
gtk_text_buffer_set_text (buf,
(const gchar *) modest_tny_msg_actions_find_body (msg, FALSE),
-1);
+
+ /* TODO: lower priority, select in the From: combo to
+ the value that comes from msg */
+
+ /* TODO: set attachments */
}
return GTK_WIDGET (obj);
#include "modest-edit-msg-window.h"
#include "modest-icon-names.h"
#include "modest-tny-platform-factory.h"
+#include "modest-tny-msg-actions.h"
#include "modest-mail-operation.h"
/* 'private'/'protected' functions */
ModestHeaderView *header_view;
TnyList *header_list;
TnyIterator *iter;
+ const gchar *from;
+ gchar *reply_key, *forward_key;
+ ModestMailOperationReplyType reply_type;
+ ModestMailOperationForwardType forward_type;
+ ModestConf *conf;
+ GError *error;
priv = MODEST_MAIN_WINDOW_GET_PRIVATE(self);
+ conf = modest_tny_platform_factory_get_modest_conf_instance (priv->factory);
header_view = modest_widget_factory_get_header_view (priv->widget_factory);
header_list = modest_header_view_get_selected_headers (header_view);
+ /* Get reply and forward types */
+ error = NULL;
+ reply_key = g_strdup_printf ("%s/%s", MODEST_CONF_NAMESPACE, MODEST_CONF_REPLY_TYPE);
+ reply_type = modest_conf_get_int (conf, reply_key, &error);
+ if (error) {
+ g_warning (N_("Key %s not defined"), reply_key);
+ reply_type = MODEST_MAIL_OPERATION_REPLY_TYPE_CITE;
+ g_error_free (error);
+ error = NULL;
+ }
+ g_free (reply_key);
+
+ forward_key = g_strdup_printf ("%s/%s", MODEST_CONF_NAMESPACE, MODEST_CONF_FORWARD_TYPE);
+ forward_type = modest_conf_get_int (conf, forward_key, NULL);
+ if (error) {
+ g_warning (N_("Key %s not defined"), forward_key);
+ reply_type = MODEST_MAIL_OPERATION_FORWARD_TYPE_INLINE;
+ g_error_free (error);
+ }
+ g_free (forward_key);
+
if (header_list) {
iter = tny_list_create_iterator (header_list);
do {
- TnyHeader *header;
+ TnyHeader *header, *new_header;
TnyFolder *folder;
TnyMsg *msg, *new_msg;
ModestEditType edit_type;
folder = tny_header_get_folder (header);
msg = tny_folder_get_msg (folder, header);
+ from = modest_folder_view_get_selected_account (priv->folder_view);
+
/* FIXME: select proper action */
switch (action) {
case 1:
- /* TODO: get reply type from config */
new_msg =
- modest_mail_operation_create_reply_mail (msg,
- MODEST_MAIL_OPERATION_REPLY_TYPE_CITE,
+ modest_mail_operation_create_reply_mail (msg, from, reply_type,
MODEST_MAIL_OPERATION_REPLY_MODE_SENDER);
edit_type = MODEST_EDIT_TYPE_REPLY;
break;
case 2:
- /* TODO: get reply type from config */
new_msg =
- modest_mail_operation_create_reply_mail (msg,
- MODEST_MAIL_OPERATION_REPLY_TYPE_QUOTE,
+ modest_mail_operation_create_reply_mail (msg, from, reply_type,
MODEST_MAIL_OPERATION_REPLY_MODE_ALL);
edit_type = MODEST_EDIT_TYPE_REPLY;
break;
case 3:
- /* TODO: get forward type from config */
new_msg =
- modest_mail_operation_create_forward_mail (msg,
- MODEST_MAIL_OPERATION_FORWARD_TYPE_INLINE);
+ modest_mail_operation_create_forward_mail (msg, from, forward_type);
edit_type = MODEST_EDIT_TYPE_FORWARD;
break;
}
+
+ /* Set from */
+ new_header = tny_msg_get_header (new_msg);
+ tny_header_set_from (new_header,
+ modest_folder_view_get_selected_account (priv->folder_view));
+
/* Show edit window */
msg_win = modest_edit_msg_window_new (priv->widget_factory,
edit_type,
gtk_widget_destroy (GTK_WIDGET(self));
}
+static void
+on_menu_delete (ModestMainWindow *self, guint action, GtkWidget *widget)
+{
+ ModestMainWindowPrivate *priv;
+ ModestHeaderView *header_view;
+ TnyList *header_list;
+ TnyIterator *iter;
+ GtkTreeModel *model;
+
+ priv = MODEST_MAIN_WINDOW_GET_PRIVATE(self);
+
+ header_view = modest_widget_factory_get_header_view (priv->widget_factory);
+ header_list = modest_header_view_get_selected_headers (header_view);
+
+ if (header_list) {
+ iter = tny_list_create_iterator (header_list);
+ model = gtk_tree_view_get_model (GTK_TREE_VIEW (header_view));
+ if (GTK_IS_TREE_MODEL_SORT (model))
+ model = gtk_tree_model_sort_get_model (GTK_TREE_MODEL_SORT (model));
+ do {
+ TnyHeader *header;
+
+ header = TNY_HEADER (tny_iterator_get_current (iter));
+
+ /* Remove from tree model */
+ tny_list_remove (TNY_LIST (model), G_OBJECT (header));
+
+ /* Remove from server */
+ modest_tny_msg_actions_remove (header);
+
+ g_object_unref (header);
+ tny_iterator_next (iter);
+
+ } while (!tny_iterator_is_done (iter));
+ }
+}
+
/* Our menu, an array of GtkItemFactoryEntry structures that defines each menu item */
static GtkItemFactoryEntry menu_items[] = {
{ "/_Actions", NULL, NULL, 0, "<Branch>" ,NULL},
{ "/Actions/_New Message", NULL, on_menu_new_message, 0, "<Item>",NULL },
- { "/Actions/_Reply", NULL, NULL, 0, "<Item>" ,NULL},
- { "/Actions/_Forward", NULL, NULL, 0, "<Item>" ,NULL},
+ { "/Actions/_Reply", NULL, on_menu_reply_forward, 1, "<Item>" ,NULL},
+ { "/Actions/_Forward", NULL, on_menu_reply_forward, 3, "<Item>" ,NULL},
{ "/Actions/_Bounce", NULL, NULL, 0, "<Item>",NULL },
{ "/_Options", NULL, NULL, 0, "<Branch>" ,NULL},
break;
case MODEST_TOOLBAR_BUTTON_DELETE:
+ on_menu_delete (self, 0, GTK_WIDGET (toolbar));
+ break;
default:
g_printerr ("modest: key %d pressed\n", button_id);
const gchar* modest_store_widget_get_servername (ModestStoreWidget *self);
const gchar* modest_store_widget_get_proto (ModestStoreWidget *self);
-
-
-
-
G_END_DECLS
#endif /* __MODEST_STORE_WIDGET_H__ */
/* configuration key definitions for modest */
#define MODEST_ACCOUNT_NAMESPACE MODEST_CONF_NAMESPACE "/" "accounts"
#define MODEST_SERVER_ACCOUNT_NAMESPACE MODEST_CONF_NAMESPACE "/" "server_accounts"
+#define MODEST_CONF_REPLY_TYPE "reply_type" /* int */
+#define MODEST_CONF_FORWARD_TYPE "forward_type" /* int */
/* per-account data */
#define MODEST_ACCOUNT_DISPLAY_NAME "display_name" /* string */
#define MODEST_ACCOUNT_FULLNAME "fullname"
#define MODEST_ACCOUNT_EMAIL "email"
-
/* server account keys */
#define MODEST_ACCOUNT_PASSWORD "password" /* string */
#define MDOEST_ACCOUNT_REMEMBER_PWD "remember_pwd" /* boolean */
return retval;
}
-
/* must be freed by caller */
static gchar *
get_account_keyname (const gchar * accname, const gchar * name, gboolean server_account)
const gchar *key, gboolean val,
gboolean server_account,
GError **err);
-
-
-
G_END_DECLS
#endif /* __MODEST_ACCOUNT_MGR_H__ */
#include <tny-folder-store.h>
#include <tny-folder-store-query.h>
#include <glib/gi18n.h>
+#include "modest-tny-platform-factory.h"
/* 'private'/'protected' functions */
static void modest_mail_operation_class_init (ModestMailOperationClass *klass);
MODEST_MAIL_OPERATION_NUM_ERROR_CODES
};
-static void set_error (ModestMailOperation *mail_operation,
- ModestMailOperationErrorCode error_code,
- const gchar *fmt, ...);
-static void status_update_cb (TnyFolder *folder, const gchar *what,
- gint status, gpointer user_data);
-static void folder_refresh_cb (TnyFolder *folder, gboolean cancelled,
- gpointer user_data);
-static void add_attachments (TnyMsg *msg, const GList *attachments_list);
-static TnyMimePart * add_body_part (TnyMsg *msg, const gchar *body,
- const gchar *content_type, gboolean has_attachments);
+static void set_error (ModestMailOperation *mail_operation,
+ ModestMailOperationErrorCode error_code,
+ const gchar *fmt, ...);
+static void status_update_cb (TnyFolder *folder,
+ const gchar *what,
+ gint status,
+ gpointer user_data);
+static void folder_refresh_cb (TnyFolder *folder,
+ gboolean cancelled,
+ gpointer user_data);
+static void add_attachments (TnyMsg *msg,
+ const GList *attachments_list);
+
+
+static TnyMimePart * add_body_part (TnyMsg *msg,
+ const gchar *body,
+ const gchar *content_type,
+ gboolean has_attachments);
+
/* list my signals */
enum {
priv->account = NULL;
}
if (priv->error) {
- g_object_unref (priv->error);
+ g_error_free (priv->error);
priv->error = NULL;
}
new_msg = TNY_MSG (tny_camel_msg_new ());
header = TNY_HEADER (tny_camel_header_new ());
- /* IMPORTANT: set the header before assign values to it */
+ /* WARNING: set the header before assign values to it */
tny_msg_set_header (new_msg, header);
tny_header_set_from (TNY_HEADER (header), from);
tny_header_set_to (TNY_HEADER (header), to);
**/
TnyMsg*
modest_mail_operation_create_forward_mail (TnyMsg *msg,
+ const gchar *from,
ModestMailOperationForwardType forward_type)
{
TnyMsg *new_msg;
TnyList *parts;
TnyIterator *iter;
-
/* Create new objects */
new_msg = TNY_MSG (tny_camel_msg_new ());
new_header = TNY_HEADER (tny_camel_header_new ());
/* Fill the header */
tny_msg_set_header (new_msg, new_header);
- /* FIXME: set it from default account, current account ... */
- tny_header_set_from (new_header, "<svsdrozo@terra.es>");
+ tny_header_set_from (new_header, from);
/* Change the subject */
new_subject = (gchar *) modest_text_utils_create_forward_subject (tny_header_get_subject(header));
/* Create the list of attachments */
parts = TNY_LIST (tny_simple_list_new());
- tny_msg_get_parts (msg, parts);
+ tny_mime_part_get_parts (TNY_MIME_PART (msg), parts);
iter = tny_list_create_iterator (parts);
attachments_list = NULL;
}
/* Clean */
- g_object_unref (parts);
if (attachments_list) g_list_free (attachments_list);
- if (text_body_part) g_object_unref (text_body_part);
+ g_object_unref (parts);
+ if (text_body_part) g_free (text_body_part);
g_free (content_type);
g_free (new_body);
**/
TnyMsg*
modest_mail_operation_create_reply_mail (TnyMsg *msg,
+ const gchar *from,
ModestMailOperationReplyType reply_type,
ModestMailOperationReplyMode reply_mode)
{
gchar *new_subject, *new_body, *content_type, *quoted;
TnyList *parts;
TnyMimePart *text_body_part;
- gchar *my_email = NULL;
/* Create new objects */
new_msg = TNY_MSG (tny_camel_msg_new ());
new_header = TNY_HEADER (tny_camel_header_new ());
-
- header = tny_msg_get_header (msg);
+ header = tny_msg_get_header (msg);
/* Fill the header */
tny_msg_set_header (new_msg, new_header);
tny_header_set_to (new_header, tny_header_get_from (header));
- /* TODO: set "From:" from my current account */
-/* current_account = modest_account_mgr_get_current_account (account_mgr); */
-/* my_email = modest_account_mgr_get_string (account_mgr, */
-/* current_account, */
-/* MODEST_ACCOUNT_EMAIL, */
-/* FALSE, */
-/* NULL); */
-/* tny_header_set_from (new_header, email); */
- my_email = g_strdup ("svsdrozo@terra.es");
+ tny_header_set_from (new_header, from);
switch (reply_mode) {
gchar *new_cc = NULL;
/* Remove my own address from the cc list */
new_cc = (gchar *)
modest_text_utils_remove_mail_from_mail_list ((const gchar *) tmp->str,
- (const gchar *) my_email);
+ (const gchar *) from);
/* FIXME: remove also the mails from the new To: */
tny_header_set_cc (new_header, new_cc);
g_free (new_cc);
break;
}
- g_free (my_email);
/* Change the subject */
new_subject = (gchar*) modest_text_utils_create_reply_subject (tny_header_get_subject(header));
(const gchar *) content_type, TRUE);
/* Clean */
- g_object_unref (G_OBJECT(text_body_part));
+/* g_free (text_body_part); */
g_free (content_type);
g_free (new_body);
query = tny_folder_store_query_new ();
tny_folder_store_query_add_item (query, NULL, TNY_FOLDER_STORE_QUERY_OPTION_SUBSCRIBED);
tny_folder_store_get_folders (TNY_FOLDER_STORE (storage_account),
- folders, NULL);
+ folders, query);
g_object_unref (query);
ifolders = tny_list_create_iterator (folders);
tny_mime_part_set_filename (attachment_part, attachment_filename);
- tny_msg_add_part (msg, attachment_part);
- g_object_unref(G_OBJECT(attachment_part));
+ tny_mime_part_add_part (TNY_MIME_PART (msg), attachment_part);
+/* g_object_unref (attachment_part); */
}
}
/* Add part if needed */
if (has_attachments) {
- tny_msg_add_part (msg, text_body_part);
+ tny_mime_part_add_part (TNY_MIME_PART (msg), text_body_part);
g_object_unref (G_OBJECT(text_body_part));
}
typedef enum _ModestMailOperationStatus ModestMailOperationStatus;
enum _ModestMailOperationForwardType {
- MODEST_MAIL_OPERATION_FORWARD_TYPE_INLINE,
+ MODEST_MAIL_OPERATION_FORWARD_TYPE_INLINE = 1,
MODEST_MAIL_OPERATION_FORWARD_TYPE_ATTACHMENT
};
enum _ModestMailOperationReplyType {
- MODEST_MAIL_OPERATION_REPLY_TYPE_CITE,
+ MODEST_MAIL_OPERATION_REPLY_TYPE_CITE = 1,
MODEST_MAIL_OPERATION_REPLY_TYPE_QUOTE
};
const GList *attachments_list);
TnyMsg* modest_mail_operation_create_forward_mail (TnyMsg *msg,
+ const gchar *from,
ModestMailOperationForwardType forward_type);
TnyMsg* modest_mail_operation_create_reply_mail (TnyMsg *msg,
+ const gchar *from,
ModestMailOperationReplyType reply_type,
ModestMailOperationReplyMode reply_mode);
#include <tny-camel-transport-account.h>
#include <tny-camel-store-account.h>
#include <modest-marshal.h>
+#include <glib/gi18n.h>
#include "modest-account-mgr.h"
#include "modest-tny-account-store.h"
#include "modest-tny-platform-factory.h"
priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
/* is it in the hash? if it's already there, it must be wrong... */
-// already_asked = g_hash_table_lookup (priv->password_hash, key) != NULL;
-/* if (already_asked) */
-/* g_warning ("password already asked for or in config (%s)", */
-/* key); */
-/* else */
-/* g_warning ("password not yet asked for or in config (%s)", */
-/* key); */
+ already_asked = g_hash_table_lookup (priv->password_hash, key) != NULL;
/* if the password is not already there, try ModestConf */
-// if (!already_asked)
+/* if (!already_asked) */
pwd = modest_account_mgr_get_string (priv->account_mgr,
key, MODEST_ACCOUNT_PASSWORD,
TRUE, NULL);
- /* if it was already asked, it must have been wrong, so ask again */
-/* if (!already_asked || !pwd || strlen(pwd) == 0) { */
-/* g_warning ("emit signal to get pass for %s", key); */
-
+/* /\* if it was already asked, it must have been wrong, so ask again *\/ */
+/* if (!already_asked || !pwd || strlen(pwd) == 0) { */
+
/* /\* we don't have it yet. we emit a signal to get the password somewhere *\/ */
/* const gchar* name = tny_account_get_name (account); */
/* *cancel = TRUE; */
/* } else */
/* *cancel = FALSE; */
-// g_hash_table_insert (priv->password_hash, (gpointer)key, (gpointer)pwd);
+/* g_hash_table_insert (priv->password_hash, key, pwd); */
return pwd;
}
#include <gtk/gtk.h>
#include <gtkhtml/gtkhtml.h>
#include <tny-gtk-text-buffer-stream.h>
-#include <tny-camel-mime-part.h>
-#include <tny-camel-msg.h>
-#include <tny-list.h>
#include <tny-simple-list.h>
+#include <tny-folder.h>
#ifdef HAVE_CONFIG_H
#include <config.h>
#include "modest-tny-msg-actions.h"
#include "modest-text-utils.h"
+static void modest_tny_msg_actions_xfer (TnyHeader *header, TnyFolder *folder,
+ gboolean delete_original);
+
+
static const gchar *
get_body_text (TnyMsg *msg, gboolean want_html)
{
return NULL;
parts = TNY_LIST (tny_simple_list_new());
- tny_msg_get_parts ((TnyMsg*)msg, parts);
+ tny_mime_part_get_parts (TNY_MIME_PART (msg), parts);
iter = tny_list_create_iterator(parts);
g_return_val_if_fail (index > 0, NULL);
parts = TNY_LIST(tny_simple_list_new());
- tny_msg_get_parts ((TnyMsg*)msg, parts);
+ tny_mime_part_get_parts (TNY_MIME_PART(msg), parts);
iter = tny_list_create_iterator (parts);
part = NULL;
else
return NULL;
}
+
+
+static void
+modest_tny_msg_actions_xfer (TnyHeader *header, TnyFolder *folder,
+ gboolean delete_original)
+{
+ TnyFolder *src_folder;
+ TnyList *headers;
+
+ src_folder = tny_header_get_folder (header);
+ headers = tny_simple_list_new ();
+
+ /* Move */
+ tny_list_prepend (headers, G_OBJECT (header));
+ tny_folder_transfer_msgs (src_folder, headers, folder, delete_original);
+
+ /* Free */
+ g_object_unref (headers);
+ g_object_unref (folder);
+}
+
+void
+modest_tny_msg_actions_copy (TnyHeader *header, TnyFolder *folder)
+{
+ g_return_if_fail (TNY_IS_HEADER (header));
+ g_return_if_fail (TNY_IS_FOLDER (folder));
+
+ modest_tny_msg_actions_xfer (header, folder, FALSE);
+}
+
+void
+modest_tny_msg_actions_move (TnyHeader *header, TnyFolder *folder)
+{
+ g_return_if_fail (TNY_IS_HEADER (header));
+ g_return_if_fail (TNY_IS_FOLDER (folder));
+
+ modest_tny_msg_actions_xfer (header, folder, TRUE);
+}
+
+void
+modest_tny_msg_actions_remove (TnyHeader *header)
+{
+ TnyFolder *folder;
+
+ g_return_if_fail (TNY_IS_HEADER (header));
+
+ folder = tny_header_get_folder (header);
+
+ /* Remove */
+ tny_folder_remove_msg (folder, header);
+ tny_folder_expunge (folder);
+
+ /* Free */
+ g_object_unref (folder);
+}
gchar* modest_tny_msg_actions_find_body (TnyMsg *self, gboolean want_html);
+void modest_tny_msg_actions_copy (TnyHeader *header, TnyFolder *folder);
+
+void modest_tny_msg_actions_move (TnyHeader *header, TnyFolder *folder);
+
+void modest_tny_msg_actions_remove (TnyHeader *header);
+
#endif /* __MODEST_TNY_MSG_ACTIONS_H__ */
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
+#include <string.h>
+#include <glib.h>
#include <tny-msg.h>
#include <tny-folder.h>
#include <tny-folder-store.h>
#include <tny-store-account.h>
#include <tny-store-account.h>
#include <tny-stream-camel.h>
-#include <string.h>
-#include <camel/camel-folder.h>
-#include <camel/camel.h>
-#include <camel/camel-folder-summary.h>
+#include "modest-tny-store-actions.h"
+
+TnyFolder *
+modest_tny_store_actions_create_folder (TnyFolderStore *parent,
+ const gchar *name)
+{
+ g_return_val_if_fail (TNY_IS_FOLDER_STORE (parent), NULL);
+ g_return_val_if_fail (name, NULL);
+ TnyFolder *new_folder = NULL;
+ TnyStoreAccount *store_account;
-#include <glib.h>
-#include "modest-tny-store-actions.h"
+ /* Create the folder */
+ new_folder = tny_folder_store_create_folder (parent, name);
+ if (!new_folder)
+ return NULL;
+ /* Subscribe to folder */
+ if (!tny_folder_is_subscribed (new_folder)) {
+ store_account = tny_folder_get_account (TNY_FOLDER (parent));
+ tny_store_account_subscribe (store_account, new_folder);
+ }
+
+ return new_folder;
+}
void
-modest_tny_store_actions_update_folders (TnyStoreAccount *storage_account)
+modest_tny_store_actions_remove_folder (TnyFolder *folder)
{
+ TnyFolderStore *folder_store;
-// FIXME TODO: This results in failure on folder change.
+ g_return_if_fail (TNY_IS_FOLDER (folder));
- TnyList *folders;
- TnyIterator *ifolders;
- const TnyFolder *cur_folder;
- TnyFolderStoreQuery *query;
+ /* Get folder store */
+ folder_store = TNY_FOLDER_STORE (tny_folder_get_account (folder));
-/* folders = tny_store_account_get_folders (storage_account, */
-/* TNY_STORE_ACCOUNT_FOLDER_TYPE_SUBSCRIBED); */
- query = tny_folder_store_query_new ();
- tny_folder_store_query_add_item (query, NULL, TNY_FOLDER_STORE_QUERY_OPTION_SUBSCRIBED);
- tny_folder_store_get_folders (TNY_FOLDER_STORE (storage_account),
- folders, NULL);
- g_object_unref (query);
-
- ifolders = tny_list_create_iterator (folders);
-
- for (tny_iterator_first (ifolders);
- !tny_iterator_is_done (ifolders);
- tny_iterator_next (ifolders)) {
-
- cur_folder = TNY_FOLDER(tny_iterator_get_current (ifolders));
- tny_folder_refresh (cur_folder);
- }
-
- g_object_unref (ifolders);
+ /* Remove folder */
+ tny_folder_store_remove_folder (folder_store, folder);
+
+ /* Free instance */
+ g_object_unref (G_OBJECT (folder));
}
+void modest_tny_store_actions_rename_folder (TnyFolder *folder,
+ const gchar *name)
+{
+ g_return_if_fail (TNY_IS_FOLDER (folder));
+ g_return_if_fail (name);
+
+ tny_folder_set_name (folder, name);
+}
+
+void modest_tny_store_actions_move_folder (TnyFolder *folder,
+ TnyFolderStore *parent)
+{
+ /* TODO: set parent as parent */
+}
#define __MODEST_TNY_STORE_ACTIONS_H__
#include <glib-object.h>
-#include <tny-store-account.h>
+#include <tny-folder.h>
G_BEGIN_DECLS
-void modest_tny_store_actions_update_folders (TnyStoreAccount *storage_account);
+TnyFolder* modest_tny_store_actions_create_folder (TnyFolderStore *parent,
+ const gchar *name);
+
+void modest_tny_store_actions_remove_folder (TnyFolder *folder);
+
+void modest_tny_store_actions_rename_folder (TnyFolder *folder,
+ const gchar *name);
+
+void modest_tny_store_actions_move_folder (TnyFolder *folder,
+ TnyFolderStore *parent);
G_END_DECLS
*/
#include <glib/gi18n.h>
+#include <gdk/gdkkeysyms.h>
#include "modest-widget-factory.h"
#include <modest-protocol-mgr.h>
#include <tny-account-store.h>
#include <tny-device.h>
#include "modest-tny-platform-factory.h"
#include "modest-account-mgr.h"
-
+/* Test: REMOVE */
+#include <tny-folder-store.h>
/* 'private'/'protected' functions */
static void modest_widget_factory_class_init (ModestWidgetFactoryClass *klass);
static void modest_widget_factory_init (ModestWidgetFactory *obj);
static void on_folder_selected (ModestFolderView *folder_view,
TnyFolder *folder,
ModestWidgetFactory *self);
+static void on_folder_key_press_event (ModestFolderView *header_view,
+ GdkEventKey *event,
+ gpointer user_data);
static void on_message_selected (ModestHeaderView *header_view, TnyMsg *msg,
ModestWidgetFactory *self);
static void on_header_status_update (ModestHeaderView *header_view, const gchar *msg,
/* folder view */
g_signal_connect (G_OBJECT(priv->folder_view), "folder_selected",
G_CALLBACK(on_folder_selected), self);
+ g_signal_connect (G_OBJECT(priv->folder_view), "key-press-event",
+ G_CALLBACK(on_folder_key_press_event), self);
/* header view */
g_signal_connect (G_OBJECT(priv->header_view), "status_update",
init_widgets (ModestWidgetFactory *self)
{
ModestWidgetFactoryPrivate *priv;
+ TnyFolderStoreQuery *query;
priv = MODEST_WIDGET_FACTORY_GET_PRIVATE(self);
/* folder view */
+ query = tny_folder_store_query_new ();
+ tny_folder_store_query_add_item (query, NULL, TNY_FOLDER_STORE_QUERY_OPTION_SUBSCRIBED);
if (!(priv->folder_view =
- MODEST_FOLDER_VIEW(modest_folder_view_new (MODEST_TNY_ACCOUNT_STORE (priv->account_store))))) {
+ MODEST_FOLDER_VIEW(modest_folder_view_new (MODEST_TNY_ACCOUNT_STORE (priv->account_store),
+ query)))) {
g_printerr ("modest: cannot instantiate folder view\n");
return FALSE;
}
+ g_object_unref (G_OBJECT (query));
/* header view */
if (!(priv->header_view =
{
GObject *obj;
ModestWidgetFactoryPrivate *priv;
- ModestAccountMgr *account_mgr;
obj = g_object_new (MODEST_TYPE_WIDGET_FACTORY, NULL);
priv = MODEST_WIDGET_FACTORY_GET_PRIVATE(obj);
data = modest_account_mgr_get_account_data (account_mgr, account_name);
if (data && data->transport_account) {
gchar *display_name = g_strdup_printf ("%s (%s)", data->email, account_name);
- ModestPair *pair = modest_pair_new ((gpointer)account_name,
- (gpointer)display_name , TRUE);
+ ModestPair *pair = modest_pair_new ((gpointer) data,
+ (gpointer) display_name , TRUE);
transports = g_slist_append (transports, pair);
}
/* don't free account name; it's freed when the transports list is freed */
guint num, unread;
num = tny_folder_get_all_count (folder);
- unread = tny_folder_get_unread_count (folder);
+ unread = tny_folder_get_unread_count (folder);
txt = g_strdup_printf (_("%d %s, %d unread"),
num, num==1 ? _("item") : _("items"), unread);
gtk_label_set_label (GTK_LABEL(priv->folder_info_label), txt);
g_free (txt);
} else
- gtk_label_set_label (GTK_LABEL(priv->folder_info_label), "");
+ gtk_label_set_label (GTK_LABEL(priv->folder_info_label), "");
}
+/*********************** Test code ********************/
+static void
+on_folder_key_press_event (ModestFolderView *folder_view, GdkEventKey *event, gpointer user_data)
+{
+ if (event->keyval == GDK_C || event->keyval == GDK_c) {
+ GtkTreeSelection *selection;
+ GtkTreeModel *model;
+ GtkTreeIter iter;
+ const gchar *name;
+ TnyFolderStore *folder;
+ gint type;
+
+ selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (folder_view));
+ gtk_tree_selection_get_selected (selection, &model, &iter);
+
+ gtk_tree_model_get (model, &iter,
+ TNY_GTK_ACCOUNT_TREE_MODEL_TYPE_COLUMN, &type,
+ TNY_GTK_ACCOUNT_TREE_MODEL_INSTANCE_COLUMN, &folder,
+ -1);
+
+ if (type == TNY_FOLDER_TYPE_ROOT) {
+ name = tny_account_get_name (TNY_ACCOUNT (folder));
+ } else {
+ name = tny_folder_get_name (TNY_FOLDER (folder));
+ modest_tny_store_actions_create_folder (TNY_FOLDER_STORE (folder),
+ "New");
+ }
+ }
+}
+/****************************************************/
static void
on_message_selected (ModestHeaderView *folder_view, TnyMsg *msg,
gchar **password, gboolean *cancel, ModestWidgetFactory *self)
{
gchar *txt;
- GtkWidget *dialog, *entry;
+ GtkWidget *dialog, *entry, *remember_pass_check;
dialog = gtk_dialog_new_with_buttons (_("Password requested"),
NULL,
txt = g_strdup_printf (_("Please enter your password for %s"), account_name);
gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), gtk_label_new(txt),
FALSE, FALSE, 0);
- g_free (txt);
+ g_free (txt);
entry = gtk_entry_new_with_max_length (40);
gtk_entry_set_visibility (GTK_ENTRY(entry), FALSE);
gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), entry,
TRUE, FALSE, 0);
-
+
+ remember_pass_check = gtk_check_button_new_with_label (_("Remember password"));
+ gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), remember_pass_check,
+ TRUE, FALSE, 0);
+
gtk_widget_show_all (GTK_WIDGET(GTK_DIALOG(dialog)->vbox));
if (gtk_dialog_run (GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
} else {
*password = NULL;
*cancel = TRUE;
- }
+ }
gtk_widget_destroy (dialog);
}
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
-
+#include <gtk/gtkcelllayout.h>
+#include <gtk/gtkcellrenderertext.h>
#include "modest-combo-box.h"
/* 'private'/'protected' functions */
(GInstanceInitFunc) modest_combo_box_init,
NULL
};
- my_type = g_type_register_static (G_TYPE_OBJECT,
+ my_type = g_type_register_static (GTK_TYPE_COMBO_BOX,
"ModestComboBox",
&my_info, 0);
}
-gpointer
-modest_combo_box_get_active_id (ModestComboBox *self)
+static void
+get_active (ModestComboBox *self, GValue *val, gint column)
{
GtkTreeIter iter;
- gpointer retval;
- g_return_val_if_fail (self, NULL);
+ g_return_if_fail (self);
- if (!gtk_combo_box_get_active_iter (GTK_COMBO_BOX(self), &iter))
- retval = NULL; /* nothing found */
- else {
+ if (gtk_combo_box_get_active_iter (GTK_COMBO_BOX(self), &iter)) {
GtkTreeModel *model;
- GValue val;
model = gtk_combo_box_get_model (GTK_COMBO_BOX(self));
+ gtk_tree_model_get_value (model, &iter, column, val);
+ }
+}
+
+gpointer
+modest_combo_box_get_active_id (ModestComboBox *self)
+{
+ g_return_val_if_fail (self, NULL);
+ GValue val = {0,};
+ gpointer retval;
- g_value_init (&val, G_TYPE_POINTER);
- gtk_tree_model_get_value (model, &iter, COLUMN_ID, &val);
+ /* Do not unset the GValue */
+ get_active (self, &val, COLUMN_ID);
+ retval = g_value_peek_pointer (&val);
+
+ return retval;
+}
+
+gpointer
+modest_combo_box_get_active_display_name (ModestComboBox *self)
+{
+ g_return_val_if_fail (self, NULL);
+ GValue val = {0,};
+ gpointer retval;
+
+ /* Do not unset the GValue */
+ get_active (self, &val, COLUMN_DISPLAY_NAME);
+ retval = g_value_peek_pointer (&val);
- retval = g_value_get_pointer (&val);
- g_value_unset (&val);
- }
return retval;
}
#ifndef __MODEST_COMBO_BOX_H__
#define __MODEST_COMBO_BOX_H__
-#include <gtk/gtk.h>
+#include <gtk/gtkcombobox.h>
#include <modest-pair.h>
G_BEGIN_DECLS
typedef struct _ModestComboBoxClass ModestComboBoxClass;
struct _ModestComboBox {
- GObject parent;
+ GtkComboBox parent;
/* insert public members, if any */
};
struct _ModestComboBoxClass {
- GObjectClass parent_class;
+ GtkComboBoxClass parent_class;
/* insert signal callback declarations, eg. */
/* void (* my_event) (ModestComboBox* obj); */
};
*/
gpointer modest_combo_box_get_active_id (ModestComboBox *self);
+/**
+ * modest_combo_box_get_active_display_name
+ * @self: a valid ModestComboBox instance
+ *
+ * get the display name for the currently active lemma, or NULL if
+ * there's nothing chosen
+ *
+ * Returns: the display name or NULL if there's nothing chosen.
+ */
+gpointer modest_combo_box_get_active_display_name (ModestComboBox *self);
+
G_END_DECLS
#endif /* __MODEST_COMBO_BOX_H__ */
static void modest_folder_view_init (ModestFolderView *obj);
static void modest_folder_view_finalize (GObject *obj);
-static gboolean update_model (ModestFolderView *self,
- ModestTnyAccountStore *account_store);
-static gboolean update_model_empty (ModestFolderView *self);
-static void on_selection_changed (GtkTreeSelection *sel, gpointer data);
-static gboolean modest_folder_view_update_model (ModestFolderView *self,
- TnyAccountStoreIface *account_store);
+static gboolean update_model (ModestFolderView *self,
+ ModestTnyAccountStore *account_store);
+static gboolean update_model_empty (ModestFolderView *self);
+
+static void on_selection_changed (GtkTreeSelection *sel, gpointer data);
+static void on_subscription_changed (TnyStoreAccount *store_account, TnyFolder *folder,
+ ModestFolderView *self);
+
+static gboolean modest_folder_view_update_model (ModestFolderView *self,
+ TnyAccountStore *account_store);
+static const gchar *get_account_name_from_folder (GtkTreeModel *model, GtkTreeIter iter);
+
+static void modest_folder_view_disconnect_store_account_handlers (GtkTreeView *self);
enum {
FOLDER_SELECTED_SIGNAL,
typedef struct _ModestFolderViewPrivate ModestFolderViewPrivate;
struct _ModestFolderViewPrivate {
- TnyAccountStoreIface *account_store;
- TnyFolder *cur_folder;
+ TnyAccountStore *account_store;
+ TnyFolder *cur_folder;
gboolean view_is_empty;
gulong sig1, sig2;
- GMutex *lock;
+ gulong *store_accounts_handlers;
+ GMutex *lock;
+ GtkTreeSelection *cur_selection;
+ TnyFolderStoreQuery *query;
+
};
#define MODEST_FOLDER_VIEW_GET_PRIVATE(o) \
(G_TYPE_INSTANCE_GET_PRIVATE((o), \
priv = MODEST_FOLDER_VIEW_GET_PRIVATE(obj);
- priv->view_is_empty = TRUE;
- priv->account_store = NULL;
- priv->cur_folder = NULL;
-
- priv->lock = g_mutex_new ();
+ priv->view_is_empty = TRUE;
+ priv->account_store = NULL;
+ priv->cur_folder = NULL;
+ priv->query = NULL;
+ priv->lock = g_mutex_new ();
column = gtk_tree_view_column_new ();
gtk_tree_view_column_set_title (column,
gtk_tree_view_column_set_fixed_width (column, TRUE);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW(obj), TRUE);
gtk_tree_view_set_headers_clickable (GTK_TREE_VIEW(obj), FALSE);
+ gtk_tree_view_set_enable_search (GTK_TREE_VIEW(obj), FALSE);
}
+static void
+modest_folder_view_disconnect_store_account_handlers (GtkTreeView *self)
+{
+ TnyIterator *iter;
+ ModestFolderViewPrivate *priv;
+ GtkTreeModel *model;
+ GtkTreeModelSort *sortable;
+ gint i = 0;
+
+ sortable = GTK_TREE_MODEL_SORT (gtk_tree_view_get_model (self));
+ if (!sortable) return;
+ model = gtk_tree_model_sort_get_model (sortable);
+ if (!model) return;
+
+ priv = MODEST_FOLDER_VIEW_GET_PRIVATE (self);
+ iter = tny_list_create_iterator (TNY_LIST (model));
+ do {
+ g_signal_handler_disconnect (G_OBJECT (tny_iterator_get_current (iter)),
+ priv->store_accounts_handlers [i++]);
+ tny_iterator_next (iter);
+ } while (!tny_iterator_is_done (iter));
+}
+
static void
modest_folder_view_finalize (GObject *obj)
priv->lock = NULL;
}
+ if (priv->store_accounts_handlers) {
+ modest_folder_view_disconnect_store_account_handlers (GTK_TREE_VIEW (obj));
+ g_free (priv->store_accounts_handlers);
+ priv->store_accounts_handlers = NULL;
+ }
+
+ if (priv->query) {
+ g_object_unref (G_OBJECT (priv->query));
+ priv->query = NULL;
+ }
+
sel = gtk_tree_view_get_selection (GTK_TREE_VIEW(obj));
if (sel)
g_signal_handler_disconnect (G_OBJECT(sel), priv->sig2);
static void
-on_account_update (TnyAccountStoreIface *account_store, const gchar *account,
+on_account_update (TnyAccountStore *account_store, const gchar *account,
gpointer user_data)
{
update_model_empty (MODEST_FOLDER_VIEW(user_data));
GtkWidget*
-modest_folder_view_new (ModestTnyAccountStore *account_store)
+modest_folder_view_new (ModestTnyAccountStore *account_store,
+ TnyFolderStoreQuery *query)
{
GObject *self;
ModestFolderViewPrivate *priv;
self = G_OBJECT(g_object_new(MODEST_TYPE_FOLDER_VIEW, NULL));
priv = MODEST_FOLDER_VIEW_GET_PRIVATE(self);
- if (!update_model (MODEST_FOLDER_VIEW(self),
+ priv->account_store = g_object_ref (G_OBJECT (account_store));
+ if (query) priv->query = g_object_ref (G_OBJECT (query));
+
+ if (!update_model (MODEST_FOLDER_VIEW(self),
MODEST_TNY_ACCOUNT_STORE(account_store)))
g_printerr ("modest: failed to update model");
}
+const gchar *
+modest_folder_view_get_selected_account (ModestFolderView *self)
+{
+ GtkTreeModel *model;
+ GtkTreeIter iter;
+ ModestFolderViewPrivate *priv;
+
+ g_return_val_if_fail (self, NULL);
+ priv = MODEST_FOLDER_VIEW_GET_PRIVATE(self);
+
+ gtk_tree_selection_get_selected (priv->cur_selection, &model, &iter);
+ return get_account_name_from_folder (model, iter);
+}
static gboolean
update_model_empty (ModestFolderView *self)
g_return_val_if_fail (self, FALSE);
priv = MODEST_FOLDER_VIEW_GET_PRIVATE(self);
+ /* Disconnect old handlers */
+ if (priv->store_accounts_handlers) {
+ modest_folder_view_disconnect_store_account_handlers (GTK_TREE_VIEW (self));
+ g_free (priv->store_accounts_handlers);
+ priv->store_accounts_handlers = NULL;
+ }
+
+ /* Create the new model */
store = gtk_tree_store_new (1, G_TYPE_STRING);
gtk_tree_store_append (store, &iter, NULL);
g_signal_emit (G_OBJECT(self), signals[FOLDER_SELECTED_SIGNAL], 0,
NULL);
-
return TRUE;
}
-
static gboolean
update_model (ModestFolderView *self, ModestTnyAccountStore *account_store)
{
g_return_val_if_fail (account_store, FALSE);
priv = MODEST_FOLDER_VIEW_GET_PRIVATE(self);
- model = GTK_TREE_MODEL(tny_gtk_account_tree_model_new (TRUE)); /* async */
+ model = GTK_TREE_MODEL(tny_gtk_account_tree_model_new (TRUE, priv->query)); /* async */
account_list = TNY_LIST(model);
update_model_empty (self); /* cleanup */
TNY_ACCOUNT_STORE_STORE_ACCOUNTS);
if (account_list) {
+ TnyIterator *iter;
+ gint i = 0, size;
sortable = gtk_tree_model_sort_new_with_model (model);
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (sortable),
GTK_SORT_ASCENDING);
gtk_tree_view_set_model (GTK_TREE_VIEW(self), sortable);
+
+ /* Listen to subscription changes */
+ size = tny_list_get_length (TNY_LIST (account_list)) * sizeof (gulong);
+ priv->store_accounts_handlers = g_malloc0 (size);
+ iter = tny_list_create_iterator (account_list);
+ do {
+ priv->store_accounts_handlers [i++] =
+ g_signal_connect (G_OBJECT (tny_iterator_get_current (iter)),
+ "subscription_changed",
+ G_CALLBACK (on_subscription_changed),
+ self);
+ tny_iterator_next (iter);
+ } while (!tny_iterator_is_done (iter));
+
priv->view_is_empty = FALSE;
+ g_object_unref (iter);
g_object_unref (model);
}
ModestFolderView *tree_view;
ModestFolderViewPrivate *priv;
gint type;
+ const gchar *account_name;
g_return_if_fail (sel);
g_return_if_fail (user_data);
priv = MODEST_FOLDER_VIEW_GET_PRIVATE(user_data);
+ priv->cur_selection = sel;
/* is_empty means that there is only the 'empty' item */
if (priv->view_is_empty)
tree_view = MODEST_FOLDER_VIEW (user_data);
gtk_tree_model_get (model, &iter,
- TNY_GTK_ACCOUNT_TREE_MODEL_TYPE_COLUMN,
- &type, -1);
+ TNY_GTK_ACCOUNT_TREE_MODEL_TYPE_COLUMN, &type,
+ TNY_GTK_ACCOUNT_TREE_MODEL_INSTANCE_COLUMN, &folder,
+ -1);
if (type == TNY_FOLDER_TYPE_ROOT) {
- g_message ("FOLDER ROOT");
+ account_name = tny_account_get_name (TNY_ACCOUNT (folder));
} else {
- gtk_tree_model_get (model, &iter,
- TNY_GTK_ACCOUNT_TREE_MODEL_INSTANCE_COLUMN,
- &folder, -1);
+ if (priv->cur_folder)
+ tny_folder_expunge (priv->cur_folder);
+ priv->cur_folder = folder;
- if (TNY_IS_FOLDER (folder)) {
-
- if (priv->cur_folder)
- tny_folder_expunge (priv->cur_folder);
- priv->cur_folder = folder;
-
+ account_name = get_account_name_from_folder (model, iter);
- g_signal_emit (G_OBJECT(tree_view), signals[FOLDER_SELECTED_SIGNAL], 0,
- folder);
- }
+ g_signal_emit (G_OBJECT(tree_view), signals[FOLDER_SELECTED_SIGNAL], 0,
+ folder);
}
}
+static void
+on_subscription_changed (TnyStoreAccount *store_account,
+ TnyFolder *folder,
+ ModestFolderView *self)
+{
+ /* TODO: probably we won't need a full reload, just the store
+ account or even the parent of the folder */
+
+ ModestFolderViewPrivate *priv;
+
+ priv = MODEST_FOLDER_VIEW_GET_PRIVATE(self);
+ update_model (self, MODEST_TNY_ACCOUNT_STORE (priv->account_store));
+}
+
static gboolean
-modest_folder_view_update_model (ModestFolderView *self, TnyAccountStoreIface *account_store)
+modest_folder_view_update_model (ModestFolderView *self, TnyAccountStore *account_store)
{
gboolean retval;
return retval;
}
+
+static const gchar *
+get_account_name_from_folder (GtkTreeModel *model, GtkTreeIter iter) {
+ GtkTreePath *path;
+ GtkTreeIter new_iter;
+ TnyFolder *account_folder;
+ gint depth, i;
+
+ path = gtk_tree_model_get_path (model, &iter);
+ depth = gtk_tree_path_get_depth (path);
+
+ for (i=1; i<= depth - 1; i++)
+ gtk_tree_path_up (path);
+
+ gtk_tree_model_get_iter (model, &new_iter, path);
+ gtk_tree_model_get (model, &new_iter,
+ TNY_GTK_ACCOUNT_TREE_MODEL_INSTANCE_COLUMN, &account_folder,
+ -1);
+ return tny_account_get_name (TNY_ACCOUNT (account_folder));
+}
/* emitted when a folder is clicked */
void (*folder_selected) (ModestFolderView* self,
- TnyFolderIface *folder,
+ TnyFolder *folder,
gpointer user_data);
gboolean (*update_model) (ModestFolderView *self,
- TnyAccountStoreIface *iface);
-
+ TnyAccountStore *account_store);
};
*
* Returns: a new GtkWidget (a GtkTreeView-subclass)
*/
-GtkWidget* modest_folder_view_new (ModestTnyAccountStore *account_store);
+GtkWidget* modest_folder_view_new (ModestTnyAccountStore *account_store,
+ TnyFolderStoreQuery *query);
/**
gboolean modest_folder_view_is_empty (ModestFolderView *self);
+const gchar* modest_folder_view_get_selected_account (ModestFolderView *self);
+
G_END_DECLS
#endif /* __MODEST_FOLDER_VIEW_H__ */
-
else { /* it's a new one or a refresh */
GSList *col;
+ if (priv->headers)
+ g_object_unref (priv->headers);
+
priv->headers = TNY_LIST(tny_gtk_header_list_model_new ());
tny_folder_get_headers (folder, priv->headers, FALSE);
/* mark message as seen; _set_flags crashes, bug in tinymail? */
header_flags = tny_header_get_flags (TNY_HEADER(header));
tny_header_set_flags (header, header_flags | TNY_HEADER_FLAG_SEEN);
+
+ /* Free */
+/* g_free (folder); */
}
parts = TNY_LIST (tny_simple_list_new());
- tny_msg_get_parts (msg, parts);
+ tny_mime_part_get_parts (TNY_MIME_PART (msg), parts);
iter = tny_list_create_iterator (parts);
while (!tny_iterator_is_done(iter)) {
priv = MODEST_MSG_VIEW_GET_PRIVATE (self);
parts = TNY_LIST(tny_simple_list_new());
- tny_msg_get_parts (msg, parts);
+ tny_mime_part_get_parts (TNY_MIME_PART (msg), parts);
iter = tny_list_create_iterator (parts);
appendix= g_string_new ("");
projects / modest / commitdiff