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