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