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