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                         selection = modest_text_utils_label_get_selection (GTK_LABEL (focused));
1813                 } else {
1814                         gboolean do_check = TRUE;
1815                         GtkClipboard *clipboard;
1816                         if (GTK_IS_HTML (focused)) {
1817                                 const gchar *sel;
1818                                 int len = -1;
1819                                 sel = gtk_html_get_selection_html (GTK_HTML (focused), &len);
1820                                 do_check = !((sel == NULL) || (sel[0] == '\0'));
1821                         }
1822                         if (do_check) {
1823                                 clipboard = gtk_clipboard_get (GDK_SELECTION_PRIMARY);
1824                                 selection = gtk_clipboard_wait_for_text (clipboard);
1825                         } else {
1826                                 selection = NULL;
1827                         }
1828                 }
1829                 dimmed = !((selection != NULL) && (modest_text_utils_validate_recipient (selection, NULL)));
1830         }
1831
1832         return dimmed;
1833 }
1834
1835 /* *********************** static utility functions ******************** */
1836
1837
1838 static gboolean
1839 _selected_folder_not_writeable (ModestMainWindow *win,
1840                                 gboolean for_paste)
1841 {
1842         GtkWidget *folder_view = NULL;
1843         TnyFolderStore *parent_folder = NULL;
1844         ModestEmailClipboard *clipboard = NULL;
1845         ModestTnyFolderRules rules;
1846         gboolean is_local_acc = FALSE;
1847         gboolean xfer_folders = FALSE;
1848         gboolean result = FALSE;
1849
1850         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
1851
1852         /* Get folder view */
1853         folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
1854                                                            MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
1855         /* If no folder view, always dimmed */
1856         if (!folder_view)
1857                 return TRUE;
1858
1859         /* Get selected folder as parent of new folder to create */
1860         parent_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
1861         if (!(parent_folder && TNY_IS_FOLDER(parent_folder))) {
1862                 /* If it's the local account and its transfering folders, then do not dim */
1863                 if (TNY_IS_ACCOUNT (parent_folder)) {
1864                         is_local_acc = modest_tny_account_is_virtual_local_folders (TNY_ACCOUNT (parent_folder));
1865                         if (for_paste) {
1866                                 clipboard = modest_runtime_get_email_clipboard ();
1867                                 xfer_folders = modest_email_clipboard_folder_copied (clipboard);
1868                         }
1869                 }
1870
1871                 if (for_paste)
1872                         result = !(is_local_acc && xfer_folders);
1873                 else
1874                         result = !is_local_acc;
1875                 goto frees;
1876         }
1877
1878         /* Check dimmed rule */
1879         rules = modest_tny_folder_get_rules (TNY_FOLDER (parent_folder));
1880         result = rules & MODEST_FOLDER_RULES_FOLDER_NON_WRITEABLE;
1881
1882         /* free */
1883  frees:
1884         if (parent_folder != NULL)
1885                 g_object_unref (parent_folder);
1886
1887         return result;
1888 }
1889
1890 static gboolean
1891 _selected_folder_not_deletable (ModestMainWindow *win)
1892 {
1893         GtkWidget *folder_view = NULL;
1894         TnyFolderStore *parent_folder = NULL;
1895         ModestTnyFolderRules rules;
1896         gboolean result = FALSE;
1897
1898         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
1899
1900         /* Get folder view */
1901         folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
1902                                                            MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
1903         /* If no folder view, always dimmed */
1904         if (!folder_view)
1905                 return TRUE;
1906
1907         /* Get selected folder as parent of new folder to create */
1908         parent_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
1909         if (!(parent_folder && TNY_IS_FOLDER(parent_folder))) {
1910                 result = TRUE;
1911                 goto frees;
1912         }
1913
1914         /* Check dimmed rule */
1915         rules = modest_tny_folder_get_rules (TNY_FOLDER (parent_folder));
1916         result = rules & MODEST_FOLDER_RULES_FOLDER_NON_DELETABLE;
1917
1918         /* free */
1919  frees:
1920         if (parent_folder != NULL)
1921                 g_object_unref (parent_folder);
1922
1923         return result;
1924 }
1925
1926 static gboolean
1927 _selected_folder_not_moveable (ModestMainWindow *win)
1928 {
1929         GtkWidget *folder_view = NULL;
1930         TnyFolderStore *parent_folder = NULL;
1931         ModestTnyFolderRules rules;
1932         gboolean result = FALSE;
1933
1934         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
1935
1936         /* Get folder view */
1937         folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
1938                                                            MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
1939         /* If no folder view, always dimmed */
1940         if (!folder_view)
1941                 return TRUE;
1942
1943         /* Get selected folder as parent of new folder to create */
1944         parent_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
1945         if (!(parent_folder && TNY_IS_FOLDER(parent_folder))) {
1946                 result = TRUE;
1947                 goto frees;
1948         }
1949
1950         /* Check dimmed rule */
1951         rules = modest_tny_folder_get_rules (TNY_FOLDER (parent_folder));
1952         result = rules & MODEST_FOLDER_RULES_FOLDER_NON_MOVEABLE;
1953
1954         /* free */
1955  frees:
1956         if (parent_folder != NULL)
1957                 g_object_unref (parent_folder);
1958
1959         return result;
1960 }
1961
1962 static gboolean
1963 _selected_folder_not_renameable (ModestMainWindow *win)
1964 {
1965         GtkWidget *folder_view = NULL;
1966         TnyFolderStore *parent_folder = NULL;
1967         ModestTnyFolderRules rules;
1968         gboolean result = FALSE;
1969
1970         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
1971
1972         /* Get folder view */
1973         folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
1974                                                            MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
1975         /* If no folder view, always dimmed */
1976         if (!folder_view)
1977                 return TRUE;
1978
1979         /* Get selected folder as parent of new folder to create */
1980         parent_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
1981         if (!(parent_folder && TNY_IS_FOLDER(parent_folder))) {
1982                 result = TRUE;
1983                 goto frees;
1984         }
1985
1986         /* Check dimmed rule */
1987         rules = modest_tny_folder_get_rules (TNY_FOLDER (parent_folder));
1988         result = rules & MODEST_FOLDER_RULES_FOLDER_NON_RENAMEABLE;
1989
1990         /* free */
1991  frees:
1992         if (parent_folder != NULL)
1993                 g_object_unref (parent_folder);
1994
1995         return result;
1996 }
1997
1998 static gboolean
1999 _selected_folder_is_root_or_inbox (ModestMainWindow *win)
2000 {
2001         TnyFolderType types[2];
2002         gboolean result = FALSE;
2003
2004         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
2005
2006         types[0] = TNY_FOLDER_TYPE_ROOT;
2007         types[1] = TNY_FOLDER_TYPE_INBOX;
2008
2009         /* Check folder type */
2010         result = _selected_folder_is_any_of_type (MODEST_WINDOW(win), types, 2);
2011
2012         /* Check pop and MMC accounts */
2013         if (!result) {
2014                 result = _selected_folder_is_MMC_or_POP_root (win);
2015         }
2016
2017         return result;
2018 }
2019
2020
2021 static gboolean
2022 _selected_folder_is_root (ModestMainWindow *win)
2023 {
2024         TnyFolderType types[1];
2025         gboolean result = FALSE;
2026
2027         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
2028
2029         /* All accounts are root items: */
2030         GtkWidget *folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
2031                                                            MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
2032         if (folder_view) {
2033                 gboolean is_account = FALSE;
2034                 TnyFolderStore *folder_store =
2035                         modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
2036                 if (folder_store) {
2037                         is_account = TNY_IS_ACCOUNT (folder_store);
2038                         g_object_unref (folder_store);
2039                         folder_store = NULL;
2040                 }
2041
2042                 if (is_account)
2043                         return TRUE;
2044         }
2045
2046         /* Try something more precise: */
2047         types[0] = TNY_FOLDER_TYPE_ROOT;
2048
2049         /* Check folder type */
2050         result = _selected_folder_is_any_of_type (MODEST_WINDOW(win), types, 1);
2051
2052         /* Check pop and MMC accounts */
2053         if (!result) {
2054                 result = _selected_folder_is_MMC_or_POP_root (win);
2055         }
2056
2057         return result;
2058 }
2059
2060 static gboolean
2061 _selected_folder_is_MMC_or_POP_root (ModestMainWindow *win)
2062 {
2063         GtkWidget *folder_view = NULL;
2064         TnyFolderStore *parent_folder = NULL;
2065         gboolean result = FALSE;
2066
2067         folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
2068                                                            MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
2069         if (!folder_view)
2070                 return FALSE;
2071
2072         /* Get selected folder as parent of new folder to create */
2073         parent_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
2074         if (!parent_folder)
2075                 return TRUE;
2076
2077         if (TNY_IS_ACCOUNT (parent_folder)) {
2078                 /* If it's the local account then do not dim */
2079                 if (modest_tny_account_is_virtual_local_folders (TNY_ACCOUNT (parent_folder))) {
2080                         result = FALSE;
2081                 } else {
2082                                 /* If it's the MMC root folder then dim it */
2083                         if (!strcmp (tny_account_get_id (TNY_ACCOUNT (parent_folder)), MODEST_MMC_ACCOUNT_ID)) {
2084                                         result = TRUE;
2085                         } else {
2086                                 const gchar *proto_str = tny_account_get_proto (TNY_ACCOUNT (parent_folder));
2087                                 /* If it's POP then dim */
2088                                 result = (modest_protocol_info_get_transport_store_protocol (proto_str) ==
2089                                                   MODEST_PROTOCOL_STORE_POP) ? TRUE : FALSE;
2090                         }
2091                 }
2092         }
2093         g_object_unref (parent_folder);
2094
2095         return result;
2096 }
2097
2098 static gboolean
2099 _header_view_is_all_selected (ModestMainWindow *win)
2100 {
2101         const DimmedState *state = NULL;
2102
2103         g_return_val_if_fail (MODEST_IS_WINDOW(win), FALSE);
2104
2105         state = modest_window_get_dimming_state (MODEST_WINDOW(win));
2106
2107         return state->all_selected;
2108 }
2109
2110 static gboolean
2111 _selected_folder_is_empty (ModestMainWindow *win)
2112 {
2113         GtkWidget *folder_view = NULL;
2114         TnyFolderStore *folder = NULL;
2115         gboolean result = FALSE;
2116
2117         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
2118
2119         /* Get folder view */
2120         folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
2121                                                            MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
2122         /* If no folder view, always dimmed */
2123         if (!folder_view)
2124                 return TRUE;
2125
2126         /* Get selected folder as parent of new folder to create */
2127         folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
2128         if (!(folder && TNY_IS_FOLDER(folder))) {
2129                 if (folder)
2130                         g_object_unref (folder);
2131                 return TRUE;
2132         }
2133
2134         /* Check folder type */
2135         result = tny_folder_get_all_count (TNY_FOLDER (folder)) == 0;
2136
2137         /* free */
2138         g_object_unref (folder);
2139
2140         return result;
2141 }
2142
2143 static gboolean
2144 _folder_view_has_focus (ModestWindow *win)
2145 {
2146         GtkWidget *folder_view = NULL;
2147
2148         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
2149
2150         /* Get folder view */
2151         folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
2152                                                            MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
2153         if (!folder_view)
2154                 return FALSE;
2155
2156         if (gtk_widget_is_focus(folder_view))
2157                 return TRUE;
2158
2159         return FALSE;
2160 }
2161
2162 static gboolean
2163 _selected_folder_is_same_as_source (ModestWindow *win)
2164 {
2165         ModestEmailClipboard *clipboard = NULL;
2166         GtkWidget *folder_view = NULL;
2167         TnyFolderStore *folder = NULL;
2168         gboolean result = FALSE;
2169
2170         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
2171
2172         /* Get folder view */
2173         folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
2174                                                            MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
2175         if (!folder_view)
2176                 return FALSE;
2177
2178         /* Get selected folder as destination folder */
2179         folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
2180         if (!(folder && TNY_IS_FOLDER(folder))) {
2181                 result = FALSE;
2182                 goto frees;
2183         }
2184
2185         /* Check clipboard is cleared */
2186         clipboard = modest_runtime_get_email_clipboard ();
2187         if (modest_email_clipboard_cleared (clipboard)) {
2188                 result = FALSE;
2189                 goto frees;
2190         }
2191
2192         /* Check source folder */
2193         result = modest_email_clipboard_check_source_folder (clipboard, TNY_FOLDER (folder));
2194
2195         /* Free */
2196  frees:
2197         g_object_unref (folder);
2198
2199         return result;
2200 }
2201
2202 static gboolean
2203 _selected_folder_is_any_of_type (ModestWindow *win,
2204                                  TnyFolderType types[],
2205                                  guint ntypes)
2206 {
2207         GtkWidget *folder_view = NULL;
2208         TnyFolderStore *folder = NULL;
2209         TnyFolderType folder_type;
2210         guint i=0;
2211         gboolean result = FALSE;
2212
2213         /*Get current folder */
2214         if (MODEST_IS_MAIN_WINDOW(win)) {
2215
2216                 /* Get folder view */
2217                 folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
2218                                                                    MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
2219                 /* If no folder view, always dimmed */
2220                 if (!folder_view)
2221                         return FALSE;
2222
2223                 /* Get selected folder as parent of new folder to create */
2224                 folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
2225
2226                 if (!(folder && TNY_IS_FOLDER(folder))) {
2227                         if (folder)
2228                                 g_object_unref (folder);
2229                         return FALSE;
2230                 }
2231
2232                 /* Check folder type */
2233                 result = _folder_is_any_of_type (TNY_FOLDER(folder), types, ntypes);
2234         }
2235         else if (MODEST_IS_MSG_VIEW_WINDOW(win)) {
2236                 folder_type = modest_msg_view_window_get_folder_type (MODEST_MSG_VIEW_WINDOW (win));
2237                 for (i=0; i < ntypes; i++) {
2238                         result = result || folder_type == types[i];
2239                 }
2240         }
2241
2242
2243         /* free */
2244         if (folder)
2245                 g_object_unref (folder);
2246
2247         return result;
2248 }
2249
2250 static gboolean
2251 _folder_is_any_of_type (TnyFolder *folder,
2252                         TnyFolderType types[],
2253                         guint ntypes)
2254 {
2255         TnyFolderType folder_type;
2256         gboolean result = FALSE;
2257         guint i;
2258
2259         g_return_val_if_fail (TNY_IS_FOLDER(folder), FALSE);
2260
2261         /* Get folder type */
2262         folder_type = modest_tny_folder_guess_folder_type (folder);
2263         if (folder_type == TNY_FOLDER_TYPE_INVALID)
2264                 g_warning ("%s: BUG: TNY_FOLDER_TYPE_INVALID", __FUNCTION__);
2265
2266         /* Check foler type */
2267         for (i=0; i < ntypes; i++) {
2268                 result = result || folder_type == types[i];
2269         }
2270
2271         return result;
2272 }
2273
2274 static gboolean
2275 _clipboard_is_empty (ModestWindow *win)
2276 {
2277         gboolean result = FALSE;
2278
2279         if (MODEST_IS_MAIN_WINDOW (win)) {
2280                 ModestEmailClipboard *clipboard = NULL;
2281                 clipboard = modest_runtime_get_email_clipboard ();
2282                 if (modest_email_clipboard_cleared (clipboard))
2283                  result = TRUE;
2284         }
2285
2286         return result;
2287 }
2288
2289 static gboolean
2290 _invalid_clipboard_selected (ModestWindow *win,
2291                              ModestDimmingRule *rule)
2292 {
2293         const DimmedState *state = NULL;
2294         gboolean result = FALSE;
2295         GtkWidget *focused = NULL;
2296
2297         g_return_val_if_fail (MODEST_IS_WINDOW(win), FALSE);
2298         state = modest_window_get_dimming_state (win);
2299         /* Get focuesed widget */
2300         focused = gtk_window_get_focus (GTK_WINDOW (win));
2301
2302         if (MODEST_IS_MSG_EDIT_WINDOW (win)) {
2303                 gboolean has_selection = FALSE;
2304                 if (GTK_IS_TEXT_VIEW (focused)) {
2305                         GtkTextBuffer *buffer = NULL;
2306                         buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused));
2307                         has_selection = modest_text_utils_buffer_selection_is_valid (buffer);
2308                 } else if (GTK_IS_EDITABLE (focused)) {
2309                         has_selection = gtk_editable_get_selection_bounds (GTK_EDITABLE (focused), NULL, NULL);
2310                 }
2311                 result = !has_selection;
2312         } else if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
2313                 if (focused) {
2314                         MODEST_DEBUG_BLOCK (g_message ("FOCUSED %s", g_type_name (G_TYPE_FROM_INSTANCE (focused))););
2315                         if (GTK_IS_LABEL (focused) &&
2316                             !gtk_label_get_selection_bounds (GTK_LABEL (focused), NULL, NULL)) {
2317                                 result = TRUE;
2318                         } else if (GTK_IS_TEXT_VIEW (focused)) {
2319                                 GtkTextBuffer *buffer;
2320                                 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (focused));
2321                                 result = !gtk_text_buffer_get_has_selection (buffer);
2322                         } else if (GTK_IS_HTML (focused)) {
2323                                 const gchar *sel;
2324                                 int len = -1;
2325                                 sel = gtk_html_get_selection_html (GTK_HTML (focused), &len);
2326                                 result = ((sel == NULL) || (sel[0] == '\0'));
2327                         } else if (MODEST_IS_ATTACHMENTS_VIEW (focused)) {
2328                                 result = TRUE;
2329                         } else {
2330                                 GtkClipboard *clipboard;
2331                                 gchar *selection;
2332
2333                                 clipboard = gtk_clipboard_get (GDK_SELECTION_PRIMARY);
2334                                 /* Get clipboard selection*/
2335                                 selection = gtk_clipboard_wait_for_text (clipboard);
2336                                 /* Check dimming */
2337                                 result = (selection == NULL);
2338                                 g_free (selection);
2339                         }
2340                 } else {
2341                         result = TRUE;
2342                 }
2343
2344                 if (result)
2345                         modest_dimming_rule_set_notification (rule, "");
2346
2347         }
2348         else if (MODEST_IS_MAIN_WINDOW (win)) {
2349                 /* Check dimming */
2350                 result = state->n_selected == 0;
2351                 if (result)
2352                         modest_dimming_rule_set_notification (rule, _("mcen_ib_no_message_selected"));
2353         }
2354
2355         return result;
2356 }
2357
2358
2359 static gboolean
2360 _invalid_attach_selected (ModestWindow *win,
2361                           gboolean unique,
2362                           gboolean for_view,
2363                           gboolean for_remove,
2364                           ModestDimmingRule *rule)
2365 {
2366         TnyList *attachments;
2367         gint n_selected;
2368         TnyHeaderFlags flags;
2369         gboolean nested_attachments = FALSE;
2370         gboolean selected_messages = FALSE;
2371         const DimmedState *state = NULL;
2372         gboolean result = FALSE;
2373
2374         g_return_val_if_fail (MODEST_IS_WINDOW(win), FALSE);
2375         state = modest_window_get_dimming_state (win);
2376
2377         if (MODEST_IS_MAIN_WINDOW (win)) {
2378                 flags = TNY_HEADER_FLAG_ATTACHMENTS;
2379                 if (!result)
2380                         result = !state->any_has_attachments;
2381         }
2382         else if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
2383
2384                 /* Get selected atachments */
2385                 attachments = modest_msg_view_window_get_attachments (MODEST_MSG_VIEW_WINDOW(win));
2386                 n_selected = tny_list_get_length (attachments);
2387
2388                 /* Check unique */
2389                 if (!result) {
2390                         if (unique)
2391                                 result = n_selected != 1;
2392                         else
2393
2394                                 result = n_selected < 1;
2395                 }
2396
2397                 /* Check attached type (view operation not required) */
2398                 if (!result && !for_view)  {
2399                         TnyIterator *iter;
2400                         iter = tny_list_create_iterator (attachments);
2401                         while (!tny_iterator_is_done (iter) && !result) {
2402                                 TnyMimePart *mime_part = TNY_MIME_PART (tny_iterator_get_current (iter));
2403                                 TnyList *nested_list = tny_simple_list_new ();
2404                                 if (!for_remove && TNY_IS_MSG (mime_part)) {
2405                                         selected_messages = TRUE;
2406                                         result = TRUE;
2407                                 }
2408                                 tny_mime_part_get_parts (mime_part, nested_list);
2409                                 if (!for_remove && tny_list_get_length (nested_list) > 0) {
2410                                         nested_attachments = TRUE;
2411                                         result = TRUE;
2412                                 }
2413                                 g_object_unref (nested_list);
2414                                 g_object_unref (mime_part);
2415                                 tny_iterator_next (iter);
2416                         }
2417                         g_object_unref (iter);
2418                 }
2419
2420                 /* Set notifications */
2421                 if (result && rule != NULL) {
2422                         if (selected_messages) {
2423                                 modest_dimming_rule_set_notification (rule, _("mcen_ib_unable_to_save_attach_mail"));
2424                         } else if (nested_attachments) {
2425                                 modest_dimming_rule_set_notification (rule, _("FIXME:unable to save attachments with nested elements"));
2426                         } else if (n_selected == 0) {
2427                                 modest_dimming_rule_set_notification (rule, _("FIXME:no attachment selected"));
2428                         } else if (unique) {
2429                                 modest_dimming_rule_set_notification (rule, _("mcen_ib_unable_to_display_more"));
2430                         }
2431                 }
2432
2433                 /* Free */
2434                 g_object_unref (attachments);
2435         }
2436
2437         return result;
2438 }
2439
2440 static gboolean
2441 _purged_attach_selected (ModestWindow *win, gboolean all, ModestDimmingRule *rule)
2442 {
2443         TnyList *attachments = NULL;
2444         TnyIterator *iter;
2445         gint purged = 0;
2446         gint n_attachments = 0;
2447         gboolean result = FALSE;
2448
2449         /* This should check if _all_ the attachments are already purged. If only some
2450          * of them are purged, then it does not cause dim as there's a confirmation dialog
2451          * for removing only local attachments */
2452
2453         /* Get selected atachments */
2454         if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
2455                 attachments = modest_msg_view_window_get_attachments (MODEST_MSG_VIEW_WINDOW(win));
2456         } else if (MODEST_IS_MAIN_WINDOW (win)) {
2457                 /* If we're in main window, we won't know if there are already purged attachments */
2458                 return FALSE;
2459         }
2460
2461         if (attachments == NULL)
2462                 return FALSE;
2463
2464         if (tny_list_get_length (attachments)) {
2465                 g_object_unref (attachments);
2466                 return FALSE;
2467         }
2468
2469         iter = tny_list_create_iterator (attachments);
2470         while (!tny_iterator_is_done (iter)) {
2471                 TnyMimePart *mime_part = TNY_MIME_PART (tny_iterator_get_current (iter));
2472                 if (tny_mime_part_is_purged (mime_part)) {
2473                         purged++;
2474                 }
2475                 n_attachments++;
2476                 g_object_unref (mime_part);
2477                 tny_iterator_next (iter);
2478         }
2479         g_object_unref (iter);
2480
2481         /* Free */
2482         g_object_unref (attachments);
2483
2484         if (all)
2485                 result = (purged == n_attachments);
2486         else
2487                 result = (purged > 0);
2488
2489         /* This string no longer exists, refer to NB#75415 for more info
2490         if (result && (rule != NULL))
2491                 modest_dimming_rule_set_notification (rule, _("mail_ib_attachment_already_purged"));
2492         */
2493
2494         return result;
2495 }
2496
2497 static gboolean
2498 _invalid_msg_selected (ModestMainWindow *win,
2499                        gboolean unique,
2500                        ModestDimmingRule *rule)
2501 {
2502         GtkWidget *folder_view = NULL;
2503         const DimmedState *state = NULL;
2504         gboolean result = FALSE;
2505
2506         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
2507         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (rule), FALSE);
2508         state = modest_window_get_dimming_state (MODEST_WINDOW(win));
2509
2510         /* Get folder view to check focus */
2511         folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
2512                                                            MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
2513
2514         /* Check dimmed rule (TODO: check focus on widgets */
2515         if (!result) {
2516                 result = ((state->n_selected == 0 ) ||
2517                           (gtk_widget_is_focus (folder_view)));
2518                 if (result)
2519                         modest_dimming_rule_set_notification (rule, _("mcen_ib_no_message_selected"));
2520         }
2521         if (!result && unique) {
2522                 result = state->n_selected > 1;
2523                 if (result)
2524                         modest_dimming_rule_set_notification (rule, _("mcen_ib_select_one_message"));
2525         }
2526
2527         return result;
2528 }
2529
2530
2531 static gboolean
2532 _msg_download_in_progress (ModestWindow *win)
2533 {
2534         gboolean result = FALSE;
2535
2536         g_return_val_if_fail (MODEST_IS_WINDOW (win), FALSE);
2537
2538         if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
2539                 result = modest_msg_view_window_toolbar_on_transfer_mode (MODEST_MSG_VIEW_WINDOW(win));
2540         }
2541         else if (MODEST_IS_MAIN_WINDOW (win)) {
2542                 result = modest_main_window_transfer_mode_enabled (MODEST_MAIN_WINDOW(win));
2543         }
2544
2545         return result;
2546 }
2547
2548 static gboolean
2549 _msg_download_completed (ModestMainWindow *win)
2550 {
2551         const DimmedState *state = modest_window_get_dimming_state (MODEST_WINDOW(win));
2552         return state->any_marked_as_cached;
2553 }
2554
2555 static void
2556 fill_list_of_caches (gpointer key, gpointer value, gpointer userdata)
2557 {
2558         GSList **send_queues = (GSList **) userdata;
2559         *send_queues = g_slist_prepend (*send_queues, value);
2560 }
2561
2562 static gboolean
2563 _selected_msg_sent_in_progress (ModestWindow *win)
2564 {
2565         const DimmedState *state = modest_window_get_dimming_state (win);
2566         return state->sent_in_progress;
2567 }
2568
2569
2570 static gboolean
2571 _sending_in_progress (ModestWindow *win)
2572 {
2573         GHashTable *send_queue_cache = NULL;
2574         ModestCacheMgr *cache_mgr = NULL;
2575         ModestTnySendQueue *send_queue = NULL;
2576         GSList *send_queues = NULL, *node = NULL;
2577         gboolean result = FALSE;
2578
2579         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW (win), FALSE);
2580
2581         /* Get send queue */
2582         cache_mgr = modest_runtime_get_cache_mgr ();
2583         send_queue_cache = modest_cache_mgr_get_cache (cache_mgr,
2584                                                        MODEST_CACHE_MGR_CACHE_TYPE_SEND_QUEUE);
2585
2586         g_hash_table_foreach (send_queue_cache, (GHFunc) fill_list_of_caches, &send_queues);
2587
2588         for (node = send_queues; node != NULL && !result; node = g_slist_next (node)) {
2589                 send_queue = MODEST_TNY_SEND_QUEUE (node->data);
2590
2591                 /* Check if send operation is in progress */
2592                 result = modest_tny_send_queue_sending_in_progress (send_queue);
2593         }
2594
2595         return result;
2596 }
2597
2598 static gboolean
2599 _invalid_folder_for_purge (ModestWindow *win,
2600                            ModestDimmingRule *rule)
2601 {
2602         TnyFolder *folder = NULL;
2603         TnyAccount *account = NULL;
2604         gboolean result = FALSE;
2605
2606         if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
2607
2608                 /* Get folder and account of message */
2609                 TnyMsg *msg = modest_msg_view_window_get_message (MODEST_MSG_VIEW_WINDOW (win));
2610                 g_return_val_if_fail(msg != NULL, TRUE);
2611                 folder = tny_msg_get_folder (msg);
2612                 g_object_unref (msg);
2613                 if (folder == NULL) {
2614                         modest_dimming_rule_set_notification (rule, _("mail_ib_unable_to_purge_attachments"));
2615                         goto frees;
2616                 }
2617         } else if (MODEST_IS_MAIN_WINDOW (win)) {
2618                 GtkWidget *folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
2619                                                                               MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
2620                 if (!folder_view)
2621                         return FALSE;
2622                 folder = TNY_FOLDER (modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view)));
2623                 if (folder == NULL || ! TNY_IS_FOLDER (folder))
2624                         goto frees;
2625         } else {
2626                 g_return_val_if_reached (FALSE);
2627         }
2628         account = modest_tny_folder_get_account (folder);
2629         if (account == NULL) goto frees;
2630
2631         /* Check account */
2632         if (modest_tny_account_is_virtual_local_folders (TNY_ACCOUNT (account))) {
2633                 TnyFolderType types[2];
2634                 types[0] = TNY_FOLDER_TYPE_DRAFTS;
2635                 types[1] = TNY_FOLDER_TYPE_OUTBOX;
2636
2637                 if (_selected_folder_is_any_of_type (win, types, 2)) {
2638                         result = TRUE;
2639                         modest_dimming_rule_set_notification (rule, _("mail_ib_unable_to_purge_editable_msg"));
2640                 } else {
2641                         result = FALSE;
2642                 }
2643         } else {
2644                 const gchar *proto_str = tny_account_get_proto (TNY_ACCOUNT (account));
2645                 /* If it's POP then dim */
2646                 if (modest_protocol_info_get_transport_store_protocol (proto_str) ==
2647                     MODEST_PROTOCOL_STORE_POP) {
2648                         TnyList *attachments = NULL;
2649                         gint n_selected = 0;
2650                         result = TRUE;
2651
2652                         /* TODO: This check is here to prevent a gwarning, but this looks like a logic error.
2653                          * murrayc */
2654                         if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
2655                                 attachments = modest_msg_view_window_get_attachments (MODEST_MSG_VIEW_WINDOW(win));
2656                                 n_selected = tny_list_get_length (attachments);
2657                                 g_object_unref (attachments);
2658                         }
2659
2660                         modest_dimming_rule_set_notification (rule,
2661                                                               ngettext ("mail_ib_unable_to_pure_attach_pop_mail_singular",
2662                                                                         "mail_ib_unable_to_pure_attach_pop_mail_plural",
2663                                                                         n_selected));
2664                 }
2665         }
2666
2667 frees:
2668         if (folder != NULL)
2669                 g_object_unref (folder);
2670         if (account != NULL)
2671                 g_object_unref (account);
2672
2673         return result;
2674 }
2675
2676 static gboolean
2677 _transfer_mode_enabled (ModestWindow *win)
2678 {
2679         gboolean result = FALSE;
2680
2681         /* Check dimming */
2682         if (MODEST_IS_MSG_VIEW_WINDOW(win)) {
2683                 result = modest_msg_view_window_transfer_mode_enabled (MODEST_MSG_VIEW_WINDOW (win));
2684         } else if (MODEST_IS_MAIN_WINDOW(win)) {
2685                 result = modest_main_window_transfer_mode_enabled (MODEST_MAIN_WINDOW (win));
2686         } else {
2687                 g_warning("_transfer_mode_enabled called with wrong window type");
2688         }
2689
2690         return result;
2691 }
2692
2693 static gboolean
2694 _selected_folder_has_subfolder_with_same_name (ModestWindow *win)
2695 {
2696         GtkWidget *folder_view = NULL;
2697         TnyFolderStore *folder = NULL;
2698         ModestEmailClipboard *clipboard = NULL;
2699         const gchar *folder_name = NULL;
2700         gboolean result = FALSE;
2701
2702         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), TRUE);
2703
2704         /*Get current parent folder */
2705         folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
2706                                                            MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
2707         /* If no folder view, always dimmed */
2708         if (!folder_view) return FALSE;
2709
2710         /* Get selected folder as parent of new folder to create */
2711         folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
2712         if (!(folder && TNY_IS_FOLDER(folder))) goto frees;
2713
2714         /* get modest clipboard and source folder */
2715         clipboard = modest_runtime_get_email_clipboard ();
2716         folder_name = modest_email_clipboard_get_folder_name (clipboard);
2717         if (folder_name == NULL) goto frees;
2718
2719         /* Check source subfolders names */
2720         result = modest_tny_folder_has_subfolder_with_name (folder, folder_name,
2721                                                             TRUE);
2722
2723         /* Free */
2724  frees:
2725         if (folder != NULL)
2726                 g_object_unref (folder);
2727
2728
2729         return result;
2730 }
2731
2732 gboolean
2733 modest_ui_dimming_rules_on_save_to_drafts (ModestWindow *win,
2734                                            gpointer user_data)
2735 {
2736         ModestDimmingRule *rule = NULL;
2737         gboolean dimmed = FALSE;
2738
2739         g_return_val_if_fail (MODEST_MSG_EDIT_WINDOW (win), FALSE);
2740         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
2741         rule = MODEST_DIMMING_RULE (user_data);
2742
2743         /* Check dimmed rule */
2744         if (!dimmed) {
2745                 dimmed = !modest_msg_edit_window_is_modified (MODEST_MSG_EDIT_WINDOW (win));
2746         }
2747
2748         return dimmed;
2749 }
2750
2751 gboolean
2752 modest_ui_dimming_rules_on_insert_image (ModestWindow *win,
2753                                          gpointer user_data)
2754 {
2755         g_return_val_if_fail (MODEST_MSG_EDIT_WINDOW (win), FALSE);
2756
2757         ModestMsgEditFormat format =
2758           modest_msg_edit_window_get_format (MODEST_MSG_EDIT_WINDOW (win));
2759
2760         return (format != MODEST_MSG_EDIT_FORMAT_HTML);
2761 }