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 <widgets/modest-attachments-view.h>
  39 #include <modest-runtime.h>
  40 #include <tny-simple-list.h>
  41
  42
  43 static gboolean _folder_is_any_of_type (TnyFolder *folder, TnyFolderType types[], guint ntypes);
  44 static gboolean _invalid_msg_selected (ModestMainWindow *win, gboolean unique, ModestDimmingRule *rule);
  45 static gboolean _invalid_attach_selected (ModestWindow *win, gboolean unique, ModestDimmingRule *rule);
  46 static gboolean _invalid_clipboard_selected (ModestMsgViewWindow *win);
  47 static gboolean _already_opened_msg (ModestWindow *win);
  48 static gboolean _selected_msg_marked_as (ModestWindow *win, TnyHeaderFlags mask, gboolean opposite);
  49 static gboolean _selected_folder_not_writeable (ModestMainWindow *win);
  50 static gboolean _selected_folder_is_any_of_type (ModestWindow *win, TnyFolderType types[], guint ntypes);
  51 static gboolean _selected_folder_is_root_or_inbox (ModestMainWindow *win);
  52 static gboolean _selected_folder_is_MMC_or_POP_root (ModestMainWindow *win);
  53 static gboolean _selected_folder_is_root (ModestMainWindow *win);
  54 static gboolean _selected_folder_is_empty (ModestMainWindow *win);
  55 static gboolean _msg_download_in_progress (ModestMsgViewWindow *win);
  56 static gboolean _msg_download_completed (ModestMainWindow *win);
  57 static gboolean _selected_msg_sent_in_progress (ModestWindow *win);
  58 static gboolean _sending_in_progress (ModestWindow *win);
  59 static gboolean _marked_as_deleted (ModestWindow *win);
  60
  61
  62 gboolean
  63 modest_ui_dimming_rules_on_new_msg (ModestWindow *win, gpointer user_data)
  64 {
  65         gboolean dimmed = FALSE;
  66
  67         g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW(win), FALSE);
  68
  69         /* Check dimmed rule */
  70         if (!dimmed)
  71                 dimmed = _msg_download_in_progress (MODEST_MSG_VIEW_WINDOW(win));
  72
  73         return dimmed;
  74 }
  75
  76 gboolean
  77 modest_ui_dimming_rules_on_new_folder (ModestWindow *win, gpointer user_data)
  78 {
  79         gboolean dimmed = FALSE;
  80         GtkWidget *folder_view = NULL;
  81         TnyFolderStore *parent_folder = NULL;
  82
  83         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
  84
  85
  86         folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
  87                                                            MODEST_WIDGET_TYPE_FOLDER_VIEW);
  88         /* Get selected folder as parent of new folder to create */
  89         parent_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
  90         if (!parent_folder)
  91                 return TRUE;
  92
  93         if (TNY_IS_ACCOUNT (parent_folder)) {
  94                 /* If it's the local account then do not dim */
  95                 if (modest_tny_account_is_virtual_local_folders (
  96                         TNY_ACCOUNT (parent_folder)))
  97                         return 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
 120         return dimmed;
 121 }
 122
 123 gboolean
 124 modest_ui_dimming_rules_on_delete_folder (ModestWindow *win, gpointer user_data)
 125 {
 126         gboolean dimmed = FALSE;
 127         TnyFolderType types[3];
 128
 129         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
 130
 131         types[0] = TNY_FOLDER_TYPE_DRAFTS;
 132         types[1] = TNY_FOLDER_TYPE_OUTBOX;
 133         types[2] = TNY_FOLDER_TYPE_SENT;
 134
 135         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
 136
 137         /* Check dimmed rule */
 138         if (!dimmed)
 139                 dimmed = _selected_folder_not_writeable (MODEST_MAIN_WINDOW(win));
 140         if (!dimmed)
 141                 dimmed = _selected_folder_is_root_or_inbox (MODEST_MAIN_WINDOW(win));
 142         if (!dimmed)
 143                 dimmed = _selected_folder_is_MMC_or_POP_root (MODEST_MAIN_WINDOW(win));
 144         if (!dimmed)
 145                 dimmed = _selected_folder_is_any_of_type (win, types, 3);
 146
 147         return dimmed;
 148 }
 149
 150 gboolean
 151 modest_ui_dimming_rules_on_sort (ModestWindow *win, gpointer user_data)
 152 {
 153         gboolean dimmed = FALSE;
 154
 155         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
 156
 157         /* Check dimmed rule */
 158         if (!dimmed)
 159                 dimmed = _selected_folder_is_root (MODEST_MAIN_WINDOW(win));
 160
 161         return dimmed;
 162
 163 }
 164
 165 gboolean
 166 modest_ui_dimming_rules_on_rename_folder (ModestWindow *win, gpointer user_data)
 167 {
 168         gboolean dimmed = FALSE;
 169         TnyFolderType types[3];
 170
 171         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
 172
 173         types[0] = TNY_FOLDER_TYPE_DRAFTS;
 174         types[1] = TNY_FOLDER_TYPE_OUTBOX;
 175         types[2] = TNY_FOLDER_TYPE_SENT;
 176
 177         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
 178
 179         /* Check dimmed rule */
 180         if (!dimmed)
 181                 dimmed = _selected_folder_not_writeable (MODEST_MAIN_WINDOW(win));
 182         if (!dimmed)
 183                 dimmed = _selected_folder_is_root_or_inbox (MODEST_MAIN_WINDOW(win));
 184         if (!dimmed)
 185                 dimmed = _selected_folder_is_any_of_type (win, types, 3);
 186
 187         return dimmed;
 188 }
 189
 190 gboolean
 191 modest_ui_dimming_rules_on_open_msg (ModestWindow *win, gpointer user_data)
 192 {
 193         ModestDimmingRule *rule = NULL;
 194         gboolean dimmed = FALSE;
 195
 196         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
 197         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 198         rule = MODEST_DIMMING_RULE (user_data);
 199
 200         /* Check dimmed rule */
 201         if (!dimmed)
 202                 dimmed = _invalid_msg_selected (MODEST_MAIN_WINDOW(win), TRUE, user_data);
 203         if (!dimmed) {
 204                 dimmed = _selected_msg_sent_in_progress (win);
 205                 if (dimmed)
 206                         modest_dimming_rule_set_notification (rule, _("TEST"));
 207         }
 208
 209         return dimmed;
 210 }
 211
 212 gboolean
 213 modest_ui_dimming_rules_on_reply_msg (ModestWindow *win, gpointer user_data)
 214 {
 215         ModestDimmingRule *rule = NULL;
 216         gboolean dimmed = FALSE;
 217         TnyFolderType types[3];
 218
 219         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 220         rule = MODEST_DIMMING_RULE (user_data);
 221
 222         /* main window dimming rules */
 223         if (MODEST_IS_MAIN_WINDOW(win)) {
 224
 225                 types[0] = TNY_FOLDER_TYPE_DRAFTS;
 226                 types[1] = TNY_FOLDER_TYPE_OUTBOX;
 227                 types[2] = TNY_FOLDER_TYPE_ROOT;
 228
 229                 /* Check dimmed rule */
 230                 if (!dimmed) {
 231                         dimmed = _selected_folder_is_any_of_type (win, types, 3);
 232                         if (dimmed)
 233                                 modest_dimming_rule_set_notification (rule, _("mcen_ib_unable_to_reply"));
 234                 }
 235                 if (!dimmed) {
 236                         dimmed = _selected_folder_is_empty (MODEST_MAIN_WINDOW(win));
 237                         if (dimmed)
 238                                 modest_dimming_rule_set_notification (rule, _("mcen_ib_nothing_to_reply"));
 239                 }
 240                 if (!dimmed)
 241                         dimmed = _invalid_msg_selected (MODEST_MAIN_WINDOW(win), TRUE, rule);
 242
 243         /* msg view window dimming rules */
 244         } else if (MODEST_IS_MSG_VIEW_WINDOW(win)) {
 245
 246                 /* Check dimmed rule */
 247                 if (!dimmed)
 248                         dimmed = _msg_download_in_progress (MODEST_MSG_VIEW_WINDOW(win));
 249         }
 250
 251         return dimmed;
 252 }
 253
 254
 255 gboolean
 256 modest_ui_dimming_rules_on_contents_msg (ModestWindow *win, gpointer user_data)
 257 {
 258         gboolean dimmed = FALSE;
 259
 260         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
 261
 262         /* Check dimmed rule */
 263         if (!dimmed)
 264                 dimmed = _invalid_msg_selected (MODEST_MAIN_WINDOW(win), FALSE, user_data);
 265         if (!dimmed)
 266                 dimmed = _msg_download_completed (MODEST_MAIN_WINDOW(win));
 267
 268         return dimmed;
 269 }
 270
 271 gboolean
 272 modest_ui_dimming_rules_always_dimmed (ModestWindow *win, gpointer user_data)
 273 {
 274         gboolean dimmed = FALSE;
 275
 276         g_return_val_if_fail (MODEST_IS_WINDOW(win), FALSE);
 277
 278         /* Check dimmed rule */
 279         if (!dimmed)
 280                 dimmed = TRUE;
 281
 282         return dimmed;
 283 }
 284
 285 gboolean
 286 modest_ui_dimming_rules_on_delete_msg (ModestWindow *win, gpointer user_data)
 287 {
 288         ModestDimmingRule *rule = NULL;
 289         gboolean dimmed = FALSE;
 290
 291         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW (win), FALSE);
 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, _("mcen_ib_nothing_to_del"));
 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 /* *********************** static utility functions ******************** */
 659
 660 static gboolean
 661 _marked_as_deleted (ModestWindow *win)
 662 {
 663         gboolean result = FALSE;
 664         TnyHeaderFlags flags;
 665
 666         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
 667
 668         flags = TNY_HEADER_FLAG_DELETED;
 669
 670         /* Check dimmed rule */
 671         result = _selected_msg_marked_as (win, flags, FALSE);
 672
 673         return result;
 674 }
 675
 676 static gboolean
 677 _selected_folder_not_writeable (ModestMainWindow *win)
 678 {
 679         GtkWidget *folder_view = NULL;
 680         TnyFolderStore *parent_folder = NULL;
 681         ModestTnyFolderRules rules;
 682         gboolean result = FALSE;
 683
 684         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
 685
 686         /* Get folder view */
 687         folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
 688                                                            MODEST_WIDGET_TYPE_FOLDER_VIEW);
 689         /* If no folder view, always dimmed */
 690         if (!folder_view)
 691                 return TRUE;
 692
 693         /* Get selected folder as parent of new folder to create */
 694         parent_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
 695         if (!(parent_folder && TNY_IS_FOLDER(parent_folder)))
 696                 return TRUE;
 697
 698         /* Check dimmed rule */
 699         rules = modest_tny_folder_get_rules (TNY_FOLDER (parent_folder));
 700         result = rules & MODEST_FOLDER_RULES_FOLDER_NON_WRITEABLE;
 701
 702         /* free */
 703         g_object_unref (parent_folder);
 704
 705         return result;
 706 }
 707
 708 static gboolean
 709 _selected_folder_is_root_or_inbox (ModestMainWindow *win)
 710 {
 711         TnyFolderType types[2];
 712         gboolean result = FALSE;
 713
 714         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
 715
 716         types[0] = TNY_FOLDER_TYPE_ROOT;
 717         types[1] = TNY_FOLDER_TYPE_INBOX;
 718
 719         /* Check folder type */
 720         result = _selected_folder_is_any_of_type (MODEST_WINDOW(win), types, 2);
 721
 722         /* Check pop and MMC accounts */
 723         if (!result) {
 724                 result = _selected_folder_is_MMC_or_POP_root (win);
 725         }
 726
 727         return result;
 728 }
 729
 730
 731 static gboolean
 732 _selected_folder_is_root (ModestMainWindow *win)
 733 {
 734         TnyFolderType types[1];
 735         gboolean result = FALSE;
 736
 737         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
 738
 739         types[0] = TNY_FOLDER_TYPE_ROOT;
 740
 741         /* Check folder type */
 742         result = _selected_folder_is_any_of_type (MODEST_WINDOW(win), types, 1);
 743
 744         /* Check pop and MMC accounts */
 745         if (!result) {
 746                 result = _selected_folder_is_MMC_or_POP_root (win);
 747         }
 748
 749         return result;
 750 }
 751
 752 static gboolean
 753 _selected_folder_is_MMC_or_POP_root (ModestMainWindow *win)
 754 {
 755         GtkWidget *folder_view = NULL;
 756         TnyFolderStore *parent_folder = NULL;
 757         gboolean result = FALSE;
 758
 759         folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
 760                                                            MODEST_WIDGET_TYPE_FOLDER_VIEW);
 761         /* Get selected folder as parent of new folder to create */
 762         parent_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
 763         if (!parent_folder)
 764                 return TRUE;
 765
 766         if (TNY_IS_ACCOUNT (parent_folder)) {
 767                 /* If it's the local account then do not dim */
 768                 if (modest_tny_account_is_virtual_local_folders (
 769                                                                  TNY_ACCOUNT (parent_folder)))
 770                         return FALSE;
 771                 else {
 772                                 /* If it's the MMC root folder then dim it */
 773                         if (!strcmp (tny_account_get_id (TNY_ACCOUNT (parent_folder)), MODEST_MMC_ACCOUNT_ID)) {
 774                                         result = TRUE;
 775                         } else {
 776                                 const gchar *proto_str = tny_account_get_proto (TNY_ACCOUNT (parent_folder));
 777                                 /* If it's POP then dim */
 778                                 result = (modest_protocol_info_get_transport_store_protocol (proto_str) ==
 779                                                   MODEST_PROTOCOL_STORE_POP) ? TRUE : FALSE;
 780                         }
 781                 }
 782         }
 783
 784         return result;
 785 }
 786
 787
 788
 789
 790 static gboolean
 791 _selected_folder_is_empty (ModestMainWindow *win)
 792 {
 793         GtkWidget *folder_view = NULL;
 794         TnyFolderStore *folder = NULL;
 795         gboolean result = FALSE;
 796
 797         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
 798
 799         /* Get folder view */
 800         folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
 801                                                            MODEST_WIDGET_TYPE_FOLDER_VIEW);
 802         /* If no folder view, always dimmed */
 803         if (!folder_view)
 804                 return TRUE;
 805
 806         /* Get selected folder as parent of new folder to create */
 807         folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
 808         if (!(folder && TNY_IS_FOLDER(folder)))
 809                 return TRUE;
 810
 811         /* Check folder type */
 812         result = tny_folder_get_all_count (TNY_FOLDER (folder)) == 0;
 813
 814         /* free */
 815         g_object_unref (folder);
 816
 817         return result;
 818 }
 819
 820 static gboolean
 821 _selected_folder_is_any_of_type (ModestWindow *win,
 822                                  TnyFolderType types[],
 823                                  guint ntypes)
 824 {
 825         GtkWidget *folder_view = NULL;
 826         TnyFolderStore *folder = NULL;
 827         TnyFolderType folder_type;
 828         guint i=0;
 829         gboolean result = FALSE;
 830
 831         /*Get curent folder */
 832         if (MODEST_IS_MAIN_WINDOW(win)) {
 833
 834                 /* Get folder view */
 835                 folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
 836                                                                    MODEST_WIDGET_TYPE_FOLDER_VIEW);
 837                 /* If no folder view, always dimmed */
 838                 if (!folder_view)
 839                         return TRUE;
 840
 841                 /* Get selected folder as parent of new folder to create */
 842                 folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
 843
 844                 if (!(folder && TNY_IS_FOLDER(folder)))
 845                         return TRUE;
 846
 847                 /* Check folder type */
 848                 result = _folder_is_any_of_type (TNY_FOLDER(folder), types, ntypes);
 849         }
 850         else if (MODEST_IS_MSG_VIEW_WINDOW(win)) {
 851                 folder_type = modest_msg_view_window_get_folder_type (MODEST_MSG_VIEW_WINDOW (win));
 852                 for (i=0; i < ntypes; i++) {
 853                         result = result || folder_type == types[i];
 854                 }
 855         }
 856
 857
 858         /* free */
 859         g_object_unref (folder);
 860
 861         return result;
 862 }
 863
 864 static gboolean
 865 _folder_is_any_of_type (TnyFolder *folder,
 866                         TnyFolderType types[],
 867                         guint ntypes)
 868 {
 869         TnyFolderType folder_type;
 870         gboolean result = FALSE;
 871         guint i;
 872
 873         g_return_val_if_fail (TNY_IS_FOLDER(folder), FALSE);
 874
 875         /* Get folder type */
 876         if (modest_tny_folder_is_local_folder (folder))
 877                 folder_type = modest_tny_folder_get_local_folder_type (folder);
 878         else
 879                 folder_type = modest_tny_folder_guess_folder_type (folder);
 880
 881         /* Check foler type */
 882         for (i=0; i < ntypes; i++) {
 883                 result = result || folder_type == types[i];
 884         }
 885
 886         return result;
 887 }
 888
 889
 890
 891 static gboolean
 892 _invalid_clipboard_selected (ModestMsgViewWindow *win)
 893 {
 894         GtkClipboard *clipboard = NULL;
 895         gchar *selection = NULL;
 896         GtkWidget *focused = NULL;
 897         gboolean result = FALSE;
 898
 899         g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW (win), TRUE);
 900
 901         /* Get clipboard selection*/
 902         clipboard = gtk_clipboard_get (GDK_SELECTION_PRIMARY);
 903         selection = gtk_clipboard_wait_for_text (clipboard);
 904
 905         /* Get focuesed widget */
 906         focused = gtk_window_get_focus (GTK_WINDOW (win));
 907
 908         /* Check dimming */
 909         result = ((selection == NULL) ||
 910                   (MODEST_IS_ATTACHMENTS_VIEW (focused)));
 911
 912         return result;
 913 }
 914
 915 static gboolean
 916 _invalid_attach_selected (ModestWindow *win,
 917                           gboolean unique,
 918                           ModestDimmingRule *rule)
 919 {
 920         GList *attachments, *node;
 921         gint n_selected;
 922         TnyHeaderFlags flags;
 923         gboolean nested_attachments = FALSE;
 924         gboolean selected_messages = FALSE;
 925         gboolean result = FALSE;
 926
 927         if (MODEST_IS_MAIN_WINDOW (win)) {
 928                 flags = TNY_HEADER_FLAG_ATTACHMENTS;
 929                 if (!result)
 930                         result = _selected_msg_marked_as (win, flags, TRUE);
 931
 932         }
 933         else if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
 934
 935                 /* Get selected atachments */
 936                 attachments = modest_msg_view_window_get_attachments (MODEST_MSG_VIEW_WINDOW(win));
 937                 n_selected = g_list_length (attachments);
 938                 for (node = attachments; node != NULL; node = g_list_next (node)) {
 939                         TnyMimePart *mime_part = TNY_MIME_PART (node->data);
 940                         TnyList *nested_list = tny_simple_list_new ();
 941                         if (!tny_mime_part_is_attachment (mime_part)) {
 942                                 selected_messages = TRUE;
 943                                 break;
 944                         }
 945                         tny_mime_part_get_parts (mime_part, nested_list);
 946                         if (tny_list_get_length (nested_list) > 0)
 947                                 nested_attachments = TRUE;
 948                         g_object_unref (nested_list);
 949                 }
 950
 951                 /* Check unique */
 952                 if (unique)
 953                         result = n_selected != 1;
 954                 else
 955
 956                         result = n_selected == 1;
 957
 958                 /* Set notifications */
 959                 if (!result && rule != NULL) {
 960                         if (selected_messages) {
 961                                 modest_dimming_rule_set_notification (rule, _("mcen_ib_unable_to_save_attach_mail"));
 962                         } else if (nested_attachments) {
 963                                 modest_dimming_rule_set_notification (rule, _("FIXME:unable to save attachments with nested elements"));
 964                         } else if (n_selected == 0) {
 965                                 modest_dimming_rule_set_notification (rule, _("FIXME:no attachment selected"));
 966                         }
 967                 }
 968
 969                 /* Free */
 970                 g_list_free (attachments);
 971         }
 972
 973         return result;
 974 }
 975
 976 static gboolean
 977 _invalid_msg_selected (ModestMainWindow *win,
 978                        gboolean unique,
 979                        ModestDimmingRule *rule)
 980 {
 981         GtkWidget *header_view = NULL;
 982         GtkWidget *folder_view = NULL;
 983         TnyList *selected_headers = NULL;
 984         gboolean result = FALSE;
 985
 986         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
 987         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (rule), FALSE);
 988
 989         /* Get header view to check selected messages */
 990         header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
 991                                                            MODEST_WIDGET_TYPE_HEADER_VIEW);
 992
 993         /* Get folder view to check focus */
 994         folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
 995                                                            MODEST_WIDGET_TYPE_FOLDER_VIEW);
 996
 997         /* Get selected headers */
 998         selected_headers = modest_header_view_get_selected_headers (MODEST_HEADER_VIEW(header_view));
 999
1000         /* Check dimmed rule (TODO: check focus on widgets */
1001         if (!result) {
1002                 result = (selected_headers == NULL);
1003 /*              result = ((selected_headers == NULL) ||  */
1004 /*                        (GTK_WIDGET_HAS_FOCUS (folder_view))); */
1005                 if (result)
1006                         modest_dimming_rule_set_notification (rule, _("mcen_ib_no_message_selected"));
1007         }
1008         if (!result && unique) {
1009                 result = tny_list_get_length (selected_headers) > 1;
1010                 if (result)
1011                         modest_dimming_rule_set_notification (rule, _("mcen_ib_select_one_message"));
1012         }
1013
1014         /* free */
1015         if (selected_headers != NULL)
1016                 g_object_unref (selected_headers);
1017
1018         return result;
1019 }
1020
1021 static gboolean
1022 _already_opened_msg (ModestWindow *win)
1023 {
1024         ModestWindow *window = NULL;
1025         ModestWindowMgr *mgr = NULL;
1026         GtkWidget *header_view = NULL;
1027         TnyList *selected_headers = NULL;
1028         TnyIterator *iter = NULL;
1029         TnyHeader *header = NULL;
1030         gboolean result = TRUE;
1031
1032         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
1033
1034         /* Get header view to check selected messages */
1035         header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
1036                                                            MODEST_WIDGET_TYPE_HEADER_VIEW);
1037
1038         /* Get selected headers */
1039         selected_headers = modest_header_view_get_selected_headers (MODEST_HEADER_VIEW(header_view));
1040         if (selected_headers == NULL)
1041                 return FALSE;
1042
1043         /* Check dimmed rule (TODO: check focus on widgets */
1044         mgr = modest_runtime_get_window_mgr ();
1045         iter = tny_list_create_iterator (selected_headers);
1046         while (!tny_iterator_is_done (iter) && result) {
1047                 header = TNY_HEADER (tny_iterator_get_current (iter));
1048                 window = modest_window_mgr_find_window_by_header (mgr, header);
1049                 result = result && (window != NULL);
1050
1051                 g_object_unref (header);
1052                 tny_iterator_next (iter);
1053         }
1054
1055         /* free */
1056         if (selected_headers != NULL)
1057                 g_object_unref (selected_headers);
1058         if (iter != NULL)
1059                 g_object_unref (iter);
1060
1061         return result;
1062 }
1063
1064 static gboolean
1065 _selected_msg_marked_as (ModestWindow *win,
1066                          TnyHeaderFlags mask,
1067                          gboolean opposite)
1068 {
1069         GtkWidget *header_view = NULL;
1070         TnyList *selected_headers = NULL;
1071         TnyIterator *iter = NULL;
1072         TnyHeader *header = NULL;
1073         TnyHeaderFlags flags;
1074         gboolean result = FALSE;
1075
1076         /* Get header view to check selected messages */
1077         header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
1078                                                            MODEST_WIDGET_TYPE_HEADER_VIEW);
1079
1080         /* Get selected headers */
1081         selected_headers = modest_header_view_get_selected_headers (MODEST_HEADER_VIEW(header_view));
1082         if (selected_headers == NULL)
1083                 return TRUE;
1084
1085         /* Call the function for each header */
1086         iter = tny_list_create_iterator (selected_headers);
1087         while (!tny_iterator_is_done (iter) && !result) {
1088                 header = TNY_HEADER (tny_iterator_get_current (iter));
1089
1090                 flags = tny_header_get_flags (header);
1091                 if (opposite)
1092                         result = (flags & mask) == 0;
1093                 else
1094                         result = (flags & mask) != 0;
1095
1096                 g_object_unref (header);
1097                 tny_iterator_next (iter);
1098         }
1099
1100         /* free */
1101         if (selected_headers != NULL)
1102                 g_object_unref (selected_headers);
1103         if (iter != NULL)
1104                 g_object_unref (iter);
1105
1106         return result;
1107 }
1108
1109 static gboolean
1110 _msg_download_in_progress (ModestMsgViewWindow *win)
1111 {
1112         gboolean result = FALSE;
1113
1114         g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW (win), FALSE);
1115
1116         result = modest_msg_view_window_toolbar_on_transfer_mode (win);
1117
1118         return result;
1119 }
1120
1121 static gboolean
1122 _msg_download_completed (ModestMainWindow *win)
1123 {
1124         GtkWidget *header_view = NULL;
1125         TnyList *selected_headers = NULL;
1126         TnyIterator *iter = NULL;
1127         TnyHeader *header = NULL;
1128         TnyHeaderFlags flags;
1129         gboolean result = FALSE;
1130
1131         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW (win), FALSE);
1132
1133
1134         /* Get header view to check selected messages */
1135         header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
1136                                                            MODEST_WIDGET_TYPE_HEADER_VIEW);
1137
1138         /* Get selected headers */
1139         selected_headers = modest_header_view_get_selected_headers (MODEST_HEADER_VIEW(header_view));
1140         if (selected_headers == NULL)
1141                 return TRUE;
1142
1143         /* Check dimmed rule  */
1144         result = TRUE;
1145         iter = tny_list_create_iterator (selected_headers);
1146         while (!tny_iterator_is_done (iter) && result) {
1147                 header = TNY_HEADER (tny_iterator_get_current (iter));
1148
1149                 flags = tny_header_get_flags (header);
1150                 /* TODO: is this the right flag?, it seems that some
1151                    headers that have been previously downloaded do not
1152                    come with it */
1153                 result = (flags & TNY_HEADER_FLAG_CACHED);
1154
1155                 g_object_unref (header);
1156                 tny_iterator_next (iter);
1157         }
1158
1159         g_object_unref (iter);
1160
1161         return result;
1162 }
1163
1164 static gboolean
1165 _selected_msg_sent_in_progress (ModestWindow *win)
1166 {
1167         ModestTnySendQueue *send_queue = NULL;
1168         GtkWidget *header_view = NULL;
1169         ModestTnyAccountStore *acc_store = NULL;
1170         TnyAccount *account = NULL;
1171         TnyList *header_list = NULL;
1172         TnyIterator *iter = NULL;
1173         TnyHeader *header = NULL;
1174         const gchar *account_name = NULL;
1175         gboolean result = FALSE;
1176         gchar *id = NULL;
1177
1178         /* Get transport account */
1179         acc_store = modest_runtime_get_account_store();
1180         account_name = modest_window_get_active_account (win);
1181
1182         /* If no account defined, this action must be always dimmed  */
1183         if (account_name == NULL) return FALSE;
1184         account = modest_tny_account_store_get_transport_account_for_open_connection (acc_store, account_name);
1185         if (!TNY_IS_TRANSPORT_ACCOUNT (account)) return FALSE;
1186
1187         /* Get send queue for current ransport account */
1188         send_queue = modest_runtime_get_send_queue (TNY_TRANSPORT_ACCOUNT(account));
1189         g_return_val_if_fail (MODEST_IS_TNY_SEND_QUEUE (send_queue), FALSE);
1190
1191         if (MODEST_IS_MAIN_WINDOW(win)) {
1192
1193                 /* Get header view to check selected messages */
1194                 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
1195                                                                    MODEST_WIDGET_TYPE_HEADER_VIEW);
1196
1197                 /* Get selected headers */
1198                 header_list = modest_header_view_get_selected_headers (MODEST_HEADER_VIEW(header_view));
1199
1200                 /* Get message header */
1201                 if (!header_list) return FALSE;
1202                 iter = tny_list_create_iterator (header_list);
1203                 header = TNY_HEADER (tny_iterator_get_current (iter));
1204
1205                 /* Get message id */
1206                 id = g_strdup(tny_header_get_message_id (header));
1207
1208         } else if (MODEST_IS_MSG_VIEW_WINDOW(win)) {
1209
1210                 /* Get message header */
1211                 header = modest_msg_view_window_get_header (MODEST_MSG_VIEW_WINDOW(win));
1212
1213                 /* Get message id */
1214                 id = g_strdup(tny_header_get_message_id (header));
1215         }
1216
1217         /* Check if msg id is being processed inside send queue */
1218         result = modest_tny_send_queue_msg_is_being_sent (send_queue, id);
1219
1220         /* Free */
1221         g_free(id);
1222         g_object_unref (header);
1223         g_free(header_list);
1224         g_free(iter);
1225
1226         return result;
1227 }
1228
1229
1230 static gboolean
1231 _sending_in_progress (ModestWindow *win)
1232 {
1233         ModestTnySendQueue *send_queue = NULL;
1234         ModestTnyAccountStore *acc_store = NULL;
1235         TnyAccount *account = NULL;
1236         const gchar *account_name = NULL;
1237         gboolean result = FALSE;
1238
1239         /* Get transport account */
1240         acc_store = modest_runtime_get_account_store();
1241         account_name = modest_window_get_active_account (win);
1242
1243         /* If no account defined, this action must be always dimmed  */
1244         if (account_name == NULL) return FALSE;
1245         account = modest_tny_account_store_get_transport_account_for_open_connection (acc_store, account_name);
1246         if (!TNY_IS_TRANSPORT_ACCOUNT (account)) return FALSE;
1247
1248         /* Get send queue for current ransport account */
1249         send_queue = modest_runtime_get_send_queue (TNY_TRANSPORT_ACCOUNT(account));
1250         g_return_val_if_fail (MODEST_IS_TNY_SEND_QUEUE (send_queue), FALSE);
1251
1252         /* Check if send queue is perfimring any send operation */
1253         result = modest_tny_send_queue_sending_in_progress (send_queue);
1254
1255         return result;
1256 }