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