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