git.maemo.org Git - modest/blob - src/gnome/modest-msg-edit-window.c

   1 /* Copyright (c) 2006, Nokia Corporation
   2  * All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions are
   6  * met:
   7  *
   8  * * Redistributions of source code must retain the above copyright
   9  *   notice, this list of conditions and the following disclaimer.
  10  * * Redistributions in binary form must reproduce the above copyright
  11  *   notice, this list of conditions and the following disclaimer in the
  12  *   documentation and/or other materials provided with the distribution.
  13  * * Neither the name of the Nokia Corporation nor the names of its
  14  *   contributors may be used to endorse or promote products derived from
  15  *   this software without specific prior written permission.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
  18  * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  19  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
  20  * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
  21  * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  22  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  23  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  24  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  25  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  26  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  27  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  28  */
  29 #include <glib/gi18n.h>
  30 #include <string.h>
  31 #include <tny-account-store.h>
  32 #include <tny-simple-list.h>
  33 #include <modest-conf.h>
  34 #include <modest-runtime.h>
  35 #include <modest-tny-msg.h>
  36
  37 #include <widgets/modest-window-priv.h>
  38 #include <widgets/modest-msg-edit-window.h>
  39 #include <widgets/modest-msg-edit-window-ui.h>
  40 #include <widgets/modest-combo-box.h>
  41
  42 #include <modest-widget-memory.h>
  43 #include <modest-account-mgr-helpers.h>
  44 #include <gtkhtml/gtkhtml.h>
  45
  46 static void  modest_msg_edit_window_class_init   (ModestMsgEditWindowClass *klass);
  47 static void  modest_msg_edit_window_init         (ModestMsgEditWindow *obj);
  48 static void  modest_msg_edit_window_finalize     (GObject *obj);
  49
  50 /* list my signals */
  51 enum {
  52         /* MY_SIGNAL_1, */
  53         /* MY_SIGNAL_2, */
  54         LAST_SIGNAL
  55 };
  56
  57 typedef struct _ModestMsgEditWindowPrivate ModestMsgEditWindowPrivate;
  58 struct _ModestMsgEditWindowPrivate {
  59
  60         GtkWidget   *toolbar;
  61         GtkWidget   *menubar;
  62
  63         GtkWidget   *msg_body;
  64
  65         ModestPairList *from_field_protos;
  66         GtkWidget   *from_field;
  67
  68         GtkWidget   *to_field;
  69         GtkWidget   *cc_field;
  70         GtkWidget   *bcc_field;
  71         GtkWidget   *subject_field;
  72
  73         gboolean    sent;
  74 };
  75
  76 #define MODEST_MSG_EDIT_WINDOW_GET_PRIVATE(o)      (G_TYPE_INSTANCE_GET_PRIVATE((o), \
  77                                                     MODEST_TYPE_MSG_EDIT_WINDOW, \
  78                                                     ModestMsgEditWindowPrivate))
  79 /* globals */
  80 static GtkWindowClass *parent_class = NULL;
  81
  82 /* uncomment the following if you have defined any signals */
  83 /* static guint signals[LAST_SIGNAL] = {0}; */
  84
  85 GType
  86 modest_msg_edit_window_get_type (void)
  87 {
  88         static GType my_type = 0;
  89         if (!my_type) {
  90                 static const GTypeInfo my_info = {
  91                         sizeof(ModestMsgEditWindowClass),
  92                         NULL,           /* base init */
  93                         NULL,           /* base finalize */
  94                         (GClassInitFunc) modest_msg_edit_window_class_init,
  95                         NULL,           /* class finalize */
  96                         NULL,           /* class data */
  97                         sizeof(ModestMsgEditWindow),
  98                         1,              /* n_preallocs */
  99                         (GInstanceInitFunc) modest_msg_edit_window_init,
 100                         NULL
 101                 };
 102                 my_type = g_type_register_static (MODEST_TYPE_WINDOW,
 103                                                   "ModestMsgEditWindow",
 104                                                   &my_info, 0);
 105         }
 106         return my_type;
 107 }
 108
 109
 110 static void
 111 save_state (ModestWindow *self)
 112 {
 113         modest_widget_memory_save (modest_runtime_get_conf (),
 114                                     G_OBJECT(self), "modest-edit-msg-window");
 115 }
 116
 117
 118 static void
 119 restore_settings (ModestMsgEditWindow *self)
 120 {
 121         modest_widget_memory_restore (modest_runtime_get_conf (),
 122                                       G_OBJECT(self), "modest-edit-msg-window");
 123 }
 124
 125 static void
 126 modest_msg_edit_window_class_init (ModestMsgEditWindowClass *klass)
 127 {
 128         GObjectClass *gobject_class;
 129         ModestWindowClass *modest_window_class;
 130
 131         gobject_class = (GObjectClass*) klass;
 132         modest_window_class = (ModestWindowClass*) klass;
 133
 134         parent_class            = g_type_class_peek_parent (klass);
 135         gobject_class->finalize = modest_msg_edit_window_finalize;
 136
 137         g_type_class_add_private (gobject_class, sizeof(ModestMsgEditWindowPrivate));
 138
 139         modest_window_class->save_state_func = save_state;
 140 }
 141
 142 static void
 143 modest_msg_edit_window_init (ModestMsgEditWindow *obj)
 144 {
 145         ModestMsgEditWindowPrivate *priv;
 146         priv = MODEST_MSG_EDIT_WINDOW_GET_PRIVATE(obj);
 147
 148         priv->toolbar       = NULL;
 149         priv->menubar       = NULL;
 150         priv->msg_body      = NULL;
 151         priv->from_field    = NULL;
 152         priv->to_field      = NULL;
 153         priv->cc_field      = NULL;
 154         priv->bcc_field     = NULL;
 155         priv->subject_field = NULL;
 156         priv->sent          = FALSE;
 157 }
 158
 159 /**
 160  * @result: A ModestPairList, which must be freed with modest_pair_list_free().
 161  */
 162 static ModestPairList*
 163 get_transports (void)
 164 {
 165         ModestAccountMgr *account_mgr;
 166         GSList *transports = NULL;
 167         GSList *cursor, *accounts;
 168
 169         account_mgr = modest_runtime_get_account_mgr();
 170         cursor = accounts = modest_account_mgr_account_names (account_mgr, TRUE);
 171         while (cursor) {
 172                 gchar *account_name = cursor->data ? g_strdup((gchar*)cursor->data) : NULL;
 173                 gchar *from_string  = modest_account_mgr_get_from_string (account_mgr,
 174                                                                           account_name);
 175                 if (!from_string)  {
 176                         /* something went wrong: ignore this one */
 177                         g_free (account_name);
 178                         cursor->data = NULL;
 179                 } else {
 180                         ModestPair *pair;
 181                         pair = modest_pair_new ((gpointer) account_name,
 182                                                 (gpointer) from_string , TRUE);
 183                         transports = g_slist_prepend (transports, pair);
 184                 } /* don't free account name; it's freed when the transports list is freed */
 185                 cursor = cursor->next;
 186         }
 187         g_slist_free (accounts);
 188         return transports;
 189 }
 190
 191
 192 static void
 193 on_from_combo_changed (ModestComboBox *combo, ModestWindow *win)
 194 {
 195         modest_window_set_active_account (
 196                 win, modest_combo_box_get_active_id(combo));
 197 }
 198
 199
 200
 201 static void
 202 init_window (ModestMsgEditWindow *obj, const gchar* account)
 203 {
 204         GtkWidget *to_button, *cc_button, *bcc_button;
 205         GtkWidget *header_table;
 206         GtkWidget *main_vbox;
 207         GtkWidget *msg_vbox;
 208         GtkWidget *scrolled_window;
 209         ModestMsgEditWindowPrivate *priv;
 210         ModestWindowPrivate *parent_priv;
 211
 212         priv = MODEST_MSG_EDIT_WINDOW_GET_PRIVATE(obj);
 213         parent_priv = MODEST_WINDOW_GET_PRIVATE(obj);
 214
 215         to_button     = gtk_button_new_with_label (_("To..."));
 216         cc_button     = gtk_button_new_with_label (_("Cc..."));
 217         bcc_button    = gtk_button_new_with_label (_("Bcc..."));
 218
 219         /* Note: This ModestPairList* must exist for as long as the combo
 220          * that uses it, because the ModestComboBox uses the ID opaquely,
 221          * so it can't know how to manage its memory. */
 222         priv->from_field_protos = get_transports ();
 223         priv->from_field    = modest_combo_box_new (priv->from_field_protos, g_str_equal);
 224
 225         if (account) {
 226                 modest_combo_box_set_active_id (MODEST_COMBO_BOX(priv->from_field),
 227                                                 (gpointer)account);
 228                 modest_window_set_active_account (MODEST_WINDOW(obj), account);
 229         }
 230         /* auto-update the active account */
 231         g_signal_connect (G_OBJECT(priv->from_field), "changed", G_CALLBACK(on_from_combo_changed), obj);
 232
 233         priv->to_field      = gtk_entry_new_with_max_length (80);
 234         priv->cc_field      = gtk_entry_new_with_max_length (80);
 235         priv->bcc_field     = gtk_entry_new_with_max_length (80);
 236         priv->subject_field = gtk_entry_new_with_max_length (80);
 237
 238         header_table = gtk_table_new (5,2, FALSE);
 239
 240         gtk_table_attach (GTK_TABLE(header_table), gtk_label_new (_("From:")),
 241                           0,1,0,1, GTK_SHRINK, 0, 0, 0);
 242         gtk_table_attach (GTK_TABLE(header_table), to_button,     0,1,1,2, GTK_SHRINK, 0, 0, 0);
 243         gtk_table_attach (GTK_TABLE(header_table), cc_button,     0,1,2,3, GTK_SHRINK, 0, 0, 0);
 244         gtk_table_attach (GTK_TABLE(header_table), bcc_button,    0,1,3,4, GTK_SHRINK, 0, 0, 0);
 245         gtk_table_attach (GTK_TABLE(header_table), gtk_label_new (_("Subject:")),
 246                           0,1,4,5, GTK_SHRINK, 0, 0, 0);
 247
 248         gtk_table_attach_defaults (GTK_TABLE(header_table), priv->from_field,   1,2,0,1);
 249         gtk_table_attach_defaults (GTK_TABLE(header_table), priv->to_field,     1,2,1,2);
 250         gtk_table_attach_defaults (GTK_TABLE(header_table), priv->cc_field,     1,2,2,3);
 251         gtk_table_attach_defaults (GTK_TABLE(header_table), priv->bcc_field,    1,2,3,4);
 252         gtk_table_attach_defaults (GTK_TABLE(header_table), priv->subject_field,1,2,4,5);
 253
 254         priv->msg_body = gtk_html_new ();
 255         gtk_html_load_empty (GTK_HTML (priv->msg_body));
 256         gtk_html_set_editable (GTK_HTML (priv->msg_body), TRUE);
 257
 258         main_vbox = gtk_vbox_new  (FALSE, 0);
 259
 260         scrolled_window = gtk_scrolled_window_new (NULL, NULL);
 261
 262         gtk_box_pack_start (GTK_BOX(main_vbox), priv->menubar, FALSE, FALSE, 0);
 263         gtk_box_pack_start (GTK_BOX(main_vbox), priv->toolbar, FALSE, FALSE, 0);
 264         gtk_box_pack_start (GTK_BOX(main_vbox), scrolled_window, TRUE, TRUE, 0);
 265
 266         msg_vbox = gtk_vbox_new (FALSE, 0);
 267         gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrolled_window), msg_vbox);
 268
 269         gtk_box_pack_start (GTK_BOX(msg_vbox), header_table, FALSE, FALSE, 0);
 270         gtk_box_pack_start (GTK_BOX(msg_vbox), priv->msg_body, TRUE, TRUE, 0);
 271
 272         gtk_widget_show_all (GTK_WIDGET(main_vbox));
 273         gtk_container_add (GTK_CONTAINER(obj), main_vbox);
 274 }
 275
 276
 277 static void
 278 modest_msg_edit_window_finalize (GObject *obj)
 279 {
 280         ModestMsgEditWindowPrivate *priv = MODEST_MSG_EDIT_WINDOW_GET_PRIVATE(obj);
 281
 282         /* These had to stay alive for as long as the comboboxes that used them: */
 283         modest_pair_list_free (priv->from_field_protos);
 284
 285         G_OBJECT_CLASS(parent_class)->finalize (obj);
 286 }
 287
 288
 289
 290 static gboolean
 291 on_delete_event (GtkWidget *widget, GdkEvent *event, ModestMsgEditWindow *self)
 292 {
 293         modest_window_save_state (MODEST_WINDOW(self));
 294         return FALSE;
 295 }
 296
 297
 298 static void
 299 set_msg (ModestMsgEditWindow *self, TnyMsg *msg)
 300 {
 301         TnyHeader *header;
 302         const gchar *to, *cc, *bcc, *subject;
 303         ModestMsgEditWindowPrivate *priv;
 304         gchar *body;
 305
 306         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (self));
 307         g_return_if_fail (TNY_IS_MSG (msg));
 308
 309         priv = MODEST_MSG_EDIT_WINDOW_GET_PRIVATE (self);
 310
 311         header  = tny_msg_get_header (msg);
 312         to      = tny_header_get_to (header);
 313         cc      = tny_header_get_cc (header);
 314         bcc     = tny_header_get_bcc (header);
 315         subject = tny_header_get_subject (header);
 316
 317         if (to)
 318                 gtk_entry_set_text (GTK_ENTRY(priv->to_field), to);
 319         if (cc)
 320                 gtk_entry_set_text (GTK_ENTRY(priv->cc_field), cc);
 321         if (bcc)
 322                 gtk_entry_set_text (GTK_ENTRY(priv->bcc_field),  bcc);
 323         if (subject)
 324                 gtk_entry_set_text (GTK_ENTRY(priv->subject_field), subject);
 325
 326
 327         body = modest_tny_msg_get_body (msg, FALSE, NULL);
 328         gtk_html_set_editable (GTK_HTML (priv->msg_body), FALSE);
 329         if (body) {
 330                 gtk_html_load_from_string (GTK_HTML (priv->msg_body), body, -1);
 331         }
 332         gtk_html_set_editable (GTK_HTML (priv->msg_body), TRUE);
 333         g_free (body);
 334 }
 335
 336
 337 ModestWindow *
 338 modest_msg_edit_window_new (TnyMsg *msg, const gchar *account,
 339                             gboolean preserve_is_rich)
 340 {
 341         ModestMsgEditWindow *self;
 342         ModestMsgEditWindowPrivate *priv;
 343         ModestWindowPrivate *parent_priv;
 344         GtkActionGroup *action_group;
 345         GError *error = NULL;
 346
 347         g_return_val_if_fail (msg, NULL);
 348
 349         self = MODEST_MSG_EDIT_WINDOW(g_object_new(MODEST_TYPE_MSG_EDIT_WINDOW, NULL));
 350         priv = MODEST_MSG_EDIT_WINDOW_GET_PRIVATE(self);
 351         parent_priv = MODEST_WINDOW_GET_PRIVATE(self);
 352
 353         parent_priv->ui_manager = gtk_ui_manager_new();
 354         action_group = gtk_action_group_new ("ModestMsgEditWindowActions");
 355
 356         /* Add common actions */
 357         gtk_action_group_add_actions (action_group,
 358                                       modest_msg_edit_action_entries,
 359                                       G_N_ELEMENTS (modest_msg_edit_action_entries),
 360                                       self);
 361         gtk_action_group_add_toggle_actions (action_group,
 362                                              modest_msg_edit_toggle_action_entries,
 363                                              G_N_ELEMENTS (modest_msg_edit_toggle_action_entries),
 364                                              self);
 365         gtk_ui_manager_insert_action_group (parent_priv->ui_manager, action_group, 0);
 366         g_object_unref (action_group);
 367
 368         /* Load the UI definition */
 369         gtk_ui_manager_add_ui_from_file (parent_priv->ui_manager,
 370                                          MODEST_UIDIR "modest-msg-edit-window-ui.xml",
 371                                          &error);
 372         if (error) {
 373                 g_printerr ("modest: could not merge modest-msg-edit-window-ui.xml: %s\n", error->message);
 374                 g_error_free (error);
 375                 error = NULL;
 376         }
 377         /* ****** */
 378
 379         /* Add accelerators */
 380         gtk_window_add_accel_group (GTK_WINDOW (self),
 381                                     gtk_ui_manager_get_accel_group (parent_priv->ui_manager));
 382
 383         /* Toolbar / Menubar */
 384         priv->toolbar = gtk_ui_manager_get_widget (parent_priv->ui_manager, "/ToolBar");
 385         priv->menubar = gtk_ui_manager_get_widget (parent_priv->ui_manager, "/MenuBar");
 386
 387         gtk_toolbar_set_tooltips (GTK_TOOLBAR (priv->toolbar), TRUE);
 388
 389         /* Init window */
 390         init_window (MODEST_MSG_EDIT_WINDOW(self), account);
 391
 392         restore_settings (MODEST_MSG_EDIT_WINDOW(self));
 393
 394         gtk_window_set_title (GTK_WINDOW(self), "Modest");
 395         gtk_window_set_icon_from_file (GTK_WINDOW(self), MODEST_APP_ICON, NULL);
 396
 397         g_signal_connect (G_OBJECT(self), "delete-event",
 398                           G_CALLBACK(on_delete_event), self);
 399
 400         set_msg (self, msg);
 401
 402         return MODEST_WINDOW(self);
 403 }
 404
 405 static gboolean
 406 html_export_save_buffer (gpointer engine,
 407                          const gchar *data,
 408                          size_t len,
 409                          GString **buffer)
 410 {
 411         *buffer = g_string_append (*buffer, data);
 412         return TRUE;
 413 }
 414
 415
 416 MsgData *
 417 modest_msg_edit_window_get_msg_data (ModestMsgEditWindow *edit_window)
 418 {
 419         MsgData *data;
 420
 421         const gchar *account_name;
 422         gchar *from_string = NULL;
 423         ModestMsgEditWindowPrivate *priv;
 424         GString *buffer;
 425
 426         g_return_val_if_fail (MODEST_IS_MSG_EDIT_WINDOW (edit_window), NULL);
 427
 428         priv = MODEST_MSG_EDIT_WINDOW_GET_PRIVATE (edit_window);
 429
 430         account_name = (gchar*)modest_combo_box_get_active_id (MODEST_COMBO_BOX (priv->from_field));
 431         if (account_name)
 432                 from_string = modest_account_mgr_get_from_string (
 433                         modest_runtime_get_account_mgr(), account_name);
 434         if (!from_string) {
 435                 g_printerr ("modest: cannot get from string\n");
 436                 return NULL;
 437         }
 438
 439
 440
 441         data = g_slice_new0 (MsgData);
 442         data->from    =  from_string; /* will be freed when data is freed */
 443         data->to      =  g_strdup (gtk_entry_get_text (GTK_ENTRY(priv->to_field)));
 444         data->cc      =  g_strdup ( gtk_entry_get_text (GTK_ENTRY(priv->cc_field)));
 445         data->bcc     =  g_strdup ( gtk_entry_get_text (GTK_ENTRY(priv->bcc_field)));
 446         data->subject =  g_strdup ( gtk_entry_get_text (GTK_ENTRY(priv->subject_field)));
 447
 448 /*      GtkTextBuffer *buf = gtk_text_view_get_buffer (GTK_TEXT_VIEW (priv->msg_body)); */
 449 /*      GtkTextIter b, e; */
 450 /*      gtk_text_buffer_get_bounds (buf, &b, &e); */
 451 /*      data->plain_body =  gtk_text_buffer_get_text (buf, &b, &e, FALSE); /\* Returns a copy. *\/ */
 452
 453         buffer = g_string_new ("");
 454         gtk_html_export (GTK_HTML (priv->msg_body), "text/html", (GtkHTMLSaveReceiverFn) html_export_save_buffer, &buffer);
 455         data->html_body = g_string_free (buffer, FALSE);
 456         buffer = g_string_new ("");
 457         gtk_html_export (GTK_HTML (priv->msg_body), "text/plain", (GtkHTMLSaveReceiverFn) html_export_save_buffer, &buffer);
 458         data->plain_body = g_string_free (buffer, FALSE);
 459
 460         return data;
 461 }
 462
 463 void
 464 modest_msg_edit_window_free_msg_data (ModestMsgEditWindow *edit_window,
 465                                       MsgData *data)
 466 {
 467         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (edit_window));
 468
 469         if (!data)
 470                 return;
 471
 472         g_free (data->to);
 473         g_free (data->cc);
 474         g_free (data->bcc);
 475         g_free (data->subject);
 476         g_free (data->plain_body);
 477         g_free (data->html_body);
 478
 479         /* TODO: Free data->attachments? */
 480
 481         g_slice_free (MsgData, data);
 482 }
 483
 484 /* Rich formatting API functions */
 485 ModestMsgEditFormat
 486 modest_msg_edit_window_get_format (ModestMsgEditWindow *self)
 487 {
 488         return MODEST_MSG_EDIT_FORMAT_TEXT;
 489 }
 490
 491 void
 492 modest_msg_edit_window_set_format (ModestMsgEditWindow *self,
 493                                    ModestMsgEditFormat format)
 494 {
 495         switch (format) {
 496         case MODEST_MSG_EDIT_FORMAT_TEXT:
 497                 break;
 498         case MODEST_MSG_EDIT_FORMAT_HTML:
 499                 g_message ("HTML format not supported in Gnome ModestMsgEditWindow");
 500                 break;
 501         default:
 502                 break;
 503         }
 504 }
 505
 506 ModestMsgEditFormatState *
 507 modest_msg_edit_window_get_format_state (ModestMsgEditWindow *self)
 508 {
 509         ModestMsgEditFormatState *format_state;
 510
 511         g_return_val_if_fail (MODEST_IS_MSG_EDIT_WINDOW (self), NULL);
 512
 513         format_state = g_new0 (ModestMsgEditFormatState, 1);
 514
 515         return format_state;
 516 }
 517
 518 void
 519 modest_msg_edit_window_set_format_state (ModestMsgEditWindow *self,
 520                                          const ModestMsgEditFormatState *format_state)
 521 {
 522         g_return_if_fail (MODEST_MSG_EDIT_WINDOW (self));
 523
 524         /* Ends silently as set_format_state should do nothing when edit window format
 525            is not HTML */
 526         return;
 527 }
 528
 529 void
 530 modest_msg_edit_window_select_color (ModestMsgEditWindow *window)
 531 {
 532         g_return_if_fail (MODEST_MSG_EDIT_WINDOW (window));
 533
 534         g_message ("Select color operation is not supported");
 535 }
 536
 537 void
 538 modest_msg_edit_window_select_file_format (ModestMsgEditWindow *window,
 539                                            gint file_format)
 540 {
 541         g_return_if_fail (MODEST_MSG_EDIT_WINDOW (window));
 542
 543         g_message ("Select file format operation is not supported");
 544 }
 545
 546 void
 547 modest_msg_edit_window_select_font (ModestMsgEditWindow *window)
 548 {
 549         g_return_if_fail (MODEST_MSG_EDIT_WINDOW (window));
 550
 551         g_message ("Select font operation is not supported");
 552 }
 553
 554 void
 555 modest_msg_edit_window_select_background_color (ModestMsgEditWindow *window)
 556 {
 557         g_return_if_fail (MODEST_MSG_EDIT_WINDOW (window));
 558
 559         g_message ("Select background color operation is not supported");
 560 }
 561
 562 void
 563 modest_msg_edit_window_insert_image (ModestMsgEditWindow *window)
 564 {
 565         g_return_if_fail (MODEST_MSG_EDIT_WINDOW (window));
 566
 567         g_message ("Insert image operation is not supported");
 568 }
 569
 570 void
 571 modest_msg_edit_window_attach_file (ModestMsgEditWindow *window)
 572 {
 573         g_return_if_fail (MODEST_MSG_EDIT_WINDOW (window));
 574
 575         g_message ("Attach file operation is not supported");
 576 }
 577
 578 void
 579 modest_msg_edit_window_remove_attachments (ModestMsgEditWindow *window,
 580                                            TnyList *att_list)
 581 {
 582         g_return_if_fail (MODEST_MSG_EDIT_WINDOW (window));
 583
 584         g_message ("Remove attachments operation is not supported");
 585 }
 586
 587 void
 588 modest_msg_edit_window_get_parts_size (ModestMsgEditWindow *window,
 589                                        gint *parts_count,
 590                                        guint64 *parts_size)
 591 {
 592         *parts_count = 0;
 593         *parts_size = 0;
 594 }
 595
 596 void
 597 modest_msg_edit_window_show_cc (ModestMsgEditWindow *window,
 598                                 gboolean show)
 599 {
 600         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
 601
 602         g_message ("not implemented yet %s", __FUNCTION__);
 603 }
 604 void
 605 modest_msg_edit_window_show_bcc (ModestMsgEditWindow *window,
 606                                 gboolean show)
 607 {
 608         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
 609
 610         g_message ("not implemented yet %s", __FUNCTION__);
 611 }
 612 void
 613 modest_msg_edit_window_undo (ModestMsgEditWindow *window)
 614 {
 615         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
 616
 617         g_message ("not implemented yet %s", __FUNCTION__);
 618 }
 619 void
 620 modest_msg_edit_window_toggle_fullscreen (ModestMsgEditWindow *window)
 621 {
 622         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
 623
 624         g_message ("not implemented yet %s", __FUNCTION__);
 625 }
 626 void
 627 modest_msg_edit_window_set_priority_flags (ModestMsgEditWindow *window,
 628                                            TnyHeaderFlags priority_flags)
 629 {
 630         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
 631
 632         g_message ("not implemented yet %s", __FUNCTION__);
 633 }
 634
 635
 636 void
 637 modest_msg_edit_window_select_contacts (ModestMsgEditWindow *window)
 638 {
 639         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
 640
 641         g_message ("not implemented yet %s", __FUNCTION__);
 642 }
 643
 644 gboolean
 645 modest_msg_edit_window_check_names (ModestMsgEditWindow *window, gboolean add_to_addressbook)
 646 {
 647         g_return_val_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window), FALSE);
 648
 649         g_message ("not implemented yet %s", __FUNCTION__);
 650         return TRUE;
 651 }
 652
 653 void
 654 modest_msg_edit_window_set_file_format (ModestMsgEditWindow *window,
 655                                         gint file_format)
 656 {
 657         g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
 658
 659         g_message ("not implemented yet %s", __FUNCTION__);
 660 }
 661
 662 gboolean
 663 modest_msg_edit_window_get_sent (ModestMsgEditWindow *window)
 664 {
 665         ModestMsgEditWindowPrivate *priv;
 666
 667         priv = MODEST_MSG_EDIT_WINDOW_GET_PRIVATE(window);
 668         return priv->sent;
 669 }
 670
 671 void
 672 modest_msg_edit_window_set_sent (ModestMsgEditWindow *window,
 673                                  gboolean sent)
 674 {
 675         ModestMsgEditWindowPrivate *priv;
 676
 677         priv = MODEST_MSG_EDIT_WINDOW_GET_PRIVATE(window);
 678         priv->sent = sent;
 679 }
 680
 681 GtkWidget *
 682 modest_msg_edit_window_get_child_widget (ModestMsgEditWindow *win,
 683                                          ModestMsgEditWindowWidgetType widget_type)
 684 {
 685         ModestMsgEditWindowPrivate *priv;
 686
 687         g_return_val_if_fail (MODEST_IS_MSG_EDIT_WINDOW (win), NULL);
 688         priv = MODEST_MSG_EDIT_WINDOW_GET_PRIVATE (win);
 689
 690         switch (widget_type) {
 691         case MODEST_MSG_EDIT_WINDOW_WIDGET_TYPE_BODY:
 692                 return priv->msg_body;
 693                 break;
 694         case MODEST_MSG_EDIT_WINDOW_WIDGET_TYPE_TO:
 695                 return priv->to_field;
 696                 break;
 697         case MODEST_MSG_EDIT_WINDOW_WIDGET_TYPE_CC:
 698                 return priv->cc_field;
 699                 break;
 700         case MODEST_MSG_EDIT_WINDOW_WIDGET_TYPE_BCC:
 701                 return priv->bcc_field;
 702                 break;
 703         case MODEST_MSG_EDIT_WINDOW_WIDGET_TYPE_SUBJECT:
 704                 return priv->subject_field;
 705                 break;
 706         case MODEST_MSG_EDIT_WINDOW_WIDGET_TYPE_ATTACHMENTS:
 707                 return NULL;
 708                 break;
 709         default:
 710                 return NULL;
 711         }
 712         return NULL;
 713 }
 714
 715 /* FUNCTIONS NOT IMPLEMENTED YET */
 716
 717 void
 718 modest_msg_edit_window_set_modified      (ModestMsgEditWindow *window,
 719                                           gboolean modified)
 720 {
 721         g_message (__FUNCTION__);
 722 }
 723
 724 void
 725 modest_msg_edit_window_toggle_find_toolbar (ModestMsgEditWindow *window,
 726                                             gboolean show)
 727 {
 728         g_message ("NOT IMPLEMENTED %s", __FUNCTION__);
 729 }
 730
 731 void
 732 modest_msg_edit_window_add_part (ModestMsgEditWindow *window,
 733                                  TnyMimePart *part)
 734 {
 735         g_message ("NOT IMPLEMENTED %s", __FUNCTION__);
 736 }
 737
 738 void
 739 modest_msg_edit_window_redo               (ModestMsgEditWindow *window)
 740 {
 741         g_message ("NOT IMPLEMENTED %s", __FUNCTION__);
 742 }
 743
 744 void
 745 modest_msg_edit_window_offer_attach_file           (ModestMsgEditWindow *window)
 746 {
 747         g_message ("NOT IMPLEMENTED %s", __FUNCTION__);
 748 }
 749
 750 void
 751 modest_msg_edit_window_attach_file_one           (ModestMsgEditWindow *window, const gchar *file_uri)
 752 {
 753         g_message ("NOT IMPLEMENTED %s", __FUNCTION__);
 754 }
 755
 756 void
 757 modest_msg_edit_window_set_draft           (ModestMsgEditWindow *window,
 758                                             TnyMsg *draft)
 759 {
 760         g_message ("NOT IMPLEMENTED %s", __FUNCTION__);
 761 }
 762
 763 gboolean
 764 modest_msg_edit_window_is_modified         (ModestMsgEditWindow *window)
 765 {
 766         g_message ("NOT IMPLEMENTED %s", __FUNCTION__);
 767         return TRUE;
 768 }
 769
 770 const gchar *
 771 modest_msg_edit_window_get_clipboard_text (ModestMsgEditWindow *win)
 772 {
 773         g_message ("NOT IMPLEMENTED %s", __FUNCTION__);
 774         return NULL;
 775 }
 776
 777 gboolean
 778 modest_msg_edit_window_can_redo               (ModestMsgEditWindow *window)
 779 {
 780         g_message ("NOT IMPLEMENTED %s", __FUNCTION__);
 781         return FALSE;
 782 }
 783 gboolean
 784 modest_msg_edit_window_can_undo               (ModestMsgEditWindow *window)
 785 {
 786         g_message ("NOT IMPLEMENTED %s", __FUNCTION__);
 787         return FALSE;
 788 }
 789
 790 const gchar*
 791 modest_msg_edit_window_get_message_uid (ModestMsgEditWindow *window)
 792 {
 793         g_message ("NOT IMPLEMENTED %s", __FUNCTION__);
 794         return NULL;
 795 }