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 _purged_attach_selected (ModestWindow *win, gboolean all, ModestDimmingRule *rule);
  48 static gboolean _clipboard_is_empty (ModestWindow *win);
  49 static gboolean _invalid_clipboard_selected (ModestWindow *win, ModestDimmingRule *rule);
  50 static gboolean _already_opened_msg (ModestWindow *win, guint *n_messages);
  51 static gboolean _selected_msg_marked_as (ModestWindow *win, TnyHeaderFlags mask, gboolean opposite);
  52 static gboolean _selected_folder_not_writeable (ModestMainWindow *win);
  53 static gboolean _selected_folder_is_snd_level (ModestMainWindow *win);
  54 static gboolean _selected_folder_is_any_of_type (ModestWindow *win, TnyFolderType types[], guint ntypes);
  55 static gboolean _selected_folder_is_root_or_inbox (ModestMainWindow *win);
  56 static gboolean _selected_folder_is_MMC_or_POP_root (ModestMainWindow *win);
  57 static gboolean _selected_folder_is_root (ModestMainWindow *win);
  58 static gboolean _selected_folder_is_empty (ModestMainWindow *win);
  59 static gboolean _selected_folder_is_same_as_source (ModestWindow *win);
  60 static gboolean _msg_download_in_progress (ModestMsgViewWindow *win);
  61 static gboolean _msg_download_completed (ModestMainWindow *win);
  62 static gboolean _selected_msg_sent_in_progress (ModestWindow *win);
  63 static gboolean _sending_in_progress (ModestWindow *win);
  64 static gboolean _marked_as_deleted (ModestWindow *win);
  65 static gboolean _invalid_folder_for_purge (ModestWindow *win, ModestDimmingRule *rule);
  66 static gboolean _transfer_mode_enabled (ModestWindow *win);
  67
  68
  69 gboolean
  70 modest_ui_dimming_rules_on_new_msg (ModestWindow *win, gpointer user_data)
  71 {
  72         ModestDimmingRule *rule = NULL;
  73         gboolean dimmed = FALSE;
  74
  75         g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW(win), FALSE);
  76         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
  77         rule = MODEST_DIMMING_RULE (user_data);
  78
  79         /* Check dimmed rule */
  80         if (!dimmed) {
  81                 dimmed = _msg_download_in_progress (MODEST_MSG_VIEW_WINDOW(win));
  82                 if (dimmed)
  83                         modest_dimming_rule_set_notification (rule, "");
  84         }
  85
  86         return dimmed;
  87 }
  88
  89 gboolean
  90 modest_ui_dimming_rules_on_csm_new_folder (ModestWindow *win, gpointer user_data)
  91 {
  92         ModestDimmingRule *rule = NULL;
  93         gboolean dimmed = FALSE;
  94
  95         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
  96         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
  97         rule = MODEST_DIMMING_RULE (user_data);
  98
  99         /* Check common new folder menu item dimming rules */
 100         dimmed = modest_ui_dimming_rules_on_new_folder (win, user_data);
 101
 102         /* Check CSM specific dimming rules */
 103         if (!dimmed) {
 104                 dimmed = _selected_folder_is_snd_level (MODEST_MAIN_WINDOW(win));
 105                 if (dimmed)
 106                         modest_dimming_rule_set_notification (rule, _("mail_in_ui_folder_create_error"));
 107         }
 108
 109         return dimmed;
 110 }
 111
 112 gboolean
 113 modest_ui_dimming_rules_on_new_folder (ModestWindow *win, gpointer user_data)
 114 {
 115         ModestDimmingRule *rule = NULL;
 116         GtkWidget *folder_view = NULL;
 117         TnyFolderStore *parent_folder = NULL;
 118         gboolean dimmed = FALSE;
 119
 120         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
 121         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 122         rule = MODEST_DIMMING_RULE (user_data);
 123
 124         /* Get selected folder as parent of new folder to create */
 125         folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
 126                                                            MODEST_WIDGET_TYPE_FOLDER_VIEW);
 127         parent_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
 128         if (!parent_folder)
 129                 return TRUE;
 130
 131         if (TNY_IS_ACCOUNT (parent_folder)) {
 132                 /* If it's the local account then do not dim */
 133                 if (modest_tny_account_is_virtual_local_folders (TNY_ACCOUNT (parent_folder))) {
 134                         dimmed = FALSE;
 135                 } else {
 136                         const gchar *proto_str = tny_account_get_proto (TNY_ACCOUNT (parent_folder));
 137                         /* If it's POP then dim */
 138                         dimmed = (modest_protocol_info_get_transport_store_protocol (proto_str) ==
 139                                   MODEST_PROTOCOL_STORE_POP) ? TRUE : FALSE;
 140                         if (dimmed)
 141                                 modest_dimming_rule_set_notification (rule, _("mail_in_ui_folder_create_error"));
 142                 }
 143         } else {
 144                 /* TODO: the specs say that only one level of subfolder is allowed, is this true ? */
 145
 146                 TnyFolderType types[3];
 147
 148                 types[0] = TNY_FOLDER_TYPE_DRAFTS;
 149                 types[1] = TNY_FOLDER_TYPE_OUTBOX;
 150                 types[2] = TNY_FOLDER_TYPE_SENT;
 151
 152                 /* Apply folder rules */
 153                 if (!dimmed) {
 154                         dimmed = _selected_folder_not_writeable (MODEST_MAIN_WINDOW(win));
 155                         if (dimmed)
 156                                 modest_dimming_rule_set_notification (rule, _("mail_in_ui_folder_create_error"));
 157                 }
 158                 if (!dimmed) {
 159                         dimmed = _selected_folder_is_any_of_type (win, types, 3);
 160                         if (dimmed)
 161                                 modest_dimming_rule_set_notification (rule, _("mail_in_ui_folder_create_error"));
 162                 }
 163         }
 164         g_object_unref (parent_folder);
 165
 166         return dimmed;
 167 }
 168
 169 gboolean
 170 modest_ui_dimming_rules_on_delete_folder (ModestWindow *win, gpointer user_data)
 171 {
 172         ModestDimmingRule *rule = NULL;
 173         TnyFolderType types[5];
 174         gboolean dimmed = FALSE;
 175
 176         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
 177         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 178         rule = MODEST_DIMMING_RULE (user_data);
 179
 180         types[0] = TNY_FOLDER_TYPE_DRAFTS;
 181         types[1] = TNY_FOLDER_TYPE_OUTBOX;
 182         types[2] = TNY_FOLDER_TYPE_SENT;
 183         types[3] = TNY_FOLDER_TYPE_INBOX;
 184         types[4] = TNY_FOLDER_TYPE_ROOT;
 185
 186
 187         /* Check dimmed rule */
 188         if (!dimmed) {
 189                 dimmed = _selected_folder_not_writeable (MODEST_MAIN_WINDOW(win));
 190                 if (dimmed)
 191                         modest_dimming_rule_set_notification (rule, _("mail_in_ui_folder_delete_error"));
 192         }
 193         if (!dimmed) {
 194                 dimmed = _selected_folder_is_any_of_type (win, types, 5);
 195                 if (dimmed)
 196                         modest_dimming_rule_set_notification (rule, _("mail_in_ui_folder_delete_error"));
 197         }
 198         if (!dimmed) {
 199                 dimmed = _selected_folder_is_root_or_inbox (MODEST_MAIN_WINDOW(win));
 200                 if (dimmed)
 201                         modest_dimming_rule_set_notification (rule, _("mail_in_ui_folder_delete_error"));
 202         }
 203         if (!dimmed) {
 204                 dimmed = _selected_folder_is_MMC_or_POP_root (MODEST_MAIN_WINDOW(win));
 205                 if (dimmed)
 206                         modest_dimming_rule_set_notification (rule, _("mail_in_ui_folder_delete_error"));
 207         }
 208
 209         return dimmed;
 210 }
 211
 212 gboolean
 213 modest_ui_dimming_rules_on_sort (ModestWindow *win, gpointer user_data)
 214 {
 215         ModestDimmingRule *rule = NULL;
 216         gboolean dimmed = FALSE;
 217
 218         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
 219         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 220         rule = MODEST_DIMMING_RULE (user_data);
 221
 222         /* Check dimmed rule */
 223         if (!dimmed) {
 224                 dimmed = _selected_folder_is_root (MODEST_MAIN_WINDOW(win));
 225                 if (dimmed)
 226                         modest_dimming_rule_set_notification (rule, "");
 227         }
 228
 229         return dimmed;
 230
 231 }
 232
 233 gboolean
 234 modest_ui_dimming_rules_on_rename_folder (ModestWindow *win, gpointer user_data)
 235 {
 236         ModestDimmingRule *rule = NULL;
 237         TnyFolderType types[3];
 238         gboolean dimmed = FALSE;
 239
 240         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
 241         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 242         rule = MODEST_DIMMING_RULE (user_data);
 243
 244         types[0] = TNY_FOLDER_TYPE_DRAFTS;
 245         types[1] = TNY_FOLDER_TYPE_OUTBOX;
 246         types[2] = TNY_FOLDER_TYPE_SENT;
 247
 248         /* Check dimmed rule */
 249         if (!dimmed) {
 250                 dimmed = _selected_folder_not_writeable (MODEST_MAIN_WINDOW(win));
 251                 if (dimmed)
 252                         modest_dimming_rule_set_notification (rule, "");
 253         }
 254         if (!dimmed) {
 255                 dimmed = _selected_folder_is_root_or_inbox (MODEST_MAIN_WINDOW(win));
 256                 if (dimmed)
 257                         modest_dimming_rule_set_notification (rule, "");
 258         }
 259         if (!dimmed) {
 260                 dimmed = _selected_folder_is_any_of_type (win, types, 3);
 261                 if (dimmed)
 262                         modest_dimming_rule_set_notification (rule, "");
 263         }
 264
 265         return dimmed;
 266 }
 267
 268 gboolean
 269 modest_ui_dimming_rules_on_open_msg (ModestWindow *win, gpointer user_data)
 270 {
 271         ModestDimmingRule *rule = NULL;
 272         gboolean dimmed = FALSE;
 273
 274         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
 275         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 276         rule = MODEST_DIMMING_RULE (user_data);
 277
 278         /* Check dimmed rule */
 279         if (!dimmed) {
 280                 dimmed = _invalid_msg_selected (MODEST_MAIN_WINDOW(win), TRUE, user_data);
 281         }
 282         if (!dimmed) {
 283                 dimmed = _marked_as_deleted (win);
 284                 if (dimmed)
 285                         modest_dimming_rule_set_notification (rule, _("mcen_ib_message_already_deleted"));
 286         }
 287         if (!dimmed) {
 288                 dimmed = _selected_msg_sent_in_progress (win);
 289                 if (dimmed)
 290                         modest_dimming_rule_set_notification (rule, _("mcen_ib_unable_to_open_while_sent"));
 291         }
 292
 293         return dimmed;
 294 }
 295
 296 gboolean
 297 modest_ui_dimming_rules_on_reply_msg (ModestWindow *win, gpointer user_data)
 298 {
 299         ModestDimmingRule *rule = NULL;
 300         gboolean dimmed = FALSE;
 301         TnyFolderType types[3];
 302
 303         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 304         rule = MODEST_DIMMING_RULE (user_data);
 305
 306         /* main window dimming rules */
 307         if (MODEST_IS_MAIN_WINDOW(win)) {
 308
 309                 types[0] = TNY_FOLDER_TYPE_DRAFTS;
 310                 types[1] = TNY_FOLDER_TYPE_OUTBOX;
 311                 types[2] = TNY_FOLDER_TYPE_ROOT;
 312
 313                 /* Check dimmed rule */
 314                 if (!dimmed) {
 315                         dimmed = _selected_folder_is_any_of_type (win, types, 3);
 316                         if (dimmed)
 317                                 modest_dimming_rule_set_notification (rule, _("mcen_ib_unable_to_reply"));
 318                 }
 319                 if (!dimmed) {
 320                         dimmed = _selected_folder_is_empty (MODEST_MAIN_WINDOW(win));
 321                         if (dimmed)
 322                                 modest_dimming_rule_set_notification (rule, _("mcen_ib_nothing_to_reply"));
 323                 }
 324                 if (!dimmed) {
 325                         dimmed = _invalid_msg_selected (MODEST_MAIN_WINDOW(win), TRUE, rule);
 326                 }
 327         /* msg view window dimming rules */
 328         } else if (MODEST_IS_MSG_VIEW_WINDOW(win)) {
 329
 330                 /* Check dimmed rule */
 331                 if (!dimmed) {
 332                         dimmed = _transfer_mode_enabled (win);
 333                         if (dimmed)
 334                                 modest_dimming_rule_set_notification (rule, _("mail_ib_notavailable_downloading"));
 335                 }
 336                 if (!dimmed) {
 337                         dimmed = _msg_download_in_progress (MODEST_MSG_VIEW_WINDOW(win));
 338                         if (dimmed)
 339                                 modest_dimming_rule_set_notification (rule, "");
 340                 }
 341         }
 342
 343         return dimmed;
 344 }
 345
 346
 347 gboolean
 348 modest_ui_dimming_rules_on_contents_msg (ModestWindow *win, gpointer user_data)
 349 {
 350         ModestDimmingRule *rule = NULL;
 351         gboolean dimmed = FALSE;
 352
 353         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
 354         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 355         rule = MODEST_DIMMING_RULE (user_data);
 356
 357         /* Check dimmed rule */
 358         if (!dimmed) {
 359                 dimmed = _invalid_msg_selected (MODEST_MAIN_WINDOW(win), FALSE, user_data);
 360         }
 361         if (!dimmed) {
 362                 dimmed = _msg_download_completed (MODEST_MAIN_WINDOW(win));
 363                 if (dimmed)
 364                         modest_dimming_rule_set_notification (rule, "");
 365         }
 366
 367         return dimmed;
 368 }
 369
 370 gboolean
 371 modest_ui_dimming_rules_always_dimmed (ModestWindow *win, gpointer user_data)
 372 {
 373         gboolean dimmed = FALSE;
 374
 375         g_return_val_if_fail (MODEST_IS_WINDOW(win), FALSE);
 376
 377         /* Check dimmed rule */
 378         if (!dimmed)
 379                 dimmed = TRUE;
 380
 381         return dimmed;
 382 }
 383
 384 gboolean
 385 modest_ui_dimming_rules_on_delete_msg (ModestWindow *win, gpointer user_data)
 386 {
 387         ModestDimmingRule *rule = NULL;
 388         guint n_messages = 0;
 389         gboolean dimmed = FALSE;
 390
 391         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 392         rule = MODEST_DIMMING_RULE (user_data);
 393
 394         /* Check dimmed rule */
 395         if (MODEST_IS_MAIN_WINDOW (win)) {
 396                 if (!dimmed) {
 397                         dimmed = _selected_folder_is_empty (MODEST_MAIN_WINDOW(win));
 398                         if (dimmed)
 399                                 modest_dimming_rule_set_notification (rule, _CS("ckct_ib_nothing_to_delete"));
 400                 }
 401                 if (!dimmed) {
 402                         dimmed = _invalid_msg_selected (MODEST_MAIN_WINDOW(win), FALSE, user_data);
 403                 }
 404                 if (!dimmed) {
 405                         dimmed = _already_opened_msg (win, &n_messages);
 406                         if (dimmed) {
 407                                 gchar *num = g_strdup_printf ("%d", n_messages);
 408                                 gchar *message = g_strdup_printf(_("mcen_nc_unable_to_delete_n_messages"), num);
 409 /*                              modest_dimming_rule_set_notification (rule, _("mcen_nc_unable_to_delete_n_messages")); */
 410                                 modest_dimming_rule_set_notification (rule, message);
 411                                 g_free(message);
 412                                 g_free(num);
 413                         }
 414                 }
 415                 if (!dimmed) {
 416                         dimmed = _marked_as_deleted (win);
 417                         if (dimmed)
 418                                 modest_dimming_rule_set_notification (rule, _("mcen_ib_message_already_deleted"));
 419                 }
 420                 if (!dimmed) {
 421                         dimmed = _selected_msg_sent_in_progress (win);
 422                         if (dimmed)
 423                                 modest_dimming_rule_set_notification (rule, _("mcen_ib_message_unableto_delete"));
 424                 }
 425         }
 426         else if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
 427                 if (!dimmed) {
 428                         dimmed = _transfer_mode_enabled (win);
 429                         if (dimmed)
 430                                 modest_dimming_rule_set_notification (rule, _("mail_ib_notavailable_downloading"));
 431                 }
 432                 if (!dimmed) {
 433                         dimmed = !modest_msg_view_window_has_headers_model (MODEST_MSG_VIEW_WINDOW(win));
 434                         if (dimmed) {
 435                                 gchar *num = g_strdup("1");
 436                                 gchar *message = g_strdup_printf(_("mcen_nc_unable_to_delete_n_messages"), num);
 437 /*                              modest_dimming_rule_set_notification (rule, _("mcen_nc_unable_to_delete_n_messages")); */
 438                                 modest_dimming_rule_set_notification (rule, message);
 439                                 g_free(message);
 440                                 g_free(num);
 441                         }
 442                 }
 443         }
 444
 445         return dimmed;
 446 }
 447
 448 gboolean
 449 modest_ui_dimming_rules_on_details (ModestWindow *win, gpointer user_data)
 450 {
 451         ModestDimmingRule *rule = NULL;
 452         GtkWidget *header_view = NULL;
 453         gboolean dimmed = FALSE;
 454
 455         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 456         rule = MODEST_DIMMING_RULE (user_data);
 457
 458         /* main window dimming rules */
 459         if (MODEST_IS_MAIN_WINDOW(win)) {
 460
 461                 /* Check dimmed rule */
 462                 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
 463                                                                    MODEST_WIDGET_TYPE_HEADER_VIEW);
 464
 465                 /* If the header view has the focus: */
 466                 if (header_view && gtk_widget_is_focus (header_view)) {
 467                         /* Check dimmed rule */
 468                         if (!dimmed)
 469                                 dimmed = _invalid_msg_selected (MODEST_MAIN_WINDOW(win), TRUE, user_data);
 470                 }
 471                 else {
 472                         /* If the folder view has the focus: */
 473                         GtkWidget *folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
 474                                 MODEST_WIDGET_TYPE_FOLDER_VIEW);
 475                         if (folder_view && gtk_widget_is_focus (folder_view)) {
 476                                 TnyFolderStore *folder_store
 477                                         = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
 478                                 if (folder_store) {
 479                                         /* Only enable for folders, not accounts,
 480                                          * though the UI spec is not clear about that.
 481                                          * If we enable this for accounts then we must
 482                                          * add code to handle them in modest_ui_actions_on_details(). */
 483                                         if (!TNY_IS_FOLDER(folder_store)) {
 484                                                 dimmed = TRUE;
 485                                                 modest_dimming_rule_set_notification (rule, "");
 486                                         }
 487
 488                                         g_object_unref (folder_store);
 489                                 }
 490                         }
 491
 492                 }
 493
 494         /* msg view window dimming rules */
 495         } else {
 496
 497                 /* Check dimmed rule */
 498                 if (!dimmed) {
 499                         dimmed = _msg_download_in_progress (MODEST_MSG_VIEW_WINDOW(win));
 500                         if (dimmed)
 501                                 modest_dimming_rule_set_notification (rule, "");
 502                 }
 503         }
 504
 505         return dimmed;
 506 }
 507
 508
 509 gboolean
 510 modest_ui_dimming_rules_on_mark_as_read_msg (ModestWindow *win, gpointer user_data)
 511 {
 512         ModestDimmingRule *rule = NULL;
 513         TnyHeaderFlags flags;
 514         gboolean dimmed = FALSE;
 515
 516         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
 517         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 518         rule = MODEST_DIMMING_RULE (user_data);
 519
 520         flags = TNY_HEADER_FLAG_SEEN;
 521
 522         /* Check dimmed rule */
 523         if (!dimmed) {
 524                 dimmed = _invalid_msg_selected (MODEST_MAIN_WINDOW(win), FALSE, user_data);
 525         }
 526         if (!dimmed) {
 527                 dimmed = _selected_msg_marked_as (win, flags, FALSE);
 528                 if (dimmed)
 529                         modest_dimming_rule_set_notification (rule, "");
 530         }
 531
 532         return dimmed;
 533 }
 534
 535 gboolean
 536 modest_ui_dimming_rules_on_mark_as_unread_msg (ModestWindow *win, gpointer user_data)
 537 {
 538         ModestDimmingRule *rule = NULL;
 539         TnyHeaderFlags flags;
 540         gboolean dimmed = FALSE;
 541
 542         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
 543         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 544         rule = MODEST_DIMMING_RULE (user_data);
 545
 546         flags = TNY_HEADER_FLAG_SEEN;
 547
 548         /* Check dimmed rule */
 549         if (!dimmed)
 550                 dimmed = _invalid_msg_selected (MODEST_MAIN_WINDOW(win), FALSE, user_data);
 551         if (!dimmed) {
 552                 dimmed = _selected_msg_marked_as (win, flags, TRUE);
 553                 if (dimmed)
 554                         modest_dimming_rule_set_notification (rule, "");
 555         }
 556
 557         return dimmed;
 558 }
 559
 560 gboolean
 561 modest_ui_dimming_rules_on_move_to (ModestWindow *win, gpointer user_data)
 562 {
 563         ModestDimmingRule *rule = NULL;
 564         gboolean dimmed = FALSE;
 565
 566         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 567         rule = MODEST_DIMMING_RULE (user_data);
 568
 569         if (MODEST_IS_MAIN_WINDOW (win))
 570                 dimmed = modest_ui_dimming_rules_on_main_window_move_to (win, user_data);
 571         else if (MODEST_IS_MSG_VIEW_WINDOW (win))
 572                  dimmed = modest_ui_dimming_rules_on_view_window_move_to (win, user_data);
 573
 574         return dimmed;
 575 }
 576
 577
 578 gboolean
 579 modest_ui_dimming_rules_on_main_window_move_to (ModestWindow *win, gpointer user_data)
 580 {
 581         GtkWidget *folder_view = NULL;
 582         GtkWidget *header_view = NULL;
 583         ModestDimmingRule *rule = NULL;
 584         gboolean dimmed = FALSE;
 585
 586         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), TRUE);
 587         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 588         rule = MODEST_DIMMING_RULE (user_data);
 589
 590         /* Get the folder view */
 591         folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
 592                                                            MODEST_WIDGET_TYPE_FOLDER_VIEW);
 593
 594         /* Get header view */
 595         header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
 596                                                            MODEST_WIDGET_TYPE_HEADER_VIEW);
 597
 598         /* Check diming rules for folders and messages transfer  */
 599         if (!dimmed) {
 600                 if (!gtk_widget_is_focus (folder_view))
 601                         dimmed = _invalid_msg_selected (MODEST_MAIN_WINDOW(win), FALSE, user_data);
 602
 603         }
 604
 605         return dimmed;
 606 }
 607
 608 gboolean
 609 modest_ui_dimming_rules_on_view_window_move_to (ModestWindow *win, gpointer user_data)
 610 {
 611         ModestDimmingRule *rule = NULL;
 612         gboolean dimmed = FALSE;
 613
 614         g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW(win), FALSE);
 615         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 616         rule = MODEST_DIMMING_RULE (user_data);
 617
 618         /* Check dimmed rule */
 619         if (!dimmed) {
 620                 dimmed = _transfer_mode_enabled (win);
 621                 if (dimmed)
 622                         modest_dimming_rule_set_notification (rule, _("mail_ib_notavailable_downloading"));
 623         }
 624         if (!dimmed) {
 625                 dimmed = !modest_msg_view_window_has_headers_model (MODEST_MSG_VIEW_WINDOW(win));
 626                 if (dimmed)
 627                         modest_dimming_rule_set_notification (rule, _("mcen_ib_unable_to_move_mail_attachment"));
 628         }
 629
 630         return dimmed;
 631 }
 632
 633 gboolean
 634 modest_ui_dimming_rules_on_find_msg (ModestWindow *win, gpointer user_data)
 635 {
 636         ModestDimmingRule *rule = NULL;
 637         gboolean dimmed = FALSE;
 638
 639         g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW(win), FALSE);
 640         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 641         rule = MODEST_DIMMING_RULE (user_data);
 642
 643         /* Check dimmed rule */
 644         if (!dimmed) {
 645                 dimmed = _transfer_mode_enabled (win);
 646                 if (dimmed)
 647                         modest_dimming_rule_set_notification (rule, _("mail_ib_notavailable_downloading"));
 648         }
 649
 650         return dimmed;
 651 }
 652
 653 gboolean
 654 modest_ui_dimming_rules_on_paste_msgs (ModestWindow *win, gpointer user_data)
 655 {
 656         ModestDimmingRule *rule = NULL;
 657         TnyFolderType types[3];
 658         gboolean dimmed = FALSE;
 659
 660         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
 661         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 662         rule = MODEST_DIMMING_RULE (user_data);
 663
 664         types[0] = TNY_FOLDER_TYPE_DRAFTS;
 665         types[1] = TNY_FOLDER_TYPE_OUTBOX;
 666         types[2] = TNY_FOLDER_TYPE_SENT;
 667
 668         /* Check dimmed rule */
 669         if (!dimmed) {
 670                 dimmed = _clipboard_is_empty (win);
 671                 if (dimmed)
 672                         modest_dimming_rule_set_notification (rule, dgettext("hildon-common-strings", "ecoc_ib_edwin_nothing_to_paste"));
 673         }
 674         if (!dimmed) {
 675                 dimmed = _selected_folder_is_any_of_type (win, types, 3);
 676                 if (dimmed)
 677                         modest_dimming_rule_set_notification (rule, _("ckct_ib_unable_to_paste_here"));
 678         }
 679         if (!dimmed) {
 680                 dimmed = _selected_folder_is_same_as_source (win);
 681                 if (dimmed)
 682                         modest_dimming_rule_set_notification (rule, _("mcen_ib_unable_to_copy_samefolder"));
 683         }
 684
 685         return dimmed;
 686 }
 687
 688
 689 gboolean
 690 modest_ui_dimming_rules_on_select_all (ModestWindow *win, gpointer user_data)
 691 {
 692         ModestDimmingRule *rule = NULL;
 693         gboolean dimmed = FALSE;
 694
 695         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
 696         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 697         rule = MODEST_DIMMING_RULE (user_data);
 698
 699         /* Check dimmed rule */
 700         if (!dimmed) {
 701                 dimmed = _selected_folder_is_empty (MODEST_MAIN_WINDOW(win));
 702                 if (dimmed)
 703                         modest_dimming_rule_set_notification (rule, "");
 704         }
 705
 706         return dimmed;
 707 }
 708
 709 gboolean
 710 modest_ui_dimming_rules_on_view_attachments (ModestWindow *win, gpointer user_data)
 711 {
 712         ModestDimmingRule *rule = NULL;
 713         gboolean dimmed = FALSE;
 714
 715         g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW(win), FALSE);
 716         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 717         rule = MODEST_DIMMING_RULE (user_data);
 718
 719         /* Check dimmed rule */
 720         if (!dimmed)
 721                 dimmed = _invalid_attach_selected (win, TRUE, TRUE, rule);
 722
 723         if (!dimmed) {
 724                 dimmed = _purged_attach_selected (win, FALSE, NULL);
 725                 if (dimmed) {
 726                         modest_dimming_rule_set_notification (rule, _("mail_ib_attach_not_local"));
 727                 }
 728         }
 729
 730         return dimmed;
 731 }
 732
 733 gboolean
 734 modest_ui_dimming_rules_on_save_attachments (ModestWindow *win, gpointer user_data)
 735 {
 736         ModestDimmingRule *rule = NULL;
 737         gboolean dimmed = FALSE;
 738
 739         g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW(win), FALSE);
 740         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 741         rule = MODEST_DIMMING_RULE (user_data);
 742
 743         /* Check dimmed rule */
 744         if (!dimmed)
 745                 dimmed = _invalid_attach_selected (win, FALSE, FALSE, rule);
 746
 747         if (!dimmed) {
 748                 dimmed = _purged_attach_selected (win, FALSE, NULL);
 749                 if (dimmed) {
 750                         modest_dimming_rule_set_notification (rule, _("mail_ib_attach_not_local"));
 751                 }
 752         }
 753
 754         return dimmed;
 755 }
 756
 757 gboolean
 758 modest_ui_dimming_rules_on_remove_attachments (ModestWindow *win, gpointer user_data)
 759 {
 760         ModestDimmingRule *rule = NULL;
 761         gboolean dimmed = FALSE;
 762
 763         g_return_val_if_fail (MODEST_IS_WINDOW(win), FALSE);
 764         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 765         rule = MODEST_DIMMING_RULE (user_data);
 766
 767         /* Check in main window if there's only one message selected */
 768         if (!dimmed && MODEST_IS_MAIN_WINDOW (win)) {
 769                 dimmed = _invalid_msg_selected (MODEST_MAIN_WINDOW (win), TRUE, rule);
 770         }
 771
 772         /* Check in view window if there's any attachment selected */
 773         if (!dimmed && MODEST_IS_MSG_VIEW_WINDOW (win)) {
 774                 dimmed = _invalid_attach_selected (win, FALSE, FALSE, NULL);
 775                 if (dimmed)
 776                         modest_dimming_rule_set_notification (rule, _("FIXME:no attachment selected"));
 777         }
 778
 779         /* cannot purge in editable drafts nor pop folders */
 780         if (!dimmed) {
 781                 dimmed = _invalid_folder_for_purge (win, rule);
 782         }
 783
 784         /* Check if the selected message in main window has attachments */
 785         if (!dimmed && MODEST_IS_MAIN_WINDOW (win)) {
 786                 dimmed = _selected_msg_marked_as (win, TNY_HEADER_FLAG_ATTACHMENTS, TRUE);
 787                 if (dimmed)
 788                         modest_dimming_rule_set_notification (rule, _("mail_ib_unable_to_purge_attachments"));
 789         }
 790
 791         /* Check if all attachments are already purged */
 792         if (!dimmed) {
 793                 dimmed = _purged_attach_selected (win, TRUE, rule);
 794         }
 795
 796         /* Check if the message is already downloaded */
 797         if (!dimmed && MODEST_IS_MAIN_WINDOW (win)) {
 798                 dimmed = !_msg_download_completed (MODEST_MAIN_WINDOW (win));
 799                 if (dimmed)
 800                         modest_dimming_rule_set_notification (rule, _("mail_ib_attach_not_local"));
 801         }
 802
 803
 804         return dimmed;
 805 }
 806
 807 gboolean
 808 modest_ui_dimming_rules_on_undo (ModestWindow *win, gpointer user_data)
 809 {
 810         ModestDimmingRule *rule = NULL;
 811         gboolean dimmed = FALSE;
 812
 813         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 814         rule = MODEST_DIMMING_RULE (user_data);
 815
 816         /* Check dimmed rule */
 817         if (!dimmed) {
 818                 dimmed = _clipboard_is_empty (win);
 819                 if (dimmed)
 820                         modest_dimming_rule_set_notification (rule, "");
 821         }
 822
 823         return dimmed;
 824 }
 825
 826 gboolean
 827 modest_ui_dimming_rules_on_cut (ModestWindow *win, gpointer user_data)
 828 {
 829         ModestDimmingRule *rule = NULL;
 830         gboolean dimmed = FALSE;
 831
 832         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 833         rule = MODEST_DIMMING_RULE (user_data);
 834
 835         /* Check common dimming rules */
 836         if (!dimmed) {
 837                 dimmed = _invalid_clipboard_selected (win, rule);
 838         }
 839
 840         /* Check window specific dimming rules */
 841         if (MODEST_IS_MAIN_WINDOW (win)) {
 842                 if (!dimmed) {
 843                         dimmed = _selected_folder_not_writeable (MODEST_MAIN_WINDOW(win));
 844                         if (dimmed)
 845                                 modest_dimming_rule_set_notification (rule, _("mcen_ib_message_unableto_delete"));
 846                 }
 847                 if (!dimmed) {
 848                         dimmed = _selected_folder_is_empty (MODEST_MAIN_WINDOW(win));
 849                         if (dimmed)
 850                                 modest_dimming_rule_set_notification (rule, "");
 851                 }
 852                 if (!dimmed) {
 853                         dimmed = _selected_msg_sent_in_progress (win);
 854                         if (dimmed)
 855                                 modest_dimming_rule_set_notification (rule, _("mcen_ib_unable_to_cut_mess"));
 856                 }
 857         }
 858
 859         return dimmed;
 860 }
 861
 862 gboolean
 863 modest_ui_dimming_rules_on_copy (ModestWindow *win, gpointer user_data)
 864 {
 865         ModestDimmingRule *rule = NULL;
 866         gboolean dimmed = FALSE;
 867
 868         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 869         rule = MODEST_DIMMING_RULE (user_data);
 870
 871         /* Check common dimming rules */
 872         if (!dimmed) {
 873                 dimmed = _invalid_clipboard_selected (win, rule);
 874         }
 875
 876         /* Check window specific dimming rules */
 877         if (MODEST_IS_MAIN_WINDOW (win)) {
 878                 if (!dimmed) {
 879                         dimmed = _selected_folder_is_empty (MODEST_MAIN_WINDOW(win));
 880                         if (dimmed)
 881                                 modest_dimming_rule_set_notification (rule, "");
 882                 }
 883                 if (!dimmed) {
 884                         dimmed = _selected_msg_sent_in_progress (win);
 885                         if (dimmed)
 886                                 modest_dimming_rule_set_notification (rule, _("mcen_ib_unable_to_cut_mess"));
 887                 }
 888         }
 889
 890         return dimmed;
 891 }
 892
 893 gboolean
 894 modest_ui_dimming_rules_on_view_previous (ModestWindow *win, gpointer user_data)
 895 {
 896         ModestDimmingRule *rule = NULL;
 897         gboolean dimmed = FALSE;
 898
 899         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 900         rule = MODEST_DIMMING_RULE (user_data);
 901
 902         g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW(win), FALSE);
 903
 904         /* Check dimmed rule */
 905         if (!dimmed) {
 906                 dimmed = _transfer_mode_enabled (win);
 907                 if (dimmed)
 908                         modest_dimming_rule_set_notification (rule, _("mail_ib_notavailable_downloading"));
 909         }
 910         if (!dimmed) {
 911                 dimmed = modest_msg_view_window_first_message_selected (MODEST_MSG_VIEW_WINDOW(win));
 912                 if (dimmed)
 913                         modest_dimming_rule_set_notification (rule, "");
 914         }
 915
 916         return dimmed;
 917 }
 918
 919 gboolean
 920 modest_ui_dimming_rules_on_view_next (ModestWindow *win, gpointer user_data)
 921 {
 922         ModestDimmingRule *rule = NULL;
 923         gboolean dimmed = FALSE;
 924
 925         g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW(win), FALSE);
 926         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 927         rule = MODEST_DIMMING_RULE (user_data);
 928
 929         /* Check dimmed rule */
 930         if (!dimmed) {
 931                 dimmed = _transfer_mode_enabled (win);
 932                 if (dimmed)
 933                         modest_dimming_rule_set_notification (rule, _("mail_ib_notavailable_downloading"));
 934         }
 935         if (!dimmed) {
 936                 dimmed = modest_msg_view_window_last_message_selected (MODEST_MSG_VIEW_WINDOW(win));
 937                 if (dimmed)
 938                         modest_dimming_rule_set_notification (rule, "");
 939         }
 940
 941         return dimmed;
 942 }
 943
 944
 945 gboolean
 946 modest_ui_dimming_rules_on_tools_smtp_servers (ModestWindow *win, gpointer user_data)
 947 {
 948         const gboolean dimmed =
 949                 !modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(),
 950                         TRUE);
 951
 952         return dimmed;
 953 }
 954
 955 gboolean
 956 modest_ui_dimming_rules_on_cancel_sending (ModestWindow *win, gpointer user_data)
 957 {
 958         gboolean dimmed = FALSE;
 959
 960         /* Check dimmed rule */
 961         if (!dimmed)
 962                 dimmed = !_sending_in_progress (win);
 963
 964         return dimmed;
 965 }
 966
 967 gboolean
 968 modest_ui_dimming_rules_on_send_receive (ModestWindow *win, gpointer user_data)
 969 {
 970         ModestDimmingRule *rule = NULL;
 971         gboolean dimmed = FALSE;
 972
 973         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 974         rule = MODEST_DIMMING_RULE (user_data);
 975
 976         /* Check dimmed rule */
 977         if (!dimmed) {
 978                 dimmed = !modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(),
 979                                                           TRUE);
 980                 if (dimmed)
 981                         modest_dimming_rule_set_notification (rule, _("mcen_nc_no_email_acnts_defined"));
 982         }
 983
 984         return dimmed;
 985 }
 986
 987 gboolean
 988 modest_ui_dimming_rules_on_add_to_contacts (ModestWindow *win, gpointer user_data)
 989 {
 990         ModestDimmingRule *rule = NULL;
 991         gboolean dimmed = FALSE;
 992
 993         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 994         rule = MODEST_DIMMING_RULE (user_data);
 995
 996         /* Check dimmed rule */
 997         if (!dimmed) {
 998                 GtkClipboard *clipboard = gtk_clipboard_get (GDK_SELECTION_PRIMARY);
 999                 gchar *selection = NULL;
1000                 selection = gtk_clipboard_wait_for_text (clipboard);
1001
1002                 dimmed = !((selection != NULL) && (modest_text_utils_validate_recipient (selection)));
1003         }
1004
1005         return dimmed;
1006 }
1007
1008 /* *********************** static utility functions ******************** */
1009
1010 static gboolean
1011 _marked_as_deleted (ModestWindow *win)
1012 {
1013         gboolean result = FALSE;
1014         TnyHeaderFlags flags;
1015
1016         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
1017
1018         flags = TNY_HEADER_FLAG_DELETED;
1019
1020         /* Check dimmed rule */
1021         result = _selected_msg_marked_as (win, flags, FALSE);
1022
1023         return result;
1024 }
1025
1026 static gboolean
1027 _selected_folder_not_writeable (ModestMainWindow *win)
1028 {
1029         GtkWidget *folder_view = NULL;
1030         TnyFolderStore *parent_folder = NULL;
1031         ModestTnyFolderRules rules;
1032         gboolean result = FALSE;
1033
1034         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
1035
1036         /* Get folder view */
1037         folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
1038                                                            MODEST_WIDGET_TYPE_FOLDER_VIEW);
1039         /* If no folder view, always dimmed */
1040         if (!folder_view)
1041                 return TRUE;
1042
1043         /* Get selected folder as parent of new folder to create */
1044         parent_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
1045         if (!(parent_folder && TNY_IS_FOLDER(parent_folder))) {
1046                 if (parent_folder)
1047                         g_object_unref (parent_folder);
1048                 return TRUE;
1049         }
1050
1051         /* Check dimmed rule */
1052         rules = modest_tny_folder_get_rules (TNY_FOLDER (parent_folder));
1053         result = rules & MODEST_FOLDER_RULES_FOLDER_NON_WRITEABLE;
1054
1055         /* free */
1056         g_object_unref (parent_folder);
1057
1058         return result;
1059 }
1060
1061 static gboolean
1062 _selected_folder_is_root_or_inbox (ModestMainWindow *win)
1063 {
1064         TnyFolderType types[2];
1065         gboolean result = FALSE;
1066
1067         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
1068
1069         types[0] = TNY_FOLDER_TYPE_ROOT;
1070         types[1] = TNY_FOLDER_TYPE_INBOX;
1071
1072         /* Check folder type */
1073         result = _selected_folder_is_any_of_type (MODEST_WINDOW(win), types, 2);
1074
1075         /* Check pop and MMC accounts */
1076         if (!result) {
1077                 result = _selected_folder_is_MMC_or_POP_root (win);
1078         }
1079
1080         return result;
1081 }
1082
1083
1084 static gboolean
1085 _selected_folder_is_root (ModestMainWindow *win)
1086 {
1087         TnyFolderType types[1];
1088         gboolean result = FALSE;
1089
1090         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
1091
1092         types[0] = TNY_FOLDER_TYPE_ROOT;
1093
1094         /* Check folder type */
1095         result = _selected_folder_is_any_of_type (MODEST_WINDOW(win), types, 1);
1096
1097         /* Check pop and MMC accounts */
1098         if (!result) {
1099                 result = _selected_folder_is_MMC_or_POP_root (win);
1100         }
1101
1102         return result;
1103 }
1104
1105 static gboolean
1106 _selected_folder_is_MMC_or_POP_root (ModestMainWindow *win)
1107 {
1108         GtkWidget *folder_view = NULL;
1109         TnyFolderStore *parent_folder = NULL;
1110         gboolean result = FALSE;
1111
1112         folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
1113                                                            MODEST_WIDGET_TYPE_FOLDER_VIEW);
1114         /* Get selected folder as parent of new folder to create */
1115         parent_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
1116         if (!parent_folder)
1117                 return TRUE;
1118
1119         if (TNY_IS_ACCOUNT (parent_folder)) {
1120                 /* If it's the local account then do not dim */
1121                 if (modest_tny_account_is_virtual_local_folders (TNY_ACCOUNT (parent_folder))) {
1122                         result = FALSE;
1123                 } else {
1124                                 /* If it's the MMC root folder then dim it */
1125                         if (!strcmp (tny_account_get_id (TNY_ACCOUNT (parent_folder)), MODEST_MMC_ACCOUNT_ID)) {
1126                                         result = TRUE;
1127                         } else {
1128                                 const gchar *proto_str = tny_account_get_proto (TNY_ACCOUNT (parent_folder));
1129                                 /* If it's POP then dim */
1130                                 result = (modest_protocol_info_get_transport_store_protocol (proto_str) ==
1131                                                   MODEST_PROTOCOL_STORE_POP) ? TRUE : FALSE;
1132                         }
1133                 }
1134         }
1135         g_object_unref (parent_folder);
1136
1137         return result;
1138 }
1139
1140
1141
1142
1143 static gboolean
1144 _selected_folder_is_empty (ModestMainWindow *win)
1145 {
1146         GtkWidget *folder_view = NULL;
1147         TnyFolderStore *folder = NULL;
1148         gboolean result = FALSE;
1149
1150         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
1151
1152         /* Get folder view */
1153         folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
1154                                                            MODEST_WIDGET_TYPE_FOLDER_VIEW);
1155         /* If no folder view, always dimmed */
1156         if (!folder_view)
1157                 return TRUE;
1158
1159         /* Get selected folder as parent of new folder to create */
1160         folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
1161         if (!(folder && TNY_IS_FOLDER(folder))) {
1162                 if (folder)
1163                         g_object_unref (folder);
1164                 return TRUE;
1165         }
1166
1167         /* Check folder type */
1168         result = tny_folder_get_all_count (TNY_FOLDER (folder)) == 0;
1169
1170         /* free */
1171         g_object_unref (folder);
1172
1173         return result;
1174 }
1175
1176 static gboolean
1177 _selected_folder_is_same_as_source (ModestWindow *win)
1178 {
1179         ModestEmailClipboard *clipboard = NULL;
1180         GtkWidget *folder_view = NULL;
1181         TnyFolderStore *folder = NULL;
1182         gboolean result = FALSE;
1183
1184         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
1185
1186         /* Get folder view */
1187         folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
1188                                                            MODEST_WIDGET_TYPE_FOLDER_VIEW);
1189         if (!folder_view)
1190                 return FALSE;
1191
1192         /* Get selected folder as destination folder */
1193         folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
1194         if (!(folder && TNY_IS_FOLDER(folder))) {
1195                 result = FALSE;
1196                 goto frees;
1197         }
1198
1199         /* Check clipboard is cleared */
1200         clipboard = modest_runtime_get_email_clipboard ();
1201         if (modest_email_clipboard_cleared (clipboard)) {
1202                 result = FALSE;
1203                 goto frees;
1204         }
1205
1206         /* Check source folder */
1207         result = modest_email_clipboard_check_source_folder (clipboard,
1208                                                              (const TnyFolder *) folder);
1209
1210         /* Free */
1211  frees:
1212         g_object_unref (folder);
1213
1214         return result;
1215 }
1216
1217 static gboolean
1218 _selected_folder_is_any_of_type (ModestWindow *win,
1219                                  TnyFolderType types[],
1220                                  guint ntypes)
1221 {
1222         GtkWidget *folder_view = NULL;
1223         TnyFolderStore *folder = NULL;
1224         TnyFolderType folder_type;
1225         guint i=0;
1226         gboolean result = FALSE;
1227
1228         /*Get curent folder */
1229         if (MODEST_IS_MAIN_WINDOW(win)) {
1230
1231                 /* Get folder view */
1232                 folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
1233                                                                    MODEST_WIDGET_TYPE_FOLDER_VIEW);
1234                 /* If no folder view, always dimmed */
1235                 if (!folder_view)
1236                         return TRUE;
1237
1238                 /* Get selected folder as parent of new folder to create */
1239                 folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
1240
1241                 if (!(folder && TNY_IS_FOLDER(folder))) {
1242                         if (folder)
1243                                 g_object_unref (folder);
1244                         return TRUE;
1245                 }
1246
1247                 /* Check folder type */
1248                 result = _folder_is_any_of_type (TNY_FOLDER(folder), types, ntypes);
1249         }
1250         else if (MODEST_IS_MSG_VIEW_WINDOW(win)) {
1251                 folder_type = modest_msg_view_window_get_folder_type (MODEST_MSG_VIEW_WINDOW (win));
1252                 for (i=0; i < ntypes; i++) {
1253                         result = result || folder_type == types[i];
1254                 }
1255         }
1256
1257
1258         /* free */
1259         g_object_unref (folder);
1260
1261         return result;
1262 }
1263
1264 static gboolean
1265 _folder_is_any_of_type (TnyFolder *folder,
1266                         TnyFolderType types[],
1267                         guint ntypes)
1268 {
1269         TnyFolderType folder_type;
1270         gboolean result = FALSE;
1271         guint i;
1272
1273         g_return_val_if_fail (TNY_IS_FOLDER(folder), FALSE);
1274
1275         /* Get folder type */
1276         if (modest_tny_folder_is_local_folder (folder))
1277                 folder_type = modest_tny_folder_get_local_folder_type (folder);
1278         else
1279                 folder_type = modest_tny_folder_guess_folder_type (folder);
1280
1281         /* Check foler type */
1282         for (i=0; i < ntypes; i++) {
1283                 result = result || folder_type == types[i];
1284         }
1285
1286         return result;
1287 }
1288
1289 static gboolean
1290 _selected_folder_is_snd_level (ModestMainWindow *win)
1291 {
1292         GtkWidget *folder_view = NULL;
1293         GtkTreeSelection *sel = NULL;
1294         GtkTreeModel *model = NULL;
1295         GtkTreePath *path = NULL;
1296         GtkTreeIter iter;
1297         TnyFolderStore *folder = NULL;
1298         gboolean result = FALSE;
1299
1300         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), TRUE);
1301
1302         /*Get curent folder */
1303         folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
1304                                                            MODEST_WIDGET_TYPE_FOLDER_VIEW);
1305         /* If no folder view, always dimmed */
1306         if (!folder_view)
1307                 goto frees;
1308
1309         /* Get selected folder as parent of new folder to create */
1310         folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
1311         if (!(folder && TNY_IS_FOLDER(folder))) {
1312                 goto frees;
1313         }
1314
1315         /* Check folder level */
1316         sel = gtk_tree_view_get_selection (GTK_TREE_VIEW(folder_view));
1317         if (!gtk_tree_selection_get_selected (sel, &model, &iter))
1318                 goto frees;
1319         path = gtk_tree_model_get_path (model, &iter);
1320         result = gtk_tree_path_get_depth (path) > 2;
1321
1322  frees:
1323         if (folder != NULL)
1324                 g_object_unref (folder);
1325         if (path != NULL)
1326                 gtk_tree_path_free (path);
1327
1328         return result;
1329
1330 }
1331
1332 static gboolean
1333 _clipboard_is_empty (ModestWindow *win)
1334 {
1335         gboolean result = FALSE;
1336
1337         if (MODEST_IS_MAIN_WINDOW (win)) {
1338                 ModestEmailClipboard *clipboard = NULL;
1339                 clipboard = modest_runtime_get_email_clipboard ();
1340                 if (modest_email_clipboard_cleared (clipboard))
1341                  result = TRUE;
1342         }
1343
1344         return result;
1345 }
1346
1347 static gboolean
1348 _invalid_clipboard_selected (ModestWindow *win,
1349                        ModestDimmingRule *rule)
1350 {
1351         gboolean result = FALSE;
1352
1353         if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
1354                 GtkClipboard *clipboard = NULL;
1355                 gchar *selection = NULL;
1356                 GtkWidget *focused = NULL;
1357
1358                 /* Get clipboard selection*/
1359                 clipboard = gtk_clipboard_get (GDK_SELECTION_PRIMARY);
1360                 selection = gtk_clipboard_wait_for_text (clipboard);
1361
1362                 /* Get focuesed widget */
1363                 focused = gtk_window_get_focus (GTK_WINDOW (win));
1364
1365                 /* Check dimming */
1366                 result = ((selection == NULL) ||
1367                           (MODEST_IS_ATTACHMENTS_VIEW (focused)));
1368
1369                 if (result)
1370                         modest_dimming_rule_set_notification (rule, _(""));
1371         }
1372         else if (MODEST_IS_MAIN_WINDOW (win)) {
1373                 GtkWidget *header_view = NULL;
1374
1375                 /* Get header view to check selected messages */
1376                 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
1377                                                                    MODEST_WIDGET_TYPE_HEADER_VIEW);
1378
1379                 /* Check dimming */
1380                 result = !modest_header_view_has_selected_headers (MODEST_HEADER_VIEW(header_view));
1381                 if (result)
1382                         modest_dimming_rule_set_notification (rule, _("mcen_ib_no_message_selected"));
1383         }
1384
1385         return result;
1386 }
1387
1388
1389 static gboolean
1390 _invalid_attach_selected (ModestWindow *win,
1391                           gboolean unique,
1392                           gboolean for_view,
1393                           ModestDimmingRule *rule)
1394 {
1395         GList *attachments, *node;
1396         gint n_selected;
1397         TnyHeaderFlags flags;
1398         gboolean nested_attachments = FALSE;
1399         gboolean selected_messages = FALSE;
1400         gboolean result = FALSE;
1401
1402         if (MODEST_IS_MAIN_WINDOW (win)) {
1403                 flags = TNY_HEADER_FLAG_ATTACHMENTS;
1404                 if (!result)
1405                         result = _selected_msg_marked_as (win, flags, TRUE);
1406         }
1407         else if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
1408
1409                 /* Get selected atachments */
1410                 attachments = modest_msg_view_window_get_attachments (MODEST_MSG_VIEW_WINDOW(win));
1411                 n_selected = g_list_length (attachments);
1412
1413                 /* Check unique */
1414                 if (!result) {
1415                         if (unique)
1416                                 result = n_selected != 1;
1417                         else
1418
1419                                 result = n_selected < 1;
1420                 }
1421
1422                 /* Check attached type (view operation not required) */
1423                 if (!result && !for_view)  {
1424                         for (node = attachments; node != NULL && !result; node = g_list_next (node)) {
1425                                 TnyMimePart *mime_part = TNY_MIME_PART (node->data);
1426                                 TnyList *nested_list = tny_simple_list_new ();
1427                                 if (TNY_IS_MSG (mime_part)) {
1428                                         selected_messages = TRUE;
1429                                         result = TRUE;
1430                                 }
1431                                 tny_mime_part_get_parts (mime_part, nested_list);
1432                                 if (tny_list_get_length (nested_list) > 0) {
1433                                 nested_attachments = TRUE;
1434                                 result = TRUE;
1435                                 }
1436                                 g_object_unref (nested_list);
1437                         }
1438                 }
1439
1440                 /* Set notifications */
1441                 if (result && rule != NULL) {
1442                         if (selected_messages) {
1443                                 modest_dimming_rule_set_notification (rule, _("mcen_ib_unable_to_save_attach_mail"));
1444                         } else if (nested_attachments) {
1445                                 modest_dimming_rule_set_notification (rule, _("FIXME:unable to save attachments with nested elements"));
1446                         } else if (n_selected == 0) {
1447                                 modest_dimming_rule_set_notification (rule, _("FIXME:no attachment selected"));
1448                         } else if (unique) {
1449                                 modest_dimming_rule_set_notification (rule, _("mcen_ib_unable_to_display_more"));
1450                         }
1451                 }
1452
1453                 /* Free */
1454                 g_list_free (attachments);
1455         }
1456
1457         return result;
1458 }
1459
1460 static gboolean
1461 _purged_attach_selected (ModestWindow *win, gboolean all, ModestDimmingRule *rule)
1462 {
1463         GList *attachments, *node;
1464         gint purged = 0;
1465         gint n_attachments = 0;
1466         gboolean result = FALSE;
1467
1468         /* This should check if _all_ the attachments are already purged. If only some
1469          * of them are purged, then it does not cause dim as there's a confirmation dialog
1470          * for removing only local attachments */
1471
1472         /* Get selected atachments */
1473         if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
1474                 attachments = modest_msg_view_window_get_attachments (MODEST_MSG_VIEW_WINDOW(win));
1475         } else if (MODEST_IS_MAIN_WINDOW (win)) {
1476                 /* If we're in main window, we won't know if there are already purged attachments */
1477                 return FALSE;
1478         }
1479
1480         if (attachments == NULL)
1481                 return FALSE;
1482
1483         for (node = attachments; node != NULL; node = g_list_next (node)) {
1484                 TnyMimePart *mime_part = TNY_MIME_PART (node->data);
1485                 if (tny_mime_part_is_purged (mime_part)) {
1486                         purged++;
1487                 }
1488                 n_attachments++;
1489         }
1490
1491         /* Free */
1492         g_list_free (attachments);
1493
1494         if (all)
1495                 result = (purged == n_attachments);
1496         else
1497                 result = (purged > 0);
1498
1499         if (result && (rule != NULL))
1500                 modest_dimming_rule_set_notification (rule, _("mail_ib_attachment_already_purged"));
1501
1502         return result;
1503 }
1504
1505 static gboolean
1506 _invalid_msg_selected (ModestMainWindow *win,
1507                        gboolean unique,
1508                        ModestDimmingRule *rule)
1509 {
1510         GtkWidget *header_view = NULL;
1511         GtkWidget *folder_view = NULL;
1512         gboolean selected_headers = FALSE;
1513         gboolean result = FALSE;
1514
1515         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
1516         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (rule), FALSE);
1517
1518         /* Get header view to check selected messages */
1519         header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
1520                                                            MODEST_WIDGET_TYPE_HEADER_VIEW);
1521
1522         /* Get folder view to check focus */
1523         folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
1524                                                            MODEST_WIDGET_TYPE_FOLDER_VIEW);
1525
1526         /* Get selected headers */
1527         selected_headers = modest_header_view_has_selected_headers (MODEST_HEADER_VIEW(header_view));
1528
1529         /* Check dimmed rule (TODO: check focus on widgets */
1530         if (!result) {
1531                 result = ((!selected_headers) ||
1532                           (gtk_widget_is_focus (folder_view)));
1533                 if (result)
1534                         modest_dimming_rule_set_notification (rule, _("mcen_ib_no_message_selected"));
1535         }
1536         if (!result && unique) {
1537                 result = modest_header_view_count_selected_headers (MODEST_HEADER_VIEW(header_view)) > 1;
1538                 if (result)
1539                         modest_dimming_rule_set_notification (rule, _("mcen_ib_select_one_message"));
1540         }
1541
1542         return result;
1543 }
1544
1545 static gboolean
1546 _already_opened_msg (ModestWindow *win,
1547                      guint *n_messages)
1548 {
1549         ModestWindow *window = NULL;
1550         ModestWindowMgr *mgr = NULL;
1551         GtkWidget *header_view = NULL;
1552         TnyList *selected_headers = NULL;
1553         TnyIterator *iter = NULL;
1554         TnyHeader *header = NULL;
1555         gboolean result = TRUE;
1556
1557         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
1558
1559         /* Get header view to check selected messages */
1560         header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
1561                                                            MODEST_WIDGET_TYPE_HEADER_VIEW);
1562
1563
1564         /* Check no selection */
1565         if (!modest_header_view_has_selected_headers (MODEST_HEADER_VIEW(header_view)))
1566             return FALSE;
1567
1568         /* Get selected headers */
1569         selected_headers = modest_header_view_get_selected_headers (MODEST_HEADER_VIEW(header_view));
1570         if (selected_headers == NULL)
1571                 return FALSE;
1572
1573         *n_messages = tny_list_get_length (selected_headers);
1574
1575         /* Check dimmed rule (TODO: check focus on widgets */
1576         mgr = modest_runtime_get_window_mgr ();
1577         iter = tny_list_create_iterator (selected_headers);
1578         while (!tny_iterator_is_done (iter) && result) {
1579                 header = TNY_HEADER (tny_iterator_get_current (iter));
1580                 window = modest_window_mgr_find_window_by_header (mgr, header);
1581                 result = result && (window != NULL);
1582
1583                 g_object_unref (header);
1584                 tny_iterator_next (iter);
1585         }
1586
1587         /* free */
1588         if (selected_headers != NULL)
1589                 g_object_unref (selected_headers);
1590         if (iter != NULL)
1591                 g_object_unref (iter);
1592
1593         return result;
1594 }
1595
1596 static gboolean
1597 _selected_msg_marked_as (ModestWindow *win,
1598                          TnyHeaderFlags mask,
1599                          gboolean opposite)
1600 {
1601         GtkWidget *header_view = NULL;
1602         TnyList *selected_headers = NULL;
1603         TnyIterator *iter = NULL;
1604         TnyHeader *header = NULL;
1605         TnyHeaderFlags flags;
1606         gboolean result = FALSE;
1607
1608         /* Get header view to check selected messages */
1609         header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
1610                                                            MODEST_WIDGET_TYPE_HEADER_VIEW);
1611
1612         /* Check no selection */
1613         if (!modest_header_view_has_selected_headers (MODEST_HEADER_VIEW(header_view)))
1614             return TRUE;
1615
1616         /* Get selected headers */
1617         selected_headers = modest_header_view_get_selected_headers (MODEST_HEADER_VIEW(header_view));
1618         if (selected_headers == NULL)
1619                 return TRUE;
1620
1621         /* Call the function for each header */
1622         iter = tny_list_create_iterator (selected_headers);
1623         while (!tny_iterator_is_done (iter) && !result) {
1624                 header = TNY_HEADER (tny_iterator_get_current (iter));
1625
1626                 flags = tny_header_get_flags (header);
1627                 if (opposite)
1628                         result = (flags & mask) == 0;
1629                 else
1630                         result = (flags & mask) != 0;
1631
1632                 g_object_unref (header);
1633                 tny_iterator_next (iter);
1634         }
1635
1636         /* free */
1637         if (selected_headers != NULL)
1638                 g_object_unref (selected_headers);
1639         if (iter != NULL)
1640                 g_object_unref (iter);
1641
1642         return result;
1643 }
1644
1645 static gboolean
1646 _msg_download_in_progress (ModestMsgViewWindow *win)
1647 {
1648         gboolean result = FALSE;
1649
1650         g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW (win), FALSE);
1651
1652         result = modest_msg_view_window_toolbar_on_transfer_mode (win);
1653
1654         return result;
1655 }
1656
1657 static gboolean
1658 _msg_download_completed (ModestMainWindow *win)
1659 {
1660         GtkWidget *header_view = NULL;
1661         TnyList *selected_headers = NULL;
1662         TnyIterator *iter = NULL;
1663         TnyHeader *header = NULL;
1664         TnyHeaderFlags flags;
1665         gboolean result = FALSE;
1666
1667         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW (win), FALSE);
1668
1669
1670         /* Get header view to check selected messages */
1671         header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
1672                                                            MODEST_WIDGET_TYPE_HEADER_VIEW);
1673
1674         /* Check no selection */
1675         if (!modest_header_view_has_selected_headers (MODEST_HEADER_VIEW(header_view)))
1676             return TRUE;
1677
1678         /* Get selected headers */
1679         selected_headers = modest_header_view_get_selected_headers (MODEST_HEADER_VIEW(header_view));
1680         if (selected_headers == NULL)
1681                 return TRUE;
1682
1683         /* Check dimmed rule  */
1684         result = TRUE;
1685         iter = tny_list_create_iterator (selected_headers);
1686         while (!tny_iterator_is_done (iter) && result) {
1687                 header = TNY_HEADER (tny_iterator_get_current (iter));
1688
1689                 flags = tny_header_get_flags (header);
1690                 /* TODO: is this the right flag?, it seems that some
1691                    headers that have been previously downloaded do not
1692                    come with it */
1693                 result = (flags & TNY_HEADER_FLAG_CACHED);
1694
1695                 g_object_unref (header);
1696                 tny_iterator_next (iter);
1697         }
1698
1699         g_object_unref (iter);
1700
1701         return result;
1702 }
1703
1704 static gboolean
1705 _selected_msg_sent_in_progress (ModestWindow *win)
1706 {
1707         ModestTnySendQueue *send_queue = NULL;
1708         GtkWidget *header_view = NULL;
1709         ModestTnyAccountStore *acc_store = NULL;
1710         TnyAccount *account = NULL;
1711         TnyList *header_list = NULL;
1712         TnyIterator *iter = NULL;
1713         TnyHeader *header = NULL;
1714         const gchar *account_name = NULL;
1715         gboolean result = FALSE;
1716         gchar *id = NULL;
1717
1718         /* Get transport account */
1719         acc_store = modest_runtime_get_account_store();
1720         account_name = modest_window_get_active_account (win);
1721
1722         /* If no account defined, this action must be always dimmed  */
1723         if (account_name == NULL) return FALSE;
1724         account = modest_tny_account_store_get_transport_account_for_open_connection (acc_store, account_name);
1725         if (!TNY_IS_TRANSPORT_ACCOUNT (account)) return FALSE;
1726
1727         /* Get send queue for current ransport account */
1728         send_queue = modest_runtime_get_send_queue (TNY_TRANSPORT_ACCOUNT(account));
1729         g_return_val_if_fail (MODEST_IS_TNY_SEND_QUEUE (send_queue), FALSE);
1730
1731         if (MODEST_IS_MAIN_WINDOW(win)) {
1732
1733                 /* Get header view to check selected messages */
1734                 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
1735                                                                    MODEST_WIDGET_TYPE_HEADER_VIEW);
1736
1737                 /* Check no selection */
1738                 if (!modest_header_view_has_selected_headers (MODEST_HEADER_VIEW(header_view)))
1739                     return FALSE;
1740
1741                 /* Get selected headers */
1742                 header_list = modest_header_view_get_selected_headers (MODEST_HEADER_VIEW(header_view));
1743
1744                 /* Get message header */
1745                 if (!header_list) return FALSE;
1746                 iter = tny_list_create_iterator (header_list);
1747                 header = TNY_HEADER (tny_iterator_get_current (iter));
1748
1749                 /* Get message id */
1750                 id = g_strdup(tny_header_get_message_id (header));
1751
1752         } else if (MODEST_IS_MSG_VIEW_WINDOW(win)) {
1753
1754                 /* Get message header */
1755                 header = modest_msg_view_window_get_header (MODEST_MSG_VIEW_WINDOW(win));
1756
1757                 /* Get message id */
1758                 id = g_strdup(tny_header_get_message_id (header));
1759         }
1760
1761         /* Check if msg id is being processed inside send queue */
1762         result = modest_tny_send_queue_msg_is_being_sent (send_queue, id);
1763
1764         /* Free */
1765         g_free(id);
1766         g_object_unref (header);
1767         g_object_unref(header_list);
1768         g_object_unref(iter);
1769
1770         return result;
1771 }
1772
1773
1774 static gboolean
1775 _sending_in_progress (ModestWindow *win)
1776 {
1777         ModestTnySendQueue *send_queue = NULL;
1778         ModestTnyAccountStore *acc_store = NULL;
1779         TnyAccount *account = NULL;
1780         const gchar *account_name = NULL;
1781         gboolean result = FALSE;
1782
1783         /* Get transport account */
1784         acc_store = modest_runtime_get_account_store();
1785         account_name = modest_window_get_active_account (win);
1786
1787         /* If no account defined, this action must be always dimmed  */
1788         if (account_name == NULL) return FALSE;
1789         account = modest_tny_account_store_get_transport_account_for_open_connection (acc_store, account_name);
1790         if (!TNY_IS_TRANSPORT_ACCOUNT (account)) return FALSE;
1791
1792         /* Get send queue for current ransport account */
1793         send_queue = modest_runtime_get_send_queue (TNY_TRANSPORT_ACCOUNT(account));
1794         g_return_val_if_fail (MODEST_IS_TNY_SEND_QUEUE (send_queue), FALSE);
1795
1796         /* Check if send queue is perfimring any send operation */
1797         result = modest_tny_send_queue_sending_in_progress (send_queue);
1798
1799         return result;
1800 }
1801
1802 static gboolean
1803 _invalid_folder_for_purge (ModestWindow *win,
1804                            ModestDimmingRule *rule)
1805 {
1806         TnyMsg *msg = NULL;
1807         TnyFolder *folder = NULL;
1808         TnyAccount *account = NULL;
1809         gboolean result = FALSE;
1810
1811         if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
1812
1813                 /* Get folder and account of message */
1814                 msg = modest_msg_view_window_get_message (MODEST_MSG_VIEW_WINDOW (win));
1815                 g_return_val_if_fail(msg != NULL, TRUE);
1816                 folder = tny_msg_get_folder (msg);
1817                 if (folder == NULL) {
1818                         modest_dimming_rule_set_notification (rule, _("mail_ib_unable_to_purge_attachments"));
1819                         goto frees;
1820                 }
1821                 g_object_unref (msg);
1822         } else if (MODEST_IS_MAIN_WINDOW (win)) {
1823                 GtkWidget *folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
1824                                                                               MODEST_WIDGET_TYPE_FOLDER_VIEW);
1825                 if (!folder_view)
1826                         return FALSE;
1827                 folder = TNY_FOLDER (modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view)));
1828                 if (folder == NULL || ! TNY_IS_FOLDER (folder))
1829                         return FALSE;
1830                 g_object_ref (folder);
1831
1832         } else {
1833                 g_return_val_if_reached (FALSE);
1834         }
1835         account = modest_tny_folder_get_account (folder);
1836         if (account == NULL) goto frees;
1837
1838         /* Check account */
1839         if (modest_tny_account_is_virtual_local_folders (TNY_ACCOUNT (account))) {
1840                 TnyFolderType types[2];
1841                 types[0] = TNY_FOLDER_TYPE_DRAFTS;
1842                 types[1] = TNY_FOLDER_TYPE_OUTBOX;
1843
1844                 if (_selected_folder_is_any_of_type (win, types, 2)) {
1845                         result = TRUE;
1846                         modest_dimming_rule_set_notification (rule, _("mail_ib_unable_to_purge_editable_msg"));
1847                 } else {
1848                         /* We're currently disabling purge in any local store */
1849                         result = TRUE;
1850                         modest_dimming_rule_set_notification (rule, _("mail_ib_unable_to_purge_attachments"));
1851                 }
1852         } else {
1853                 const gchar *proto_str = tny_account_get_proto (TNY_ACCOUNT (account));
1854                 /* If it's POP then dim */
1855                 if (modest_protocol_info_get_transport_store_protocol (proto_str) ==
1856                     MODEST_PROTOCOL_STORE_POP) {
1857                         GList *attachments;
1858                         gint n_selected;
1859                         result = TRUE;
1860                         attachments = modest_msg_view_window_get_attachments (MODEST_MSG_VIEW_WINDOW(win));
1861                         n_selected = g_list_length (attachments);
1862                         g_list_free (attachments);
1863
1864                         modest_dimming_rule_set_notification (rule,
1865                                                               ngettext ("mail_ib_unable_to_pure_attach_pop_mail_singular",
1866                                                                         "mail_ib_unable_to_pure_attach_pop_mail_plural",
1867                                                                         n_selected));
1868                 }
1869         }
1870
1871 frees:
1872         if (folder != NULL)
1873                 g_object_unref (folder);
1874         if (account != NULL)
1875                 g_object_unref (account);
1876
1877         return result;
1878 }
1879
1880 static gboolean
1881 _transfer_mode_enabled (ModestWindow *win)
1882 {
1883         gboolean result = FALSE;
1884
1885         g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW (win), FALSE);
1886
1887         /* Check dimming */
1888         result = modest_msg_view_window_transfer_mode_enabled (MODEST_MSG_VIEW_WINDOW (win));
1889
1890         return result;
1891 }