git.maemo.org Git - modest/blob - src/modest-ui-dimming-rules.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
  30 #ifdef HAVE_CONFIG_H
  31 #include <config.h>
  32 #endif /*HAVE_CONFIG_H*/
  33
  34 #include <string.h>
  35 #include "modest-ui-dimming-rules.h"
  36 #include "modest-dimming-rule.h"
  37 #include "modest-tny-folder.h"
  38 #include "modest-text-utils.h"
  39 #include <widgets/modest-attachments-view.h>
  40 #include <modest-runtime.h>
  41 #include <tny-simple-list.h>
  42
  43
  44 static gboolean _folder_is_any_of_type (TnyFolder *folder, TnyFolderType types[], guint ntypes);
  45 static gboolean _invalid_msg_selected (ModestMainWindow *win, gboolean unique, ModestDimmingRule *rule);
  46 static gboolean _invalid_attach_selected (ModestWindow *win, gboolean unique, ModestDimmingRule *rule);
  47 static gboolean _invalid_clipboard_selected (ModestMsgViewWindow *win);
  48 static gboolean _already_opened_msg (ModestWindow *win);
  49 static gboolean _selected_msg_marked_as (ModestWindow *win, TnyHeaderFlags mask, gboolean opposite);
  50 static gboolean _selected_folder_not_writeable (ModestMainWindow *win);
  51 static gboolean _selected_folder_is_any_of_type (ModestWindow *win, TnyFolderType types[], guint ntypes);
  52 static gboolean _selected_folder_is_root_or_inbox (ModestMainWindow *win);
  53 static gboolean _selected_folder_is_MMC_or_POP_root (ModestMainWindow *win);
  54 static gboolean _selected_folder_is_root (ModestMainWindow *win);
  55 static gboolean _selected_folder_is_empty (ModestMainWindow *win);
  56 static gboolean _msg_download_in_progress (ModestMsgViewWindow *win);
  57 static gboolean _msg_download_completed (ModestMainWindow *win);
  58 static gboolean _selected_msg_sent_in_progress (ModestWindow *win);
  59 static gboolean _sending_in_progress (ModestWindow *win);
  60 static gboolean _marked_as_deleted (ModestWindow *win);
  61
  62
  63 gboolean
  64 modest_ui_dimming_rules_on_new_msg (ModestWindow *win, gpointer user_data)
  65 {
  66         gboolean dimmed = FALSE;
  67
  68         g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW(win), FALSE);
  69
  70         /* Check dimmed rule */
  71         if (!dimmed)
  72                 dimmed = _msg_download_in_progress (MODEST_MSG_VIEW_WINDOW(win));
  73
  74         return dimmed;
  75 }
  76
  77 gboolean
  78 modest_ui_dimming_rules_on_new_folder (ModestWindow *win, gpointer user_data)
  79 {
  80         gboolean dimmed = FALSE;
  81         GtkWidget *folder_view = NULL;
  82         TnyFolderStore *parent_folder = NULL;
  83
  84         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
  85
  86
  87         folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
  88                                                            MODEST_WIDGET_TYPE_FOLDER_VIEW);
  89         /* Get selected folder as parent of new folder to create */
  90         parent_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
  91         if (!parent_folder)
  92                 return TRUE;
  93
  94         if (TNY_IS_ACCOUNT (parent_folder)) {
  95                 /* If it's the local account then do not dim */
  96                 if (modest_tny_account_is_virtual_local_folders (TNY_ACCOUNT (parent_folder))) {
  97                         dimmed = FALSE;
  98                 } else {
  99                         const gchar *proto_str = tny_account_get_proto (TNY_ACCOUNT (parent_folder));
 100                         /* If it's POP then dim */
 101                         dimmed = (modest_protocol_info_get_transport_store_protocol (proto_str) ==
 102                                   MODEST_PROTOCOL_STORE_POP) ? TRUE : FALSE;
 103                 }
 104         } else {
 105                 /* TODO: the specs say that only one level of subfolder is allowed, is this true ? */
 106
 107                 TnyFolderType types[3];
 108
 109                 types[0] = TNY_FOLDER_TYPE_DRAFTS;
 110                 types[1] = TNY_FOLDER_TYPE_OUTBOX;
 111                 types[2] = TNY_FOLDER_TYPE_SENT;
 112
 113                 /* Apply folder rules */
 114                 if (!dimmed)
 115                         dimmed = _selected_folder_not_writeable (MODEST_MAIN_WINDOW(win));
 116                 if (!dimmed)
 117                         dimmed = _selected_folder_is_any_of_type (win, types, 3);
 118         }
 119         g_object_unref (parent_folder);
 120
 121         return dimmed;
 122 }
 123
 124 gboolean
 125 modest_ui_dimming_rules_on_delete_folder (ModestWindow *win, gpointer user_data)
 126 {
 127         gboolean dimmed = FALSE;
 128         TnyFolderType types[3];
 129
 130         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
 131
 132         types[0] = TNY_FOLDER_TYPE_DRAFTS;
 133         types[1] = TNY_FOLDER_TYPE_OUTBOX;
 134         types[2] = TNY_FOLDER_TYPE_SENT;
 135
 136         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
 137
 138         /* Check dimmed rule */
 139         if (!dimmed)
 140                 dimmed = _selected_folder_not_writeable (MODEST_MAIN_WINDOW(win));
 141         if (!dimmed)
 142                 dimmed = _selected_folder_is_root_or_inbox (MODEST_MAIN_WINDOW(win));
 143         if (!dimmed)
 144                 dimmed = _selected_folder_is_MMC_or_POP_root (MODEST_MAIN_WINDOW(win));
 145         if (!dimmed)
 146                 dimmed = _selected_folder_is_any_of_type (win, types, 3);
 147
 148         return dimmed;
 149 }
 150
 151 gboolean
 152 modest_ui_dimming_rules_on_sort (ModestWindow *win, gpointer user_data)
 153 {
 154         gboolean dimmed = FALSE;
 155
 156         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
 157
 158         /* Check dimmed rule */
 159         if (!dimmed)
 160                 dimmed = _selected_folder_is_root (MODEST_MAIN_WINDOW(win));
 161
 162         return dimmed;
 163
 164 }
 165
 166 gboolean
 167 modest_ui_dimming_rules_on_rename_folder (ModestWindow *win, gpointer user_data)
 168 {
 169         gboolean dimmed = FALSE;
 170         TnyFolderType types[3];
 171
 172         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
 173
 174         types[0] = TNY_FOLDER_TYPE_DRAFTS;
 175         types[1] = TNY_FOLDER_TYPE_OUTBOX;
 176         types[2] = TNY_FOLDER_TYPE_SENT;
 177
 178         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
 179
 180         /* Check dimmed rule */
 181         if (!dimmed)
 182                 dimmed = _selected_folder_not_writeable (MODEST_MAIN_WINDOW(win));
 183         if (!dimmed)
 184                 dimmed = _selected_folder_is_root_or_inbox (MODEST_MAIN_WINDOW(win));
 185         if (!dimmed)
 186                 dimmed = _selected_folder_is_any_of_type (win, types, 3);
 187
 188         return dimmed;
 189 }
 190
 191 gboolean
 192 modest_ui_dimming_rules_on_open_msg (ModestWindow *win, gpointer user_data)
 193 {
 194         ModestDimmingRule *rule = NULL;
 195         gboolean dimmed = FALSE;
 196
 197         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
 198         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 199         rule = MODEST_DIMMING_RULE (user_data);
 200
 201         /* Check dimmed rule */
 202         if (!dimmed)
 203                 dimmed = _invalid_msg_selected (MODEST_MAIN_WINDOW(win), TRUE, user_data);
 204         if (!dimmed) {
 205                 dimmed = _selected_msg_sent_in_progress (win);
 206                 if (dimmed)
 207                         modest_dimming_rule_set_notification (rule, _("TEST"));
 208         }
 209
 210         return dimmed;
 211 }
 212
 213 gboolean
 214 modest_ui_dimming_rules_on_reply_msg (ModestWindow *win, gpointer user_data)
 215 {
 216         ModestDimmingRule *rule = NULL;
 217         gboolean dimmed = FALSE;
 218         TnyFolderType types[3];
 219
 220         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 221         rule = MODEST_DIMMING_RULE (user_data);
 222
 223         /* main window dimming rules */
 224         if (MODEST_IS_MAIN_WINDOW(win)) {
 225
 226                 types[0] = TNY_FOLDER_TYPE_DRAFTS;
 227                 types[1] = TNY_FOLDER_TYPE_OUTBOX;
 228                 types[2] = TNY_FOLDER_TYPE_ROOT;
 229
 230                 /* Check dimmed rule */
 231                 if (!dimmed) {
 232                         dimmed = _selected_folder_is_any_of_type (win, types, 3);
 233                         if (dimmed)
 234                                 modest_dimming_rule_set_notification (rule, _("mcen_ib_unable_to_reply"));
 235                 }
 236                 if (!dimmed) {
 237                         dimmed = _selected_folder_is_empty (MODEST_MAIN_WINDOW(win));
 238                         if (dimmed)
 239                                 modest_dimming_rule_set_notification (rule, _("mcen_ib_nothing_to_reply"));
 240                 }
 241                 if (!dimmed)
 242                         dimmed = _invalid_msg_selected (MODEST_MAIN_WINDOW(win), TRUE, rule);
 243
 244         /* msg view window dimming rules */
 245         } else if (MODEST_IS_MSG_VIEW_WINDOW(win)) {
 246
 247                 /* Check dimmed rule */
 248                 if (!dimmed)
 249                         dimmed = _msg_download_in_progress (MODEST_MSG_VIEW_WINDOW(win));
 250         }
 251
 252         return dimmed;
 253 }
 254
 255
 256 gboolean
 257 modest_ui_dimming_rules_on_contents_msg (ModestWindow *win, gpointer user_data)
 258 {
 259         gboolean dimmed = FALSE;
 260
 261         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
 262
 263         /* Check dimmed rule */
 264         if (!dimmed)
 265                 dimmed = _invalid_msg_selected (MODEST_MAIN_WINDOW(win), FALSE, user_data);
 266         if (!dimmed)
 267                 dimmed = _msg_download_completed (MODEST_MAIN_WINDOW(win));
 268
 269         return dimmed;
 270 }
 271
 272 gboolean
 273 modest_ui_dimming_rules_always_dimmed (ModestWindow *win, gpointer user_data)
 274 {
 275         gboolean dimmed = FALSE;
 276
 277         g_return_val_if_fail (MODEST_IS_WINDOW(win), FALSE);
 278
 279         /* Check dimmed rule */
 280         if (!dimmed)
 281                 dimmed = TRUE;
 282
 283         return dimmed;
 284 }
 285
 286 gboolean
 287 modest_ui_dimming_rules_on_delete_msg (ModestWindow *win, gpointer user_data)
 288 {
 289         ModestDimmingRule *rule = NULL;
 290         gboolean dimmed = FALSE;
 291
 292         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 293         rule = MODEST_DIMMING_RULE (user_data);
 294
 295         /* Check dimmed rule */
 296         if (MODEST_IS_MAIN_WINDOW (win)) {
 297                 if (!dimmed) {
 298                         dimmed = _selected_folder_is_empty (MODEST_MAIN_WINDOW(win));
 299                         if (dimmed)
 300                                 modest_dimming_rule_set_notification (rule, _("ckct_ib_nothing_to_delete"));
 301                 }
 302                 if (!dimmed) {
 303                         dimmed = _invalid_msg_selected (MODEST_MAIN_WINDOW(win), FALSE, user_data);
 304                         if (dimmed)
 305                                 modest_dimming_rule_set_notification (rule, _("mcen_ib_no_message_selected"));
 306                 }
 307                 if (!dimmed) {
 308                         dimmed = _already_opened_msg (win);
 309                         if (dimmed)
 310                                 modest_dimming_rule_set_notification (rule, _("mcen_nc_unable_to_delete_n_messages"));
 311                 }
 312                 if (!dimmed) {
 313                         dimmed = _marked_as_deleted (win);
 314                         if (dimmed)
 315                                 modest_dimming_rule_set_notification (rule, _("mcen_ib_message_unableto_delete"));
 316                 }
 317                 if (!dimmed) {
 318                         dimmed = _selected_msg_sent_in_progress (win);
 319                         if (dimmed)
 320                                 modest_dimming_rule_set_notification (rule, _("mcen_ib_message_unableto_delete"));
 321                 }
 322         }
 323         else if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
 324                 if (!dimmed) {
 325                         dimmed = !modest_msg_view_window_has_headers_model (MODEST_MSG_VIEW_WINDOW(win));
 326                 }
 327         }
 328
 329         return dimmed;
 330 }
 331
 332 gboolean
 333 modest_ui_dimming_rules_on_details (ModestWindow *win, gpointer user_data)
 334 {
 335         gboolean dimmed = FALSE;
 336         GtkWidget *header_view = NULL;
 337
 338         /* main window dimming rules */
 339         if (MODEST_IS_MAIN_WINDOW(win)) {
 340
 341                 /* Check dimmed rule */
 342                 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
 343                                                                    MODEST_WIDGET_TYPE_HEADER_VIEW);
 344
 345                 /* If the header view does not have the focus then do
 346                    not apply msg dimming rules because the action will
 347                    show the folder details that have no dimming
 348                    rule */
 349                 if (gtk_widget_is_focus (header_view)) {
 350                         /* Check dimmed rule */
 351                         if (!dimmed)
 352                                 dimmed = _invalid_msg_selected (MODEST_MAIN_WINDOW(win), TRUE, user_data);
 353                 }
 354
 355         /* msg view window dimming rules */
 356         } else {
 357
 358                 /* Check dimmed rule */
 359                 if (!dimmed)
 360                         dimmed = _msg_download_in_progress (MODEST_MSG_VIEW_WINDOW(win));
 361         }
 362
 363         return dimmed;
 364 }
 365
 366
 367 gboolean
 368 modest_ui_dimming_rules_on_mark_as_read_msg (ModestWindow *win, gpointer user_data)
 369 {
 370         gboolean dimmed = FALSE;
 371         TnyHeaderFlags flags;
 372
 373         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
 374
 375         flags = TNY_HEADER_FLAG_SEEN;
 376
 377         /* Check dimmed rule */
 378         if (!dimmed)
 379                 dimmed = _invalid_msg_selected (MODEST_MAIN_WINDOW(win), FALSE, user_data);
 380         if (!dimmed)
 381                 dimmed = _selected_msg_marked_as (win, flags, FALSE);
 382
 383         return dimmed;
 384 }
 385
 386 gboolean
 387 modest_ui_dimming_rules_on_mark_as_unread_msg (ModestWindow *win, gpointer user_data)
 388 {
 389         gboolean dimmed = FALSE;
 390         TnyHeaderFlags flags;
 391
 392         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
 393
 394         flags = TNY_HEADER_FLAG_SEEN;
 395
 396         /* Check dimmed rule */
 397         if (!dimmed)
 398                 dimmed = _invalid_msg_selected (MODEST_MAIN_WINDOW(win), FALSE, user_data);
 399         if (!dimmed)
 400                 dimmed = _selected_msg_marked_as (win, flags, TRUE);
 401
 402         return dimmed;
 403 }
 404
 405 gboolean
 406 modest_ui_dimming_rules_on_move_to (ModestWindow *win, gpointer user_data)
 407 {
 408         gboolean dimmed = FALSE;
 409
 410         if (MODEST_IS_MAIN_WINDOW (win))
 411                 dimmed = modest_ui_dimming_rules_on_main_window_move_to (win, user_data);
 412         else if (MODEST_IS_MSG_VIEW_WINDOW (win))
 413                  dimmed = modest_ui_dimming_rules_on_view_window_move_to (win, user_data);
 414
 415         return dimmed;
 416 }
 417
 418
 419 gboolean
 420 modest_ui_dimming_rules_on_main_window_move_to (ModestWindow *win, gpointer user_data)
 421 {
 422         GtkWidget *folder_view = NULL;
 423         GtkWidget *header_view = NULL;
 424         gboolean dimmed = FALSE;
 425
 426         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), TRUE);
 427
 428         /* Get the folder view */
 429         folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
 430                                                            MODEST_WIDGET_TYPE_FOLDER_VIEW);
 431
 432         /* Get header view */
 433         header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
 434                                                            MODEST_WIDGET_TYPE_HEADER_VIEW);
 435
 436         /* Check common diming rules */
 437
 438         /* Check diming rules for folder transfer  */
 439         if (gtk_widget_is_focus (folder_view)) {
 440                 if (!dimmed)
 441                         dimmed = _selected_folder_not_writeable(MODEST_MAIN_WINDOW(win));
 442         }
 443         /* Check diming rules for msg transfer  */
 444         else if (gtk_widget_is_focus (header_view)) {
 445                 if (!dimmed)
 446                         dimmed = _invalid_msg_selected (MODEST_MAIN_WINDOW(win), FALSE, user_data);
 447
 448         }
 449
 450         return dimmed;
 451 }
 452
 453 gboolean
 454 modest_ui_dimming_rules_on_view_window_move_to (ModestWindow *win, gpointer user_data)
 455 {
 456         gboolean dimmed = FALSE;
 457
 458         g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW(win), FALSE);
 459
 460         /* Check dimmed rule */
 461         if (!dimmed)
 462                 dimmed = !modest_msg_view_window_has_headers_model (MODEST_MSG_VIEW_WINDOW(win));
 463
 464         return dimmed;
 465 }
 466
 467 gboolean
 468 modest_ui_dimming_rules_on_paste_msgs (ModestWindow *win, gpointer user_data)
 469 {
 470         TnyFolderType types[3];
 471         gboolean dimmed = FALSE;
 472
 473         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
 474
 475         types[0] = TNY_FOLDER_TYPE_DRAFTS;
 476         types[1] = TNY_FOLDER_TYPE_OUTBOX;
 477         types[2] = TNY_FOLDER_TYPE_SENT;
 478
 479         /* Check dimmed rule */
 480         if (!dimmed)
 481                 dimmed = _selected_folder_is_any_of_type (win, types, 3);
 482
 483         return dimmed;
 484 }
 485
 486 gboolean
 487 modest_ui_dimming_rules_on_delete_msgs (ModestWindow *win, gpointer user_data)
 488 {
 489         TnyFolderType types[5];
 490         gboolean dimmed = FALSE;
 491
 492         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
 493
 494         types[0] = TNY_FOLDER_TYPE_DRAFTS;
 495         types[1] = TNY_FOLDER_TYPE_OUTBOX;
 496         types[2] = TNY_FOLDER_TYPE_SENT;
 497         types[3] = TNY_FOLDER_TYPE_INBOX;
 498         types[4] = TNY_FOLDER_TYPE_ROOT;
 499
 500         /* Check dimmed rule */
 501         if (!dimmed)
 502                 dimmed = _selected_folder_is_any_of_type (win, types, 5);
 503
 504         return dimmed;
 505 }
 506
 507 gboolean
 508 modest_ui_dimming_rules_on_select_all (ModestWindow *win, gpointer user_data)
 509 {
 510         gboolean dimmed = FALSE;
 511
 512         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
 513
 514         /* Check dimmed rule */
 515         if (!dimmed)
 516                 dimmed = _selected_folder_is_empty (MODEST_MAIN_WINDOW(win));
 517
 518         return dimmed;
 519 }
 520
 521 gboolean
 522 modest_ui_dimming_rules_on_view_attachments (ModestWindow *win, gpointer user_data)
 523 {
 524         ModestDimmingRule *rule = NULL;
 525         gboolean dimmed = FALSE;
 526
 527         g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW(win), FALSE);
 528         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 529         rule = MODEST_DIMMING_RULE (user_data);
 530
 531         /* Check dimmed rule */
 532         if (!dimmed)
 533                 dimmed = _invalid_attach_selected (win, TRUE, rule);
 534
 535         return dimmed;
 536 }
 537
 538 gboolean
 539 modest_ui_dimming_rules_on_save_attachments (ModestWindow *win, gpointer user_data)
 540 {
 541         ModestDimmingRule *rule = NULL;
 542         gboolean dimmed = FALSE;
 543
 544         g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW(win), FALSE);
 545         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 546         rule = MODEST_DIMMING_RULE (user_data);
 547
 548         /* Check dimmed rule */
 549         if (!dimmed)
 550                 dimmed = _invalid_attach_selected (win, FALSE, rule);
 551
 552         return dimmed;
 553 }
 554
 555 gboolean
 556 modest_ui_dimming_rules_on_remove_attachments (ModestWindow *win, gpointer user_data)
 557 {
 558         ModestDimmingRule *rule = NULL;
 559         gboolean dimmed = FALSE;
 560
 561         g_return_val_if_fail (MODEST_IS_WINDOW(win), FALSE);
 562         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 563         rule = MODEST_DIMMING_RULE (user_data);
 564
 565         /* Check dimmed rule */
 566         if (!dimmed) {
 567                 dimmed = _invalid_attach_selected (win, FALSE, NULL);
 568                 modest_dimming_rule_set_notification (rule, _("mcen_ib_unable_to_display_more"));
 569         }
 570
 571         return dimmed;
 572 }
 573
 574 gboolean
 575 modest_ui_dimming_rules_on_copy (ModestWindow *win, gpointer user_data)
 576 {
 577         gboolean dimmed = FALSE;
 578
 579         g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW(win), FALSE);
 580
 581         /* Check dimmed rule */
 582         if (!dimmed)
 583                 dimmed = _invalid_clipboard_selected (MODEST_MSG_VIEW_WINDOW(win));
 584
 585         return dimmed;
 586 }
 587
 588 gboolean
 589 modest_ui_dimming_rules_on_view_previous (ModestWindow *win, gpointer user_data)
 590 {
 591         gboolean dimmed = FALSE;
 592
 593         g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW(win), FALSE);
 594
 595         /* Check dimmed rule */
 596         if (!dimmed)
 597                 dimmed = modest_msg_view_window_first_message_selected (MODEST_MSG_VIEW_WINDOW(win));
 598
 599         return dimmed;
 600 }
 601
 602 gboolean
 603 modest_ui_dimming_rules_on_view_next (ModestWindow *win, gpointer user_data)
 604 {
 605         gboolean dimmed = FALSE;
 606
 607         g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW(win), FALSE);
 608
 609         /* Check dimmed rule */
 610         if (!dimmed)
 611                 dimmed = modest_msg_view_window_last_message_selected (MODEST_MSG_VIEW_WINDOW(win));
 612
 613         return dimmed;
 614 }
 615
 616
 617 gboolean
 618 modest_ui_dimming_rules_on_tools_smtp_servers (ModestWindow *win, gpointer user_data)
 619 {
 620         const gboolean dimmed =
 621                 !modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(),
 622                         TRUE);
 623
 624         return dimmed;
 625 }
 626
 627 gboolean
 628 modest_ui_dimming_rules_on_cancel_sending (ModestWindow *win, gpointer user_data)
 629 {
 630         gboolean dimmed = FALSE;
 631
 632         /* Check dimmed rule */
 633         if (!dimmed)
 634                 dimmed = !_sending_in_progress (win);
 635
 636         return dimmed;
 637 }
 638
 639 gboolean
 640 modest_ui_dimming_rules_on_send_receive (ModestWindow *win, gpointer user_data)
 641 {
 642         ModestDimmingRule *rule = NULL;
 643         gboolean dimmed = FALSE;
 644
 645         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 646         rule = MODEST_DIMMING_RULE (user_data);
 647
 648         /* Check dimmed rule */
 649         if (!dimmed) {
 650                 dimmed = !modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(),
 651                                                           TRUE);
 652                 modest_dimming_rule_set_notification (rule, _("mcen_nc_no_email_acnts_defined"));
 653         }
 654
 655         return dimmed;
 656 }
 657
 658 gboolean
 659 modest_ui_dimming_rules_on_add_to_contacts (ModestWindow *win, gpointer user_data)
 660 {
 661         ModestDimmingRule *rule = NULL;
 662         gboolean dimmed = FALSE;
 663
 664         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 665         rule = MODEST_DIMMING_RULE (user_data);
 666
 667         /* Check dimmed rule */
 668         if (!dimmed) {
 669                 GtkClipboard *clipboard = gtk_clipboard_get (GDK_SELECTION_PRIMARY);
 670                 gchar *selection = NULL;
 671                 selection = gtk_clipboard_wait_for_text (clipboard);
 672
 673                 dimmed = !((selection != NULL) && (modest_text_utils_validate_recipient (selection)));
 674         }
 675
 676         return dimmed;
 677 }
 678
 679 /* *********************** static utility functions ******************** */
 680
 681 static gboolean
 682 _marked_as_deleted (ModestWindow *win)
 683 {
 684         gboolean result = FALSE;
 685         TnyHeaderFlags flags;
 686
 687         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
 688
 689         flags = TNY_HEADER_FLAG_DELETED;
 690
 691         /* Check dimmed rule */
 692         result = _selected_msg_marked_as (win, flags, FALSE);
 693
 694         return result;
 695 }
 696
 697 static gboolean
 698 _selected_folder_not_writeable (ModestMainWindow *win)
 699 {
 700         GtkWidget *folder_view = NULL;
 701         TnyFolderStore *parent_folder = NULL;
 702         ModestTnyFolderRules rules;
 703         gboolean result = FALSE;
 704
 705         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
 706
 707         /* Get folder view */
 708         folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
 709                                                            MODEST_WIDGET_TYPE_FOLDER_VIEW);
 710         /* If no folder view, always dimmed */
 711         if (!folder_view)
 712                 return TRUE;
 713
 714         /* Get selected folder as parent of new folder to create */
 715         parent_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
 716         if (!(parent_folder && TNY_IS_FOLDER(parent_folder))) {
 717                 if (parent_folder)
 718                         g_object_unref (parent_folder);
 719                 return TRUE;
 720         }
 721
 722         /* Check dimmed rule */
 723         rules = modest_tny_folder_get_rules (TNY_FOLDER (parent_folder));
 724         result = rules & MODEST_FOLDER_RULES_FOLDER_NON_WRITEABLE;
 725
 726         /* free */
 727         g_object_unref (parent_folder);
 728
 729         return result;
 730 }
 731
 732 static gboolean
 733 _selected_folder_is_root_or_inbox (ModestMainWindow *win)
 734 {
 735         TnyFolderType types[2];
 736         gboolean result = FALSE;
 737
 738         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
 739
 740         types[0] = TNY_FOLDER_TYPE_ROOT;
 741         types[1] = TNY_FOLDER_TYPE_INBOX;
 742
 743         /* Check folder type */
 744         result = _selected_folder_is_any_of_type (MODEST_WINDOW(win), types, 2);
 745
 746         /* Check pop and MMC accounts */
 747         if (!result) {
 748                 result = _selected_folder_is_MMC_or_POP_root (win);
 749         }
 750
 751         return result;
 752 }
 753
 754
 755 static gboolean
 756 _selected_folder_is_root (ModestMainWindow *win)
 757 {
 758         TnyFolderType types[1];
 759         gboolean result = FALSE;
 760
 761         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
 762
 763         types[0] = TNY_FOLDER_TYPE_ROOT;
 764
 765         /* Check folder type */
 766         result = _selected_folder_is_any_of_type (MODEST_WINDOW(win), types, 1);
 767
 768         /* Check pop and MMC accounts */
 769         if (!result) {
 770                 result = _selected_folder_is_MMC_or_POP_root (win);
 771         }
 772
 773         return result;
 774 }
 775
 776 static gboolean
 777 _selected_folder_is_MMC_or_POP_root (ModestMainWindow *win)
 778 {
 779         GtkWidget *folder_view = NULL;
 780         TnyFolderStore *parent_folder = NULL;
 781         gboolean result = FALSE;
 782
 783         folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
 784                                                            MODEST_WIDGET_TYPE_FOLDER_VIEW);
 785         /* Get selected folder as parent of new folder to create */
 786         parent_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
 787         if (!parent_folder)
 788                 return TRUE;
 789
 790         if (TNY_IS_ACCOUNT (parent_folder)) {
 791                 /* If it's the local account then do not dim */
 792                 if (modest_tny_account_is_virtual_local_folders (TNY_ACCOUNT (parent_folder))) {
 793                         result = FALSE;
 794                 } else {
 795                                 /* If it's the MMC root folder then dim it */
 796                         if (!strcmp (tny_account_get_id (TNY_ACCOUNT (parent_folder)), MODEST_MMC_ACCOUNT_ID)) {
 797                                         result = TRUE;
 798                         } else {
 799                                 const gchar *proto_str = tny_account_get_proto (TNY_ACCOUNT (parent_folder));
 800                                 /* If it's POP then dim */
 801                                 result = (modest_protocol_info_get_transport_store_protocol (proto_str) ==
 802                                                   MODEST_PROTOCOL_STORE_POP) ? TRUE : FALSE;
 803                         }
 804                 }
 805         }
 806         g_object_unref (parent_folder);
 807
 808         return result;
 809 }
 810
 811
 812
 813
 814 static gboolean
 815 _selected_folder_is_empty (ModestMainWindow *win)
 816 {
 817         GtkWidget *folder_view = NULL;
 818         TnyFolderStore *folder = NULL;
 819         gboolean result = FALSE;
 820
 821         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
 822
 823         /* Get folder view */
 824         folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
 825                                                            MODEST_WIDGET_TYPE_FOLDER_VIEW);
 826         /* If no folder view, always dimmed */
 827         if (!folder_view)
 828                 return TRUE;
 829
 830         /* Get selected folder as parent of new folder to create */
 831         folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
 832         if (!(folder && TNY_IS_FOLDER(folder))) {
 833                 if (folder)
 834                         g_object_unref (folder);
 835                 return TRUE;
 836         }
 837
 838         /* Check folder type */
 839         result = tny_folder_get_all_count (TNY_FOLDER (folder)) == 0;
 840
 841         /* free */
 842         g_object_unref (folder);
 843
 844         return result;
 845 }
 846
 847 static gboolean
 848 _selected_folder_is_any_of_type (ModestWindow *win,
 849                                  TnyFolderType types[],
 850                                  guint ntypes)
 851 {
 852         GtkWidget *folder_view = NULL;
 853         TnyFolderStore *folder = NULL;
 854         TnyFolderType folder_type;
 855         guint i=0;
 856         gboolean result = FALSE;
 857
 858         /*Get curent folder */
 859         if (MODEST_IS_MAIN_WINDOW(win)) {
 860
 861                 /* Get folder view */
 862                 folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
 863                                                                    MODEST_WIDGET_TYPE_FOLDER_VIEW);
 864                 /* If no folder view, always dimmed */
 865                 if (!folder_view)
 866                         return TRUE;
 867
 868                 /* Get selected folder as parent of new folder to create */
 869                 folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
 870
 871                 if (!(folder && TNY_IS_FOLDER(folder))) {
 872                         if (folder)
 873                                 g_object_unref (folder);
 874                         return TRUE;
 875                 }
 876
 877                 /* Check folder type */
 878                 result = _folder_is_any_of_type (TNY_FOLDER(folder), types, ntypes);
 879         }
 880         else if (MODEST_IS_MSG_VIEW_WINDOW(win)) {
 881                 folder_type = modest_msg_view_window_get_folder_type (MODEST_MSG_VIEW_WINDOW (win));
 882                 for (i=0; i < ntypes; i++) {
 883                         result = result || folder_type == types[i];
 884                 }
 885         }
 886
 887
 888         /* free */
 889         g_object_unref (folder);
 890
 891         return result;
 892 }
 893
 894 static gboolean
 895 _folder_is_any_of_type (TnyFolder *folder,
 896                         TnyFolderType types[],
 897                         guint ntypes)
 898 {
 899         TnyFolderType folder_type;
 900         gboolean result = FALSE;
 901         guint i;
 902
 903         g_return_val_if_fail (TNY_IS_FOLDER(folder), FALSE);
 904
 905         /* Get folder type */
 906         if (modest_tny_folder_is_local_folder (folder))
 907                 folder_type = modest_tny_folder_get_local_folder_type (folder);
 908         else
 909                 folder_type = modest_tny_folder_guess_folder_type (folder);
 910
 911         /* Check foler type */
 912         for (i=0; i < ntypes; i++) {
 913                 result = result || folder_type == types[i];
 914         }
 915
 916         return result;
 917 }
 918
 919
 920
 921 static gboolean
 922 _invalid_clipboard_selected (ModestMsgViewWindow *win)
 923 {
 924         GtkClipboard *clipboard = NULL;
 925         gchar *selection = NULL;
 926         GtkWidget *focused = NULL;
 927         gboolean result = FALSE;
 928
 929         g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW (win), TRUE);
 930
 931         /* Get clipboard selection*/
 932         clipboard = gtk_clipboard_get (GDK_SELECTION_PRIMARY);
 933         selection = gtk_clipboard_wait_for_text (clipboard);
 934
 935         /* Get focuesed widget */
 936         focused = gtk_window_get_focus (GTK_WINDOW (win));
 937
 938         /* Check dimming */
 939         result = ((selection == NULL) ||
 940                   (MODEST_IS_ATTACHMENTS_VIEW (focused)));
 941
 942         return result;
 943 }
 944
 945 static gboolean
 946 _invalid_attach_selected (ModestWindow *win,
 947                           gboolean unique,
 948                           ModestDimmingRule *rule)
 949 {
 950         GList *attachments, *node;
 951         gint n_selected;
 952         TnyHeaderFlags flags;
 953         gboolean nested_attachments = FALSE;
 954         gboolean selected_messages = FALSE;
 955         gboolean result = FALSE;
 956
 957         if (MODEST_IS_MAIN_WINDOW (win)) {
 958                 flags = TNY_HEADER_FLAG_ATTACHMENTS;
 959                 if (!result)
 960                         result = _selected_msg_marked_as (win, flags, TRUE);
 961
 962         }
 963         else if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
 964
 965                 /* Get selected atachments */
 966                 attachments = modest_msg_view_window_get_attachments (MODEST_MSG_VIEW_WINDOW(win));
 967                 n_selected = g_list_length (attachments);
 968                 for (node = attachments; node != NULL; node = g_list_next (node)) {
 969                         TnyMimePart *mime_part = TNY_MIME_PART (node->data);
 970                         TnyList *nested_list = tny_simple_list_new ();
 971                         if (!tny_mime_part_is_attachment (mime_part)) {
 972                                 selected_messages = TRUE;
 973                                 break;
 974                         }
 975                         tny_mime_part_get_parts (mime_part, nested_list);
 976                         if (tny_list_get_length (nested_list) > 0)
 977                                 nested_attachments = TRUE;
 978                         g_object_unref (nested_list);
 979                 }
 980
 981                 /* Check unique */
 982                 if (unique)
 983                         result = n_selected != 1;
 984                 else
 985
 986                         result = n_selected < 1;
 987
 988                 /* Set notifications */
 989                 if (!result && rule != NULL) {
 990                         if (selected_messages) {
 991                                 modest_dimming_rule_set_notification (rule, _("mcen_ib_unable_to_save_attach_mail"));
 992                         } else if (nested_attachments) {
 993                                 modest_dimming_rule_set_notification (rule, _("FIXME:unable to save attachments with nested elements"));
 994                         } else if (n_selected == 0) {
 995                                 modest_dimming_rule_set_notification (rule, _("FIXME:no attachment selected"));
 996                         }
 997                 }
 998
 999                 /* Free */
1000                 g_list_free (attachments);
1001         }
1002
1003         return result;
1004 }
1005
1006 static gboolean
1007 _invalid_msg_selected (ModestMainWindow *win,
1008                        gboolean unique,
1009                        ModestDimmingRule *rule)
1010 {
1011         GtkWidget *header_view = NULL;
1012         GtkWidget *folder_view = NULL;
1013         TnyList *selected_headers = NULL;
1014         gboolean result = FALSE;
1015
1016         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
1017         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (rule), FALSE);
1018
1019         /* Get header view to check selected messages */
1020         header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
1021                                                            MODEST_WIDGET_TYPE_HEADER_VIEW);
1022
1023         /* Get folder view to check focus */
1024         folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
1025                                                            MODEST_WIDGET_TYPE_FOLDER_VIEW);
1026
1027         /* Get selected headers */
1028         selected_headers = modest_header_view_get_selected_headers (MODEST_HEADER_VIEW(header_view));
1029
1030         /* Check dimmed rule (TODO: check focus on widgets */
1031         if (!result) {
1032                 result = (selected_headers == NULL);
1033 /*              result = ((selected_headers == NULL) || */
1034 /*                        (GTK_WIDGET_HAS_FOCUS (folder_view))); */
1035                 if (result)
1036                         modest_dimming_rule_set_notification (rule, _("mcen_ib_no_message_selected"));
1037         }
1038         if (!result && unique) {
1039                 result = tny_list_get_length (selected_headers) > 1;
1040                 if (result)
1041                         modest_dimming_rule_set_notification (rule, _("mcen_ib_select_one_message"));
1042         }
1043
1044         /* free */
1045         if (selected_headers != NULL)
1046                 g_object_unref (selected_headers);
1047
1048         return result;
1049 }
1050
1051 static gboolean
1052 _already_opened_msg (ModestWindow *win)
1053 {
1054         ModestWindow *window = NULL;
1055         ModestWindowMgr *mgr = NULL;
1056         GtkWidget *header_view = NULL;
1057         TnyList *selected_headers = NULL;
1058         TnyIterator *iter = NULL;
1059         TnyHeader *header = NULL;
1060         gboolean result = TRUE;
1061
1062         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
1063
1064         /* Get header view to check selected messages */
1065         header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
1066                                                            MODEST_WIDGET_TYPE_HEADER_VIEW);
1067
1068         /* Get selected headers */
1069         selected_headers = modest_header_view_get_selected_headers (MODEST_HEADER_VIEW(header_view));
1070         if (selected_headers == NULL)
1071                 return FALSE;
1072
1073         /* Check dimmed rule (TODO: check focus on widgets */
1074         mgr = modest_runtime_get_window_mgr ();
1075         iter = tny_list_create_iterator (selected_headers);
1076         while (!tny_iterator_is_done (iter) && result) {
1077                 header = TNY_HEADER (tny_iterator_get_current (iter));
1078                 window = modest_window_mgr_find_window_by_header (mgr, header);
1079                 result = result && (window != NULL);
1080
1081                 g_object_unref (header);
1082                 tny_iterator_next (iter);
1083         }
1084
1085         /* free */
1086         if (selected_headers != NULL)
1087                 g_object_unref (selected_headers);
1088         if (iter != NULL)
1089                 g_object_unref (iter);
1090
1091         return result;
1092 }
1093
1094 static gboolean
1095 _selected_msg_marked_as (ModestWindow *win,
1096                          TnyHeaderFlags mask,
1097                          gboolean opposite)
1098 {
1099         GtkWidget *header_view = NULL;
1100         TnyList *selected_headers = NULL;
1101         TnyIterator *iter = NULL;
1102         TnyHeader *header = NULL;
1103         TnyHeaderFlags flags;
1104         gboolean result = FALSE;
1105
1106         /* Get header view to check selected messages */
1107         header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
1108                                                            MODEST_WIDGET_TYPE_HEADER_VIEW);
1109
1110         /* Get selected headers */
1111         selected_headers = modest_header_view_get_selected_headers (MODEST_HEADER_VIEW(header_view));
1112         if (selected_headers == NULL)
1113                 return TRUE;
1114
1115         /* Call the function for each header */
1116         iter = tny_list_create_iterator (selected_headers);
1117         while (!tny_iterator_is_done (iter) && !result) {
1118                 header = TNY_HEADER (tny_iterator_get_current (iter));
1119
1120                 flags = tny_header_get_flags (header);
1121                 if (opposite)
1122                         result = (flags & mask) == 0;
1123                 else
1124                         result = (flags & mask) != 0;
1125
1126                 g_object_unref (header);
1127                 tny_iterator_next (iter);
1128         }
1129
1130         /* free */
1131         if (selected_headers != NULL)
1132                 g_object_unref (selected_headers);
1133         if (iter != NULL)
1134                 g_object_unref (iter);
1135
1136         return result;
1137 }
1138
1139 static gboolean
1140 _msg_download_in_progress (ModestMsgViewWindow *win)
1141 {
1142         gboolean result = FALSE;
1143
1144         g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW (win), FALSE);
1145
1146         result = modest_msg_view_window_toolbar_on_transfer_mode (win);
1147
1148         return result;
1149 }
1150
1151 static gboolean
1152 _msg_download_completed (ModestMainWindow *win)
1153 {
1154         GtkWidget *header_view = NULL;
1155         TnyList *selected_headers = NULL;
1156         TnyIterator *iter = NULL;
1157         TnyHeader *header = NULL;
1158         TnyHeaderFlags flags;
1159         gboolean result = FALSE;
1160
1161         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW (win), FALSE);
1162
1163
1164         /* Get header view to check selected messages */
1165         header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
1166                                                            MODEST_WIDGET_TYPE_HEADER_VIEW);
1167
1168         /* Get selected headers */
1169         selected_headers = modest_header_view_get_selected_headers (MODEST_HEADER_VIEW(header_view));
1170         if (selected_headers == NULL)
1171                 return TRUE;
1172
1173         /* Check dimmed rule  */
1174         result = TRUE;
1175         iter = tny_list_create_iterator (selected_headers);
1176         while (!tny_iterator_is_done (iter) && result) {
1177                 header = TNY_HEADER (tny_iterator_get_current (iter));
1178
1179                 flags = tny_header_get_flags (header);
1180                 /* TODO: is this the right flag?, it seems that some
1181                    headers that have been previously downloaded do not
1182                    come with it */
1183                 result = (flags & TNY_HEADER_FLAG_CACHED);
1184
1185                 g_object_unref (header);
1186                 tny_iterator_next (iter);
1187         }
1188
1189         g_object_unref (iter);
1190
1191         return result;
1192 }
1193
1194 static gboolean
1195 _selected_msg_sent_in_progress (ModestWindow *win)
1196 {
1197         ModestTnySendQueue *send_queue = NULL;
1198         GtkWidget *header_view = NULL;
1199         ModestTnyAccountStore *acc_store = NULL;
1200         TnyAccount *account = NULL;
1201         TnyList *header_list = NULL;
1202         TnyIterator *iter = NULL;
1203         TnyHeader *header = NULL;
1204         const gchar *account_name = NULL;
1205         gboolean result = FALSE;
1206         gchar *id = NULL;
1207
1208         /* Get transport account */
1209         acc_store = modest_runtime_get_account_store();
1210         account_name = modest_window_get_active_account (win);
1211
1212         /* If no account defined, this action must be always dimmed  */
1213         if (account_name == NULL) return FALSE;
1214         account = modest_tny_account_store_get_transport_account_for_open_connection (acc_store, account_name);
1215         if (!TNY_IS_TRANSPORT_ACCOUNT (account)) return FALSE;
1216
1217         /* Get send queue for current ransport account */
1218         send_queue = modest_runtime_get_send_queue (TNY_TRANSPORT_ACCOUNT(account));
1219         g_return_val_if_fail (MODEST_IS_TNY_SEND_QUEUE (send_queue), FALSE);
1220
1221         if (MODEST_IS_MAIN_WINDOW(win)) {
1222
1223                 /* Get header view to check selected messages */
1224                 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
1225                                                                    MODEST_WIDGET_TYPE_HEADER_VIEW);
1226
1227                 /* Get selected headers */
1228                 header_list = modest_header_view_get_selected_headers (MODEST_HEADER_VIEW(header_view));
1229
1230                 /* Get message header */
1231                 if (!header_list) return FALSE;
1232                 iter = tny_list_create_iterator (header_list);
1233                 header = TNY_HEADER (tny_iterator_get_current (iter));
1234
1235                 /* Get message id */
1236                 id = g_strdup(tny_header_get_message_id (header));
1237
1238         } else if (MODEST_IS_MSG_VIEW_WINDOW(win)) {
1239
1240                 /* Get message header */
1241                 header = modest_msg_view_window_get_header (MODEST_MSG_VIEW_WINDOW(win));
1242
1243                 /* Get message id */
1244                 id = g_strdup(tny_header_get_message_id (header));
1245         }
1246
1247         /* Check if msg id is being processed inside send queue */
1248         result = modest_tny_send_queue_msg_is_being_sent (send_queue, id);
1249
1250         /* Free */
1251         g_free(id);
1252         g_object_unref (header);
1253         g_object_unref(header_list);
1254         g_object_unref(iter);
1255
1256         return result;
1257 }
1258
1259
1260 static gboolean
1261 _sending_in_progress (ModestWindow *win)
1262 {
1263         ModestTnySendQueue *send_queue = NULL;
1264         ModestTnyAccountStore *acc_store = NULL;
1265         TnyAccount *account = NULL;
1266         const gchar *account_name = NULL;
1267         gboolean result = FALSE;
1268
1269         /* Get transport account */
1270         acc_store = modest_runtime_get_account_store();
1271         account_name = modest_window_get_active_account (win);
1272
1273         /* If no account defined, this action must be always dimmed  */
1274         if (account_name == NULL) return FALSE;
1275         account = modest_tny_account_store_get_transport_account_for_open_connection (acc_store, account_name);
1276         if (!TNY_IS_TRANSPORT_ACCOUNT (account)) return FALSE;
1277
1278         /* Get send queue for current ransport account */
1279         send_queue = modest_runtime_get_send_queue (TNY_TRANSPORT_ACCOUNT(account));
1280         g_return_val_if_fail (MODEST_IS_TNY_SEND_QUEUE (send_queue), FALSE);
1281
1282         /* Check if send queue is perfimring any send operation */
1283         result = modest_tny_send_queue_sending_in_progress (send_queue);
1284
1285         return result;
1286 }