git.maemo.org Git - modest/blob - src/modest-ui-dimming-rules.c

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