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