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
 959         if (!dimmed) {
 960                 if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
 961                         /* The move_to button should be dimmed when viewing an attachment,
 962                          * but should be enabled when viewing a message from the list,
 963                          * or when viewing a search result.
 964                          */
 965                         if (!modest_msg_view_window_is_search_result (MODEST_MSG_VIEW_WINDOW(win))) {
 966                                 dimmed = !modest_msg_view_window_has_headers_model (MODEST_MSG_VIEW_WINDOW (win));
 967                         }
 968                 }
 969
 970                 if (dimmed)
 971                         modest_dimming_rule_set_notification (rule, _("mcen_ib_unable_to_move_mail_attachment"));
 972         }
 973
 974         return dimmed;
 975 }
 976
 977 gboolean
 978 modest_ui_dimming_rules_on_find_msg (ModestWindow *win, gpointer user_data)
 979 {
 980         ModestDimmingRule *rule = NULL;
 981         gboolean dimmed = FALSE;
 982
 983         g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW(win), FALSE);
 984         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 985         rule = MODEST_DIMMING_RULE (user_data);
 986
 987         /* Check dimmed rule */
 988         if (!dimmed) {
 989                 dimmed = _transfer_mode_enabled (win);
 990                 if (dimmed)
 991                         modest_dimming_rule_set_notification (rule, _("mail_ib_notavailable_downloading"));
 992         }
 993
 994         return dimmed;
 995 }
 996
 997 gboolean
 998 modest_ui_dimming_rules_on_paste_msgs (ModestWindow *win, gpointer user_data)
 999 {
1000         ModestDimmingRule *rule = NULL;
1001         TnyFolderType types[3];
1002         gboolean dimmed = FALSE;
1003
1004         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
1005         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
1006         rule = MODEST_DIMMING_RULE (user_data);
1007
1008         types[0] = TNY_FOLDER_TYPE_DRAFTS;
1009         types[1] = TNY_FOLDER_TYPE_OUTBOX;
1010         types[2] = TNY_FOLDER_TYPE_SENT;
1011
1012         /* Check dimmed rule */
1013         if (!dimmed) {
1014                 dimmed = _clipboard_is_empty (win);
1015                 if (dimmed)
1016                         modest_dimming_rule_set_notification (rule, dgettext("hildon-common-strings", "ecoc_ib_edwin_nothing_to_paste"));
1017         }
1018         if (!dimmed) {
1019                 dimmed = _selected_folder_is_any_of_type (win, types, 3);
1020                 if (dimmed)
1021                         modest_dimming_rule_set_notification (rule, dgettext("hildon-common-strings", "ckct_ib_unable_to_paste_here"));
1022         }
1023         if (!dimmed) {
1024                 dimmed = _selected_folder_not_writeable (MODEST_MAIN_WINDOW(win));
1025                 if (dimmed) {
1026                         modest_dimming_rule_set_notification (rule, dgettext("hildon-common-strings", "ckct_ib_unable_to_paste_here"));
1027                 }
1028         }
1029         if (!dimmed) {
1030                 dimmed = _selected_folder_is_same_as_source (win);
1031                 if (dimmed)
1032                         modest_dimming_rule_set_notification (rule, _("mcen_ib_unable_to_copy_samefolder"));
1033         }
1034
1035         return dimmed;
1036 }
1037
1038
1039 gboolean
1040 modest_ui_dimming_rules_on_select_all (ModestWindow *win, gpointer user_data)
1041 {
1042         ModestDimmingRule *rule = NULL;
1043         gboolean dimmed = FALSE;
1044
1045         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
1046         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
1047         rule = MODEST_DIMMING_RULE (user_data);
1048
1049         /* Check dimmed rule */
1050         if (!dimmed) {
1051                 dimmed = _selected_folder_is_empty (MODEST_MAIN_WINDOW(win));
1052                 if (dimmed)
1053                         modest_dimming_rule_set_notification (rule, "");
1054         }
1055
1056         return dimmed;
1057 }
1058
1059 gboolean
1060 modest_ui_dimming_rules_on_view_attachments (ModestWindow *win, gpointer user_data)
1061 {
1062         ModestDimmingRule *rule = NULL;
1063         gboolean dimmed = FALSE;
1064
1065         g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW(win), FALSE);
1066         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
1067         rule = MODEST_DIMMING_RULE (user_data);
1068
1069         /* Check dimmed rule */
1070         if (!dimmed)
1071                 dimmed = _invalid_attach_selected (win, TRUE, TRUE, FALSE, rule);
1072
1073         if (!dimmed) {
1074                 dimmed = _purged_attach_selected (win, FALSE, NULL);
1075                 if (dimmed) {
1076                         modest_dimming_rule_set_notification (rule, _("mail_ib_attach_not_local"));
1077                 }
1078         }
1079
1080         return dimmed;
1081 }
1082
1083 gboolean
1084 modest_ui_dimming_rules_on_save_attachments (ModestWindow *win, gpointer user_data)
1085 {
1086         ModestDimmingRule *rule = NULL;
1087         gboolean dimmed = FALSE;
1088
1089         g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW(win), FALSE);
1090         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
1091         rule = MODEST_DIMMING_RULE (user_data);
1092
1093         /* Check dimmed rule */
1094         if (!dimmed)
1095                 dimmed = _invalid_attach_selected (win, FALSE, FALSE, FALSE, rule);
1096
1097         if (!dimmed) {
1098                 dimmed = _purged_attach_selected (win, FALSE, NULL);
1099                 if (dimmed) {
1100                         modest_dimming_rule_set_notification (rule, _("mail_ib_attach_not_local"));
1101                 }
1102         }
1103
1104         return dimmed;
1105 }
1106
1107 gboolean
1108 modest_ui_dimming_rules_on_remove_attachments (ModestWindow *win, gpointer user_data)
1109 {
1110         ModestDimmingRule *rule = NULL;
1111         const DimmedState *state = NULL;
1112         gboolean dimmed = FALSE;
1113
1114         g_return_val_if_fail (MODEST_IS_WINDOW(win), FALSE);
1115         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
1116         rule = MODEST_DIMMING_RULE (user_data);
1117         state = modest_window_get_dimming_state (win);
1118
1119         /* Check in main window if there's only one message selected */
1120         if (!dimmed && MODEST_IS_MAIN_WINDOW (win)) {
1121                 dimmed = _invalid_msg_selected (MODEST_MAIN_WINDOW (win), TRUE, rule);
1122         }
1123
1124         /* Check in view window if there's any attachment selected */
1125         if (!dimmed && MODEST_IS_MSG_VIEW_WINDOW (win)) {
1126                 dimmed = _invalid_attach_selected (win, FALSE, FALSE, TRUE, NULL);
1127                 if (dimmed)
1128                         modest_dimming_rule_set_notification (rule, _("FIXME:no attachment selected"));
1129         }
1130
1131         /* cannot purge in editable drafts nor pop folders */
1132         if (!dimmed) {
1133                 dimmed = _invalid_folder_for_purge (win, rule);
1134         }
1135
1136         /* Check if the selected message in main window has attachments */
1137         if (!dimmed && MODEST_IS_MAIN_WINDOW (win)) {
1138                 dimmed = state->any_has_attachments;
1139                 if (dimmed)
1140                         modest_dimming_rule_set_notification (rule, _("mail_ib_unable_to_purge_attachments"));
1141         }
1142
1143         /* Check if all attachments are already purged */
1144         if (!dimmed) {
1145                 dimmed = _purged_attach_selected (win, TRUE, rule);
1146         }
1147
1148         /* Check if the message is already downloaded */
1149         if (!dimmed && MODEST_IS_MAIN_WINDOW (win)) {
1150                 dimmed = !_msg_download_completed (MODEST_MAIN_WINDOW (win));
1151                 if (dimmed)
1152                         modest_dimming_rule_set_notification (rule, _("mail_ib_attach_not_local"));
1153         }
1154
1155
1156         return dimmed;
1157 }
1158
1159 gboolean
1160 modest_ui_dimming_rules_on_undo (ModestWindow *win, gpointer user_data)
1161 {
1162         ModestDimmingRule *rule = NULL;
1163         gboolean dimmed = FALSE;
1164
1165         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
1166         rule = MODEST_DIMMING_RULE (user_data);
1167
1168         /* Check dimmed rule */
1169         if (!dimmed) {
1170                 dimmed = _clipboard_is_empty (win);
1171                 if (dimmed)
1172                         modest_dimming_rule_set_notification (rule, "");
1173         }
1174
1175         return dimmed;
1176 }
1177
1178 gboolean
1179 modest_ui_dimming_rules_on_cut (ModestWindow *win, gpointer user_data)
1180 {
1181         ModestDimmingRule *rule = NULL;
1182         gboolean dimmed = FALSE;
1183
1184         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
1185         rule = MODEST_DIMMING_RULE (user_data);
1186
1187         /* Check common dimming rules */
1188         if (!dimmed) {
1189                 dimmed = _invalid_clipboard_selected (win, rule);
1190         }
1191
1192         /* Check window specific dimming rules */
1193         if (MODEST_IS_MAIN_WINDOW (win)) {
1194                 /* Get focused widget */
1195                 GtkWidget *focused = gtk_window_get_focus (GTK_WINDOW (win));
1196
1197                 if (MODEST_IS_HEADER_VIEW (focused)) {
1198                         if (!dimmed) {
1199                                 dimmed = _selected_folder_is_empty (MODEST_MAIN_WINDOW(win));
1200                                 if (dimmed)
1201                                         modest_dimming_rule_set_notification (rule, "");
1202                         }
1203                         if (!dimmed) {
1204                                 dimmed = _selected_msg_sent_in_progress (win);
1205                                 if (dimmed)
1206                                 modest_dimming_rule_set_notification (rule, _("mcen_ib_unable_to_cut_mess"));
1207                         }
1208                 }
1209         }
1210
1211         return dimmed;
1212 }
1213
1214 gboolean
1215 modest_ui_dimming_rules_on_copy (ModestWindow *win, gpointer user_data)
1216 {
1217         ModestDimmingRule *rule = NULL;
1218         gboolean dimmed = FALSE;
1219
1220         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
1221         rule = MODEST_DIMMING_RULE (user_data);
1222
1223         /* Check common dimming rules */
1224         if (!dimmed) {
1225                 dimmed = _invalid_clipboard_selected (win, rule);
1226         }
1227
1228         /* Check window specific dimming rules */
1229         if (MODEST_IS_MAIN_WINDOW (win)) {
1230                 /* Get focused widget */
1231                 GtkWidget *focused = gtk_window_get_focus (GTK_WINDOW (win));
1232
1233                 if (MODEST_IS_HEADER_VIEW (focused)) {
1234                         if (!dimmed) {
1235                                 dimmed = _selected_folder_is_empty (MODEST_MAIN_WINDOW(win));
1236                                 if (dimmed)
1237                                         modest_dimming_rule_set_notification (rule, "");
1238                         }
1239                         if (!dimmed) {
1240                                 dimmed = _selected_msg_sent_in_progress (win);
1241                                 if (dimmed)
1242                                         modest_dimming_rule_set_notification (rule, _("mcen_ib_unable_to_cut_mess"));
1243                         }
1244                 }
1245         }
1246
1247         return dimmed;
1248 }
1249
1250 gboolean
1251 modest_ui_dimming_rules_on_view_previous (ModestWindow *win, gpointer user_data)
1252 {
1253         ModestDimmingRule *rule = NULL;
1254         gboolean dimmed = FALSE;
1255
1256         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
1257         rule = MODEST_DIMMING_RULE (user_data);
1258
1259         g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW(win), FALSE);
1260
1261         /* Check dimmed rule */
1262         if (!dimmed) {
1263                 dimmed = _transfer_mode_enabled (win);
1264                 if (dimmed)
1265                         modest_dimming_rule_set_notification (
1266                                         rule, _("mail_ib_notavailable_downloading"));
1267         }
1268         if (!dimmed) {
1269                 dimmed = modest_msg_view_window_first_message_selected (
1270                                 MODEST_MSG_VIEW_WINDOW(win));
1271                 modest_dimming_rule_set_notification (rule, NULL);
1272         }
1273
1274         return dimmed;
1275 }
1276
1277 gboolean
1278 modest_ui_dimming_rules_on_view_next (ModestWindow *win, gpointer user_data)
1279 {
1280         ModestDimmingRule *rule = NULL;
1281         gboolean dimmed = FALSE;
1282
1283         g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW(win), FALSE);
1284         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
1285         rule = MODEST_DIMMING_RULE (user_data);
1286
1287         /* Check dimmed rule */
1288         if (!dimmed) {
1289                 dimmed = _transfer_mode_enabled (win);
1290                 if (dimmed)
1291                         modest_dimming_rule_set_notification (rule, _("mail_ib_notavailable_downloading"));
1292         }
1293         if (!dimmed) {
1294                 dimmed = modest_msg_view_window_last_message_selected (MODEST_MSG_VIEW_WINDOW (win));
1295                 modest_dimming_rule_set_notification (rule, NULL);
1296         }
1297
1298         return dimmed;
1299 }
1300
1301
1302 gboolean
1303 modest_ui_dimming_rules_on_tools_smtp_servers (ModestWindow *win, gpointer user_data)
1304 {
1305         const gboolean dimmed =
1306                 !modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(),
1307                         TRUE);
1308
1309         return dimmed;
1310 }
1311
1312 gboolean
1313 modest_ui_dimming_rules_on_cancel_sending (ModestWindow *win, gpointer user_data)
1314 {
1315         ModestDimmingRule *rule = NULL;
1316         TnyFolderType types[1];
1317         guint n_messages = 0;
1318         const DimmedState *state = NULL;
1319         gboolean dimmed = FALSE;
1320
1321         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
1322         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
1323         rule = MODEST_DIMMING_RULE (user_data);
1324         state = modest_window_get_dimming_state (win);
1325
1326         types[0] = TNY_FOLDER_TYPE_OUTBOX;
1327
1328         /* Check dimmed rules */
1329         if (!dimmed) {
1330                 dimmed = state->already_opened_msg;
1331                 n_messages = state->n_selected;
1332                 if (dimmed)
1333                         modest_dimming_rule_set_notification (rule, _("mcen_ib_message_unableto_cancel_send"));
1334         }
1335         if (!dimmed) {
1336                 dimmed = !_selected_folder_is_any_of_type (win, types, 1);
1337                 if (dimmed)
1338                         modest_dimming_rule_set_notification (rule, "");
1339         }
1340         if (!dimmed) {
1341                 dimmed = !_sending_in_progress (win);
1342                 if (dimmed)
1343                         modest_dimming_rule_set_notification (rule, "");
1344         }
1345
1346         return dimmed;
1347 }
1348
1349 gboolean
1350 modest_ui_dimming_rules_on_send_receive (ModestWindow *win, gpointer user_data)
1351 {
1352         ModestDimmingRule *rule = NULL;
1353         gboolean dimmed = FALSE;
1354
1355         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
1356         rule = MODEST_DIMMING_RULE (user_data);
1357
1358         /* Check dimmed rule */
1359         if (!dimmed) {
1360                 dimmed = !modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(),
1361                                                           TRUE);
1362                 if (dimmed)
1363                         modest_dimming_rule_set_notification (rule, _("mcen_nc_no_email_acnts_defined"));
1364         }
1365
1366         return dimmed;
1367 }
1368
1369 gboolean
1370 modest_ui_dimming_rules_on_add_to_contacts (ModestWindow *win, gpointer user_data)
1371 {
1372         ModestDimmingRule *rule = NULL;
1373         gboolean dimmed = FALSE;
1374
1375         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
1376         rule = MODEST_DIMMING_RULE (user_data);
1377
1378         /* Check dimmed rule */
1379         if (!dimmed) {
1380                 GtkClipboard *clipboard = gtk_clipboard_get (GDK_SELECTION_PRIMARY);
1381                 gchar *selection = NULL;
1382                 selection = gtk_clipboard_wait_for_text (clipboard);
1383
1384                 dimmed = !((selection != NULL) && (modest_text_utils_validate_recipient (selection, NULL)));
1385         }
1386
1387         return dimmed;
1388 }
1389
1390 /* *********************** static utility functions ******************** */
1391
1392
1393 static gboolean
1394 _selected_folder_not_writeable (ModestMainWindow *win)
1395 {
1396         GtkWidget *folder_view = NULL;
1397         TnyFolderStore *parent_folder = NULL;
1398         ModestTnyFolderRules rules;
1399         gboolean result = FALSE;
1400
1401         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
1402
1403         /* Get folder view */
1404         folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
1405                                                            MODEST_WIDGET_TYPE_FOLDER_VIEW);
1406         /* If no folder view, always dimmed */
1407         if (!folder_view)
1408                 return TRUE;
1409
1410         /* Get selected folder as parent of new folder to create */
1411         parent_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
1412         if (!(parent_folder && TNY_IS_FOLDER(parent_folder))) {
1413                 if (parent_folder)
1414                         g_object_unref (parent_folder);
1415                 return TRUE;
1416         }
1417
1418         /* Check dimmed rule */
1419         rules = modest_tny_folder_get_rules (TNY_FOLDER (parent_folder));
1420         result = rules & MODEST_FOLDER_RULES_FOLDER_NON_WRITEABLE;
1421
1422         /* free */
1423         g_object_unref (parent_folder);
1424
1425         return result;
1426 }
1427
1428 static gboolean
1429 _selected_folder_is_root_or_inbox (ModestMainWindow *win)
1430 {
1431         TnyFolderType types[2];
1432         gboolean result = FALSE;
1433
1434         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
1435
1436         types[0] = TNY_FOLDER_TYPE_ROOT;
1437         types[1] = TNY_FOLDER_TYPE_INBOX;
1438
1439         /* Check folder type */
1440         result = _selected_folder_is_any_of_type (MODEST_WINDOW(win), types, 2);
1441
1442         /* Check pop and MMC accounts */
1443         if (!result) {
1444                 result = _selected_folder_is_MMC_or_POP_root (win);
1445         }
1446
1447         return result;
1448 }
1449
1450
1451 static gboolean
1452 _selected_folder_is_root (ModestMainWindow *win)
1453 {
1454         TnyFolderType types[1];
1455         gboolean result = FALSE;
1456
1457         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
1458
1459         /* All accounts are root items: */
1460         GtkWidget *folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
1461                                                            MODEST_WIDGET_TYPE_FOLDER_VIEW);
1462         if (folder_view) {
1463                 gboolean is_account = FALSE;
1464                 TnyFolderStore *folder_store =
1465                         modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
1466                 if (folder_store) {
1467                         is_account = TNY_IS_ACCOUNT (folder_store);
1468                         g_object_unref (folder_store);
1469                         folder_store = NULL;
1470                 }
1471
1472                 if (is_account)
1473                         return TRUE;
1474         }
1475
1476         /* Try something more precise: */
1477         types[0] = TNY_FOLDER_TYPE_ROOT;
1478
1479         /* Check folder type */
1480         result = _selected_folder_is_any_of_type (MODEST_WINDOW(win), types, 1);
1481
1482         /* Check pop and MMC accounts */
1483         if (!result) {
1484                 result = _selected_folder_is_MMC_or_POP_root (win);
1485         }
1486
1487         return result;
1488 }
1489
1490 static gboolean
1491 _selected_folder_is_MMC_or_POP_root (ModestMainWindow *win)
1492 {
1493         GtkWidget *folder_view = NULL;
1494         TnyFolderStore *parent_folder = NULL;
1495         gboolean result = FALSE;
1496
1497         folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
1498                                                            MODEST_WIDGET_TYPE_FOLDER_VIEW);
1499         /* Get selected folder as parent of new folder to create */
1500         parent_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
1501         if (!parent_folder)
1502                 return TRUE;
1503
1504         if (TNY_IS_ACCOUNT (parent_folder)) {
1505                 /* If it's the local account then do not dim */
1506                 if (modest_tny_account_is_virtual_local_folders (TNY_ACCOUNT (parent_folder))) {
1507                         result = FALSE;
1508                 } else {
1509                                 /* If it's the MMC root folder then dim it */
1510                         if (!strcmp (tny_account_get_id (TNY_ACCOUNT (parent_folder)), MODEST_MMC_ACCOUNT_ID)) {
1511                                         result = TRUE;
1512                         } else {
1513                                 const gchar *proto_str = tny_account_get_proto (TNY_ACCOUNT (parent_folder));
1514                                 /* If it's POP then dim */
1515                                 result = (modest_protocol_info_get_transport_store_protocol (proto_str) ==
1516                                                   MODEST_PROTOCOL_STORE_POP) ? TRUE : FALSE;
1517                         }
1518                 }
1519         }
1520         g_object_unref (parent_folder);
1521
1522         return result;
1523 }
1524
1525
1526 static gboolean
1527 _selected_folder_is_empty (ModestMainWindow *win)
1528 {
1529         GtkWidget *folder_view = NULL;
1530         TnyFolderStore *folder = NULL;
1531         gboolean result = FALSE;
1532
1533         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
1534
1535         /* Get folder view */
1536         folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
1537                                                            MODEST_WIDGET_TYPE_FOLDER_VIEW);
1538         /* If no folder view, always dimmed */
1539         if (!folder_view)
1540                 return TRUE;
1541
1542         /* Get selected folder as parent of new folder to create */
1543         folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
1544         if (!(folder && TNY_IS_FOLDER(folder))) {
1545                 if (folder)
1546                         g_object_unref (folder);
1547                 return TRUE;
1548         }
1549
1550         /* Check folder type */
1551         result = tny_folder_get_all_count (TNY_FOLDER (folder)) == 0;
1552
1553         /* free */
1554         g_object_unref (folder);
1555
1556         return result;
1557 }
1558
1559 static gboolean
1560 _selected_folder_is_same_as_source (ModestWindow *win)
1561 {
1562         ModestEmailClipboard *clipboard = NULL;
1563         GtkWidget *folder_view = NULL;
1564         TnyFolderStore *folder = NULL;
1565         gboolean result = FALSE;
1566
1567         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
1568
1569         /* Get folder view */
1570         folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
1571                                                            MODEST_WIDGET_TYPE_FOLDER_VIEW);
1572         if (!folder_view)
1573                 return FALSE;
1574
1575         /* Get selected folder as destination folder */
1576         folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
1577         if (!(folder && TNY_IS_FOLDER(folder))) {
1578                 result = FALSE;
1579                 goto frees;
1580         }
1581
1582         /* Check clipboard is cleared */
1583         clipboard = modest_runtime_get_email_clipboard ();
1584         if (modest_email_clipboard_cleared (clipboard)) {
1585                 result = FALSE;
1586                 goto frees;
1587         }
1588
1589         /* Check source folder */
1590         result = modest_email_clipboard_check_source_folder (clipboard,
1591                                                              (const TnyFolder *) folder);
1592
1593         /* Free */
1594  frees:
1595         g_object_unref (folder);
1596
1597         return result;
1598 }
1599
1600 static gboolean
1601 _selected_folder_is_any_of_type (ModestWindow *win,
1602                                  TnyFolderType types[],
1603                                  guint ntypes)
1604 {
1605         GtkWidget *folder_view = NULL;
1606         TnyFolderStore *folder = NULL;
1607         TnyFolderType folder_type;
1608         guint i=0;
1609         gboolean result = FALSE;
1610
1611         /*Get current folder */
1612         if (MODEST_IS_MAIN_WINDOW(win)) {
1613
1614                 /* Get folder view */
1615                 folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
1616                                                                    MODEST_WIDGET_TYPE_FOLDER_VIEW);
1617                 /* If no folder view, always dimmed */
1618                 if (!folder_view)
1619                         return FALSE;
1620
1621                 /* Get selected folder as parent of new folder to create */
1622                 folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
1623
1624                 if (!(folder && TNY_IS_FOLDER(folder))) {
1625                         if (folder)
1626                                 g_object_unref (folder);
1627                         return FALSE;
1628                 }
1629
1630                 /* Check folder type */
1631                 result = _folder_is_any_of_type (TNY_FOLDER(folder), types, ntypes);
1632         }
1633         else if (MODEST_IS_MSG_VIEW_WINDOW(win)) {
1634                 folder_type = modest_msg_view_window_get_folder_type (MODEST_MSG_VIEW_WINDOW (win));
1635                 for (i=0; i < ntypes; i++) {
1636                         result = result || folder_type == types[i];
1637                 }
1638         }
1639
1640
1641         /* free */
1642         g_object_unref (folder);
1643
1644         return result;
1645 }
1646
1647 static gboolean
1648 _folder_is_any_of_type (TnyFolder *folder,
1649                         TnyFolderType types[],
1650                         guint ntypes)
1651 {
1652         TnyFolderType folder_type;
1653         gboolean result = FALSE;
1654         guint i;
1655
1656         g_return_val_if_fail (TNY_IS_FOLDER(folder), FALSE);
1657
1658         /* Get folder type */
1659         folder_type = modest_tny_folder_guess_folder_type (folder);
1660
1661         /* Check foler type */
1662         for (i=0; i < ntypes; i++) {
1663                 result = result || folder_type == types[i];
1664         }
1665
1666         return result;
1667 }
1668
1669 static gboolean
1670 _selected_folder_is_snd_level (ModestMainWindow *win)
1671 {
1672         GtkWidget *folder_view = NULL;
1673         GtkTreeSelection *sel = NULL;
1674         GtkTreeModel *model = NULL;
1675         GtkTreePath *path = NULL;
1676         GtkTreeIter iter;
1677         TnyFolderStore *folder = NULL;
1678         gboolean result = FALSE;
1679
1680         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), TRUE);
1681
1682         /*Get curent folder */
1683         folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
1684                                                            MODEST_WIDGET_TYPE_FOLDER_VIEW);
1685         /* If no folder view, always dimmed */
1686         if (!folder_view)
1687                 goto frees;
1688
1689         /* Get selected folder as parent of new folder to create */
1690         folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
1691         if (!(folder && TNY_IS_FOLDER(folder))) {
1692                 goto frees;
1693         }
1694
1695         /* Check folder level */
1696         sel = gtk_tree_view_get_selection (GTK_TREE_VIEW(folder_view));
1697         if (!gtk_tree_selection_get_selected (sel, &model, &iter))
1698                 goto frees;
1699         path = gtk_tree_model_get_path (model, &iter);
1700         result = gtk_tree_path_get_depth (path) > 2;
1701
1702  frees:
1703         if (folder != NULL)
1704                 g_object_unref (folder);
1705         if (path != NULL)
1706                 gtk_tree_path_free (path);
1707
1708         return result;
1709
1710 }
1711
1712 static gboolean
1713 _clipboard_is_empty (ModestWindow *win)
1714 {
1715         gboolean result = FALSE;
1716
1717         if (MODEST_IS_MAIN_WINDOW (win)) {
1718                 ModestEmailClipboard *clipboard = NULL;
1719                 clipboard = modest_runtime_get_email_clipboard ();
1720                 if (modest_email_clipboard_cleared (clipboard))
1721                  result = TRUE;
1722         }
1723
1724         return result;
1725 }
1726
1727 static gboolean
1728 _invalid_clipboard_selected (ModestWindow *win,
1729                        ModestDimmingRule *rule)
1730 {
1731         const DimmedState *state = NULL;
1732         gboolean result = FALSE;
1733
1734         g_return_val_if_fail (MODEST_IS_WINDOW(win), FALSE);
1735         state = modest_window_get_dimming_state (win);
1736
1737         if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
1738                 GtkClipboard *clipboard = NULL;
1739                 gchar *selection = NULL;
1740                 GtkWidget *focused = NULL;
1741
1742                 /* Get clipboard selection*/
1743                 clipboard = gtk_clipboard_get (GDK_SELECTION_PRIMARY);
1744                 selection = gtk_clipboard_wait_for_text (clipboard);
1745
1746                 /* Get focuesed widget */
1747                 focused = gtk_window_get_focus (GTK_WINDOW (win));
1748
1749                 /* Check dimming */
1750                 result = ((selection == NULL) ||
1751                           (MODEST_IS_ATTACHMENTS_VIEW (focused)));
1752
1753                 if (result)
1754                         modest_dimming_rule_set_notification (rule, "");
1755
1756                 if (selection != NULL)
1757                         g_free(selection);
1758         }
1759         else if (MODEST_IS_MAIN_WINDOW (win)) {
1760                 /* Check dimming */
1761                 result = state->n_selected == 0;
1762                 if (result)
1763                         modest_dimming_rule_set_notification (rule, _("mcen_ib_no_message_selected"));
1764         }
1765
1766         return result;
1767 }
1768
1769
1770 static gboolean
1771 _invalid_attach_selected (ModestWindow *win,
1772                           gboolean unique,
1773                           gboolean for_view,
1774                           gboolean for_remove,
1775                           ModestDimmingRule *rule)
1776 {
1777         GList *attachments, *node;
1778         gint n_selected;
1779         TnyHeaderFlags flags;
1780         gboolean nested_attachments = FALSE;
1781         gboolean selected_messages = FALSE;
1782         const DimmedState *state = NULL;
1783         gboolean result = FALSE;
1784
1785         g_return_val_if_fail (MODEST_IS_WINDOW(win), FALSE);
1786         state = modest_window_get_dimming_state (win);
1787
1788         if (MODEST_IS_MAIN_WINDOW (win)) {
1789                 flags = TNY_HEADER_FLAG_ATTACHMENTS;
1790                 if (!result)
1791                         result = !state->any_has_attachments;
1792         }
1793         else if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
1794
1795                 /* Get selected atachments */
1796                 attachments = modest_msg_view_window_get_attachments (MODEST_MSG_VIEW_WINDOW(win));
1797                 n_selected = g_list_length (attachments);
1798
1799                 /* Check unique */
1800                 if (!result) {
1801                         if (unique)
1802                                 result = n_selected != 1;
1803                         else
1804
1805                                 result = n_selected < 1;
1806                 }
1807
1808                 /* Check attached type (view operation not required) */
1809                 if (!result && !for_view)  {
1810                         for (node = attachments; node != NULL && !result; node = g_list_next (node)) {
1811                                 TnyMimePart *mime_part = TNY_MIME_PART (node->data);
1812                                 TnyList *nested_list = tny_simple_list_new ();
1813                                 if (!for_remove && TNY_IS_MSG (mime_part)) {
1814                                         selected_messages = TRUE;
1815                                         result = TRUE;
1816                                 }
1817                                 tny_mime_part_get_parts (mime_part, nested_list);
1818                                 if (!for_remove && tny_list_get_length (nested_list) > 0) {
1819                                         nested_attachments = TRUE;
1820                                         result = TRUE;
1821                                 }
1822                                 g_object_unref (nested_list);
1823                         }
1824                 }
1825
1826                 /* Set notifications */
1827                 if (result && rule != NULL) {
1828                         if (selected_messages) {
1829                                 modest_dimming_rule_set_notification (rule, _("mcen_ib_unable_to_save_attach_mail"));
1830                         } else if (nested_attachments) {
1831                                 modest_dimming_rule_set_notification (rule, _("FIXME:unable to save attachments with nested elements"));
1832                         } else if (n_selected == 0) {
1833                                 modest_dimming_rule_set_notification (rule, _("FIXME:no attachment selected"));
1834                         } else if (unique) {
1835                                 modest_dimming_rule_set_notification (rule, _("mcen_ib_unable_to_display_more"));
1836                         }
1837                 }
1838
1839                 /* Free */
1840                 g_list_free (attachments);
1841         }
1842
1843         return result;
1844 }
1845
1846 static gboolean
1847 _purged_attach_selected (ModestWindow *win, gboolean all, ModestDimmingRule *rule)
1848 {
1849         GList *attachments = NULL, *node;
1850         gint purged = 0;
1851         gint n_attachments = 0;
1852         gboolean result = FALSE;
1853
1854         /* This should check if _all_ the attachments are already purged. If only some
1855          * of them are purged, then it does not cause dim as there's a confirmation dialog
1856          * for removing only local attachments */
1857
1858         /* Get selected atachments */
1859         if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
1860                 attachments = modest_msg_view_window_get_attachments (MODEST_MSG_VIEW_WINDOW(win));
1861         } else if (MODEST_IS_MAIN_WINDOW (win)) {
1862                 /* If we're in main window, we won't know if there are already purged attachments */
1863                 return FALSE;
1864         }
1865
1866         if (attachments == NULL)
1867                 return FALSE;
1868
1869         for (node = attachments; node != NULL; node = g_list_next (node)) {
1870                 TnyMimePart *mime_part = TNY_MIME_PART (node->data);
1871                 if (tny_mime_part_is_purged (mime_part)) {
1872                         purged++;
1873                 }
1874                 n_attachments++;
1875         }
1876
1877         /* Free */
1878         g_list_free (attachments);
1879
1880         if (all)
1881                 result = (purged == n_attachments);
1882         else
1883                 result = (purged > 0);
1884
1885         if (result && (rule != NULL))
1886                 modest_dimming_rule_set_notification (rule, _("mail_ib_attachment_already_purged"));
1887
1888         return result;
1889 }
1890
1891 static gboolean
1892 _invalid_msg_selected (ModestMainWindow *win,
1893                        gboolean unique,
1894                        ModestDimmingRule *rule)
1895 {
1896         GtkWidget *folder_view = NULL;
1897         const DimmedState *state = NULL;
1898         gboolean result = FALSE;
1899
1900         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
1901         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (rule), FALSE);
1902         state = modest_window_get_dimming_state (MODEST_WINDOW(win));
1903
1904         /* Get folder view to check focus */
1905         folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
1906                                                            MODEST_WIDGET_TYPE_FOLDER_VIEW);
1907
1908         /* Check dimmed rule (TODO: check focus on widgets */
1909         if (!result) {
1910                 result = ((state->n_selected == 0 ) ||
1911                           (gtk_widget_is_focus (folder_view)));
1912                 if (result)
1913                         modest_dimming_rule_set_notification (rule, _("mcen_ib_no_message_selected"));
1914         }
1915         if (!result && unique) {
1916                 result = state->n_selected > 1;
1917                 if (result)
1918                         modest_dimming_rule_set_notification (rule, _("mcen_ib_select_one_message"));
1919         }
1920
1921         return result;
1922 }
1923
1924
1925 static gboolean
1926 _msg_download_in_progress (ModestMsgViewWindow *win)
1927 {
1928         gboolean result = FALSE;
1929
1930         g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW (win), FALSE);
1931
1932         result = modest_msg_view_window_toolbar_on_transfer_mode (win);
1933
1934         return result;
1935 }
1936
1937 static gboolean
1938 _msg_download_completed (ModestMainWindow *win)
1939 {
1940         const DimmedState *state = modest_window_get_dimming_state (MODEST_WINDOW(win));
1941         return state->any_marked_as_cached;
1942 }
1943
1944 static void
1945 fill_list_of_caches (gpointer key, gpointer value, gpointer userdata)
1946 {
1947         GSList **send_queues = (GSList **) userdata;
1948         *send_queues = g_slist_prepend (*send_queues, value);
1949 }
1950
1951 static gboolean
1952 _selected_msg_sent_in_progress (ModestWindow *win)
1953 {
1954         const DimmedState *state = modest_window_get_dimming_state (win);
1955         return state->sent_in_progress;
1956 }
1957
1958
1959 static gboolean
1960 _sending_in_progress (ModestWindow *win)
1961 {
1962         gboolean result = FALSE;
1963
1964         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW (win), FALSE);
1965
1966         /* Check if send operation is in progress */
1967         result = modest_main_window_send_receive_in_progress (MODEST_MAIN_WINDOW (win));
1968
1969         return result;
1970 }
1971
1972 static gboolean
1973 _invalid_folder_for_purge (ModestWindow *win,
1974                            ModestDimmingRule *rule)
1975 {
1976         TnyMsg *msg = NULL;
1977         TnyFolder *folder = NULL;
1978         TnyAccount *account = NULL;
1979         gboolean result = FALSE;
1980
1981         if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
1982
1983                 /* Get folder and account of message */
1984                 msg = modest_msg_view_window_get_message (MODEST_MSG_VIEW_WINDOW (win));
1985                 g_return_val_if_fail(msg != NULL, TRUE);
1986                 folder = tny_msg_get_folder (msg);
1987                 if (folder == NULL) {
1988                         modest_dimming_rule_set_notification (rule, _("mail_ib_unable_to_purge_attachments"));
1989                         goto frees;
1990                 }
1991                 g_object_unref (msg);
1992         } else if (MODEST_IS_MAIN_WINDOW (win)) {
1993                 GtkWidget *folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
1994                                                                               MODEST_WIDGET_TYPE_FOLDER_VIEW);
1995                 if (!folder_view)
1996                         return FALSE;
1997                 folder = TNY_FOLDER (modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view)));
1998                 if (folder == NULL || ! TNY_IS_FOLDER (folder))
1999                         goto frees;
2000         } else {
2001                 g_return_val_if_reached (FALSE);
2002         }
2003         account = modest_tny_folder_get_account (folder);
2004         if (account == NULL) goto frees;
2005
2006         /* Check account */
2007         if (modest_tny_account_is_virtual_local_folders (TNY_ACCOUNT (account))) {
2008                 TnyFolderType types[2];
2009                 types[0] = TNY_FOLDER_TYPE_DRAFTS;
2010                 types[1] = TNY_FOLDER_TYPE_OUTBOX;
2011
2012                 if (_selected_folder_is_any_of_type (win, types, 2)) {
2013                         result = TRUE;
2014                         modest_dimming_rule_set_notification (rule, _("mail_ib_unable_to_purge_editable_msg"));
2015                 } else {
2016                         /* We're currently disabling purge in any local store */
2017                         result = TRUE;
2018                         modest_dimming_rule_set_notification (rule, _("mail_ib_unable_to_purge_attachments"));
2019                 }
2020         } else {
2021                 const gchar *proto_str = tny_account_get_proto (TNY_ACCOUNT (account));
2022                 /* If it's POP then dim */
2023                 if (modest_protocol_info_get_transport_store_protocol (proto_str) ==
2024                     MODEST_PROTOCOL_STORE_POP) {
2025                         GList *attachments = NULL;
2026                         gint n_selected = 0;
2027                         result = TRUE;
2028
2029                         /* TODO: This check is here to prevent a gwarning, but this looks like a logic error.
2030                          * murrayc */
2031                         if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
2032                                 attachments = modest_msg_view_window_get_attachments (MODEST_MSG_VIEW_WINDOW(win));
2033                                 n_selected = g_list_length (attachments);
2034                                 g_list_free (attachments);
2035                         }
2036
2037                         modest_dimming_rule_set_notification (rule,
2038                                                               ngettext ("mail_ib_unable_to_pure_attach_pop_mail_singular",
2039                                                                         "mail_ib_unable_to_pure_attach_pop_mail_plural",
2040                                                                         n_selected));
2041                 }
2042         }
2043
2044 frees:
2045         if (folder != NULL)
2046                 g_object_unref (folder);
2047         if (account != NULL)
2048                 g_object_unref (account);
2049
2050         return result;
2051 }
2052
2053 static gboolean
2054 _transfer_mode_enabled (ModestWindow *win)
2055 {
2056         gboolean result = FALSE;
2057
2058         g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW (win), FALSE);
2059
2060         /* Check dimming */
2061         result = modest_msg_view_window_transfer_mode_enabled (MODEST_MSG_VIEW_WINDOW (win));
2062
2063         return result;
2064 }
2065