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