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