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                 else if (MODEST_IS_FOLDER_VIEW (focused)) {
1210                         TnyFolderType types[3];
1211
1212                         types[0] = TNY_FOLDER_TYPE_DRAFTS;
1213                         types[1] = TNY_FOLDER_TYPE_OUTBOX;
1214                         types[2] = TNY_FOLDER_TYPE_SENT;
1215
1216                         /* Apply folder rules */
1217                         if (!dimmed) {
1218                                 dimmed = _selected_folder_not_writeable (MODEST_MAIN_WINDOW(win));
1219                                 if (dimmed)
1220                                         modest_dimming_rule_set_notification (rule, _("emev_bd_unabletomove_items"));
1221                         }
1222                         if (!dimmed) {
1223                                 dimmed = _selected_folder_is_root_or_inbox (MODEST_MAIN_WINDOW(win));
1224                                 if (dimmed)
1225                                         modest_dimming_rule_set_notification (rule, _("emev_bd_unabletomove_itemsr"));
1226                         }
1227                         if (!dimmed) {
1228                                 dimmed = _selected_folder_is_any_of_type (win, types, 3);
1229                                 if (dimmed)
1230                                         modest_dimming_rule_set_notification (rule, _("emev_bd_unabletomove_itemsr"));
1231                         }
1232                 }
1233         }
1234
1235         return dimmed;
1236 }
1237
1238 gboolean
1239 modest_ui_dimming_rules_on_copy (ModestWindow *win, gpointer user_data)
1240 {
1241         ModestDimmingRule *rule = NULL;
1242         gboolean dimmed = FALSE;
1243
1244         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
1245         rule = MODEST_DIMMING_RULE (user_data);
1246
1247         /* Check common dimming rules */
1248         if (!dimmed) {
1249                 dimmed = _invalid_clipboard_selected (win, rule);
1250         }
1251
1252         /* Check window specific dimming rules */
1253         if (MODEST_IS_MAIN_WINDOW (win)) {
1254                 /* Get focused widget */
1255                 GtkWidget *focused = gtk_window_get_focus (GTK_WINDOW (win));
1256
1257                 if (MODEST_IS_HEADER_VIEW (focused)) {
1258                         if (!dimmed) {
1259                                 dimmed = _selected_folder_is_empty (MODEST_MAIN_WINDOW(win));
1260                                 if (dimmed)
1261                                         modest_dimming_rule_set_notification (rule, "");
1262                         }
1263                         if (!dimmed) {
1264                                 dimmed = _selected_msg_sent_in_progress (win);
1265                                 if (dimmed)
1266                                         modest_dimming_rule_set_notification (rule, _(""));
1267                         }
1268                 }
1269                 else if (MODEST_IS_FOLDER_VIEW (focused)) {
1270                         if (!dimmed) {
1271                                 dimmed = _selected_folder_is_root (MODEST_MAIN_WINDOW(win));
1272                                 if (dimmed)
1273                                         modest_dimming_rule_set_notification (rule, _(""));
1274                         }
1275                 }
1276         }
1277
1278         return dimmed;
1279 }
1280
1281 gboolean
1282 modest_ui_dimming_rules_on_view_previous (ModestWindow *win, gpointer user_data)
1283 {
1284         ModestDimmingRule *rule = NULL;
1285         gboolean dimmed = FALSE;
1286
1287         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
1288         rule = MODEST_DIMMING_RULE (user_data);
1289
1290         g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW(win), FALSE);
1291
1292         /* Check dimmed rule */
1293         if (!dimmed) {
1294                 dimmed = _transfer_mode_enabled (win);
1295                 if (dimmed)
1296                         modest_dimming_rule_set_notification (
1297                                         rule, _("mail_ib_notavailable_downloading"));
1298         }
1299         if (!dimmed) {
1300                 dimmed = modest_msg_view_window_first_message_selected (
1301                                 MODEST_MSG_VIEW_WINDOW(win));
1302                 modest_dimming_rule_set_notification (rule, NULL);
1303         }
1304
1305         return dimmed;
1306 }
1307
1308 gboolean
1309 modest_ui_dimming_rules_on_view_next (ModestWindow *win, gpointer user_data)
1310 {
1311         ModestDimmingRule *rule = NULL;
1312         gboolean dimmed = FALSE;
1313
1314         g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW(win), FALSE);
1315         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
1316         rule = MODEST_DIMMING_RULE (user_data);
1317
1318         /* Check dimmed rule */
1319         if (!dimmed) {
1320                 dimmed = _transfer_mode_enabled (win);
1321                 if (dimmed)
1322                         modest_dimming_rule_set_notification (rule, _("mail_ib_notavailable_downloading"));
1323         }
1324         if (!dimmed) {
1325                 dimmed = modest_msg_view_window_last_message_selected (MODEST_MSG_VIEW_WINDOW (win));
1326                 modest_dimming_rule_set_notification (rule, NULL);
1327         }
1328
1329         return dimmed;
1330 }
1331
1332
1333 gboolean
1334 modest_ui_dimming_rules_on_tools_smtp_servers (ModestWindow *win, gpointer user_data)
1335 {
1336         const gboolean dimmed =
1337                 !modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(),
1338                         TRUE);
1339
1340         return dimmed;
1341 }
1342
1343 gboolean
1344 modest_ui_dimming_rules_on_cancel_sending (ModestWindow *win, gpointer user_data)
1345 {
1346         ModestDimmingRule *rule = NULL;
1347         TnyFolderType types[1];
1348         guint n_messages = 0;
1349         const DimmedState *state = NULL;
1350         gboolean dimmed = FALSE;
1351
1352         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
1353         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
1354         rule = MODEST_DIMMING_RULE (user_data);
1355         state = modest_window_get_dimming_state (win);
1356
1357         types[0] = TNY_FOLDER_TYPE_OUTBOX;
1358
1359         /* Check dimmed rules */
1360         if (!dimmed) {
1361                 dimmed = state->already_opened_msg;
1362                 n_messages = state->n_selected;
1363                 if (dimmed)
1364                         modest_dimming_rule_set_notification (rule, _("mcen_ib_message_unableto_cancel_send"));
1365         }
1366         if (!dimmed) {
1367                 dimmed = !_selected_folder_is_any_of_type (win, types, 1);
1368                 if (dimmed)
1369                         modest_dimming_rule_set_notification (rule, "");
1370         }
1371         if (!dimmed) {
1372                 dimmed = !_sending_in_progress (win);
1373                 if (dimmed)
1374                         modest_dimming_rule_set_notification (rule, "");
1375         }
1376
1377         return dimmed;
1378 }
1379
1380 gboolean
1381 modest_ui_dimming_rules_on_send_receive (ModestWindow *win, gpointer user_data)
1382 {
1383         ModestDimmingRule *rule = NULL;
1384         gboolean dimmed = FALSE;
1385
1386         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
1387         rule = MODEST_DIMMING_RULE (user_data);
1388
1389         /* Check dimmed rule */
1390         if (!dimmed) {
1391                 dimmed = !modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(),
1392                                                           TRUE);
1393                 if (dimmed)
1394                         modest_dimming_rule_set_notification (rule, _("mcen_nc_no_email_acnts_defined"));
1395         }
1396
1397         return dimmed;
1398 }
1399
1400 gboolean
1401 modest_ui_dimming_rules_on_add_to_contacts (ModestWindow *win, gpointer user_data)
1402 {
1403         ModestDimmingRule *rule = NULL;
1404         gboolean dimmed = FALSE;
1405
1406         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
1407         rule = MODEST_DIMMING_RULE (user_data);
1408
1409         /* Check dimmed rule */
1410         if (!dimmed) {
1411                 GtkClipboard *clipboard = gtk_clipboard_get (GDK_SELECTION_PRIMARY);
1412                 gchar *selection = NULL;
1413                 selection = gtk_clipboard_wait_for_text (clipboard);
1414
1415                 dimmed = !((selection != NULL) && (modest_text_utils_validate_recipient (selection, NULL)));
1416         }
1417
1418         return dimmed;
1419 }
1420
1421 /* *********************** static utility functions ******************** */
1422
1423
1424 static gboolean
1425 _selected_folder_not_writeable (ModestMainWindow *win)
1426 {
1427         GtkWidget *folder_view = NULL;
1428         TnyFolderStore *parent_folder = NULL;
1429         ModestTnyFolderRules rules;
1430         gboolean result = FALSE;
1431
1432         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
1433
1434         /* Get folder view */
1435         folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
1436                                                            MODEST_WIDGET_TYPE_FOLDER_VIEW);
1437         /* If no folder view, always dimmed */
1438         if (!folder_view)
1439                 return TRUE;
1440
1441         /* Get selected folder as parent of new folder to create */
1442         parent_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
1443         if (!(parent_folder && TNY_IS_FOLDER(parent_folder))) {
1444                 if (parent_folder)
1445                         g_object_unref (parent_folder);
1446                 return TRUE;
1447         }
1448
1449         /* Check dimmed rule */
1450         rules = modest_tny_folder_get_rules (TNY_FOLDER (parent_folder));
1451         result = rules & MODEST_FOLDER_RULES_FOLDER_NON_WRITEABLE;
1452
1453         /* free */
1454         g_object_unref (parent_folder);
1455
1456         return result;
1457 }
1458
1459 static gboolean
1460 _selected_folder_is_root_or_inbox (ModestMainWindow *win)
1461 {
1462         TnyFolderType types[2];
1463         gboolean result = FALSE;
1464
1465         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
1466
1467         types[0] = TNY_FOLDER_TYPE_ROOT;
1468         types[1] = TNY_FOLDER_TYPE_INBOX;
1469
1470         /* Check folder type */
1471         result = _selected_folder_is_any_of_type (MODEST_WINDOW(win), types, 2);
1472
1473         /* Check pop and MMC accounts */
1474         if (!result) {
1475                 result = _selected_folder_is_MMC_or_POP_root (win);
1476         }
1477
1478         return result;
1479 }
1480
1481
1482 static gboolean
1483 _selected_folder_is_root (ModestMainWindow *win)
1484 {
1485         TnyFolderType types[1];
1486         gboolean result = FALSE;
1487
1488         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
1489
1490         /* All accounts are root items: */
1491         GtkWidget *folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
1492                                                            MODEST_WIDGET_TYPE_FOLDER_VIEW);
1493         if (folder_view) {
1494                 gboolean is_account = FALSE;
1495                 TnyFolderStore *folder_store =
1496                         modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
1497                 if (folder_store) {
1498                         is_account = TNY_IS_ACCOUNT (folder_store);
1499                         g_object_unref (folder_store);
1500                         folder_store = NULL;
1501                 }
1502
1503                 if (is_account)
1504                         return TRUE;
1505         }
1506
1507         /* Try something more precise: */
1508         types[0] = TNY_FOLDER_TYPE_ROOT;
1509
1510         /* Check folder type */
1511         result = _selected_folder_is_any_of_type (MODEST_WINDOW(win), types, 1);
1512
1513         /* Check pop and MMC accounts */
1514         if (!result) {
1515                 result = _selected_folder_is_MMC_or_POP_root (win);
1516         }
1517
1518         return result;
1519 }
1520
1521 static gboolean
1522 _selected_folder_is_MMC_or_POP_root (ModestMainWindow *win)
1523 {
1524         GtkWidget *folder_view = NULL;
1525         TnyFolderStore *parent_folder = NULL;
1526         gboolean result = FALSE;
1527
1528         folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
1529                                                            MODEST_WIDGET_TYPE_FOLDER_VIEW);
1530         /* Get selected folder as parent of new folder to create */
1531         parent_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
1532         if (!parent_folder)
1533                 return TRUE;
1534
1535         if (TNY_IS_ACCOUNT (parent_folder)) {
1536                 /* If it's the local account then do not dim */
1537                 if (modest_tny_account_is_virtual_local_folders (TNY_ACCOUNT (parent_folder))) {
1538                         result = FALSE;
1539                 } else {
1540                                 /* If it's the MMC root folder then dim it */
1541                         if (!strcmp (tny_account_get_id (TNY_ACCOUNT (parent_folder)), MODEST_MMC_ACCOUNT_ID)) {
1542                                         result = TRUE;
1543                         } else {
1544                                 const gchar *proto_str = tny_account_get_proto (TNY_ACCOUNT (parent_folder));
1545                                 /* If it's POP then dim */
1546                                 result = (modest_protocol_info_get_transport_store_protocol (proto_str) ==
1547                                                   MODEST_PROTOCOL_STORE_POP) ? TRUE : FALSE;
1548                         }
1549                 }
1550         }
1551         g_object_unref (parent_folder);
1552
1553         return result;
1554 }
1555
1556
1557 static gboolean
1558 _selected_folder_is_empty (ModestMainWindow *win)
1559 {
1560         GtkWidget *folder_view = NULL;
1561         TnyFolderStore *folder = NULL;
1562         gboolean result = FALSE;
1563
1564         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
1565
1566         /* Get folder view */
1567         folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
1568                                                            MODEST_WIDGET_TYPE_FOLDER_VIEW);
1569         /* If no folder view, always dimmed */
1570         if (!folder_view)
1571                 return TRUE;
1572
1573         /* Get selected folder as parent of new folder to create */
1574         folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
1575         if (!(folder && TNY_IS_FOLDER(folder))) {
1576                 if (folder)
1577                         g_object_unref (folder);
1578                 return TRUE;
1579         }
1580
1581         /* Check folder type */
1582         result = tny_folder_get_all_count (TNY_FOLDER (folder)) == 0;
1583
1584         /* free */
1585         g_object_unref (folder);
1586
1587         return result;
1588 }
1589
1590 static gboolean
1591 _selected_folder_is_same_as_source (ModestWindow *win)
1592 {
1593         ModestEmailClipboard *clipboard = NULL;
1594         GtkWidget *folder_view = NULL;
1595         TnyFolderStore *folder = NULL;
1596         gboolean result = FALSE;
1597
1598         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
1599
1600         /* Get folder view */
1601         folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
1602                                                            MODEST_WIDGET_TYPE_FOLDER_VIEW);
1603         if (!folder_view)
1604                 return FALSE;
1605
1606         /* Get selected folder as destination folder */
1607         folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
1608         if (!(folder && TNY_IS_FOLDER(folder))) {
1609                 result = FALSE;
1610                 goto frees;
1611         }
1612
1613         /* Check clipboard is cleared */
1614         clipboard = modest_runtime_get_email_clipboard ();
1615         if (modest_email_clipboard_cleared (clipboard)) {
1616                 result = FALSE;
1617                 goto frees;
1618         }
1619
1620         /* Check source folder */
1621         result = modest_email_clipboard_check_source_folder (clipboard,
1622                                                              (const TnyFolder *) folder);
1623
1624         /* Free */
1625  frees:
1626         g_object_unref (folder);
1627
1628         return result;
1629 }
1630
1631 static gboolean
1632 _selected_folder_is_any_of_type (ModestWindow *win,
1633                                  TnyFolderType types[],
1634                                  guint ntypes)
1635 {
1636         GtkWidget *folder_view = NULL;
1637         TnyFolderStore *folder = NULL;
1638         TnyFolderType folder_type;
1639         guint i=0;
1640         gboolean result = FALSE;
1641
1642         /*Get current folder */
1643         if (MODEST_IS_MAIN_WINDOW(win)) {
1644
1645                 /* Get folder view */
1646                 folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
1647                                                                    MODEST_WIDGET_TYPE_FOLDER_VIEW);
1648                 /* If no folder view, always dimmed */
1649                 if (!folder_view)
1650                         return FALSE;
1651
1652                 /* Get selected folder as parent of new folder to create */
1653                 folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
1654
1655                 if (!(folder && TNY_IS_FOLDER(folder))) {
1656                         if (folder)
1657                                 g_object_unref (folder);
1658                         return FALSE;
1659                 }
1660
1661                 /* Check folder type */
1662                 result = _folder_is_any_of_type (TNY_FOLDER(folder), types, ntypes);
1663         }
1664         else if (MODEST_IS_MSG_VIEW_WINDOW(win)) {
1665                 folder_type = modest_msg_view_window_get_folder_type (MODEST_MSG_VIEW_WINDOW (win));
1666                 for (i=0; i < ntypes; i++) {
1667                         result = result || folder_type == types[i];
1668                 }
1669         }
1670
1671
1672         /* free */
1673         g_object_unref (folder);
1674
1675         return result;
1676 }
1677
1678 static gboolean
1679 _folder_is_any_of_type (TnyFolder *folder,
1680                         TnyFolderType types[],
1681                         guint ntypes)
1682 {
1683         TnyFolderType folder_type;
1684         gboolean result = FALSE;
1685         guint i;
1686
1687         g_return_val_if_fail (TNY_IS_FOLDER(folder), FALSE);
1688
1689         /* Get folder type */
1690         folder_type = modest_tny_folder_guess_folder_type (folder);
1691
1692         /* Check foler type */
1693         for (i=0; i < ntypes; i++) {
1694                 result = result || folder_type == types[i];
1695         }
1696
1697         return result;
1698 }
1699
1700 static gboolean
1701 _selected_folder_is_snd_level (ModestMainWindow *win)
1702 {
1703         GtkWidget *folder_view = NULL;
1704         GtkTreeSelection *sel = NULL;
1705         GtkTreeModel *model = NULL;
1706         GtkTreePath *path = NULL;
1707         GtkTreeIter iter;
1708         TnyFolderStore *folder = NULL;
1709         gboolean result = FALSE;
1710
1711         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), TRUE);
1712
1713         /*Get curent folder */
1714         folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
1715                                                            MODEST_WIDGET_TYPE_FOLDER_VIEW);
1716         /* If no folder view, always dimmed */
1717         if (!folder_view)
1718                 goto frees;
1719
1720         /* Get selected folder as parent of new folder to create */
1721         folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
1722         if (!(folder && TNY_IS_FOLDER(folder))) {
1723                 goto frees;
1724         }
1725
1726         /* Check folder level */
1727         sel = gtk_tree_view_get_selection (GTK_TREE_VIEW(folder_view));
1728         if (!gtk_tree_selection_get_selected (sel, &model, &iter))
1729                 goto frees;
1730         path = gtk_tree_model_get_path (model, &iter);
1731         result = gtk_tree_path_get_depth (path) > 2;
1732
1733  frees:
1734         if (folder != NULL)
1735                 g_object_unref (folder);
1736         if (path != NULL)
1737                 gtk_tree_path_free (path);
1738
1739         return result;
1740
1741 }
1742
1743 static gboolean
1744 _clipboard_is_empty (ModestWindow *win)
1745 {
1746         gboolean result = FALSE;
1747
1748         if (MODEST_IS_MAIN_WINDOW (win)) {
1749                 ModestEmailClipboard *clipboard = NULL;
1750                 clipboard = modest_runtime_get_email_clipboard ();
1751                 if (modest_email_clipboard_cleared (clipboard))
1752                  result = TRUE;
1753         }
1754
1755         return result;
1756 }
1757
1758 static gboolean
1759 _invalid_clipboard_selected (ModestWindow *win,
1760                        ModestDimmingRule *rule)
1761 {
1762         const DimmedState *state = NULL;
1763         gboolean result = FALSE;
1764
1765         g_return_val_if_fail (MODEST_IS_WINDOW(win), FALSE);
1766         state = modest_window_get_dimming_state (win);
1767
1768         if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
1769                 GtkClipboard *clipboard = NULL;
1770                 gchar *selection = NULL;
1771                 GtkWidget *focused = NULL;
1772
1773                 /* Get clipboard selection*/
1774                 clipboard = gtk_clipboard_get (GDK_SELECTION_PRIMARY);
1775                 selection = gtk_clipboard_wait_for_text (clipboard);
1776
1777                 /* Get focuesed widget */
1778                 focused = gtk_window_get_focus (GTK_WINDOW (win));
1779
1780                 /* Check dimming */
1781                 result = ((selection == NULL) ||
1782                           (MODEST_IS_ATTACHMENTS_VIEW (focused)));
1783
1784                 if (result)
1785                         modest_dimming_rule_set_notification (rule, "");
1786
1787                 if (selection != NULL)
1788                         g_free(selection);
1789         }
1790         else if (MODEST_IS_MAIN_WINDOW (win)) {
1791                 /* Check dimming */
1792                 result = state->n_selected == 0;
1793                 if (result)
1794                         modest_dimming_rule_set_notification (rule, _("mcen_ib_no_message_selected"));
1795         }
1796
1797         return result;
1798 }
1799
1800
1801 static gboolean
1802 _invalid_attach_selected (ModestWindow *win,
1803                           gboolean unique,
1804                           gboolean for_view,
1805                           gboolean for_remove,
1806                           ModestDimmingRule *rule)
1807 {
1808         GList *attachments, *node;
1809         gint n_selected;
1810         TnyHeaderFlags flags;
1811         gboolean nested_attachments = FALSE;
1812         gboolean selected_messages = FALSE;
1813         const DimmedState *state = NULL;
1814         gboolean result = FALSE;
1815
1816         g_return_val_if_fail (MODEST_IS_WINDOW(win), FALSE);
1817         state = modest_window_get_dimming_state (win);
1818
1819         if (MODEST_IS_MAIN_WINDOW (win)) {
1820                 flags = TNY_HEADER_FLAG_ATTACHMENTS;
1821                 if (!result)
1822                         result = !state->any_has_attachments;
1823         }
1824         else if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
1825
1826                 /* Get selected atachments */
1827                 attachments = modest_msg_view_window_get_attachments (MODEST_MSG_VIEW_WINDOW(win));
1828                 n_selected = g_list_length (attachments);
1829
1830                 /* Check unique */
1831                 if (!result) {
1832                         if (unique)
1833                                 result = n_selected != 1;
1834                         else
1835
1836                                 result = n_selected < 1;
1837                 }
1838
1839                 /* Check attached type (view operation not required) */
1840                 if (!result && !for_view)  {
1841                         for (node = attachments; node != NULL && !result; node = g_list_next (node)) {
1842                                 TnyMimePart *mime_part = TNY_MIME_PART (node->data);
1843                                 TnyList *nested_list = tny_simple_list_new ();
1844                                 if (!for_remove && TNY_IS_MSG (mime_part)) {
1845                                         selected_messages = TRUE;
1846                                         result = TRUE;
1847                                 }
1848                                 tny_mime_part_get_parts (mime_part, nested_list);
1849                                 if (!for_remove && tny_list_get_length (nested_list) > 0) {
1850                                         nested_attachments = TRUE;
1851                                         result = TRUE;
1852                                 }
1853                                 g_object_unref (nested_list);
1854                         }
1855                 }
1856
1857                 /* Set notifications */
1858                 if (result && rule != NULL) {
1859                         if (selected_messages) {
1860                                 modest_dimming_rule_set_notification (rule, _("mcen_ib_unable_to_save_attach_mail"));
1861                         } else if (nested_attachments) {
1862                                 modest_dimming_rule_set_notification (rule, _("FIXME:unable to save attachments with nested elements"));
1863                         } else if (n_selected == 0) {
1864                                 modest_dimming_rule_set_notification (rule, _("FIXME:no attachment selected"));
1865                         } else if (unique) {
1866                                 modest_dimming_rule_set_notification (rule, _("mcen_ib_unable_to_display_more"));
1867                         }
1868                 }
1869
1870                 /* Free */
1871                 g_list_free (attachments);
1872         }
1873
1874         return result;
1875 }
1876
1877 static gboolean
1878 _purged_attach_selected (ModestWindow *win, gboolean all, ModestDimmingRule *rule)
1879 {
1880         GList *attachments = NULL, *node;
1881         gint purged = 0;
1882         gint n_attachments = 0;
1883         gboolean result = FALSE;
1884
1885         /* This should check if _all_ the attachments are already purged. If only some
1886          * of them are purged, then it does not cause dim as there's a confirmation dialog
1887          * for removing only local attachments */
1888
1889         /* Get selected atachments */
1890         if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
1891                 attachments = modest_msg_view_window_get_attachments (MODEST_MSG_VIEW_WINDOW(win));
1892         } else if (MODEST_IS_MAIN_WINDOW (win)) {
1893                 /* If we're in main window, we won't know if there are already purged attachments */
1894                 return FALSE;
1895         }
1896
1897         if (attachments == NULL)
1898                 return FALSE;
1899
1900         for (node = attachments; node != NULL; node = g_list_next (node)) {
1901                 TnyMimePart *mime_part = TNY_MIME_PART (node->data);
1902                 if (tny_mime_part_is_purged (mime_part)) {
1903                         purged++;
1904                 }
1905                 n_attachments++;
1906         }
1907
1908         /* Free */
1909         g_list_free (attachments);
1910
1911         if (all)
1912                 result = (purged == n_attachments);
1913         else
1914                 result = (purged > 0);
1915
1916         if (result && (rule != NULL))
1917                 modest_dimming_rule_set_notification (rule, _("mail_ib_attachment_already_purged"));
1918
1919         return result;
1920 }
1921
1922 static gboolean
1923 _invalid_msg_selected (ModestMainWindow *win,
1924                        gboolean unique,
1925                        ModestDimmingRule *rule)
1926 {
1927         GtkWidget *folder_view = NULL;
1928         const DimmedState *state = NULL;
1929         gboolean result = FALSE;
1930
1931         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
1932         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (rule), FALSE);
1933         state = modest_window_get_dimming_state (MODEST_WINDOW(win));
1934
1935         /* Get folder view to check focus */
1936         folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
1937                                                            MODEST_WIDGET_TYPE_FOLDER_VIEW);
1938
1939         /* Check dimmed rule (TODO: check focus on widgets */
1940         if (!result) {
1941                 result = ((state->n_selected == 0 ) ||
1942                           (gtk_widget_is_focus (folder_view)));
1943                 if (result)
1944                         modest_dimming_rule_set_notification (rule, _("mcen_ib_no_message_selected"));
1945         }
1946         if (!result && unique) {
1947                 result = state->n_selected > 1;
1948                 if (result)
1949                         modest_dimming_rule_set_notification (rule, _("mcen_ib_select_one_message"));
1950         }
1951
1952         return result;
1953 }
1954
1955
1956 static gboolean
1957 _msg_download_in_progress (ModestMsgViewWindow *win)
1958 {
1959         gboolean result = FALSE;
1960
1961         g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW (win), FALSE);
1962
1963         result = modest_msg_view_window_toolbar_on_transfer_mode (win);
1964
1965         return result;
1966 }
1967
1968 static gboolean
1969 _msg_download_completed (ModestMainWindow *win)
1970 {
1971         const DimmedState *state = modest_window_get_dimming_state (MODEST_WINDOW(win));
1972         return state->any_marked_as_cached;
1973 }
1974
1975 static void
1976 fill_list_of_caches (gpointer key, gpointer value, gpointer userdata)
1977 {
1978         GSList **send_queues = (GSList **) userdata;
1979         *send_queues = g_slist_prepend (*send_queues, value);
1980 }
1981
1982 static gboolean
1983 _selected_msg_sent_in_progress (ModestWindow *win)
1984 {
1985         const DimmedState *state = modest_window_get_dimming_state (win);
1986         return state->sent_in_progress;
1987 }
1988
1989
1990 static gboolean
1991 _sending_in_progress (ModestWindow *win)
1992 {
1993         gboolean result = FALSE;
1994
1995         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW (win), FALSE);
1996
1997         /* Check if send operation is in progress */
1998         result = modest_main_window_send_receive_in_progress (MODEST_MAIN_WINDOW (win));
1999
2000         return result;
2001 }
2002
2003 static gboolean
2004 _invalid_folder_for_purge (ModestWindow *win,
2005                            ModestDimmingRule *rule)
2006 {
2007         TnyMsg *msg = NULL;
2008         TnyFolder *folder = NULL;
2009         TnyAccount *account = NULL;
2010         gboolean result = FALSE;
2011
2012         if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
2013
2014                 /* Get folder and account of message */
2015                 msg = modest_msg_view_window_get_message (MODEST_MSG_VIEW_WINDOW (win));
2016                 g_return_val_if_fail(msg != NULL, TRUE);
2017                 folder = tny_msg_get_folder (msg);
2018                 if (folder == NULL) {
2019                         modest_dimming_rule_set_notification (rule, _("mail_ib_unable_to_purge_attachments"));
2020                         goto frees;
2021                 }
2022                 g_object_unref (msg);
2023         } else if (MODEST_IS_MAIN_WINDOW (win)) {
2024                 GtkWidget *folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
2025                                                                               MODEST_WIDGET_TYPE_FOLDER_VIEW);
2026                 if (!folder_view)
2027                         return FALSE;
2028                 folder = TNY_FOLDER (modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view)));
2029                 if (folder == NULL || ! TNY_IS_FOLDER (folder))
2030                         goto frees;
2031         } else {
2032                 g_return_val_if_reached (FALSE);
2033         }
2034         account = modest_tny_folder_get_account (folder);
2035         if (account == NULL) goto frees;
2036
2037         /* Check account */
2038         if (modest_tny_account_is_virtual_local_folders (TNY_ACCOUNT (account))) {
2039                 TnyFolderType types[2];
2040                 types[0] = TNY_FOLDER_TYPE_DRAFTS;
2041                 types[1] = TNY_FOLDER_TYPE_OUTBOX;
2042
2043                 if (_selected_folder_is_any_of_type (win, types, 2)) {
2044                         result = TRUE;
2045                         modest_dimming_rule_set_notification (rule, _("mail_ib_unable_to_purge_editable_msg"));
2046                 } else {
2047                         /* We're currently disabling purge in any local store */
2048                         result = TRUE;
2049                         modest_dimming_rule_set_notification (rule, _("mail_ib_unable_to_purge_attachments"));
2050                 }
2051         } else {
2052                 const gchar *proto_str = tny_account_get_proto (TNY_ACCOUNT (account));
2053                 /* If it's POP then dim */
2054                 if (modest_protocol_info_get_transport_store_protocol (proto_str) ==
2055                     MODEST_PROTOCOL_STORE_POP) {
2056                         GList *attachments = NULL;
2057                         gint n_selected = 0;
2058                         result = TRUE;
2059
2060                         /* TODO: This check is here to prevent a gwarning, but this looks like a logic error.
2061                          * murrayc */
2062                         if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
2063                                 attachments = modest_msg_view_window_get_attachments (MODEST_MSG_VIEW_WINDOW(win));
2064                                 n_selected = g_list_length (attachments);
2065                                 g_list_free (attachments);
2066                         }
2067
2068                         modest_dimming_rule_set_notification (rule,
2069                                                               ngettext ("mail_ib_unable_to_pure_attach_pop_mail_singular",
2070                                                                         "mail_ib_unable_to_pure_attach_pop_mail_plural",
2071                                                                         n_selected));
2072                 }
2073         }
2074
2075 frees:
2076         if (folder != NULL)
2077                 g_object_unref (folder);
2078         if (account != NULL)
2079                 g_object_unref (account);
2080
2081         return result;
2082 }
2083
2084 static gboolean
2085 _transfer_mode_enabled (ModestWindow *win)
2086 {
2087         gboolean result = FALSE;
2088
2089         g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW (win), FALSE);
2090
2091         /* Check dimming */
2092         result = modest_msg_view_window_transfer_mode_enabled (MODEST_MSG_VIEW_WINDOW (win));
2093
2094         return result;
2095 }
2096