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-tny-account.h"
  39 #include "modest-text-utils.h"
  40 #include <widgets/modest-attachments-view.h>
  41 #include <modest-runtime.h>
  42 #include <tny-simple-list.h>
  43
  44
  45 static gboolean _folder_is_any_of_type (TnyFolder *folder, TnyFolderType types[], guint ntypes);
  46 static gboolean _invalid_msg_selected (ModestMainWindow *win, gboolean unique, ModestDimmingRule *rule);
  47 static gboolean _invalid_attach_selected (ModestWindow *win,
  48                                           gboolean unique, gboolean for_view, gboolean for_remove,
  49                                           ModestDimmingRule *rule);
  50 static gboolean _purged_attach_selected (ModestWindow *win, gboolean all, ModestDimmingRule *rule);
  51 static gboolean _clipboard_is_empty (ModestWindow *win);
  52 static gboolean _invalid_clipboard_selected (ModestWindow *win, ModestDimmingRule *rule);
  53 static gboolean _selected_folder_not_writeable (ModestMainWindow *win, gboolean for_paste);
  54 static gboolean _selected_folder_not_moveable (ModestMainWindow *win);
  55 static gboolean _selected_folder_not_renameable (ModestMainWindow *win);
  56 static gboolean _selected_folder_not_deletable (ModestMainWindow *win);
  57 static gboolean _selected_folder_is_any_of_type (ModestWindow *win, TnyFolderType types[], guint ntypes);
  58 static gboolean _selected_folder_is_root_or_inbox (ModestMainWindow *win);
  59 static gboolean _selected_folder_is_MMC_or_POP_root (ModestMainWindow *win);
  60 static gboolean _selected_folder_is_root (ModestMainWindow *win);
  61 static gboolean _header_view_is_all_selected (ModestMainWindow *win);
  62 static gboolean _selected_folder_is_empty (ModestMainWindow *win);
  63 static gboolean _folder_view_has_focus (ModestWindow *win);
  64 static gboolean _selected_folder_is_same_as_source (ModestWindow *win);
  65 static gboolean _msg_download_in_progress (ModestMsgViewWindow *win);
  66 static gboolean _msg_download_completed (ModestMainWindow *win);
  67 static gboolean _selected_msg_sent_in_progress (ModestWindow *win);
  68 static gboolean _sending_in_progress (ModestWindow *win);
  69 static gboolean _invalid_folder_for_purge (ModestWindow *win, ModestDimmingRule *rule);
  70 static gboolean _transfer_mode_enabled (ModestWindow *win);
  71 static gboolean _selected_folder_has_subfolder_with_same_name (ModestWindow *win);
  72 static void fill_list_of_caches (gpointer key, gpointer value, gpointer userdata);
  73
  74
  75 static DimmedState *
  76 _define_main_window_dimming_state (ModestMainWindow *window)
  77 {
  78         DimmedState *state = NULL;
  79         GtkWidget *focused_widget = NULL;
  80         GtkWidget *header_view = NULL;
  81         GtkTreeModel *model = NULL;
  82         TnyList *selected_headers = NULL;
  83         TnyIterator *iter = NULL;
  84         TnyHeader *header = NULL;
  85         ModestCacheMgr *cache_mgr = NULL;
  86         GHashTable *send_queue_cache = NULL;
  87         ModestTnySendQueue *send_queue = NULL;
  88         GSList *send_queues = NULL, *node = NULL;
  89         ModestWindowMgr *mgr = NULL;
  90         gboolean found = FALSE;
  91         gchar *msg_uid = NULL;
  92         TnyHeaderFlags flags;
  93         gboolean all_deleted = TRUE;
  94         gboolean all_seen = TRUE;
  95         gboolean all_cached = TRUE;
  96         gboolean all_has_attach = TRUE;
  97
  98         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(window), NULL);
  99
 100         /* Init state */
 101         state = g_slice_new0 (DimmedState);
 102         state->n_selected = 0;
 103         state->already_opened_msg = FALSE;
 104         state->any_marked_as_deleted = FALSE;
 105         state->all_marked_as_deleted = FALSE;
 106         state->any_marked_as_seen = FALSE;
 107         state->all_marked_as_seen = FALSE;
 108         state->any_marked_as_cached = FALSE;
 109         state->all_marked_as_cached = FALSE;
 110         state->any_has_attachments = FALSE;
 111         state->all_has_attachments = FALSE;
 112         state->sent_in_progress = FALSE;
 113         state->all_selected = FALSE;
 114
 115         /* Get focused widget */
 116         focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
 117         if (MODEST_IS_FOLDER_VIEW (focused_widget)) {
 118                 state->n_selected++;
 119                 return state;
 120         } else if (MODEST_IS_HEADER_VIEW (focused_widget)) {
 121                 header_view = focused_widget;
 122         } else {
 123                 header_view = modest_main_window_get_child_widget (window, MODEST_WIDGET_TYPE_HEADER_VIEW);
 124         }
 125
 126         /* Get header view and selected headers */
 127         selected_headers = modest_header_view_get_selected_headers (MODEST_HEADER_VIEW(header_view));
 128         if (!selected_headers)
 129                 return state;
 130
 131         /* Examine selected headers */
 132         iter = tny_list_create_iterator (selected_headers);
 133         while (!tny_iterator_is_done (iter)) {
 134                 header = TNY_HEADER (tny_iterator_get_current (iter));
 135                 flags = tny_header_get_flags (header);
 136
 137                 /* No selected */
 138                 state->n_selected++;
 139
 140                 /* Already opened */
 141                 mgr = modest_runtime_get_window_mgr ();
 142                 if (!state->already_opened_msg)
 143                         state->already_opened_msg = modest_window_mgr_find_registered_header (mgr, header, NULL);
 144
 145
 146                 /* Mark as deleted */
 147                 all_deleted = all_deleted && (flags & TNY_HEADER_FLAG_DELETED);
 148                 state->all_marked_as_deleted = all_deleted;
 149                 if (!state->any_marked_as_deleted)
 150                         state->any_marked_as_deleted = flags & TNY_HEADER_FLAG_DELETED;
 151
 152                 /* Mark as seen */
 153                 all_seen = all_seen && (flags & TNY_HEADER_FLAG_SEEN);
 154                 state->all_marked_as_seen = all_seen;
 155                 if (!state->any_marked_as_seen)
 156                         state->any_marked_as_seen = flags & TNY_HEADER_FLAG_SEEN;
 157
 158                 /* Mark as cached */
 159                 all_cached = all_cached && (flags & TNY_HEADER_FLAG_CACHED);
 160                 state->all_marked_as_cached = all_cached;
 161                 if (!state->any_marked_as_cached)
 162                         state->any_marked_as_cached = flags & TNY_HEADER_FLAG_CACHED;
 163
 164                 /* Mark has_attachments */
 165                 all_has_attach = all_has_attach && (flags & TNY_HEADER_FLAG_ATTACHMENTS);
 166                 state->all_has_attachments = all_has_attach;
 167                 if (!state->any_has_attachments)
 168                         state->any_has_attachments = flags & TNY_HEADER_FLAG_ATTACHMENTS;
 169
 170                 /* sent in progress */
 171                 msg_uid = modest_tny_send_queue_get_msg_id (header);
 172                 if (!state->sent_in_progress) {
 173                         cache_mgr = modest_runtime_get_cache_mgr ();
 174                         send_queue_cache = modest_cache_mgr_get_cache (cache_mgr,
 175                                                                        MODEST_CACHE_MGR_CACHE_TYPE_SEND_QUEUE);
 176
 177                         g_hash_table_foreach (send_queue_cache, (GHFunc) fill_list_of_caches, &send_queues);
 178
 179                         for (node = send_queues; node != NULL && !found; node = g_slist_next (node)) {
 180                                 send_queue = MODEST_TNY_SEND_QUEUE (node->data);
 181
 182                                 /* Check if msg uid is being processed inside send queue */
 183                                 found = modest_tny_send_queue_msg_is_being_sent (send_queue, msg_uid);
 184                         }
 185                         state->sent_in_progress = found;
 186                 }
 187
 188                 tny_iterator_next (iter);
 189                 g_object_unref (header);
 190         }
 191
 192         /* check if all the headers are selected or not */
 193         model = gtk_tree_view_get_model(GTK_TREE_VIEW(header_view));
 194         if (model != NULL){
 195                 gint count;
 196                 count = gtk_tree_model_iter_n_children(model, NULL);
 197                 if(state->n_selected == count != 0)
 198                         state->all_selected = TRUE;
 199         }
 200
 201         /* Free */
 202         g_free(msg_uid);
 203         g_object_unref(selected_headers);
 204         g_object_unref(iter);
 205         g_slist_free (send_queues);
 206
 207         return state;
 208 }
 209
 210 static DimmedState *
 211 _define_msg_view_window_dimming_state (ModestMsgViewWindow *window)
 212 {
 213         DimmedState *state = NULL;
 214         TnyHeader *header = NULL;
 215         ModestCacheMgr *cache_mgr = NULL;
 216         GHashTable *send_queue_cache = NULL;
 217         ModestTnySendQueue *send_queue = NULL;
 218         GSList *send_queues = NULL, *node = NULL;
 219         gboolean found = FALSE;
 220         gchar *msg_uid = NULL;
 221         TnyHeaderFlags flags;
 222         gboolean all_deleted = TRUE;
 223         gboolean all_seen = TRUE;
 224         gboolean all_cached = TRUE;
 225         gboolean all_has_attach = TRUE;
 226
 227         g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW(window), NULL);
 228
 229         /* Init state */
 230         state = g_slice_new0 (DimmedState);
 231         state->n_selected = 0;
 232         state->already_opened_msg = FALSE;
 233         state->any_marked_as_deleted = FALSE;
 234         state->all_marked_as_deleted = FALSE;
 235         state->any_marked_as_seen = FALSE;
 236         state->all_marked_as_seen = FALSE;
 237         state->any_marked_as_cached = FALSE;
 238         state->all_marked_as_cached = FALSE;
 239         state->any_has_attachments = FALSE;
 240         state->all_has_attachments = FALSE;
 241         state->sent_in_progress = FALSE;
 242
 243         header = modest_msg_view_window_get_header (MODEST_MSG_VIEW_WINDOW(window));
 244         g_return_val_if_fail (TNY_IS_HEADER(header), state);
 245         flags = tny_header_get_flags (header);
 246
 247         /* Selected */
 248         state->n_selected++;
 249
 250         /* Mark as deleted */
 251         all_deleted = all_deleted && (flags & TNY_HEADER_FLAG_DELETED);
 252         state->all_marked_as_deleted = all_deleted;
 253         if (!state->any_marked_as_deleted)
 254                 state->any_marked_as_deleted = flags & TNY_HEADER_FLAG_DELETED;
 255
 256         /* Mark as seen */
 257         all_seen = all_seen && (flags & TNY_HEADER_FLAG_SEEN);
 258         state->all_marked_as_seen = all_seen;
 259         if (!state->any_marked_as_seen)
 260                 state->any_marked_as_seen = flags & TNY_HEADER_FLAG_SEEN;
 261
 262         /* Mark as cached */
 263         all_cached = all_cached && (flags & TNY_HEADER_FLAG_CACHED);
 264         state->all_marked_as_cached = all_cached;
 265         if (!state->any_marked_as_cached)
 266                 state->any_marked_as_cached = flags & TNY_HEADER_FLAG_CACHED;
 267
 268         /* Mark has_attachments */
 269         all_has_attach = all_has_attach && (flags & TNY_HEADER_FLAG_ATTACHMENTS);
 270         state->all_has_attachments = all_has_attach;
 271         if (!state->any_has_attachments)
 272                 state->any_has_attachments = flags & TNY_HEADER_FLAG_ATTACHMENTS;
 273
 274         /* sent in progress */
 275         msg_uid = modest_tny_send_queue_get_msg_id (header);
 276         if (!state->sent_in_progress) {
 277                 cache_mgr = modest_runtime_get_cache_mgr ();
 278                 send_queue_cache = modest_cache_mgr_get_cache (cache_mgr,
 279                                                                MODEST_CACHE_MGR_CACHE_TYPE_SEND_QUEUE);
 280
 281                 g_hash_table_foreach (send_queue_cache, (GHFunc) fill_list_of_caches, &send_queues);
 282
 283                 for (node = send_queues; node != NULL && !found; node = g_slist_next (node)) {
 284                         send_queue = MODEST_TNY_SEND_QUEUE (node->data);
 285
 286                         /* Check if msg uid is being processed inside send queue */
 287                         found = modest_tny_send_queue_msg_is_being_sent (send_queue, msg_uid);
 288                 }
 289                 state->sent_in_progress = found;
 290         }
 291
 292         /* Free */
 293         g_free(msg_uid);
 294         g_object_unref (header);
 295         g_slist_free (send_queues);
 296
 297         return state;
 298 }
 299
 300
 301 DimmedState *
 302 modest_ui_dimming_rules_define_dimming_state (ModestWindow *window)
 303 {
 304         DimmedState *state = NULL;
 305
 306         g_return_val_if_fail (MODEST_IS_WINDOW(window), NULL);
 307
 308         if (MODEST_IS_MAIN_WINDOW (window))
 309                 state = _define_main_window_dimming_state (MODEST_MAIN_WINDOW(window));
 310         else if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
 311                 state = _define_msg_view_window_dimming_state (MODEST_MSG_VIEW_WINDOW(window));
 312         }
 313
 314         return state;
 315 }
 316
 317
 318 gboolean
 319 modest_ui_dimming_rules_on_new_msg (ModestWindow *win, gpointer user_data)
 320 {
 321         ModestDimmingRule *rule = NULL;
 322         gboolean dimmed = FALSE;
 323
 324         g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW(win), FALSE);
 325         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 326         rule = MODEST_DIMMING_RULE (user_data);
 327
 328         /* Check dimmed rule */
 329         if (!dimmed) {
 330                 dimmed = _msg_download_in_progress (MODEST_MSG_VIEW_WINDOW(win));
 331                 if (dimmed)
 332                         modest_dimming_rule_set_notification (rule, "");
 333         }
 334
 335         return dimmed;
 336 }
 337
 338 gboolean
 339 modest_ui_dimming_rules_on_new_folder (ModestWindow *win, gpointer user_data)
 340 {
 341         ModestDimmingRule *rule = NULL;
 342         GtkWidget *folder_view = NULL;
 343         TnyFolderStore *parent_folder = NULL;
 344         gboolean dimmed = FALSE;
 345
 346         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
 347         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 348         rule = MODEST_DIMMING_RULE (user_data);
 349
 350         /* Get selected folder as parent of new folder to create */
 351         folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
 352                                                            MODEST_WIDGET_TYPE_FOLDER_VIEW);
 353         parent_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
 354         if (!parent_folder)
 355                 return TRUE;
 356
 357         if (TNY_IS_ACCOUNT (parent_folder)) {
 358                 /* If it's the local account then do not dim */
 359                 if (modest_tny_account_is_virtual_local_folders (TNY_ACCOUNT (parent_folder))) {
 360                         dimmed = FALSE;
 361                 } else {
 362                         const gchar *proto_str = tny_account_get_proto (TNY_ACCOUNT (parent_folder));
 363                         if (proto_str != NULL) {
 364                                 /* If it's POP then dim */
 365                                 dimmed = (modest_protocol_info_get_transport_store_protocol (proto_str) ==
 366                                           MODEST_PROTOCOL_STORE_POP) ? TRUE : FALSE;
 367                                 if (dimmed)
 368                                         modest_dimming_rule_set_notification (rule, _("mail_in_ui_folder_create_error"));
 369                         }
 370                 }
 371         } else {
 372                 /* TODO: the specs say that only one level of subfolder is allowed, is this true ? */
 373
 374                 TnyFolderType types[3];
 375
 376                 types[0] = TNY_FOLDER_TYPE_DRAFTS;
 377                 types[1] = TNY_FOLDER_TYPE_OUTBOX;
 378                 types[2] = TNY_FOLDER_TYPE_SENT;
 379
 380                 /* Apply folder rules */
 381                 if (!dimmed) {
 382                         dimmed = _selected_folder_not_writeable (MODEST_MAIN_WINDOW(win), FALSE);
 383                         if (dimmed)
 384                                 modest_dimming_rule_set_notification (rule, _("mail_in_ui_folder_create_error"));
 385                 }
 386                 if (!dimmed) {
 387                         dimmed = _selected_folder_is_any_of_type (win, types, 3);
 388                         if (dimmed)
 389                                 modest_dimming_rule_set_notification (rule, _("mail_in_ui_folder_create_error"));
 390                 }
 391         }
 392
 393         /* if not the folder is selected then dim */
 394         folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
 395                                                            MODEST_WIDGET_TYPE_FOLDER_VIEW);
 396         if (folder_view && !gtk_widget_is_focus (folder_view))
 397                 dimmed = TRUE;
 398
 399         g_object_unref (parent_folder);
 400
 401         return dimmed;
 402 }
 403
 404 gboolean
 405 modest_ui_dimming_rules_on_delete (ModestWindow *win, gpointer user_data)
 406 {
 407         ModestDimmingRule *rule = NULL;
 408         GtkWidget *folder_view = NULL;
 409         GtkWidget *header_view = NULL;
 410         gboolean dimmed = FALSE;
 411
 412         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 413         rule = MODEST_DIMMING_RULE (user_data);
 414
 415         if (MODEST_IS_MAIN_WINDOW (win)) {
 416                 /* Get the folder view */
 417                 folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
 418                                                                    MODEST_WIDGET_TYPE_FOLDER_VIEW);
 419
 420                 /* Get header view */
 421                 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
 422                                                            MODEST_WIDGET_TYPE_HEADER_VIEW);
 423
 424                 if (header_view && gtk_widget_is_focus (header_view))
 425                         dimmed = modest_ui_dimming_rules_on_delete_msg (win, rule);
 426
 427                 if (folder_view && gtk_widget_is_focus (folder_view))
 428                         dimmed = modest_ui_dimming_rules_on_delete_folder (win, rule);
 429
 430                 if (header_view && folder_view &&
 431                     !gtk_widget_is_focus (header_view) &&
 432                     !gtk_widget_is_focus (folder_view)) {
 433                         dimmed = TRUE;
 434                         modest_dimming_rule_set_notification (rule, dgettext("hildon-common-strings", "ckct_ib_nothing_to_delete"));
 435                 }
 436         } else {
 437                 dimmed = modest_ui_dimming_rules_on_delete_folder (win, rule);
 438         }
 439
 440         return dimmed;
 441 }
 442
 443
 444
 445 gboolean
 446 modest_ui_dimming_rules_on_delete_folder (ModestWindow *win, gpointer user_data)
 447 {
 448         ModestDimmingRule *rule = NULL;
 449         TnyFolderType types[6];
 450         gboolean dimmed = FALSE;
 451
 452         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
 453         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 454         rule = MODEST_DIMMING_RULE (user_data);
 455
 456         types[0] = TNY_FOLDER_TYPE_DRAFTS;
 457         types[1] = TNY_FOLDER_TYPE_OUTBOX;
 458         types[2] = TNY_FOLDER_TYPE_SENT;
 459         types[3] = TNY_FOLDER_TYPE_INBOX;
 460         types[4] = TNY_FOLDER_TYPE_ROOT;
 461         types[5] = TNY_FOLDER_TYPE_ARCHIVE;
 462
 463
 464         /* Check dimmed rule */
 465         if (!dimmed) {
 466                 dimmed = _selected_folder_not_deletable (MODEST_MAIN_WINDOW(win));
 467                 if (dimmed)
 468                         modest_dimming_rule_set_notification (rule, _("mail_in_ui_folder_delete_error"));
 469         }
 470         if (!dimmed) {
 471                 dimmed = _selected_folder_is_any_of_type (win, types, 6);
 472                 if (dimmed)
 473                         modest_dimming_rule_set_notification (rule, _("mail_in_ui_folder_delete_error"));
 474         }
 475         if (!dimmed) {
 476                 dimmed = _selected_folder_is_root_or_inbox (MODEST_MAIN_WINDOW(win));
 477                 if (dimmed)
 478                         modest_dimming_rule_set_notification (rule, _("mail_in_ui_folder_delete_error"));
 479         }
 480         if (!dimmed) {
 481                 dimmed = _selected_folder_is_MMC_or_POP_root (MODEST_MAIN_WINDOW(win));
 482                 if (dimmed)
 483                         modest_dimming_rule_set_notification (rule, _("mail_in_ui_folder_delete_error"));
 484         }
 485         if (!dimmed) {
 486                 dimmed = _transfer_mode_enabled (win);
 487                 if (dimmed)
 488                         modest_dimming_rule_set_notification (rule, _CS("ckct_ib_unable_to_delete"));
 489         }
 490
 491         return dimmed;
 492 }
 493
 494 gboolean
 495 modest_ui_dimming_rules_on_sort (ModestWindow *win, gpointer user_data)
 496 {
 497         ModestDimmingRule *rule = NULL;
 498         gboolean dimmed = FALSE;
 499
 500         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
 501         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 502         rule = MODEST_DIMMING_RULE (user_data);
 503
 504         /* Check dimmed rule */
 505         if (!dimmed) {
 506                 dimmed = _selected_folder_is_root (MODEST_MAIN_WINDOW(win));
 507                 modest_dimming_rule_set_notification (rule, _CS("ckdg_ib_nothing_to_sort"));
 508         }
 509
 510         if (!dimmed) {
 511                 dimmed = _selected_folder_is_empty (MODEST_MAIN_WINDOW(win));
 512                 modest_dimming_rule_set_notification (rule, _CS("ckdg_ib_nothing_to_sort"));
 513         }
 514
 515         return dimmed;
 516
 517 }
 518
 519 gboolean
 520 modest_ui_dimming_rules_on_rename_folder (ModestWindow *win, gpointer user_data)
 521 {
 522         ModestDimmingRule *rule = NULL;
 523         TnyFolderType types[4];
 524         gboolean dimmed = FALSE;
 525
 526         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
 527         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 528         rule = MODEST_DIMMING_RULE (user_data);
 529
 530         types[0] = TNY_FOLDER_TYPE_DRAFTS;
 531         types[1] = TNY_FOLDER_TYPE_OUTBOX;
 532         types[2] = TNY_FOLDER_TYPE_SENT;
 533         types[3] = TNY_FOLDER_TYPE_ARCHIVE;
 534
 535         /* Check dimmed rule */
 536         if (!dimmed) {
 537                 dimmed = _selected_folder_not_renameable (MODEST_MAIN_WINDOW(win));
 538                 if (dimmed)
 539                         modest_dimming_rule_set_notification (rule, "");
 540         }
 541         if (!dimmed) {
 542                 dimmed = _selected_folder_is_root_or_inbox (MODEST_MAIN_WINDOW(win));
 543                 if (dimmed)
 544                         modest_dimming_rule_set_notification (rule, "");
 545         }
 546         if (!dimmed) {
 547                 dimmed = _selected_folder_is_any_of_type (win, types, 4);
 548                 if (dimmed)
 549                         modest_dimming_rule_set_notification (rule, "");
 550         }
 551
 552         return dimmed;
 553 }
 554
 555 gboolean
 556 modest_ui_dimming_rules_on_open_msg (ModestWindow *win, gpointer user_data)
 557 {
 558         ModestDimmingRule *rule = NULL;
 559         gboolean dimmed = FALSE;
 560         const DimmedState *state = NULL;
 561
 562         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
 563         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 564         rule = MODEST_DIMMING_RULE (user_data);
 565         state = modest_window_get_dimming_state (win);
 566
 567         /* Check dimmed rule */
 568         if (!dimmed) {
 569                 dimmed = _invalid_msg_selected (MODEST_MAIN_WINDOW(win), TRUE, user_data);
 570         }
 571         if (!dimmed) {
 572                 dimmed = state->any_marked_as_deleted;
 573                 if (dimmed)
 574                         modest_dimming_rule_set_notification (rule, _("mcen_ib_message_already_deleted"));
 575         }
 576         if (!dimmed) {
 577                 dimmed = _selected_msg_sent_in_progress (win);
 578                 if (dimmed)
 579                         modest_dimming_rule_set_notification (rule, _("mcen_ib_unable_to_open_while_sent"));
 580         }
 581
 582         return dimmed;
 583 }
 584
 585 gboolean
 586 modest_ui_dimming_rules_on_reply_msg (ModestWindow *win, gpointer user_data)
 587 {
 588         ModestDimmingRule *rule = NULL;
 589         gboolean dimmed = FALSE;
 590         TnyFolderType types[3];
 591
 592         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 593         rule = MODEST_DIMMING_RULE (user_data);
 594
 595         /* main window dimming rules */
 596         if (MODEST_IS_MAIN_WINDOW(win)) {
 597
 598                 types[0] = TNY_FOLDER_TYPE_DRAFTS;
 599                 types[1] = TNY_FOLDER_TYPE_OUTBOX;
 600                 types[2] = TNY_FOLDER_TYPE_ROOT;
 601
 602                 /* Check dimmed rule */
 603                 if (!dimmed) {
 604                         dimmed = _selected_folder_is_any_of_type (win, types, 3);
 605                         if (dimmed)
 606                                 modest_dimming_rule_set_notification (rule, _("mcen_ib_unable_to_reply"));
 607                 }
 608                 if (!dimmed) {
 609                         dimmed = _selected_folder_is_empty (MODEST_MAIN_WINDOW(win));
 610                         if (dimmed)
 611                                 modest_dimming_rule_set_notification (rule, _("mcen_ib_nothing_to_reply"));
 612                 }
 613                 if (!dimmed) {
 614                         dimmed = _invalid_msg_selected (MODEST_MAIN_WINDOW(win), TRUE, rule);
 615                 }
 616         /* msg view window dimming rules */
 617         } else if (MODEST_IS_MSG_VIEW_WINDOW(win)) {
 618
 619                 /* Check dimmed rule */
 620                 if (!dimmed) {
 621                         dimmed = _transfer_mode_enabled (win);
 622                         if (dimmed)
 623                                 modest_dimming_rule_set_notification (rule, _("mail_ib_notavailable_downloading"));
 624                 }
 625                 if (!dimmed) {
 626                         dimmed = _msg_download_in_progress (MODEST_MSG_VIEW_WINDOW (win));
 627                         if (dimmed)
 628                                 modest_dimming_rule_set_notification (rule, _("mcen_ib_unable_to_reply"));
 629                 }
 630         }
 631
 632         return dimmed;
 633 }
 634
 635
 636 gboolean
 637 modest_ui_dimming_rules_on_contents_msg (ModestWindow *win, gpointer user_data)
 638 {
 639         ModestDimmingRule *rule = NULL;
 640         gboolean dimmed = FALSE;
 641
 642         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
 643         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 644         rule = MODEST_DIMMING_RULE (user_data);
 645
 646         /* Check dimmed rule */
 647         if (!dimmed) {
 648                 dimmed = _invalid_msg_selected (MODEST_MAIN_WINDOW(win), FALSE, user_data);
 649         }
 650         if (!dimmed) {
 651                 dimmed = _msg_download_completed (MODEST_MAIN_WINDOW(win));
 652                 if (dimmed)
 653                         modest_dimming_rule_set_notification (rule, "");
 654         }
 655
 656         return dimmed;
 657 }
 658
 659 gboolean
 660 modest_ui_dimming_rules_always_dimmed (ModestWindow *win, gpointer user_data)
 661 {
 662         gboolean dimmed = FALSE;
 663
 664         g_return_val_if_fail (MODEST_IS_WINDOW(win), FALSE);
 665
 666         /* Check dimmed rule */
 667         if (!dimmed)
 668                 dimmed = TRUE;
 669
 670         return dimmed;
 671 }
 672
 673 gboolean
 674 modest_ui_dimming_rules_on_delete_msg (ModestWindow *win, gpointer user_data)
 675 {
 676         ModestDimmingRule *rule = NULL;
 677         guint n_messages = 0;
 678         const DimmedState *state = NULL;
 679         gboolean dimmed = FALSE;
 680
 681         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 682         rule = MODEST_DIMMING_RULE (user_data);
 683         state = modest_window_get_dimming_state (win);
 684
 685         /* Check dimmed rule */
 686         if (MODEST_IS_MAIN_WINDOW (win)) {
 687                 if (!dimmed) {
 688                         dimmed = _selected_folder_is_empty (MODEST_MAIN_WINDOW(win));
 689                         if (dimmed)
 690                                 modest_dimming_rule_set_notification (rule, _CS("ckct_ib_nothing_to_delete"));
 691                 }
 692                 if (!dimmed) {
 693                         dimmed = _invalid_msg_selected (MODEST_MAIN_WINDOW(win), FALSE, user_data);
 694                 }
 695                 if (!dimmed) {
 696                         dimmed = state->already_opened_msg;
 697                         n_messages = state->n_selected;
 698                         if (dimmed) {
 699                                 gchar *num = g_strdup_printf ("%d", n_messages);
 700                                 gchar *message = g_strdup_printf(_("mcen_nc_unable_to_delete_n_messages"), num);
 701                                 modest_dimming_rule_set_notification (rule, message);
 702                                 g_free(message);
 703                                 g_free(num);
 704                         }
 705
 706                 }
 707                 if (!dimmed) {
 708                         dimmed = state->any_marked_as_deleted;
 709                         if (dimmed) {
 710                                 modest_dimming_rule_set_notification (rule, _("mcen_ib_message_already_deleted"));
 711                         }
 712                 }
 713                 if (!dimmed) {
 714                         dimmed = state->sent_in_progress;
 715                         if (dimmed)
 716                                 modest_dimming_rule_set_notification (rule, _CS("ckct_ib_unable_to_delete"));
 717                 }
 718         }
 719         else if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
 720                 if (!dimmed) {
 721                         dimmed = _transfer_mode_enabled (win);
 722                         if (dimmed)
 723                                 modest_dimming_rule_set_notification (rule, _("mail_ib_notavailable_downloading"));
 724                 }
 725                 if (!dimmed) {
 726                         dimmed = state->any_marked_as_deleted;
 727                         if (dimmed)
 728                                 modest_dimming_rule_set_notification (rule, _("mcen_ib_message_already_deleted"));
 729                 }
 730
 731                 /* The delete button should be dimmed when viewing an attachment,
 732                  * but should be enabled when viewing a message from the list,
 733                  * or when viewing a search result.
 734                  */
 735                 if (!dimmed) {
 736                         if (!modest_msg_view_window_is_search_result (MODEST_MSG_VIEW_WINDOW(win))) {
 737                                 dimmed = !modest_msg_view_window_has_headers_model (MODEST_MSG_VIEW_WINDOW(win));
 738                                 if (dimmed) {
 739                                         modest_dimming_rule_set_notification (rule, _CS("ckct_ib_unable_to_delete"));
 740                                 }
 741                         }
 742                 }
 743         }
 744
 745         return dimmed;
 746 }
 747
 748 gboolean
 749 modest_ui_dimming_rules_on_details (ModestWindow *win, gpointer user_data)
 750 {
 751         ModestDimmingRule *rule = NULL;
 752         GtkWidget *header_view = NULL;
 753         gboolean dimmed = FALSE;
 754
 755         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 756         rule = MODEST_DIMMING_RULE (user_data);
 757
 758         /* main window dimming rules */
 759         if (MODEST_IS_MAIN_WINDOW(win)) {
 760
 761                 /* Check dimmed rule */
 762                 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
 763                                                                    MODEST_WIDGET_TYPE_HEADER_VIEW);
 764
 765                 /* If the header view has the focus: */
 766                 if (header_view && gtk_widget_is_focus (header_view)) {
 767                         /* Check dimmed rule */
 768                         if (!dimmed)
 769                                 dimmed = _invalid_msg_selected (MODEST_MAIN_WINDOW(win), TRUE, user_data);
 770                 }
 771                 else {
 772                         /* If the folder view has the focus: */
 773                         GtkWidget *folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
 774                                 MODEST_WIDGET_TYPE_FOLDER_VIEW);
 775                         if (folder_view && gtk_widget_is_focus (folder_view)) {
 776                                 TnyFolderStore *folder_store
 777                                         = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
 778                                 if (folder_store) {
 779                                         /* Only enable for folders, not accounts,
 780                                          * though the UI spec is not clear about that.
 781                                          * If we enable this for accounts then we must
 782                                          * add code to handle them in modest_ui_actions_on_details(). */
 783                                         if (!TNY_IS_FOLDER(folder_store)) {
 784                                                 dimmed = TRUE;
 785                                                 modest_dimming_rule_set_notification (rule, "");
 786                                         }
 787
 788                                         g_object_unref (folder_store);
 789                                 }
 790                         }
 791
 792                 }
 793
 794         /* msg view window dimming rules */
 795         } else {
 796
 797                 /* Check dimmed rule */
 798                 if (!dimmed) {
 799                         if (MODEST_IS_MSG_VIEW_WINDOW (win))
 800                                 dimmed = _msg_download_in_progress (MODEST_MSG_VIEW_WINDOW (win));
 801                         if (dimmed)
 802                                 modest_dimming_rule_set_notification (rule, "");
 803                 }
 804         }
 805
 806         return dimmed;
 807 }
 808
 809
 810 gboolean
 811 modest_ui_dimming_rules_on_mark_as_read_msg (ModestWindow *win, gpointer user_data)
 812 {
 813         ModestDimmingRule *rule = NULL;
 814         TnyHeaderFlags flags;
 815         const DimmedState *state = NULL;
 816         gboolean dimmed = FALSE;
 817
 818         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
 819         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 820         rule = MODEST_DIMMING_RULE (user_data);
 821         state = modest_window_get_dimming_state (win);
 822
 823         flags = TNY_HEADER_FLAG_SEEN;
 824
 825         /* Check dimmed rule */
 826         if (!dimmed) {
 827                 dimmed = _invalid_msg_selected (MODEST_MAIN_WINDOW(win), FALSE, user_data);
 828         }
 829         if (!dimmed) {
 830                 dimmed = state->all_marked_as_seen;
 831                 if (dimmed)
 832                         modest_dimming_rule_set_notification (rule, "");
 833         }
 834
 835         return dimmed;
 836 }
 837
 838 gboolean
 839 modest_ui_dimming_rules_on_mark_as_unread_msg (ModestWindow *win, gpointer user_data)
 840 {
 841         ModestDimmingRule *rule = NULL;
 842         TnyHeaderFlags flags;
 843         const DimmedState *state = NULL;
 844         gboolean dimmed = FALSE;
 845
 846         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
 847         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 848         rule = MODEST_DIMMING_RULE (user_data);
 849         state = modest_window_get_dimming_state (win);
 850
 851         flags = TNY_HEADER_FLAG_SEEN;
 852
 853         /* Check dimmed rule */
 854         if (!dimmed)
 855                 dimmed = _invalid_msg_selected (MODEST_MAIN_WINDOW(win), FALSE, user_data);
 856         if (!dimmed) {
 857                 dimmed = !state->any_marked_as_seen;
 858                 if (dimmed)
 859                         modest_dimming_rule_set_notification (rule, "");
 860         }
 861
 862         return dimmed;
 863 }
 864
 865 gboolean
 866 modest_ui_dimming_rules_on_move_to (ModestWindow *win, gpointer user_data)
 867 {
 868         ModestDimmingRule *rule = NULL;
 869         gboolean dimmed = FALSE;
 870
 871         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 872         rule = MODEST_DIMMING_RULE (user_data);
 873
 874         if (MODEST_IS_MAIN_WINDOW (win))
 875                 dimmed = modest_ui_dimming_rules_on_main_window_move_to (win, user_data);
 876         else if (MODEST_IS_MSG_VIEW_WINDOW (win))
 877                  dimmed = modest_ui_dimming_rules_on_view_window_move_to (win, user_data);
 878
 879         return dimmed;
 880 }
 881
 882
 883 gboolean
 884 modest_ui_dimming_rules_on_main_window_move_to (ModestWindow *win, gpointer user_data)
 885 {
 886         GtkWidget *folder_view = NULL;
 887         ModestDimmingRule *rule = NULL;
 888         guint n_messages = 0;
 889         const DimmedState *state = NULL;
 890         gboolean dimmed = FALSE;
 891
 892         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), TRUE);
 893         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 894         rule = MODEST_DIMMING_RULE (user_data);
 895         state = modest_window_get_dimming_state (win);
 896
 897         /* Get the folder view */
 898         folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
 899                                                            MODEST_WIDGET_TYPE_FOLDER_VIEW);
 900
 901
 902         /* Check diming rules for folders transfer  */
 903         if (gtk_widget_is_focus (folder_view)) {
 904                 TnyFolderType types[5];
 905
 906                 types[0] = TNY_FOLDER_TYPE_DRAFTS;
 907                 types[1] = TNY_FOLDER_TYPE_OUTBOX;
 908                 types[2] = TNY_FOLDER_TYPE_SENT;
 909                 types[3] = TNY_FOLDER_TYPE_ROOT;
 910                 types[4] = TNY_FOLDER_TYPE_INBOX;
 911
 912                 /* Apply folder rules */
 913                 if (!dimmed) {
 914                         dimmed = _selected_folder_not_moveable (MODEST_MAIN_WINDOW(win));
 915                         if (dimmed)
 916                                 modest_dimming_rule_set_notification (rule, _("emev_bd_unabletomove_items"));
 917                 }
 918                 if (!dimmed) {
 919                         dimmed = _selected_folder_is_any_of_type (win, types, 5);
 920                         if (dimmed)
 921                                 modest_dimming_rule_set_notification (rule, _("emev_bd_unabletomove_itemsr"));
 922                 }
 923         }
 924
 925         /* Check diming rules for messages transfer  */
 926         if (!dimmed) {
 927                 dimmed = state->already_opened_msg;
 928                 n_messages = state->n_selected;
 929                 if (dimmed) {
 930                         gchar *message = g_strdup_printf(_("emev_bd_unabletomove_items"), n_messages);
 931                         modest_dimming_rule_set_notification (rule, message);
 932                         g_free(message);
 933                 }
 934         }
 935         if (!dimmed) {
 936                 if (!gtk_widget_is_focus (folder_view))
 937                         dimmed = _invalid_msg_selected (MODEST_MAIN_WINDOW(win), FALSE, user_data);
 938
 939         }
 940         if (!dimmed) {
 941                 dimmed = _selected_msg_sent_in_progress (win);
 942                 if (dimmed)
 943                         modest_dimming_rule_set_notification (rule, _("sfil_ib_unable_to_move_selected_items"));
 944         }
 945
 946         return dimmed;
 947 }
 948
 949 gboolean
 950 modest_ui_dimming_rules_on_view_window_move_to (ModestWindow *win, gpointer user_data)
 951 {
 952         ModestDimmingRule *rule = NULL;
 953         gboolean dimmed = FALSE;
 954
 955         g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW(win), FALSE);
 956         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 957         rule = MODEST_DIMMING_RULE (user_data);
 958
 959         /* Check dimmed rule */
 960         if (!dimmed) {
 961                 dimmed = _transfer_mode_enabled (win);
 962                 if (dimmed)
 963                         modest_dimming_rule_set_notification (rule, _("mail_ib_notavailable_downloading"));
 964         }
 965
 966         if (!dimmed) {
 967                 if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
 968                         /* The move_to button should be dimmed when viewing an attachment,
 969                          * but should be enabled when viewing a message from the list,
 970                          * or when viewing a search result.
 971                          */
 972                         if (!modest_msg_view_window_is_search_result (MODEST_MSG_VIEW_WINDOW(win))) {
 973                                 dimmed = !modest_msg_view_window_has_headers_model (MODEST_MSG_VIEW_WINDOW (win));
 974                         }
 975                 }
 976
 977                 if (dimmed)
 978                         modest_dimming_rule_set_notification (rule, _("mcen_ib_unable_to_move_mail_attachment"));
 979         }
 980
 981         return dimmed;
 982 }
 983
 984 gboolean
 985 modest_ui_dimming_rules_on_find_msg (ModestWindow *win, gpointer user_data)
 986 {
 987         ModestDimmingRule *rule = NULL;
 988         gboolean dimmed = FALSE;
 989
 990         g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW(win), FALSE);
 991         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 992         rule = MODEST_DIMMING_RULE (user_data);
 993
 994         /* Check dimmed rule */
 995         if (!dimmed) {
 996                 dimmed = _transfer_mode_enabled (win);
 997                 if (dimmed)
 998                         modest_dimming_rule_set_notification (rule, _("mail_ib_notavailable_downloading"));
 999         }
1000
1001         return dimmed;
1002 }
1003
1004 gboolean
1005 modest_ui_dimming_rules_on_paste (ModestWindow *win, gpointer user_data)
1006 {
1007         ModestDimmingRule *rule = NULL;
1008         TnyFolderType types[3];
1009         gboolean dimmed = FALSE;
1010
1011         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
1012         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
1013         rule = MODEST_DIMMING_RULE (user_data);
1014
1015         types[0] = TNY_FOLDER_TYPE_DRAFTS;
1016         types[1] = TNY_FOLDER_TYPE_OUTBOX;
1017         types[2] = TNY_FOLDER_TYPE_SENT;
1018
1019         /* Check dimmed rule */
1020         if (!dimmed) {
1021                 dimmed = _clipboard_is_empty (win);
1022                 if (dimmed)
1023                         modest_dimming_rule_set_notification (rule,
1024                                                               dgettext("hildon-common-strings",
1025                                                                        "ecoc_ib_edwin_nothing_to_paste"));
1026         }
1027         if (!dimmed) {
1028                 dimmed = _selected_folder_is_any_of_type (win, types, 3);
1029                 if (dimmed)
1030                         modest_dimming_rule_set_notification (rule,
1031                                                               dgettext("hildon-common-strings",
1032                                                                        "ckct_ib_unable_to_paste_here"));
1033         }
1034         if (!dimmed) {
1035                 dimmed = !_folder_view_has_focus (win);
1036                 if (dimmed)
1037                         modest_dimming_rule_set_notification (rule,
1038                                         dgettext("hildon-common-strings",
1039                                         "ckct_ib_unable_to_paste_here"));
1040         }
1041         if (!dimmed) {
1042                 dimmed = _selected_folder_not_writeable (MODEST_MAIN_WINDOW(win), TRUE);
1043                 if (dimmed)
1044                         modest_dimming_rule_set_notification (rule,
1045                                                               dgettext("hildon-common-strings",
1046                                                                        "ckct_ib_unable_to_paste_here"));
1047         }
1048         if (!dimmed) {
1049                 dimmed = _selected_folder_is_same_as_source (win);
1050                 if (dimmed)
1051                         modest_dimming_rule_set_notification (rule, _("mcen_ib_unable_to_copy_samefolder"));
1052         }
1053         if (!dimmed) {
1054                 dimmed = _selected_folder_has_subfolder_with_same_name (win);
1055                 if (dimmed)
1056                         modest_dimming_rule_set_notification (rule, _("mcen_ib_unable_to_copy_samefolder"));
1057         }
1058
1059         return dimmed;
1060 }
1061
1062
1063 gboolean
1064 modest_ui_dimming_rules_on_select_all (ModestWindow *win, gpointer user_data)
1065 {
1066         ModestDimmingRule *rule = NULL;
1067         gboolean dimmed = FALSE;
1068
1069         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
1070         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
1071         rule = MODEST_DIMMING_RULE (user_data);
1072
1073         /* Check dimmed rule */
1074         if (!dimmed)
1075                 dimmed = _selected_folder_is_empty (MODEST_MAIN_WINDOW(win));
1076
1077         if (!dimmed)
1078                 dimmed = _header_view_is_all_selected (MODEST_MAIN_WINDOW(win));
1079
1080         if (dimmed)
1081                 modest_dimming_rule_set_notification (rule, "");
1082
1083         return dimmed;
1084 }
1085
1086 gboolean
1087 modest_ui_dimming_rules_on_view_attachments (ModestWindow *win, gpointer user_data)
1088 {
1089         ModestDimmingRule *rule = NULL;
1090         gboolean dimmed = FALSE;
1091
1092         g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW(win), FALSE);
1093         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
1094         rule = MODEST_DIMMING_RULE (user_data);
1095
1096         /* Check dimmed rule */
1097         if (!dimmed)
1098                 dimmed = _invalid_attach_selected (win, TRUE, TRUE, FALSE, rule);
1099
1100         if (!dimmed) {
1101                 dimmed = _purged_attach_selected (win, FALSE, NULL);
1102                 if (dimmed) {
1103                         modest_dimming_rule_set_notification (rule, _("mail_ib_attach_not_local"));
1104                 }
1105         }
1106
1107         return dimmed;
1108 }
1109
1110 gboolean
1111 modest_ui_dimming_rules_on_save_attachments (ModestWindow *win, gpointer user_data)
1112 {
1113         ModestDimmingRule *rule = NULL;
1114         gboolean dimmed = FALSE;
1115
1116         g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW(win), FALSE);
1117         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
1118         rule = MODEST_DIMMING_RULE (user_data);
1119
1120         /* Check dimmed rule */
1121         if (!dimmed)
1122                 dimmed = _invalid_attach_selected (win, FALSE, FALSE, FALSE, rule);
1123
1124         if (!dimmed) {
1125                 dimmed = _purged_attach_selected (win, FALSE, NULL);
1126                 if (dimmed) {
1127                         modest_dimming_rule_set_notification (rule, _("mail_ib_attach_not_local"));
1128                 }
1129         }
1130
1131         return dimmed;
1132 }
1133
1134 gboolean
1135 modest_ui_dimming_rules_on_remove_attachments (ModestWindow *win, gpointer user_data)
1136 {
1137         ModestDimmingRule *rule = NULL;
1138         const DimmedState *state = NULL;
1139         gboolean dimmed = FALSE;
1140
1141         g_return_val_if_fail (MODEST_IS_WINDOW(win), FALSE);
1142         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
1143         rule = MODEST_DIMMING_RULE (user_data);
1144         state = modest_window_get_dimming_state (win);
1145
1146         /* Check in main window if there's only one message selected */
1147         if (!dimmed && MODEST_IS_MAIN_WINDOW (win)) {
1148                 dimmed = _invalid_msg_selected (MODEST_MAIN_WINDOW (win), TRUE, rule);
1149         }
1150
1151         /* Check in view window if there's any attachment selected */
1152         if (!dimmed && MODEST_IS_MSG_VIEW_WINDOW (win)) {
1153                 dimmed = _invalid_attach_selected (win, FALSE, FALSE, TRUE, NULL);
1154                 if (dimmed)
1155                         modest_dimming_rule_set_notification (rule, _("FIXME:no attachment selected"));
1156         }
1157
1158         /* cannot purge in editable drafts nor pop folders */
1159         if (!dimmed) {
1160                 dimmed = _invalid_folder_for_purge (win, rule);
1161         }
1162
1163         /* Check if the selected message in main window has attachments */
1164         if (!dimmed && MODEST_IS_MAIN_WINDOW (win)) {
1165                 dimmed = state->any_has_attachments;
1166                 if (dimmed)
1167                         modest_dimming_rule_set_notification (rule, _("mail_ib_unable_to_purge_attachments"));
1168         }
1169
1170         /* Check if all attachments are already purged */
1171         if (!dimmed) {
1172                 dimmed = _purged_attach_selected (win, TRUE, rule);
1173         }
1174
1175         /* Check if the message is already downloaded */
1176         if (!dimmed && MODEST_IS_MAIN_WINDOW (win)) {
1177                 dimmed = !_msg_download_completed (MODEST_MAIN_WINDOW (win));
1178                 if (dimmed)
1179                         modest_dimming_rule_set_notification (rule, _("mail_ib_attach_not_local"));
1180         }
1181
1182
1183         return dimmed;
1184 }
1185
1186 gboolean
1187 modest_ui_dimming_rules_on_undo (ModestWindow *win, gpointer user_data)
1188 {
1189         ModestDimmingRule *rule = NULL;
1190         gboolean dimmed = FALSE;
1191
1192         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
1193         rule = MODEST_DIMMING_RULE (user_data);
1194
1195         /* Check dimmed rule */
1196         if (!dimmed) {
1197                 dimmed = _clipboard_is_empty (win);
1198                 if (dimmed)
1199                         modest_dimming_rule_set_notification (rule, "");
1200         }
1201
1202         return dimmed;
1203 }
1204
1205 gboolean
1206 modest_ui_dimming_rules_on_cut (ModestWindow *win, gpointer user_data)
1207 {
1208         ModestDimmingRule *rule = NULL;
1209         const DimmedState *state = NULL;
1210         gboolean dimmed = FALSE;
1211
1212         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
1213         rule = MODEST_DIMMING_RULE (user_data);
1214         state = modest_window_get_dimming_state (win);
1215
1216         /* Check common dimming rules */
1217         if (!dimmed) {
1218                 dimmed = _invalid_clipboard_selected (win, rule);
1219         }
1220
1221         /* Check window specific dimming rules */
1222         if (MODEST_IS_MAIN_WINDOW (win)) {
1223                 /* Get focused widget */
1224                 GtkWidget *focused = gtk_window_get_focus (GTK_WINDOW (win));
1225
1226                 if (MODEST_IS_HEADER_VIEW (focused)) {
1227                         if (!dimmed) {
1228                                 dimmed = _selected_folder_is_empty (MODEST_MAIN_WINDOW(win));
1229                                 if (dimmed)
1230                                         modest_dimming_rule_set_notification (rule, "");
1231                         }
1232                         if (!dimmed) {
1233                                 dimmed = _selected_msg_sent_in_progress (win);
1234                                 if (dimmed)
1235                                         modest_dimming_rule_set_notification (rule, _("mcen_ib_unable_to_cut_mess"));
1236                         }
1237                         if (!dimmed) {
1238                                 dimmed = state->already_opened_msg;
1239                                 if(dimmed)
1240                                         modest_dimming_rule_set_notification (rule, _("mcen_ib_unable_to_cut_mess"));
1241                         }
1242                 }
1243                 else if (MODEST_IS_FOLDER_VIEW (focused)) {
1244                         TnyFolderType types[3];
1245
1246                         types[0] = TNY_FOLDER_TYPE_DRAFTS;
1247                         types[1] = TNY_FOLDER_TYPE_OUTBOX;
1248                         types[2] = TNY_FOLDER_TYPE_SENT;
1249
1250                         /* Apply folder rules */
1251                         if (!dimmed) {
1252                                 dimmed = _selected_folder_not_deletable (MODEST_MAIN_WINDOW(win));
1253                                 if (dimmed)
1254                                         modest_dimming_rule_set_notification (rule, _("emev_bd_unabletomove_items"));
1255                         }
1256                         if (!dimmed) {
1257                                 dimmed = _selected_folder_is_root_or_inbox (MODEST_MAIN_WINDOW(win));
1258                                 if (dimmed)
1259                                         modest_dimming_rule_set_notification (rule, _("emev_bd_unabletomove_itemsr"));
1260                         }
1261                         if (!dimmed) {
1262                                 dimmed = _selected_folder_is_any_of_type (win, types, 3);
1263                                 if (dimmed)
1264                                         modest_dimming_rule_set_notification (rule, _("emev_bd_unabletomove_itemsr"));
1265                         }
1266                 }
1267         }
1268
1269         return dimmed;
1270 }
1271
1272 gboolean
1273 modest_ui_dimming_rules_on_copy (ModestWindow *win, gpointer user_data)
1274 {
1275         ModestDimmingRule *rule = NULL;
1276         const DimmedState *state = NULL;
1277         gboolean dimmed = FALSE;
1278
1279         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
1280         rule = MODEST_DIMMING_RULE (user_data);
1281         state = modest_window_get_dimming_state (win);
1282
1283         /* Check common dimming rules */
1284         if (!dimmed) {
1285                 dimmed = _invalid_clipboard_selected (win, rule);
1286         }
1287
1288         /* Check window specific dimming rules */
1289         if (MODEST_IS_MAIN_WINDOW (win)) {
1290                 /* Get focused widget */
1291                 GtkWidget *focused = gtk_window_get_focus (GTK_WINDOW (win));
1292
1293                 if (MODEST_IS_HEADER_VIEW (focused)) {
1294                         if (!dimmed) {
1295                                 dimmed = _selected_folder_is_empty (MODEST_MAIN_WINDOW(win));
1296                                 if (dimmed)
1297                                         modest_dimming_rule_set_notification (rule, "");
1298                         }
1299                         if (!dimmed) {
1300                                 dimmed = _selected_msg_sent_in_progress (win);
1301                                 if (dimmed)
1302                                         modest_dimming_rule_set_notification (rule, _(""));
1303                         }
1304                         if (!dimmed) {
1305                                 dimmed = state->already_opened_msg;
1306                                 if(dimmed)
1307                                         modest_dimming_rule_set_notification (rule, _(""));
1308                         }
1309                 }
1310                 else if (MODEST_IS_FOLDER_VIEW (focused)) {
1311                         TnyFolderType types[3];
1312
1313                         types[0] = TNY_FOLDER_TYPE_DRAFTS;
1314                         types[1] = TNY_FOLDER_TYPE_OUTBOX;
1315                         types[2] = TNY_FOLDER_TYPE_SENT;
1316
1317                         if (!dimmed) {
1318                                 dimmed = _selected_folder_is_root (MODEST_MAIN_WINDOW(win));
1319                                 if (dimmed)
1320                                         modest_dimming_rule_set_notification (rule, _(""));
1321                         }
1322                         if (!dimmed) {
1323                                 dimmed = _selected_folder_is_any_of_type (win, types, 3);
1324                                 if (dimmed)
1325                                         modest_dimming_rule_set_notification (rule, _(""));
1326                         }
1327                 }
1328         }
1329
1330         return dimmed;
1331 }
1332
1333 gboolean
1334 modest_ui_dimming_rules_on_view_previous (ModestWindow *win, gpointer user_data)
1335 {
1336         ModestDimmingRule *rule = NULL;
1337         gboolean dimmed = FALSE;
1338
1339         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
1340         rule = MODEST_DIMMING_RULE (user_data);
1341
1342         g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW(win), FALSE);
1343
1344         /* Check dimmed rule */
1345         if (!dimmed) {
1346                 dimmed = _transfer_mode_enabled (win);
1347                 if (dimmed)
1348                         modest_dimming_rule_set_notification (
1349                                         rule, _("mail_ib_notavailable_downloading"));
1350         }
1351         if (!dimmed) {
1352                 dimmed = modest_msg_view_window_first_message_selected (
1353                                 MODEST_MSG_VIEW_WINDOW(win));
1354                 modest_dimming_rule_set_notification (rule, NULL);
1355         }
1356
1357         return dimmed;
1358 }
1359
1360 gboolean
1361 modest_ui_dimming_rules_on_view_next (ModestWindow *win, gpointer user_data)
1362 {
1363         ModestDimmingRule *rule = NULL;
1364         gboolean dimmed = FALSE;
1365
1366         g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW(win), FALSE);
1367         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
1368         rule = MODEST_DIMMING_RULE (user_data);
1369
1370         /* Check dimmed rule */
1371         if (!dimmed) {
1372                 dimmed = _transfer_mode_enabled (win);
1373                 if (dimmed)
1374                         modest_dimming_rule_set_notification (rule, _("mail_ib_notavailable_downloading"));
1375         }
1376         if (!dimmed) {
1377                 dimmed = modest_msg_view_window_last_message_selected (MODEST_MSG_VIEW_WINDOW (win));
1378                 modest_dimming_rule_set_notification (rule, NULL);
1379         }
1380
1381         return dimmed;
1382 }
1383
1384
1385 gboolean
1386 modest_ui_dimming_rules_on_tools_smtp_servers (ModestWindow *win, gpointer user_data)
1387 {
1388         const gboolean dimmed =
1389                 !modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(),
1390                         TRUE);
1391
1392         return dimmed;
1393 }
1394
1395 gboolean
1396 modest_ui_dimming_rules_on_cancel_sending (ModestWindow *win, gpointer user_data)
1397 {
1398         ModestDimmingRule *rule = NULL;
1399         TnyFolderType types[1];
1400         guint n_messages = 0;
1401         const DimmedState *state = NULL;
1402         gboolean dimmed = FALSE;
1403
1404         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
1405         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
1406         rule = MODEST_DIMMING_RULE (user_data);
1407         state = modest_window_get_dimming_state (win);
1408
1409         types[0] = TNY_FOLDER_TYPE_OUTBOX;
1410
1411         /* Check dimmed rules */
1412         if (!dimmed) {
1413                 dimmed = state->already_opened_msg;
1414                 n_messages = state->n_selected;
1415                 if (dimmed)
1416                         modest_dimming_rule_set_notification (rule, _("mcen_ib_message_unableto_cancel_send"));
1417         }
1418         if (!dimmed) {
1419                 dimmed = !_selected_folder_is_any_of_type (win, types, 1);
1420                 if (dimmed)
1421                         modest_dimming_rule_set_notification (rule, "");
1422         }
1423         if (!dimmed) {
1424                 dimmed = !_sending_in_progress (win);
1425                 if (dimmed)
1426                         modest_dimming_rule_set_notification (rule, "");
1427         }
1428
1429         return dimmed;
1430 }
1431
1432 gboolean
1433 modest_ui_dimming_rules_on_send_receive (ModestWindow *win, gpointer user_data)
1434 {
1435         ModestDimmingRule *rule = NULL;
1436         gboolean dimmed = FALSE;
1437
1438         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
1439         rule = MODEST_DIMMING_RULE (user_data);
1440
1441         /* Check dimmed rule */
1442         if (!dimmed) {
1443                 dimmed = !modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(),
1444                                                           TRUE);
1445                 if (dimmed)
1446                         modest_dimming_rule_set_notification (rule, _("mcen_nc_no_email_acnts_defined"));
1447         }
1448
1449         return dimmed;
1450 }
1451
1452 gboolean
1453 modest_ui_dimming_rules_on_add_to_contacts (ModestWindow *win, gpointer user_data)
1454 {
1455         ModestDimmingRule *rule = NULL;
1456         gboolean dimmed = FALSE;
1457
1458         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
1459         rule = MODEST_DIMMING_RULE (user_data);
1460
1461         /* Check dimmed rule */
1462         if (!dimmed) {
1463                 GtkClipboard *clipboard = gtk_clipboard_get (GDK_SELECTION_PRIMARY);
1464                 gchar *selection = NULL;
1465                 selection = gtk_clipboard_wait_for_text (clipboard);
1466
1467                 dimmed = !((selection != NULL) && (modest_text_utils_validate_recipient (selection, NULL)));
1468         }
1469
1470         return dimmed;
1471 }
1472
1473 /* *********************** static utility functions ******************** */
1474
1475
1476 static gboolean
1477 _selected_folder_not_writeable (ModestMainWindow *win,
1478                                 gboolean for_paste)
1479 {
1480         GtkWidget *folder_view = NULL;
1481         TnyFolderStore *parent_folder = NULL;
1482         ModestEmailClipboard *clipboard = NULL;
1483         ModestTnyFolderRules rules;
1484         gboolean is_local_acc = FALSE;
1485         gboolean xfer_folders = FALSE;
1486         gboolean result = FALSE;
1487
1488         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
1489
1490         /* Get folder view */
1491         folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
1492                                                            MODEST_WIDGET_TYPE_FOLDER_VIEW);
1493         /* If no folder view, always dimmed */
1494         if (!folder_view)
1495                 return TRUE;
1496
1497         /* Get selected folder as parent of new folder to create */
1498         parent_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
1499         if (!(parent_folder && TNY_IS_FOLDER(parent_folder))) {
1500                 /* If it's the local account and its transfering folders, then do not dim */
1501                 if (TNY_IS_ACCOUNT (parent_folder)) {
1502                         is_local_acc = modest_tny_account_is_virtual_local_folders (TNY_ACCOUNT (parent_folder));
1503                         if (for_paste) {
1504                                 clipboard = modest_runtime_get_email_clipboard ();
1505                                 xfer_folders = modest_email_clipboard_folder_copied (clipboard);
1506                         }
1507                 }
1508
1509                 if (for_paste)
1510                         result = !(is_local_acc && xfer_folders);
1511                 else
1512                         result = !is_local_acc;
1513                 goto frees;
1514         }
1515
1516         /* Check dimmed rule */
1517         rules = modest_tny_folder_get_rules (TNY_FOLDER (parent_folder));
1518         result = rules & MODEST_FOLDER_RULES_FOLDER_NON_WRITEABLE;
1519
1520         /* free */
1521  frees:
1522         if (parent_folder != NULL)
1523                 g_object_unref (parent_folder);
1524
1525         return result;
1526 }
1527
1528 static gboolean
1529 _selected_folder_not_deletable (ModestMainWindow *win)
1530 {
1531         GtkWidget *folder_view = NULL;
1532         TnyFolderStore *parent_folder = NULL;
1533         ModestTnyFolderRules rules;
1534         gboolean result = FALSE;
1535
1536         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
1537
1538         /* Get folder view */
1539         folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
1540                                                            MODEST_WIDGET_TYPE_FOLDER_VIEW);
1541         /* If no folder view, always dimmed */
1542         if (!folder_view)
1543                 return TRUE;
1544
1545         /* Get selected folder as parent of new folder to create */
1546         parent_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
1547         if (!(parent_folder && TNY_IS_FOLDER(parent_folder))) {
1548                 result = TRUE;
1549                 goto frees;
1550         }
1551
1552         /* Check dimmed rule */
1553         rules = modest_tny_folder_get_rules (TNY_FOLDER (parent_folder));
1554         result = rules & MODEST_FOLDER_RULES_FOLDER_NON_DELETABLE;
1555
1556         /* free */
1557  frees:
1558         if (parent_folder != NULL)
1559                 g_object_unref (parent_folder);
1560
1561         return result;
1562 }
1563
1564 static gboolean
1565 _selected_folder_not_moveable (ModestMainWindow *win)
1566 {
1567         GtkWidget *folder_view = NULL;
1568         TnyFolderStore *parent_folder = NULL;
1569         ModestTnyFolderRules rules;
1570         gboolean result = FALSE;
1571
1572         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
1573
1574         /* Get folder view */
1575         folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
1576                                                            MODEST_WIDGET_TYPE_FOLDER_VIEW);
1577         /* If no folder view, always dimmed */
1578         if (!folder_view)
1579                 return TRUE;
1580
1581         /* Get selected folder as parent of new folder to create */
1582         parent_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
1583         if (!(parent_folder && TNY_IS_FOLDER(parent_folder))) {
1584                 result = TRUE;
1585                 goto frees;
1586         }
1587
1588         /* Check dimmed rule */
1589         rules = modest_tny_folder_get_rules (TNY_FOLDER (parent_folder));
1590         result = rules & MODEST_FOLDER_RULES_FOLDER_NON_MOVEABLE;
1591
1592         /* free */
1593  frees:
1594         if (parent_folder != NULL)
1595                 g_object_unref (parent_folder);
1596
1597         return result;
1598 }
1599
1600 static gboolean
1601 _selected_folder_not_renameable (ModestMainWindow *win)
1602 {
1603         GtkWidget *folder_view = NULL;
1604         TnyFolderStore *parent_folder = NULL;
1605         ModestTnyFolderRules rules;
1606         gboolean result = FALSE;
1607
1608         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
1609
1610         /* Get folder view */
1611         folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
1612                                                            MODEST_WIDGET_TYPE_FOLDER_VIEW);
1613         /* If no folder view, always dimmed */
1614         if (!folder_view)
1615                 return TRUE;
1616
1617         /* Get selected folder as parent of new folder to create */
1618         parent_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
1619         if (!(parent_folder && TNY_IS_FOLDER(parent_folder))) {
1620                 result = TRUE;
1621                 goto frees;
1622         }
1623
1624         /* Check dimmed rule */
1625         rules = modest_tny_folder_get_rules (TNY_FOLDER (parent_folder));
1626         result = rules & MODEST_FOLDER_RULES_FOLDER_NON_RENAMEABLE;
1627
1628         /* free */
1629  frees:
1630         if (parent_folder != NULL)
1631                 g_object_unref (parent_folder);
1632
1633         return result;
1634 }
1635
1636 static gboolean
1637 _selected_folder_is_root_or_inbox (ModestMainWindow *win)
1638 {
1639         TnyFolderType types[2];
1640         gboolean result = FALSE;
1641
1642         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
1643
1644         types[0] = TNY_FOLDER_TYPE_ROOT;
1645         types[1] = TNY_FOLDER_TYPE_INBOX;
1646
1647         /* Check folder type */
1648         result = _selected_folder_is_any_of_type (MODEST_WINDOW(win), types, 2);
1649
1650         /* Check pop and MMC accounts */
1651         if (!result) {
1652                 result = _selected_folder_is_MMC_or_POP_root (win);
1653         }
1654
1655         return result;
1656 }
1657
1658
1659 static gboolean
1660 _selected_folder_is_root (ModestMainWindow *win)
1661 {
1662         TnyFolderType types[1];
1663         gboolean result = FALSE;
1664
1665         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
1666
1667         /* All accounts are root items: */
1668         GtkWidget *folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
1669                                                            MODEST_WIDGET_TYPE_FOLDER_VIEW);
1670         if (folder_view) {
1671                 gboolean is_account = FALSE;
1672                 TnyFolderStore *folder_store =
1673                         modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
1674                 if (folder_store) {
1675                         is_account = TNY_IS_ACCOUNT (folder_store);
1676                         g_object_unref (folder_store);
1677                         folder_store = NULL;
1678                 }
1679
1680                 if (is_account)
1681                         return TRUE;
1682         }
1683
1684         /* Try something more precise: */
1685         types[0] = TNY_FOLDER_TYPE_ROOT;
1686
1687         /* Check folder type */
1688         result = _selected_folder_is_any_of_type (MODEST_WINDOW(win), types, 1);
1689
1690         /* Check pop and MMC accounts */
1691         if (!result) {
1692                 result = _selected_folder_is_MMC_or_POP_root (win);
1693         }
1694
1695         return result;
1696 }
1697
1698 static gboolean
1699 _selected_folder_is_MMC_or_POP_root (ModestMainWindow *win)
1700 {
1701         GtkWidget *folder_view = NULL;
1702         TnyFolderStore *parent_folder = NULL;
1703         gboolean result = FALSE;
1704
1705         folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
1706                                                            MODEST_WIDGET_TYPE_FOLDER_VIEW);
1707         if (!folder_view)
1708                 return FALSE;
1709
1710         /* Get selected folder as parent of new folder to create */
1711         parent_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
1712         if (!parent_folder)
1713                 return TRUE;
1714
1715         if (TNY_IS_ACCOUNT (parent_folder)) {
1716                 /* If it's the local account then do not dim */
1717                 if (modest_tny_account_is_virtual_local_folders (TNY_ACCOUNT (parent_folder))) {
1718                         result = FALSE;
1719                 } else {
1720                                 /* If it's the MMC root folder then dim it */
1721                         if (!strcmp (tny_account_get_id (TNY_ACCOUNT (parent_folder)), MODEST_MMC_ACCOUNT_ID)) {
1722                                         result = TRUE;
1723                         } else {
1724                                 const gchar *proto_str = tny_account_get_proto (TNY_ACCOUNT (parent_folder));
1725                                 /* If it's POP then dim */
1726                                 result = (modest_protocol_info_get_transport_store_protocol (proto_str) ==
1727                                                   MODEST_PROTOCOL_STORE_POP) ? TRUE : FALSE;
1728                         }
1729                 }
1730         }
1731         g_object_unref (parent_folder);
1732
1733         return result;
1734 }
1735
1736 static gboolean
1737 _header_view_is_all_selected (ModestMainWindow *win)
1738 {
1739         const DimmedState *state = NULL;
1740
1741         g_return_val_if_fail (MODEST_IS_WINDOW(win), FALSE);
1742
1743         state = modest_window_get_dimming_state (MODEST_WINDOW(win));
1744
1745         return state->all_selected;
1746 }
1747
1748 static gboolean
1749 _selected_folder_is_empty (ModestMainWindow *win)
1750 {
1751         GtkWidget *folder_view = NULL;
1752         TnyFolderStore *folder = NULL;
1753         gboolean result = FALSE;
1754
1755         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
1756
1757         /* Get folder view */
1758         folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
1759                                                            MODEST_WIDGET_TYPE_FOLDER_VIEW);
1760         /* If no folder view, always dimmed */
1761         if (!folder_view)
1762                 return TRUE;
1763
1764         /* Get selected folder as parent of new folder to create */
1765         folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
1766         if (!(folder && TNY_IS_FOLDER(folder))) {
1767                 if (folder)
1768                         g_object_unref (folder);
1769                 return TRUE;
1770         }
1771
1772         /* Check folder type */
1773         result = tny_folder_get_all_count (TNY_FOLDER (folder)) == 0;
1774
1775         /* free */
1776         g_object_unref (folder);
1777
1778         return result;
1779 }
1780
1781 static gboolean
1782 _folder_view_has_focus (ModestWindow *win)
1783 {
1784         GtkWidget *folder_view = NULL;
1785
1786         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
1787
1788         /* Get folder view */
1789         folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
1790                                                            MODEST_WIDGET_TYPE_FOLDER_VIEW);
1791         if (!folder_view)
1792                 return FALSE;
1793
1794         if (gtk_widget_is_focus(folder_view))
1795                 return TRUE;
1796
1797         return FALSE;
1798 }
1799
1800 static gboolean
1801 _selected_folder_is_same_as_source (ModestWindow *win)
1802 {
1803         ModestEmailClipboard *clipboard = NULL;
1804         GtkWidget *folder_view = NULL;
1805         TnyFolderStore *folder = NULL;
1806         gboolean result = FALSE;
1807
1808         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
1809
1810         /* Get folder view */
1811         folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
1812                                                            MODEST_WIDGET_TYPE_FOLDER_VIEW);
1813         if (!folder_view)
1814                 return FALSE;
1815
1816         /* Get selected folder as destination folder */
1817         folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
1818         if (!(folder && TNY_IS_FOLDER(folder))) {
1819                 result = FALSE;
1820                 goto frees;
1821         }
1822
1823         /* Check clipboard is cleared */
1824         clipboard = modest_runtime_get_email_clipboard ();
1825         if (modest_email_clipboard_cleared (clipboard)) {
1826                 result = FALSE;
1827                 goto frees;
1828         }
1829
1830         /* Check source folder */
1831         result = modest_email_clipboard_check_source_folder (clipboard,
1832                                                              (const TnyFolder *) folder);
1833
1834         /* Free */
1835  frees:
1836         g_object_unref (folder);
1837
1838         return result;
1839 }
1840
1841 static gboolean
1842 _selected_folder_is_any_of_type (ModestWindow *win,
1843                                  TnyFolderType types[],
1844                                  guint ntypes)
1845 {
1846         GtkWidget *folder_view = NULL;
1847         TnyFolderStore *folder = NULL;
1848         TnyFolderType folder_type;
1849         guint i=0;
1850         gboolean result = FALSE;
1851
1852         /*Get current folder */
1853         if (MODEST_IS_MAIN_WINDOW(win)) {
1854
1855                 /* Get folder view */
1856                 folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
1857                                                                    MODEST_WIDGET_TYPE_FOLDER_VIEW);
1858                 /* If no folder view, always dimmed */
1859                 if (!folder_view)
1860                         return FALSE;
1861
1862                 /* Get selected folder as parent of new folder to create */
1863                 folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
1864
1865                 if (!(folder && TNY_IS_FOLDER(folder))) {
1866                         if (folder)
1867                                 g_object_unref (folder);
1868                         return FALSE;
1869                 }
1870
1871                 /* Check folder type */
1872                 result = _folder_is_any_of_type (TNY_FOLDER(folder), types, ntypes);
1873         }
1874         else if (MODEST_IS_MSG_VIEW_WINDOW(win)) {
1875                 folder_type = modest_msg_view_window_get_folder_type (MODEST_MSG_VIEW_WINDOW (win));
1876                 for (i=0; i < ntypes; i++) {
1877                         result = result || folder_type == types[i];
1878                 }
1879         }
1880
1881
1882         /* free */
1883         g_object_unref (folder);
1884
1885         return result;
1886 }
1887
1888 static gboolean
1889 _folder_is_any_of_type (TnyFolder *folder,
1890                         TnyFolderType types[],
1891                         guint ntypes)
1892 {
1893         TnyFolderType folder_type;
1894         gboolean result = FALSE;
1895         guint i;
1896
1897         g_return_val_if_fail (TNY_IS_FOLDER(folder), FALSE);
1898
1899         /* Get folder type */
1900         folder_type = modest_tny_folder_guess_folder_type (folder);
1901
1902         /* Check foler type */
1903         for (i=0; i < ntypes; i++) {
1904                 result = result || folder_type == types[i];
1905         }
1906
1907         return result;
1908 }
1909
1910 static gboolean
1911 _clipboard_is_empty (ModestWindow *win)
1912 {
1913         gboolean result = FALSE;
1914
1915         if (MODEST_IS_MAIN_WINDOW (win)) {
1916                 ModestEmailClipboard *clipboard = NULL;
1917                 clipboard = modest_runtime_get_email_clipboard ();
1918                 if (modest_email_clipboard_cleared (clipboard))
1919                  result = TRUE;
1920         }
1921
1922         return result;
1923 }
1924
1925 static gboolean
1926 _invalid_clipboard_selected (ModestWindow *win,
1927                              ModestDimmingRule *rule)
1928 {
1929         const DimmedState *state = NULL;
1930         gboolean result = FALSE;
1931
1932         g_return_val_if_fail (MODEST_IS_WINDOW(win), FALSE);
1933         state = modest_window_get_dimming_state (win);
1934
1935         if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
1936                 GtkClipboard *clipboard = NULL;
1937                 gchar *selection = NULL;
1938                 GtkWidget *focused = NULL;
1939
1940                 /* Get clipboard selection*/
1941                 clipboard = gtk_clipboard_get (GDK_SELECTION_PRIMARY);
1942                 selection = gtk_clipboard_wait_for_text (clipboard);
1943
1944                 /* Get focuesed widget */
1945                 focused = gtk_window_get_focus (GTK_WINDOW (win));
1946
1947                 /* Check dimming */
1948                 result = ((selection == NULL) ||
1949                           (MODEST_IS_ATTACHMENTS_VIEW (focused)));
1950
1951                 if (result)
1952                         modest_dimming_rule_set_notification (rule, "");
1953
1954                 if (selection != NULL)
1955                         g_free(selection);
1956         }
1957         else if (MODEST_IS_MAIN_WINDOW (win)) {
1958                 /* Check dimming */
1959                 result = state->n_selected == 0;
1960                 if (result)
1961                         modest_dimming_rule_set_notification (rule, _("mcen_ib_no_message_selected"));
1962         }
1963
1964         return result;
1965 }
1966
1967
1968 static gboolean
1969 _invalid_attach_selected (ModestWindow *win,
1970                           gboolean unique,
1971                           gboolean for_view,
1972                           gboolean for_remove,
1973                           ModestDimmingRule *rule)
1974 {
1975         GList *attachments, *node;
1976         gint n_selected;
1977         TnyHeaderFlags flags;
1978         gboolean nested_attachments = FALSE;
1979         gboolean selected_messages = FALSE;
1980         const DimmedState *state = NULL;
1981         gboolean result = FALSE;
1982
1983         g_return_val_if_fail (MODEST_IS_WINDOW(win), FALSE);
1984         state = modest_window_get_dimming_state (win);
1985
1986         if (MODEST_IS_MAIN_WINDOW (win)) {
1987                 flags = TNY_HEADER_FLAG_ATTACHMENTS;
1988                 if (!result)
1989                         result = !state->any_has_attachments;
1990         }
1991         else if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
1992
1993                 /* Get selected atachments */
1994                 attachments = modest_msg_view_window_get_attachments (MODEST_MSG_VIEW_WINDOW(win));
1995                 n_selected = g_list_length (attachments);
1996
1997                 /* Check unique */
1998                 if (!result) {
1999                         if (unique)
2000                                 result = n_selected != 1;
2001                         else
2002
2003                                 result = n_selected < 1;
2004                 }
2005
2006                 /* Check attached type (view operation not required) */
2007                 if (!result && !for_view)  {
2008                         for (node = attachments; node != NULL && !result; node = g_list_next (node)) {
2009                                 TnyMimePart *mime_part = TNY_MIME_PART (node->data);
2010                                 TnyList *nested_list = tny_simple_list_new ();
2011                                 if (!for_remove && TNY_IS_MSG (mime_part)) {
2012                                         selected_messages = TRUE;
2013                                         result = TRUE;
2014                                 }
2015                                 tny_mime_part_get_parts (mime_part, nested_list);
2016                                 if (!for_remove && tny_list_get_length (nested_list) > 0) {
2017                                         nested_attachments = TRUE;
2018                                         result = TRUE;
2019                                 }
2020                                 g_object_unref (nested_list);
2021                         }
2022                 }
2023
2024                 /* Set notifications */
2025                 if (result && rule != NULL) {
2026                         if (selected_messages) {
2027                                 modest_dimming_rule_set_notification (rule, _("mcen_ib_unable_to_save_attach_mail"));
2028                         } else if (nested_attachments) {
2029                                 modest_dimming_rule_set_notification (rule, _("FIXME:unable to save attachments with nested elements"));
2030                         } else if (n_selected == 0) {
2031                                 modest_dimming_rule_set_notification (rule, _("FIXME:no attachment selected"));
2032                         } else if (unique) {
2033                                 modest_dimming_rule_set_notification (rule, _("mcen_ib_unable_to_display_more"));
2034                         }
2035                 }
2036
2037                 /* Free */
2038                 g_list_free (attachments);
2039         }
2040
2041         return result;
2042 }
2043
2044 static gboolean
2045 _purged_attach_selected (ModestWindow *win, gboolean all, ModestDimmingRule *rule)
2046 {
2047         GList *attachments = NULL, *node;
2048         gint purged = 0;
2049         gint n_attachments = 0;
2050         gboolean result = FALSE;
2051
2052         /* This should check if _all_ the attachments are already purged. If only some
2053          * of them are purged, then it does not cause dim as there's a confirmation dialog
2054          * for removing only local attachments */
2055
2056         /* Get selected atachments */
2057         if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
2058                 attachments = modest_msg_view_window_get_attachments (MODEST_MSG_VIEW_WINDOW(win));
2059         } else if (MODEST_IS_MAIN_WINDOW (win)) {
2060                 /* If we're in main window, we won't know if there are already purged attachments */
2061                 return FALSE;
2062         }
2063
2064         if (attachments == NULL)
2065                 return FALSE;
2066
2067         for (node = attachments; node != NULL; node = g_list_next (node)) {
2068                 TnyMimePart *mime_part = TNY_MIME_PART (node->data);
2069                 if (tny_mime_part_is_purged (mime_part)) {
2070                         purged++;
2071                 }
2072                 n_attachments++;
2073         }
2074
2075         /* Free */
2076         g_list_free (attachments);
2077
2078         if (all)
2079                 result = (purged == n_attachments);
2080         else
2081                 result = (purged > 0);
2082
2083         if (result && (rule != NULL))
2084                 modest_dimming_rule_set_notification (rule, _("mail_ib_attachment_already_purged"));
2085
2086         return result;
2087 }
2088
2089 static gboolean
2090 _invalid_msg_selected (ModestMainWindow *win,
2091                        gboolean unique,
2092                        ModestDimmingRule *rule)
2093 {
2094         GtkWidget *folder_view = NULL;
2095         const DimmedState *state = NULL;
2096         gboolean result = FALSE;
2097
2098         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
2099         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (rule), FALSE);
2100         state = modest_window_get_dimming_state (MODEST_WINDOW(win));
2101
2102         /* Get folder view to check focus */
2103         folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
2104                                                            MODEST_WIDGET_TYPE_FOLDER_VIEW);
2105
2106         /* Check dimmed rule (TODO: check focus on widgets */
2107         if (!result) {
2108                 result = ((state->n_selected == 0 ) ||
2109                           (gtk_widget_is_focus (folder_view)));
2110                 if (result)
2111                         modest_dimming_rule_set_notification (rule, _("mcen_ib_no_message_selected"));
2112         }
2113         if (!result && unique) {
2114                 result = state->n_selected > 1;
2115                 if (result)
2116                         modest_dimming_rule_set_notification (rule, _("mcen_ib_select_one_message"));
2117         }
2118
2119         return result;
2120 }
2121
2122
2123 static gboolean
2124 _msg_download_in_progress (ModestMsgViewWindow *win)
2125 {
2126         gboolean result = FALSE;
2127
2128         g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW (win), FALSE);
2129
2130         result = modest_msg_view_window_toolbar_on_transfer_mode (win);
2131
2132         return result;
2133 }
2134
2135 static gboolean
2136 _msg_download_completed (ModestMainWindow *win)
2137 {
2138         const DimmedState *state = modest_window_get_dimming_state (MODEST_WINDOW(win));
2139         return state->any_marked_as_cached;
2140 }
2141
2142 static void
2143 fill_list_of_caches (gpointer key, gpointer value, gpointer userdata)
2144 {
2145         GSList **send_queues = (GSList **) userdata;
2146         *send_queues = g_slist_prepend (*send_queues, value);
2147 }
2148
2149 static gboolean
2150 _selected_msg_sent_in_progress (ModestWindow *win)
2151 {
2152         const DimmedState *state = modest_window_get_dimming_state (win);
2153         return state->sent_in_progress;
2154 }
2155
2156
2157 static gboolean
2158 _sending_in_progress (ModestWindow *win)
2159 {
2160         gboolean result = FALSE;
2161
2162         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW (win), FALSE);
2163
2164         /* Check if send operation is in progress */
2165         result = modest_main_window_send_receive_in_progress (MODEST_MAIN_WINDOW (win));
2166
2167         return result;
2168 }
2169
2170 static gboolean
2171 _invalid_folder_for_purge (ModestWindow *win,
2172                            ModestDimmingRule *rule)
2173 {
2174         TnyMsg *msg = NULL;
2175         TnyFolder *folder = NULL;
2176         TnyAccount *account = NULL;
2177         gboolean result = FALSE;
2178
2179         if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
2180
2181                 /* Get folder and account of message */
2182                 msg = modest_msg_view_window_get_message (MODEST_MSG_VIEW_WINDOW (win));
2183                 g_return_val_if_fail(msg != NULL, TRUE);
2184                 folder = tny_msg_get_folder (msg);
2185                 if (folder == NULL) {
2186                         modest_dimming_rule_set_notification (rule, _("mail_ib_unable_to_purge_attachments"));
2187                         goto frees;
2188                 }
2189                 g_object_unref (msg);
2190         } else if (MODEST_IS_MAIN_WINDOW (win)) {
2191                 GtkWidget *folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
2192                                                                               MODEST_WIDGET_TYPE_FOLDER_VIEW);
2193                 if (!folder_view)
2194                         return FALSE;
2195                 folder = TNY_FOLDER (modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view)));
2196                 if (folder == NULL || ! TNY_IS_FOLDER (folder))
2197                         goto frees;
2198         } else {
2199                 g_return_val_if_reached (FALSE);
2200         }
2201         account = modest_tny_folder_get_account (folder);
2202         if (account == NULL) goto frees;
2203
2204         /* Check account */
2205         if (modest_tny_account_is_virtual_local_folders (TNY_ACCOUNT (account))) {
2206                 TnyFolderType types[2];
2207                 types[0] = TNY_FOLDER_TYPE_DRAFTS;
2208                 types[1] = TNY_FOLDER_TYPE_OUTBOX;
2209
2210                 if (_selected_folder_is_any_of_type (win, types, 2)) {
2211                         result = TRUE;
2212                         modest_dimming_rule_set_notification (rule, _("mail_ib_unable_to_purge_editable_msg"));
2213                 } else {
2214                         /* We're currently disabling purge in any local store */
2215                         result = TRUE;
2216                         modest_dimming_rule_set_notification (rule, _("mail_ib_unable_to_purge_attachments"));
2217                 }
2218         } else {
2219                 const gchar *proto_str = tny_account_get_proto (TNY_ACCOUNT (account));
2220                 /* If it's POP then dim */
2221                 if (modest_protocol_info_get_transport_store_protocol (proto_str) ==
2222                     MODEST_PROTOCOL_STORE_POP) {
2223                         GList *attachments = NULL;
2224                         gint n_selected = 0;
2225                         result = TRUE;
2226
2227                         /* TODO: This check is here to prevent a gwarning, but this looks like a logic error.
2228                          * murrayc */
2229                         if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
2230                                 attachments = modest_msg_view_window_get_attachments (MODEST_MSG_VIEW_WINDOW(win));
2231                                 n_selected = g_list_length (attachments);
2232                                 g_list_free (attachments);
2233                         }
2234
2235                         modest_dimming_rule_set_notification (rule,
2236                                                               ngettext ("mail_ib_unable_to_pure_attach_pop_mail_singular",
2237                                                                         "mail_ib_unable_to_pure_attach_pop_mail_plural",
2238                                                                         n_selected));
2239                 }
2240         }
2241
2242 frees:
2243         if (folder != NULL)
2244                 g_object_unref (folder);
2245         if (account != NULL)
2246                 g_object_unref (account);
2247
2248         return result;
2249 }
2250
2251 static gboolean
2252 _transfer_mode_enabled (ModestWindow *win)
2253 {
2254         gboolean result = FALSE;
2255
2256         /* Check dimming */
2257         if (MODEST_IS_MSG_VIEW_WINDOW(win)) {
2258                 result = modest_msg_view_window_transfer_mode_enabled (MODEST_MSG_VIEW_WINDOW (win));
2259         } else if (MODEST_IS_MAIN_WINDOW(win)) {
2260                 result = modest_main_window_transfer_mode_enabled (MODEST_MAIN_WINDOW (win));
2261         } else {
2262                 g_warning("_transfer_mode_enabled called with wrong window type");
2263         }
2264
2265         return result;
2266 }
2267
2268 static gboolean
2269 _selected_folder_has_subfolder_with_same_name (ModestWindow *win)
2270 {
2271         GtkWidget *folder_view = NULL;
2272         TnyFolderStore *folder = NULL;
2273         ModestEmailClipboard *clipboard = NULL;
2274         const gchar *folder_name = NULL;
2275         gboolean result = FALSE;
2276
2277         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), TRUE);
2278
2279         /*Get current parent folder */
2280         folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
2281                                                            MODEST_WIDGET_TYPE_FOLDER_VIEW);
2282         /* If no folder view, always dimmed */
2283         if (!folder_view) return FALSE;
2284
2285         /* Get selected folder as parent of new folder to create */
2286         folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
2287         if (!(folder && TNY_IS_FOLDER(folder))) goto frees;
2288
2289         /* get modest clipboard and source folder */
2290         clipboard = modest_runtime_get_email_clipboard ();
2291         folder_name = modest_email_clipboard_get_folder_name (clipboard);
2292         if (folder_name == NULL) goto frees;
2293
2294         /* Check source subfolders names */
2295         result = modest_tny_folder_has_subfolder_with_name (folder, folder_name);
2296
2297
2298         /* Free */
2299  frees:
2300         if (folder != NULL)
2301                 g_object_unref (folder);
2302
2303
2304         return result;
2305 }
2306