git.maemo.org Git - modest/blob - src/modest-ui-dimming-rules.c

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