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