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