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

   1 /* Copyright (c) 2006, Nokia Corporation
   2  * All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions are
   6  * met:
   7  *
   8  * * Redistributions of source code must retain the above copyright
   9  *   notice, this list of conditions and the following disclaimer.
  10  * * Redistributions in binary form must reproduce the above copyright
  11  *   notice, this list of conditions and the following disclaimer in the
  12  *   documentation and/or other materials provided with the distribution.
  13  * * Neither the name of the Nokia Corporation nor the names of its
  14  *   contributors may be used to endorse or promote products derived from
  15  *   this software without specific prior written permission.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
  18  * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  19  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
  20  * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
  21  * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  22  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  23  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  24  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  25  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  26  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  27  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  28  */
  29
  30 #ifdef HAVE_CONFIG_H
  31 #include <config.h>
  32 #endif /*HAVE_CONFIG_H*/
  33
  34 #include <string.h>
  35 #include "modest-ui-dimming-rules.h"
  36 #include "modest-dimming-rule.h"
  37 #include "modest-tny-folder.h"
  38 #include "modest-text-utils.h"
  39 #include <widgets/modest-attachments-view.h>
  40 #include <modest-runtime.h>
  41 #include <tny-simple-list.h>
  42
  43
  44 static gboolean _folder_is_any_of_type (TnyFolder *folder, TnyFolderType types[], guint ntypes);
  45 static gboolean _invalid_msg_selected (ModestMainWindow *win, gboolean unique, ModestDimmingRule *rule);
  46 static gboolean _invalid_attach_selected (ModestWindow *win, gboolean unique, ModestDimmingRule *rule);
  47 static gboolean _invalid_clipboard_selected (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, _("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, 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, 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, FALSE, NULL);
 581                 if (dimmed)
 582                         modest_dimming_rule_set_notification (rule, _("mcen_ib_unable_to_display_more"));
 583         }
 584
 585         return dimmed;
 586 }
 587
 588 gboolean
 589 modest_ui_dimming_rules_on_copy (ModestWindow *win, gpointer user_data)
 590 {
 591         gboolean dimmed = FALSE;
 592
 593         g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW(win), FALSE);
 594
 595         /* Check dimmed rule */
 596         if (!dimmed)
 597                 dimmed = _invalid_clipboard_selected (win);
 598
 599         return dimmed;
 600 }
 601
 602 gboolean
 603 modest_ui_dimming_rules_on_view_previous (ModestWindow *win, gpointer user_data)
 604 {
 605         gboolean dimmed = FALSE;
 606
 607         g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW(win), FALSE);
 608
 609         /* Check dimmed rule */
 610         if (!dimmed)
 611                 dimmed = modest_msg_view_window_first_message_selected (MODEST_MSG_VIEW_WINDOW(win));
 612
 613         return dimmed;
 614 }
 615
 616 gboolean
 617 modest_ui_dimming_rules_on_view_next (ModestWindow *win, gpointer user_data)
 618 {
 619         gboolean dimmed = FALSE;
 620
 621         g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW(win), FALSE);
 622
 623         /* Check dimmed rule */
 624         if (!dimmed)
 625                 dimmed = modest_msg_view_window_last_message_selected (MODEST_MSG_VIEW_WINDOW(win));
 626
 627         return dimmed;
 628 }
 629
 630
 631 gboolean
 632 modest_ui_dimming_rules_on_tools_smtp_servers (ModestWindow *win, gpointer user_data)
 633 {
 634         const gboolean dimmed =
 635                 !modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(),
 636                         TRUE);
 637
 638         return dimmed;
 639 }
 640
 641 gboolean
 642 modest_ui_dimming_rules_on_cancel_sending (ModestWindow *win, gpointer user_data)
 643 {
 644         gboolean dimmed = FALSE;
 645
 646         /* Check dimmed rule */
 647         if (!dimmed)
 648                 dimmed = !_sending_in_progress (win);
 649
 650         return dimmed;
 651 }
 652
 653 gboolean
 654 modest_ui_dimming_rules_on_send_receive (ModestWindow *win, gpointer user_data)
 655 {
 656         ModestDimmingRule *rule = NULL;
 657         gboolean dimmed = FALSE;
 658
 659         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 660         rule = MODEST_DIMMING_RULE (user_data);
 661
 662         /* Check dimmed rule */
 663         if (!dimmed) {
 664                 dimmed = !modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(),
 665                                                           TRUE);
 666                 if (dimmed)
 667                         modest_dimming_rule_set_notification (rule, _("mcen_nc_no_email_acnts_defined"));
 668         }
 669
 670         return dimmed;
 671 }
 672
 673 gboolean
 674 modest_ui_dimming_rules_on_add_to_contacts (ModestWindow *win, gpointer user_data)
 675 {
 676         ModestDimmingRule *rule = NULL;
 677         gboolean dimmed = FALSE;
 678
 679         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 680         rule = MODEST_DIMMING_RULE (user_data);
 681
 682         /* Check dimmed rule */
 683         if (!dimmed) {
 684                 GtkClipboard *clipboard = gtk_clipboard_get (GDK_SELECTION_PRIMARY);
 685                 gchar *selection = NULL;
 686                 selection = gtk_clipboard_wait_for_text (clipboard);
 687
 688                 dimmed = !((selection != NULL) && (modest_text_utils_validate_recipient (selection)));
 689         }
 690
 691         return dimmed;
 692 }
 693
 694 /* *********************** static utility functions ******************** */
 695
 696 static gboolean
 697 _marked_as_deleted (ModestWindow *win)
 698 {
 699         gboolean result = FALSE;
 700         TnyHeaderFlags flags;
 701
 702         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
 703
 704         flags = TNY_HEADER_FLAG_DELETED;
 705
 706         /* Check dimmed rule */
 707         result = _selected_msg_marked_as (win, flags, FALSE);
 708
 709         return result;
 710 }
 711
 712 static gboolean
 713 _selected_folder_not_writeable (ModestMainWindow *win)
 714 {
 715         GtkWidget *folder_view = NULL;
 716         TnyFolderStore *parent_folder = NULL;
 717         ModestTnyFolderRules rules;
 718         gboolean result = FALSE;
 719
 720         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
 721
 722         /* Get folder view */
 723         folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
 724                                                            MODEST_WIDGET_TYPE_FOLDER_VIEW);
 725         /* If no folder view, always dimmed */
 726         if (!folder_view)
 727                 return TRUE;
 728
 729         /* Get selected folder as parent of new folder to create */
 730         parent_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
 731         if (!(parent_folder && TNY_IS_FOLDER(parent_folder))) {
 732                 if (parent_folder)
 733                         g_object_unref (parent_folder);
 734                 return TRUE;
 735         }
 736
 737         /* Check dimmed rule */
 738         rules = modest_tny_folder_get_rules (TNY_FOLDER (parent_folder));
 739         result = rules & MODEST_FOLDER_RULES_FOLDER_NON_WRITEABLE;
 740
 741         /* free */
 742         g_object_unref (parent_folder);
 743
 744         return result;
 745 }
 746
 747 static gboolean
 748 _selected_folder_is_root_or_inbox (ModestMainWindow *win)
 749 {
 750         TnyFolderType types[2];
 751         gboolean result = FALSE;
 752
 753         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
 754
 755         types[0] = TNY_FOLDER_TYPE_ROOT;
 756         types[1] = TNY_FOLDER_TYPE_INBOX;
 757
 758         /* Check folder type */
 759         result = _selected_folder_is_any_of_type (MODEST_WINDOW(win), types, 2);
 760
 761         /* Check pop and MMC accounts */
 762         if (!result) {
 763                 result = _selected_folder_is_MMC_or_POP_root (win);
 764         }
 765
 766         return result;
 767 }
 768
 769
 770 static gboolean
 771 _selected_folder_is_root (ModestMainWindow *win)
 772 {
 773         TnyFolderType types[1];
 774         gboolean result = FALSE;
 775
 776         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
 777
 778         types[0] = TNY_FOLDER_TYPE_ROOT;
 779
 780         /* Check folder type */
 781         result = _selected_folder_is_any_of_type (MODEST_WINDOW(win), types, 1);
 782
 783         /* Check pop and MMC accounts */
 784         if (!result) {
 785                 result = _selected_folder_is_MMC_or_POP_root (win);
 786         }
 787
 788         return result;
 789 }
 790
 791 static gboolean
 792 _selected_folder_is_MMC_or_POP_root (ModestMainWindow *win)
 793 {
 794         GtkWidget *folder_view = NULL;
 795         TnyFolderStore *parent_folder = NULL;
 796         gboolean result = FALSE;
 797
 798         folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
 799                                                            MODEST_WIDGET_TYPE_FOLDER_VIEW);
 800         /* Get selected folder as parent of new folder to create */
 801         parent_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
 802         if (!parent_folder)
 803                 return TRUE;
 804
 805         if (TNY_IS_ACCOUNT (parent_folder)) {
 806                 /* If it's the local account then do not dim */
 807                 if (modest_tny_account_is_virtual_local_folders (TNY_ACCOUNT (parent_folder))) {
 808                         result = FALSE;
 809                 } else {
 810                                 /* If it's the MMC root folder then dim it */
 811                         if (!strcmp (tny_account_get_id (TNY_ACCOUNT (parent_folder)), MODEST_MMC_ACCOUNT_ID)) {
 812                                         result = TRUE;
 813                         } else {
 814                                 const gchar *proto_str = tny_account_get_proto (TNY_ACCOUNT (parent_folder));
 815                                 /* If it's POP then dim */
 816                                 result = (modest_protocol_info_get_transport_store_protocol (proto_str) ==
 817                                                   MODEST_PROTOCOL_STORE_POP) ? TRUE : FALSE;
 818                         }
 819                 }
 820         }
 821         g_object_unref (parent_folder);
 822
 823         return result;
 824 }
 825
 826
 827
 828
 829 static gboolean
 830 _selected_folder_is_empty (ModestMainWindow *win)
 831 {
 832         GtkWidget *folder_view = NULL;
 833         TnyFolderStore *folder = NULL;
 834         gboolean result = FALSE;
 835
 836         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
 837
 838         /* Get folder view */
 839         folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
 840                                                            MODEST_WIDGET_TYPE_FOLDER_VIEW);
 841         /* If no folder view, always dimmed */
 842         if (!folder_view)
 843                 return TRUE;
 844
 845         /* Get selected folder as parent of new folder to create */
 846         folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
 847         if (!(folder && TNY_IS_FOLDER(folder))) {
 848                 if (folder)
 849                         g_object_unref (folder);
 850                 return TRUE;
 851         }
 852
 853         /* Check folder type */
 854         result = tny_folder_get_all_count (TNY_FOLDER (folder)) == 0;
 855
 856         /* free */
 857         g_object_unref (folder);
 858
 859         return result;
 860 }
 861
 862 static gboolean
 863 _selected_folder_is_same_as_source (ModestWindow *win)
 864 {
 865         ModestEmailClipboard *clipboard = NULL;
 866         GtkWidget *folder_view = NULL;
 867         TnyFolderStore *folder = NULL;
 868         gboolean result = FALSE;
 869
 870         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
 871
 872         /* Get folder view */
 873         folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
 874                                                            MODEST_WIDGET_TYPE_FOLDER_VIEW);
 875         if (!folder_view)
 876                 return FALSE;
 877
 878         /* Get selected folder as destination folder */
 879         folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
 880         if (!(folder && TNY_IS_FOLDER(folder))) {
 881                 result = FALSE;
 882                 goto frees;
 883         }
 884
 885         /* Check clipboard is cleared */
 886         clipboard = modest_runtime_get_email_clipboard ();
 887         if (modest_email_clipboard_cleared (clipboard)) {
 888                 result = FALSE;
 889                 goto frees;
 890         }
 891
 892         /* Check source folder */
 893         result = modest_email_clipboard_check_source_folder (clipboard,
 894                                                              (const TnyFolder *) folder);
 895
 896         /* Free */
 897  frees:
 898         g_object_unref (folder);
 899
 900         return result;
 901 }
 902
 903 static gboolean
 904 _selected_folder_is_any_of_type (ModestWindow *win,
 905                                  TnyFolderType types[],
 906                                  guint ntypes)
 907 {
 908         GtkWidget *folder_view = NULL;
 909         TnyFolderStore *folder = NULL;
 910         TnyFolderType folder_type;
 911         guint i=0;
 912         gboolean result = FALSE;
 913
 914         /*Get curent folder */
 915         if (MODEST_IS_MAIN_WINDOW(win)) {
 916
 917                 /* Get folder view */
 918                 folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
 919                                                                    MODEST_WIDGET_TYPE_FOLDER_VIEW);
 920                 /* If no folder view, always dimmed */
 921                 if (!folder_view)
 922                         return TRUE;
 923
 924                 /* Get selected folder as parent of new folder to create */
 925                 folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
 926
 927                 if (!(folder && TNY_IS_FOLDER(folder))) {
 928                         if (folder)
 929                                 g_object_unref (folder);
 930                         return TRUE;
 931                 }
 932
 933                 /* Check folder type */
 934                 result = _folder_is_any_of_type (TNY_FOLDER(folder), types, ntypes);
 935         }
 936         else if (MODEST_IS_MSG_VIEW_WINDOW(win)) {
 937                 folder_type = modest_msg_view_window_get_folder_type (MODEST_MSG_VIEW_WINDOW (win));
 938                 for (i=0; i < ntypes; i++) {
 939                         result = result || folder_type == types[i];
 940                 }
 941         }
 942
 943
 944         /* free */
 945         g_object_unref (folder);
 946
 947         return result;
 948 }
 949
 950 static gboolean
 951 _folder_is_any_of_type (TnyFolder *folder,
 952                         TnyFolderType types[],
 953                         guint ntypes)
 954 {
 955         TnyFolderType folder_type;
 956         gboolean result = FALSE;
 957         guint i;
 958
 959         g_return_val_if_fail (TNY_IS_FOLDER(folder), FALSE);
 960
 961         /* Get folder type */
 962         if (modest_tny_folder_is_local_folder (folder))
 963                 folder_type = modest_tny_folder_get_local_folder_type (folder);
 964         else
 965                 folder_type = modest_tny_folder_guess_folder_type (folder);
 966
 967         /* Check foler type */
 968         for (i=0; i < ntypes; i++) {
 969                 result = result || folder_type == types[i];
 970         }
 971
 972         return result;
 973 }
 974
 975
 976
 977 static gboolean
 978 _invalid_clipboard_selected (ModestWindow *win)
 979 {
 980         gboolean result = FALSE;
 981
 982         if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
 983                 GtkClipboard *clipboard = NULL;
 984                 gchar *selection = NULL;
 985                 GtkWidget *focused = NULL;
 986
 987                 /* Get clipboard selection*/
 988                 clipboard = gtk_clipboard_get (GDK_SELECTION_PRIMARY);
 989                 selection = gtk_clipboard_wait_for_text (clipboard);
 990
 991                 /* Get focuesed widget */
 992                 focused = gtk_window_get_focus (GTK_WINDOW (win));
 993
 994                 /* Check dimming */
 995                 result = ((selection == NULL) ||
 996                           (MODEST_IS_ATTACHMENTS_VIEW (focused)));
 997         }
 998         else if (MODEST_IS_MAIN_WINDOW (win)) {
 999                 ModestEmailClipboard *clipboard = NULL;
1000
1001                 clipboard = modest_runtime_get_email_clipboard ();
1002                 if (modest_email_clipboard_cleared (clipboard))
1003                         result = TRUE;
1004         }
1005
1006         return result;
1007 }
1008
1009 static gboolean
1010 _invalid_attach_selected (ModestWindow *win,
1011                           gboolean unique,
1012                           ModestDimmingRule *rule)
1013 {
1014         GList *attachments, *node;
1015         gint n_selected;
1016         TnyHeaderFlags flags;
1017         gboolean nested_attachments = FALSE;
1018         gboolean selected_messages = FALSE;
1019         gboolean result = FALSE;
1020
1021         if (MODEST_IS_MAIN_WINDOW (win)) {
1022                 flags = TNY_HEADER_FLAG_ATTACHMENTS;
1023                 if (!result)
1024                         result = _selected_msg_marked_as (win, flags, TRUE);
1025
1026         }
1027         else if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
1028
1029                 /* Get selected atachments */
1030                 attachments = modest_msg_view_window_get_attachments (MODEST_MSG_VIEW_WINDOW(win));
1031                 n_selected = g_list_length (attachments);
1032                 for (node = attachments; node != NULL; node = g_list_next (node)) {
1033                         TnyMimePart *mime_part = TNY_MIME_PART (node->data);
1034                         TnyList *nested_list = tny_simple_list_new ();
1035                         if (!tny_mime_part_is_attachment (mime_part)) {
1036                                 selected_messages = TRUE;
1037                                 break;
1038                         }
1039                         tny_mime_part_get_parts (mime_part, nested_list);
1040                         if (tny_list_get_length (nested_list) > 0)
1041                                 nested_attachments = TRUE;
1042                         g_object_unref (nested_list);
1043                 }
1044
1045                 /* Check unique */
1046                 if (unique)
1047                         result = n_selected != 1;
1048                 else
1049
1050                         result = n_selected < 1;
1051
1052                 /* Set notifications */
1053                 if (!result && rule != NULL) {
1054                         if (selected_messages) {
1055                                 modest_dimming_rule_set_notification (rule, _("mcen_ib_unable_to_save_attach_mail"));
1056                         } else if (nested_attachments) {
1057                                 modest_dimming_rule_set_notification (rule, _("FIXME:unable to save attachments with nested elements"));
1058                         } else if (n_selected == 0) {
1059                                 modest_dimming_rule_set_notification (rule, _("FIXME:no attachment selected"));
1060                         }
1061                 }
1062
1063                 /* Free */
1064                 g_list_free (attachments);
1065         }
1066
1067         return result;
1068 }
1069
1070 static gboolean
1071 _invalid_msg_selected (ModestMainWindow *win,
1072                        gboolean unique,
1073                        ModestDimmingRule *rule)
1074 {
1075         GtkWidget *header_view = NULL;
1076         GtkWidget *folder_view = NULL;
1077         gboolean selected_headers = FALSE;
1078         gboolean result = FALSE;
1079
1080         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
1081         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (rule), FALSE);
1082
1083         /* Get header view to check selected messages */
1084         header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
1085                                                            MODEST_WIDGET_TYPE_HEADER_VIEW);
1086
1087         /* Get folder view to check focus */
1088         folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
1089                                                            MODEST_WIDGET_TYPE_FOLDER_VIEW);
1090
1091         /* Get selected headers */
1092         selected_headers = modest_header_view_has_selected_headers (MODEST_HEADER_VIEW(header_view));
1093
1094         /* Check dimmed rule (TODO: check focus on widgets */
1095         if (!result) {
1096                 result = ((!selected_headers) ||
1097                           (gtk_widget_is_focus (folder_view)));
1098                 if (result)
1099                         modest_dimming_rule_set_notification (rule, _("mcen_ib_no_message_selected"));
1100         }
1101         if (!result && unique) {
1102                 result = modest_header_view_count_selected_headers (MODEST_HEADER_VIEW(header_view)) > 1;
1103                 if (result)
1104                         modest_dimming_rule_set_notification (rule, _("mcen_ib_select_one_message"));
1105         }
1106
1107         return result;
1108 }
1109
1110 static gboolean
1111 _already_opened_msg (ModestWindow *win)
1112 {
1113         ModestWindow *window = NULL;
1114         ModestWindowMgr *mgr = NULL;
1115         GtkWidget *header_view = NULL;
1116         TnyList *selected_headers = NULL;
1117         TnyIterator *iter = NULL;
1118         TnyHeader *header = NULL;
1119         gboolean result = TRUE;
1120
1121         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
1122
1123         /* Get header view to check selected messages */
1124         header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
1125                                                            MODEST_WIDGET_TYPE_HEADER_VIEW);
1126
1127
1128         /* Check no selection */
1129         if (!modest_header_view_has_selected_headers (MODEST_HEADER_VIEW(header_view)))
1130             return FALSE;
1131
1132         /* Get selected headers */
1133         selected_headers = modest_header_view_get_selected_headers (MODEST_HEADER_VIEW(header_view));
1134         if (selected_headers == NULL)
1135                 return FALSE;
1136
1137         /* Check dimmed rule (TODO: check focus on widgets */
1138         mgr = modest_runtime_get_window_mgr ();
1139         iter = tny_list_create_iterator (selected_headers);
1140         while (!tny_iterator_is_done (iter) && result) {
1141                 header = TNY_HEADER (tny_iterator_get_current (iter));
1142                 window = modest_window_mgr_find_window_by_header (mgr, header);
1143                 result = result && (window != NULL);
1144
1145                 g_object_unref (header);
1146                 tny_iterator_next (iter);
1147         }
1148
1149         /* free */
1150         if (selected_headers != NULL)
1151                 g_object_unref (selected_headers);
1152         if (iter != NULL)
1153                 g_object_unref (iter);
1154
1155         return result;
1156 }
1157
1158 static gboolean
1159 _selected_msg_marked_as (ModestWindow *win,
1160                          TnyHeaderFlags mask,
1161                          gboolean opposite)
1162 {
1163         GtkWidget *header_view = NULL;
1164         TnyList *selected_headers = NULL;
1165         TnyIterator *iter = NULL;
1166         TnyHeader *header = NULL;
1167         TnyHeaderFlags flags;
1168         gboolean result = FALSE;
1169
1170         /* Get header view to check selected messages */
1171         header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
1172                                                            MODEST_WIDGET_TYPE_HEADER_VIEW);
1173
1174         /* Check no selection */
1175         if (!modest_header_view_has_selected_headers (MODEST_HEADER_VIEW(header_view)))
1176             return TRUE;
1177
1178         /* Get selected headers */
1179         selected_headers = modest_header_view_get_selected_headers (MODEST_HEADER_VIEW(header_view));
1180         if (selected_headers == NULL)
1181                 return TRUE;
1182
1183         /* Call the function for each header */
1184         iter = tny_list_create_iterator (selected_headers);
1185         while (!tny_iterator_is_done (iter) && !result) {
1186                 header = TNY_HEADER (tny_iterator_get_current (iter));
1187
1188                 flags = tny_header_get_flags (header);
1189                 if (opposite)
1190                         result = (flags & mask) == 0;
1191                 else
1192                         result = (flags & mask) != 0;
1193
1194                 g_object_unref (header);
1195                 tny_iterator_next (iter);
1196         }
1197
1198         /* free */
1199         if (selected_headers != NULL)
1200                 g_object_unref (selected_headers);
1201         if (iter != NULL)
1202                 g_object_unref (iter);
1203
1204         return result;
1205 }
1206
1207 static gboolean
1208 _msg_download_in_progress (ModestMsgViewWindow *win)
1209 {
1210         gboolean result = FALSE;
1211
1212         g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW (win), FALSE);
1213
1214         result = modest_msg_view_window_toolbar_on_transfer_mode (win);
1215
1216         return result;
1217 }
1218
1219 static gboolean
1220 _msg_download_completed (ModestMainWindow *win)
1221 {
1222         GtkWidget *header_view = NULL;
1223         TnyList *selected_headers = NULL;
1224         TnyIterator *iter = NULL;
1225         TnyHeader *header = NULL;
1226         TnyHeaderFlags flags;
1227         gboolean result = FALSE;
1228
1229         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW (win), FALSE);
1230
1231
1232         /* Get header view to check selected messages */
1233         header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
1234                                                            MODEST_WIDGET_TYPE_HEADER_VIEW);
1235
1236         /* Check no selection */
1237         if (!modest_header_view_has_selected_headers (MODEST_HEADER_VIEW(header_view)))
1238             return TRUE;
1239
1240         /* Get selected headers */
1241         selected_headers = modest_header_view_get_selected_headers (MODEST_HEADER_VIEW(header_view));
1242         if (selected_headers == NULL)
1243                 return TRUE;
1244
1245         /* Check dimmed rule  */
1246         result = TRUE;
1247         iter = tny_list_create_iterator (selected_headers);
1248         while (!tny_iterator_is_done (iter) && result) {
1249                 header = TNY_HEADER (tny_iterator_get_current (iter));
1250
1251                 flags = tny_header_get_flags (header);
1252                 /* TODO: is this the right flag?, it seems that some
1253                    headers that have been previously downloaded do not
1254                    come with it */
1255                 result = (flags & TNY_HEADER_FLAG_CACHED);
1256
1257                 g_object_unref (header);
1258                 tny_iterator_next (iter);
1259         }
1260
1261         g_object_unref (iter);
1262
1263         return result;
1264 }
1265
1266 static gboolean
1267 _selected_msg_sent_in_progress (ModestWindow *win)
1268 {
1269         ModestTnySendQueue *send_queue = NULL;
1270         GtkWidget *header_view = NULL;
1271         ModestTnyAccountStore *acc_store = NULL;
1272         TnyAccount *account = NULL;
1273         TnyList *header_list = NULL;
1274         TnyIterator *iter = NULL;
1275         TnyHeader *header = NULL;
1276         const gchar *account_name = NULL;
1277         gboolean result = FALSE;
1278         gchar *id = NULL;
1279
1280         /* Get transport account */
1281         acc_store = modest_runtime_get_account_store();
1282         account_name = modest_window_get_active_account (win);
1283
1284         /* If no account defined, this action must be always dimmed  */
1285         if (account_name == NULL) return FALSE;
1286         account = modest_tny_account_store_get_transport_account_for_open_connection (acc_store, account_name);
1287         if (!TNY_IS_TRANSPORT_ACCOUNT (account)) return FALSE;
1288
1289         /* Get send queue for current ransport account */
1290         send_queue = modest_runtime_get_send_queue (TNY_TRANSPORT_ACCOUNT(account));
1291         g_return_val_if_fail (MODEST_IS_TNY_SEND_QUEUE (send_queue), FALSE);
1292
1293         if (MODEST_IS_MAIN_WINDOW(win)) {
1294
1295                 /* Get header view to check selected messages */
1296                 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
1297                                                                    MODEST_WIDGET_TYPE_HEADER_VIEW);
1298
1299                 /* Check no selection */
1300                 if (!modest_header_view_has_selected_headers (MODEST_HEADER_VIEW(header_view)))
1301                     return FALSE;
1302
1303                 /* Get selected headers */
1304                 header_list = modest_header_view_get_selected_headers (MODEST_HEADER_VIEW(header_view));
1305
1306                 /* Get message header */
1307                 if (!header_list) return FALSE;
1308                 iter = tny_list_create_iterator (header_list);
1309                 header = TNY_HEADER (tny_iterator_get_current (iter));
1310
1311                 /* Get message id */
1312                 id = g_strdup(tny_header_get_message_id (header));
1313
1314         } else if (MODEST_IS_MSG_VIEW_WINDOW(win)) {
1315
1316                 /* Get message header */
1317                 header = modest_msg_view_window_get_header (MODEST_MSG_VIEW_WINDOW(win));
1318
1319                 /* Get message id */
1320                 id = g_strdup(tny_header_get_message_id (header));
1321         }
1322
1323         /* Check if msg id is being processed inside send queue */
1324         result = modest_tny_send_queue_msg_is_being_sent (send_queue, id);
1325
1326         /* Free */
1327         g_free(id);
1328         g_object_unref (header);
1329         g_object_unref(header_list);
1330         g_object_unref(iter);
1331
1332         return result;
1333 }
1334
1335
1336 static gboolean
1337 _sending_in_progress (ModestWindow *win)
1338 {
1339         ModestTnySendQueue *send_queue = NULL;
1340         ModestTnyAccountStore *acc_store = NULL;
1341         TnyAccount *account = NULL;
1342         const gchar *account_name = NULL;
1343         gboolean result = FALSE;
1344
1345         /* Get transport account */
1346         acc_store = modest_runtime_get_account_store();
1347         account_name = modest_window_get_active_account (win);
1348
1349         /* If no account defined, this action must be always dimmed  */
1350         if (account_name == NULL) return FALSE;
1351         account = modest_tny_account_store_get_transport_account_for_open_connection (acc_store, account_name);
1352         if (!TNY_IS_TRANSPORT_ACCOUNT (account)) return FALSE;
1353
1354         /* Get send queue for current ransport account */
1355         send_queue = modest_runtime_get_send_queue (TNY_TRANSPORT_ACCOUNT(account));
1356         g_return_val_if_fail (MODEST_IS_TNY_SEND_QUEUE (send_queue), FALSE);
1357
1358         /* Check if send queue is perfimring any send operation */
1359         result = modest_tny_send_queue_sending_in_progress (send_queue);
1360
1361         return result;
1362 }