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-dimming-rule.h"
  37 #include "modest-tny-folder.h"
  38 #include "modest-tny-account.h"
  39 #include "modest-text-utils.h"
  40 #include <widgets/modest-attachments-view.h>
  41 #include <modest-runtime.h>
  42 #include <tny-simple-list.h>
  43
  44
  45 static gboolean _folder_is_any_of_type (TnyFolder *folder, TnyFolderType types[], guint ntypes);
  46 static gboolean _invalid_msg_selected (ModestMainWindow *win, gboolean unique, ModestDimmingRule *rule);
  47 static gboolean _invalid_attach_selected (ModestWindow *win,
  48                                           gboolean unique, gboolean for_view, gboolean for_remove,
  49                                           ModestDimmingRule *rule);
  50 static gboolean _purged_attach_selected (ModestWindow *win, gboolean all, ModestDimmingRule *rule);
  51 static gboolean _clipboard_is_empty (ModestWindow *win);
  52 static gboolean _invalid_clipboard_selected (ModestWindow *win, ModestDimmingRule *rule);
  53 /* static gboolean _already_opened_msg (ModestWindow *win, guint *n_messages); */
  54 /* static gboolean _selected_msg_marked_as (ModestMainWindow *win, TnyHeaderFlags mask, gboolean opposite, gboolean all); */
  55 static gboolean _selected_folder_not_writeable (ModestMainWindow *win);
  56 static gboolean _selected_folder_is_snd_level (ModestMainWindow *win);
  57 static gboolean _selected_folder_is_any_of_type (ModestWindow *win, TnyFolderType types[], guint ntypes);
  58 static gboolean _selected_folder_is_root_or_inbox (ModestMainWindow *win);
  59 static gboolean _selected_folder_is_MMC_or_POP_root (ModestMainWindow *win);
  60 static gboolean _selected_folder_is_root (ModestMainWindow *win);
  61 static gboolean _header_view_is_all_selected (ModestMainWindow *win);
  62 static gboolean _selected_folder_is_empty (ModestMainWindow *win);
  63 static gboolean _selected_folder_is_same_as_source (ModestWindow *win);
  64 static gboolean _msg_download_in_progress (ModestMsgViewWindow *win);
  65 static gboolean _msg_download_completed (ModestMainWindow *win);
  66 static gboolean _selected_msg_sent_in_progress (ModestWindow *win);
  67 static gboolean _sending_in_progress (ModestWindow *win);
  68 /* static gboolean _message_is_marked_as_deleted (ModestMsgViewWindow *win); */
  69 /* static gboolean _selected_message_is_marked_as_deleted (ModestMainWindow *win); */
  70 static gboolean _invalid_folder_for_purge (ModestWindow *win, ModestDimmingRule *rule);
  71 static gboolean _transfer_mode_enabled (ModestWindow *win);
  72
  73 static void  fill_list_of_caches (gpointer key, gpointer value, gpointer userdata);
  74
  75
  76 static DimmedState *
  77 _define_main_window_dimming_state (ModestMainWindow *window)
  78 {
  79         DimmedState *state = NULL;
  80         GtkWidget *focused_widget = NULL;
  81         GtkWidget *header_view = NULL;
  82         TnyList *selected_headers = NULL;
  83         TnyIterator *iter = NULL;
  84         TnyHeader *header = NULL;
  85         ModestCacheMgr *cache_mgr = NULL;
  86         GHashTable *send_queue_cache = NULL;
  87         ModestTnySendQueue *send_queue = NULL;
  88         GSList *send_queues = NULL, *node = NULL;
  89         ModestWindowMgr *mgr = NULL;
  90         gboolean found = FALSE;
  91         gchar *msg_uid = NULL;
  92         TnyHeaderFlags flags;
  93         gboolean all_deleted = TRUE;
  94         gboolean all_seen = TRUE;
  95         gboolean all_cached = TRUE;
  96         gboolean all_has_attach = TRUE;
  97
  98         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(window), NULL);
  99
 100         /* Init state */
 101         state = g_slice_new0 (DimmedState);
 102         state->n_selected = 0;
 103         state->already_opened_msg = FALSE;
 104         state->any_marked_as_deleted = FALSE;
 105         state->all_marked_as_deleted = FALSE;
 106         state->any_marked_as_seen = FALSE;
 107         state->all_marked_as_seen = FALSE;
 108         state->any_marked_as_cached = FALSE;
 109         state->all_marked_as_cached = FALSE;
 110         state->any_has_attachments = FALSE;
 111         state->all_has_attachments = FALSE;
 112         state->sent_in_progress = FALSE;
 113
 114         /* Get focused widget */
 115         focused_widget = gtk_window_get_focus (GTK_WINDOW (window));
 116         if (MODEST_IS_FOLDER_VIEW (focused_widget)) {
 117                 state->n_selected++;
 118                 return state;
 119         } else if (MODEST_IS_HEADER_VIEW (focused_widget)) {
 120                 header_view = focused_widget;
 121         } else {
 122                 header_view = modest_main_window_get_child_widget (window, MODEST_WIDGET_TYPE_HEADER_VIEW);
 123         }
 124
 125         /* Get header view and selected headers */
 126         selected_headers = modest_header_view_get_selected_headers (MODEST_HEADER_VIEW(header_view));
 127         if (!selected_headers)
 128                 return state;
 129
 130         /* Examine selected headers */
 131         iter = tny_list_create_iterator (selected_headers);
 132         while (!tny_iterator_is_done (iter)) {
 133                 header = TNY_HEADER (tny_iterator_get_current (iter));
 134                 flags = tny_header_get_flags (header);
 135
 136                 /* No selected */
 137                 state->n_selected++;
 138
 139                 /* Already opened */
 140                 mgr = modest_runtime_get_window_mgr ();
 141                 if (!state->already_opened_msg)
 142                         state->already_opened_msg = modest_window_mgr_find_registered_header (mgr, header, NULL);
 143
 144
 145                 /* Mark as deleted */
 146                 all_deleted = all_deleted && (flags & TNY_HEADER_FLAG_DELETED);
 147                 state->all_marked_as_deleted = all_deleted;
 148                 if (!state->any_marked_as_deleted)
 149                         state->any_marked_as_deleted = flags & TNY_HEADER_FLAG_DELETED;
 150
 151                 /* Mark as seen */
 152                 all_seen = all_seen && (flags & TNY_HEADER_FLAG_SEEN);
 153                 state->all_marked_as_seen = all_seen;
 154                 if (!state->any_marked_as_seen)
 155                         state->any_marked_as_seen = flags & TNY_HEADER_FLAG_SEEN;
 156
 157                 /* Mark as cached */
 158                 all_cached = all_cached && (flags & TNY_HEADER_FLAG_CACHED);
 159                 state->all_marked_as_cached = all_cached;
 160                 if (!state->any_marked_as_cached)
 161                         state->any_marked_as_cached = flags & TNY_HEADER_FLAG_CACHED;
 162
 163                 /* Mark has_attachments */
 164                 all_has_attach = all_has_attach && (flags & TNY_HEADER_FLAG_ATTACHMENTS);
 165                 state->all_has_attachments = all_has_attach;
 166                 if (!state->any_has_attachments)
 167                         state->any_has_attachments = flags & TNY_HEADER_FLAG_ATTACHMENTS;
 168
 169                 /* sent in progress */
 170                 msg_uid = modest_tny_send_queue_get_msg_id (header);
 171                 if (!state->sent_in_progress) {
 172                         cache_mgr = modest_runtime_get_cache_mgr ();
 173                         send_queue_cache = modest_cache_mgr_get_cache (cache_mgr,
 174                                                                        MODEST_CACHE_MGR_CACHE_TYPE_SEND_QUEUE);
 175
 176                         g_hash_table_foreach (send_queue_cache, (GHFunc) fill_list_of_caches, &send_queues);
 177
 178                         for (node = send_queues; node != NULL && !found; node = g_slist_next (node)) {
 179                                 send_queue = MODEST_TNY_SEND_QUEUE (node->data);
 180
 181                                 /* Check if msg uid is being processed inside send queue */
 182                                 found = modest_tny_send_queue_msg_is_being_sent (send_queue, msg_uid);
 183                         }
 184                         state->sent_in_progress = found;
 185                 }
 186
 187                 tny_iterator_next (iter);
 188                 g_object_unref (header);
 189         }
 190
 191         /* Free */
 192         g_free(msg_uid);
 193         g_object_unref(selected_headers);
 194         g_object_unref(iter);
 195         g_slist_free (send_queues);
 196
 197         return state;
 198 }
 199
 200 static DimmedState *
 201 _define_msg_view_window_dimming_state (ModestMsgViewWindow *window)
 202 {
 203         DimmedState *state = NULL;
 204         TnyHeader *header = NULL;
 205         ModestCacheMgr *cache_mgr = NULL;
 206         GHashTable *send_queue_cache = NULL;
 207         ModestTnySendQueue *send_queue = NULL;
 208         GSList *send_queues = NULL, *node = NULL;
 209         gboolean found = FALSE;
 210         gchar *msg_uid = NULL;
 211         TnyHeaderFlags flags;
 212         gboolean all_deleted = TRUE;
 213         gboolean all_seen = TRUE;
 214         gboolean all_cached = TRUE;
 215         gboolean all_has_attach = TRUE;
 216
 217         g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW(window), NULL);
 218
 219         /* Init state */
 220         state = g_slice_new0 (DimmedState);
 221         state->n_selected = 0;
 222         state->already_opened_msg = FALSE;
 223         state->any_marked_as_deleted = FALSE;
 224         state->all_marked_as_deleted = FALSE;
 225         state->any_marked_as_seen = FALSE;
 226         state->all_marked_as_seen = FALSE;
 227         state->any_marked_as_cached = FALSE;
 228         state->all_marked_as_cached = FALSE;
 229         state->any_has_attachments = FALSE;
 230         state->all_has_attachments = FALSE;
 231         state->sent_in_progress = FALSE;
 232
 233         header = modest_msg_view_window_get_header (MODEST_MSG_VIEW_WINDOW(window));
 234         g_return_val_if_fail (TNY_IS_HEADER(header), state);
 235         flags = tny_header_get_flags (header);
 236
 237         /* Selected */
 238         state->n_selected++;
 239
 240         /* Mark as deleted */
 241         all_deleted = all_deleted && (flags & TNY_HEADER_FLAG_DELETED);
 242         state->all_marked_as_deleted = all_deleted;
 243         if (!state->any_marked_as_deleted)
 244                 state->any_marked_as_deleted = flags & TNY_HEADER_FLAG_DELETED;
 245
 246         /* Mark as seen */
 247         all_seen = all_seen && (flags & TNY_HEADER_FLAG_SEEN);
 248         state->all_marked_as_seen = all_seen;
 249         if (!state->any_marked_as_seen)
 250                 state->any_marked_as_seen = flags & TNY_HEADER_FLAG_SEEN;
 251
 252         /* Mark as cached */
 253         all_cached = all_cached && (flags & TNY_HEADER_FLAG_CACHED);
 254         state->all_marked_as_cached = all_cached;
 255         if (!state->any_marked_as_cached)
 256                 state->any_marked_as_cached = flags & TNY_HEADER_FLAG_CACHED;
 257
 258         /* Mark has_attachments */
 259         all_has_attach = all_has_attach && (flags & TNY_HEADER_FLAG_ATTACHMENTS);
 260         state->all_has_attachments = all_has_attach;
 261         if (!state->any_has_attachments)
 262                 state->any_has_attachments = flags & TNY_HEADER_FLAG_ATTACHMENTS;
 263
 264         /* sent in progress */
 265         msg_uid = modest_tny_send_queue_get_msg_id (header);
 266         if (!state->sent_in_progress) {
 267                 cache_mgr = modest_runtime_get_cache_mgr ();
 268                 send_queue_cache = modest_cache_mgr_get_cache (cache_mgr,
 269                                                                MODEST_CACHE_MGR_CACHE_TYPE_SEND_QUEUE);
 270
 271                 g_hash_table_foreach (send_queue_cache, (GHFunc) fill_list_of_caches, &send_queues);
 272
 273                 for (node = send_queues; node != NULL && !found; node = g_slist_next (node)) {
 274                         send_queue = MODEST_TNY_SEND_QUEUE (node->data);
 275
 276                         /* Check if msg uid is being processed inside send queue */
 277                         found = modest_tny_send_queue_msg_is_being_sent (send_queue, msg_uid);
 278                 }
 279                 state->sent_in_progress = found;
 280         }
 281
 282         /* Free */
 283         g_free(msg_uid);
 284         g_object_unref (header);
 285         g_slist_free (send_queues);
 286
 287         return state;
 288 }
 289
 290
 291 DimmedState *
 292 modest_ui_dimming_rules_define_dimming_state (ModestWindow *window)
 293 {
 294         DimmedState *state = NULL;
 295
 296         g_return_val_if_fail (MODEST_IS_WINDOW(window), NULL);
 297
 298         if (MODEST_IS_MAIN_WINDOW (window))
 299                 state = _define_main_window_dimming_state (MODEST_MAIN_WINDOW(window));
 300         else if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
 301                 state = _define_msg_view_window_dimming_state (MODEST_MSG_VIEW_WINDOW(window));
 302         }
 303
 304         return state;
 305 }
 306
 307
 308 gboolean
 309 modest_ui_dimming_rules_on_new_msg (ModestWindow *win, gpointer user_data)
 310 {
 311         ModestDimmingRule *rule = NULL;
 312         gboolean dimmed = FALSE;
 313
 314         g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW(win), FALSE);
 315         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 316         rule = MODEST_DIMMING_RULE (user_data);
 317
 318         /* Check dimmed rule */
 319         if (!dimmed) {
 320                 dimmed = _msg_download_in_progress (MODEST_MSG_VIEW_WINDOW(win));
 321                 if (dimmed)
 322                         modest_dimming_rule_set_notification (rule, "");
 323         }
 324
 325         return dimmed;
 326 }
 327
 328 gboolean
 329 modest_ui_dimming_rules_on_csm_new_folder (ModestWindow *win, gpointer user_data)
 330 {
 331         ModestDimmingRule *rule = NULL;
 332         gboolean dimmed = FALSE;
 333
 334         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
 335         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 336         rule = MODEST_DIMMING_RULE (user_data);
 337
 338         /* Check common new folder menu item dimming rules */
 339         dimmed = modest_ui_dimming_rules_on_new_folder (win, user_data);
 340
 341         /* Check CSM specific dimming rules */
 342         if (!dimmed) {
 343                 dimmed = _selected_folder_is_snd_level (MODEST_MAIN_WINDOW(win));
 344                 if (dimmed)
 345                         modest_dimming_rule_set_notification (rule, _("mail_in_ui_folder_create_error"));
 346         }
 347
 348         return dimmed;
 349 }
 350
 351 gboolean
 352 modest_ui_dimming_rules_on_new_folder (ModestWindow *win, gpointer user_data)
 353 {
 354         ModestDimmingRule *rule = NULL;
 355         GtkWidget *folder_view = NULL;
 356         TnyFolderStore *parent_folder = NULL;
 357         gboolean dimmed = FALSE;
 358
 359         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
 360         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 361         rule = MODEST_DIMMING_RULE (user_data);
 362
 363         /* Get selected folder as parent of new folder to create */
 364         folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
 365                                                            MODEST_WIDGET_TYPE_FOLDER_VIEW);
 366         parent_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
 367         if (!parent_folder)
 368                 return TRUE;
 369
 370         if (TNY_IS_ACCOUNT (parent_folder)) {
 371                 /* If it's the local account then do not dim */
 372                 if (modest_tny_account_is_virtual_local_folders (TNY_ACCOUNT (parent_folder))) {
 373                         dimmed = FALSE;
 374                 } else {
 375                         const gchar *proto_str = tny_account_get_proto (TNY_ACCOUNT (parent_folder));
 376                         /* If it's POP then dim */
 377                         dimmed = (modest_protocol_info_get_transport_store_protocol (proto_str) ==
 378                                   MODEST_PROTOCOL_STORE_POP) ? TRUE : FALSE;
 379                         if (dimmed)
 380                                 modest_dimming_rule_set_notification (rule, _("mail_in_ui_folder_create_error"));
 381                 }
 382         } else {
 383                 /* TODO: the specs say that only one level of subfolder is allowed, is this true ? */
 384
 385                 TnyFolderType types[3];
 386
 387                 types[0] = TNY_FOLDER_TYPE_DRAFTS;
 388                 types[1] = TNY_FOLDER_TYPE_OUTBOX;
 389                 types[2] = TNY_FOLDER_TYPE_SENT;
 390
 391                 /* Apply folder rules */
 392                 if (!dimmed) {
 393                         dimmed = _selected_folder_not_writeable (MODEST_MAIN_WINDOW(win));
 394                         if (dimmed)
 395                                 modest_dimming_rule_set_notification (rule, _("mail_in_ui_folder_create_error"));
 396                 }
 397                 if (!dimmed) {
 398                         dimmed = _selected_folder_is_any_of_type (win, types, 3);
 399                         if (dimmed)
 400                                 modest_dimming_rule_set_notification (rule, _("mail_in_ui_folder_create_error"));
 401                 }
 402         }
 403         g_object_unref (parent_folder);
 404
 405         return dimmed;
 406 }
 407
 408 gboolean
 409 modest_ui_dimming_rules_on_delete (ModestWindow *win, gpointer user_data)
 410 {
 411         ModestDimmingRule *rule = NULL;
 412         GtkWidget *folder_view = NULL;
 413         GtkWidget *header_view = NULL;
 414         gboolean dimmed = FALSE;
 415
 416         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 417         rule = MODEST_DIMMING_RULE (user_data);
 418
 419         if (MODEST_IS_MAIN_WINDOW (win)) {
 420                 /* Get the folder view */
 421                 folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
 422                                                                    MODEST_WIDGET_TYPE_FOLDER_VIEW);
 423
 424                 /* Get header view */
 425                 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
 426                                                            MODEST_WIDGET_TYPE_HEADER_VIEW);
 427
 428                 if (header_view && gtk_widget_is_focus (header_view))
 429                         dimmed = modest_ui_dimming_rules_on_delete_msg (win, rule);
 430
 431                 if (folder_view && gtk_widget_is_focus (folder_view))
 432                         dimmed = modest_ui_dimming_rules_on_delete_folder (win, rule);
 433
 434                 if (header_view && folder_view &&
 435                     !gtk_widget_is_focus (header_view) &&
 436                     !gtk_widget_is_focus (folder_view)) {
 437                         dimmed = TRUE;
 438                         modest_dimming_rule_set_notification (rule, dgettext("hildon-common-strings", "ckct_ib_nothing_to_delete"));
 439                 }
 440         } else {
 441                 dimmed = modest_ui_dimming_rules_on_delete_folder (win, rule);
 442         }
 443
 444         return dimmed;
 445 }
 446
 447
 448
 449 gboolean
 450 modest_ui_dimming_rules_on_delete_folder (ModestWindow *win, gpointer user_data)
 451 {
 452         ModestDimmingRule *rule = NULL;
 453         TnyFolderType types[6];
 454         gboolean dimmed = FALSE;
 455
 456         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
 457         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 458         rule = MODEST_DIMMING_RULE (user_data);
 459
 460         types[0] = TNY_FOLDER_TYPE_DRAFTS;
 461         types[1] = TNY_FOLDER_TYPE_OUTBOX;
 462         types[2] = TNY_FOLDER_TYPE_SENT;
 463         types[3] = TNY_FOLDER_TYPE_INBOX;
 464         types[4] = TNY_FOLDER_TYPE_ROOT;
 465         types[5] = TNY_FOLDER_TYPE_ARCHIVE;
 466
 467
 468         /* Check dimmed rule */
 469         if (!dimmed) {
 470                 dimmed = _selected_folder_not_writeable (MODEST_MAIN_WINDOW(win));
 471                 if (dimmed)
 472                         modest_dimming_rule_set_notification (rule, _("mail_in_ui_folder_delete_error"));
 473         }
 474         if (!dimmed) {
 475                 dimmed = _selected_folder_is_any_of_type (win, types, 6);
 476                 if (dimmed)
 477                         modest_dimming_rule_set_notification (rule, _("mail_in_ui_folder_delete_error"));
 478         }
 479         if (!dimmed) {
 480                 dimmed = _selected_folder_is_root_or_inbox (MODEST_MAIN_WINDOW(win));
 481                 if (dimmed)
 482                         modest_dimming_rule_set_notification (rule, _("mail_in_ui_folder_delete_error"));
 483         }
 484         if (!dimmed) {
 485                 dimmed = _selected_folder_is_MMC_or_POP_root (MODEST_MAIN_WINDOW(win));
 486                 if (dimmed)
 487                         modest_dimming_rule_set_notification (rule, _("mail_in_ui_folder_delete_error"));
 488         }
 489         if (!dimmed) {
 490                 dimmed = _transfer_mode_enabled (win);
 491                 if (dimmed)
 492                         modest_dimming_rule_set_notification (rule, _CS("ckct_ib_unable_to_delete"));
 493         }
 494
 495         return dimmed;
 496 }
 497
 498 gboolean
 499 modest_ui_dimming_rules_on_sort (ModestWindow *win, gpointer user_data)
 500 {
 501         ModestDimmingRule *rule = NULL;
 502         gboolean dimmed = FALSE;
 503
 504         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
 505         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 506         rule = MODEST_DIMMING_RULE (user_data);
 507
 508         /* Check dimmed rule */
 509         if (!dimmed) {
 510                 dimmed = _selected_folder_is_root (MODEST_MAIN_WINDOW(win));
 511                 modest_dimming_rule_set_notification (rule, _CS("ckdg_ib_nothing_to_sort"));
 512         }
 513
 514         if (!dimmed) {
 515                 dimmed = _selected_folder_is_empty (MODEST_MAIN_WINDOW(win));
 516                 modest_dimming_rule_set_notification (rule, _CS("ckdg_ib_nothing_to_sort"));
 517         }
 518
 519         return dimmed;
 520
 521 }
 522
 523 gboolean
 524 modest_ui_dimming_rules_on_rename_folder (ModestWindow *win, gpointer user_data)
 525 {
 526         ModestDimmingRule *rule = NULL;
 527         TnyFolderType types[4];
 528         gboolean dimmed = FALSE;
 529
 530         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
 531         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 532         rule = MODEST_DIMMING_RULE (user_data);
 533
 534         types[0] = TNY_FOLDER_TYPE_DRAFTS;
 535         types[1] = TNY_FOLDER_TYPE_OUTBOX;
 536         types[2] = TNY_FOLDER_TYPE_SENT;
 537         types[3] = TNY_FOLDER_TYPE_ARCHIVE;
 538
 539         /* Check dimmed rule */
 540         if (!dimmed) {
 541                 dimmed = _selected_folder_not_writeable (MODEST_MAIN_WINDOW(win));
 542                 if (dimmed)
 543                         modest_dimming_rule_set_notification (rule, "");
 544         }
 545         if (!dimmed) {
 546                 dimmed = _selected_folder_is_root_or_inbox (MODEST_MAIN_WINDOW(win));
 547                 if (dimmed)
 548                         modest_dimming_rule_set_notification (rule, "");
 549         }
 550         if (!dimmed) {
 551                 dimmed = _selected_folder_is_any_of_type (win, types, 4);
 552                 if (dimmed)
 553                         modest_dimming_rule_set_notification (rule, "");
 554         }
 555
 556         return dimmed;
 557 }
 558
 559 gboolean
 560 modest_ui_dimming_rules_on_open_msg (ModestWindow *win, gpointer user_data)
 561 {
 562         ModestDimmingRule *rule = NULL;
 563         gboolean dimmed = FALSE;
 564         const DimmedState *state = NULL;
 565
 566         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
 567         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 568         rule = MODEST_DIMMING_RULE (user_data);
 569         state = modest_window_get_dimming_state (win);
 570
 571         /* Check dimmed rule */
 572         if (!dimmed) {
 573                 dimmed = _invalid_msg_selected (MODEST_MAIN_WINDOW(win), TRUE, user_data);
 574         }
 575         if (!dimmed) {
 576                 dimmed = state->any_marked_as_deleted;
 577                 if (dimmed)
 578                         modest_dimming_rule_set_notification (rule, _("mcen_ib_message_already_deleted"));
 579         }
 580         if (!dimmed) {
 581                 dimmed = _selected_msg_sent_in_progress (win);
 582                 if (dimmed)
 583                         modest_dimming_rule_set_notification (rule, _("mcen_ib_unable_to_open_while_sent"));
 584         }
 585
 586         return dimmed;
 587 }
 588
 589 gboolean
 590 modest_ui_dimming_rules_on_reply_msg (ModestWindow *win, gpointer user_data)
 591 {
 592         ModestDimmingRule *rule = NULL;
 593         gboolean dimmed = FALSE;
 594         TnyFolderType types[3];
 595
 596         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 597         rule = MODEST_DIMMING_RULE (user_data);
 598
 599         /* main window dimming rules */
 600         if (MODEST_IS_MAIN_WINDOW(win)) {
 601
 602                 types[0] = TNY_FOLDER_TYPE_DRAFTS;
 603                 types[1] = TNY_FOLDER_TYPE_OUTBOX;
 604                 types[2] = TNY_FOLDER_TYPE_ROOT;
 605
 606                 /* Check dimmed rule */
 607                 if (!dimmed) {
 608                         dimmed = _selected_folder_is_any_of_type (win, types, 3);
 609                         if (dimmed)
 610                                 modest_dimming_rule_set_notification (rule, _("mcen_ib_unable_to_reply"));
 611                 }
 612                 if (!dimmed) {
 613                         dimmed = _selected_folder_is_empty (MODEST_MAIN_WINDOW(win));
 614                         if (dimmed)
 615                                 modest_dimming_rule_set_notification (rule, _("mcen_ib_nothing_to_reply"));
 616                 }
 617                 if (!dimmed) {
 618                         dimmed = _invalid_msg_selected (MODEST_MAIN_WINDOW(win), TRUE, rule);
 619                 }
 620         /* msg view window dimming rules */
 621         } else if (MODEST_IS_MSG_VIEW_WINDOW(win)) {
 622
 623                 /* Check dimmed rule */
 624                 if (!dimmed) {
 625                         dimmed = _transfer_mode_enabled (win);
 626                         if (dimmed)
 627                                 modest_dimming_rule_set_notification (rule, _("mail_ib_notavailable_downloading"));
 628                 }
 629                 if (!dimmed) {
 630                         dimmed = _msg_download_in_progress (MODEST_MSG_VIEW_WINDOW (win));
 631                         if (dimmed)
 632                                 modest_dimming_rule_set_notification (rule, _("mcen_ib_unable_to_reply"));
 633                 }
 634         }
 635
 636         return dimmed;
 637 }
 638
 639
 640 gboolean
 641 modest_ui_dimming_rules_on_contents_msg (ModestWindow *win, gpointer user_data)
 642 {
 643         ModestDimmingRule *rule = NULL;
 644         gboolean dimmed = FALSE;
 645
 646         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
 647         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 648         rule = MODEST_DIMMING_RULE (user_data);
 649
 650         /* Check dimmed rule */
 651         if (!dimmed) {
 652                 dimmed = _invalid_msg_selected (MODEST_MAIN_WINDOW(win), FALSE, user_data);
 653         }
 654         if (!dimmed) {
 655                 dimmed = _msg_download_completed (MODEST_MAIN_WINDOW(win));
 656                 if (dimmed)
 657                         modest_dimming_rule_set_notification (rule, "");
 658         }
 659
 660         return dimmed;
 661 }
 662
 663 gboolean
 664 modest_ui_dimming_rules_always_dimmed (ModestWindow *win, gpointer user_data)
 665 {
 666         gboolean dimmed = FALSE;
 667
 668         g_return_val_if_fail (MODEST_IS_WINDOW(win), FALSE);
 669
 670         /* Check dimmed rule */
 671         if (!dimmed)
 672                 dimmed = TRUE;
 673
 674         return dimmed;
 675 }
 676
 677 gboolean
 678 modest_ui_dimming_rules_on_delete_msg (ModestWindow *win, gpointer user_data)
 679 {
 680         ModestDimmingRule *rule = NULL;
 681         guint n_messages = 0;
 682         const DimmedState *state = NULL;
 683         gboolean dimmed = FALSE;
 684
 685         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 686         rule = MODEST_DIMMING_RULE (user_data);
 687         state = modest_window_get_dimming_state (win);
 688
 689         /* Check dimmed rule */
 690         if (MODEST_IS_MAIN_WINDOW (win)) {
 691                 if (!dimmed) {
 692                         dimmed = _selected_folder_is_empty (MODEST_MAIN_WINDOW(win));
 693                         if (dimmed)
 694                                 modest_dimming_rule_set_notification (rule, _CS("ckct_ib_nothing_to_delete"));
 695                 }
 696                 if (!dimmed) {
 697                         dimmed = _invalid_msg_selected (MODEST_MAIN_WINDOW(win), FALSE, user_data);
 698                 }
 699                 if (!dimmed) {
 700                         dimmed = state->already_opened_msg;
 701                         n_messages = state->n_selected;
 702                         if (dimmed) {
 703                                 gchar *num = g_strdup_printf ("%d", n_messages);
 704                                 gchar *message = g_strdup_printf(_("mcen_nc_unable_to_delete_n_messages"), num);
 705                                 modest_dimming_rule_set_notification (rule, message);
 706                                 g_free(message);
 707                                 g_free(num);
 708                         }
 709
 710                 }
 711                 if (!dimmed) {
 712                         dimmed = state->any_marked_as_deleted;
 713                         if (dimmed) {
 714                                 modest_dimming_rule_set_notification (rule, _("mcen_ib_message_already_deleted"));
 715                         }
 716                 }
 717                 if (!dimmed) {
 718                         dimmed = state->sent_in_progress;
 719                         if (dimmed)
 720                                 modest_dimming_rule_set_notification (rule, _CS("ckct_ib_unable_to_delete"));
 721                 }
 722         }
 723         else if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
 724                 if (!dimmed) {
 725                         dimmed = _transfer_mode_enabled (win);
 726                         if (dimmed)
 727                                 modest_dimming_rule_set_notification (rule, _("mail_ib_notavailable_downloading"));
 728                 }
 729                 if (!dimmed) {
 730                         dimmed = state->any_marked_as_deleted;
 731                         if (dimmed)
 732                                 modest_dimming_rule_set_notification (rule, _("mcen_ib_message_already_deleted"));
 733                 }
 734
 735                 /* The delete button should be dimmed when viewing an attachment,
 736                  * but should be enabled when viewing a message from the list,
 737                  * or when viewing a search result.
 738                  */
 739                 if (!dimmed) {
 740                         if (!modest_msg_view_window_is_search_result (MODEST_MSG_VIEW_WINDOW(win))) {
 741                                 dimmed = !modest_msg_view_window_has_headers_model (MODEST_MSG_VIEW_WINDOW(win));
 742                                 if (dimmed) {
 743                                         modest_dimming_rule_set_notification (rule, _CS("ckct_ib_unable_to_delete"));
 744                                 }
 745                         }
 746                 }
 747         }
 748
 749         return dimmed;
 750 }
 751
 752 gboolean
 753 modest_ui_dimming_rules_on_details (ModestWindow *win, gpointer user_data)
 754 {
 755         ModestDimmingRule *rule = NULL;
 756         GtkWidget *header_view = NULL;
 757         gboolean dimmed = FALSE;
 758
 759         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 760         rule = MODEST_DIMMING_RULE (user_data);
 761
 762         /* main window dimming rules */
 763         if (MODEST_IS_MAIN_WINDOW(win)) {
 764
 765                 /* Check dimmed rule */
 766                 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
 767                                                                    MODEST_WIDGET_TYPE_HEADER_VIEW);
 768
 769                 /* If the header view has the focus: */
 770                 if (header_view && gtk_widget_is_focus (header_view)) {
 771                         /* Check dimmed rule */
 772                         if (!dimmed)
 773                                 dimmed = _invalid_msg_selected (MODEST_MAIN_WINDOW(win), TRUE, user_data);
 774                 }
 775                 else {
 776                         /* If the folder view has the focus: */
 777                         GtkWidget *folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
 778                                 MODEST_WIDGET_TYPE_FOLDER_VIEW);
 779                         if (folder_view && gtk_widget_is_focus (folder_view)) {
 780                                 TnyFolderStore *folder_store
 781                                         = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
 782                                 if (folder_store) {
 783                                         /* Only enable for folders, not accounts,
 784                                          * though the UI spec is not clear about that.
 785                                          * If we enable this for accounts then we must
 786                                          * add code to handle them in modest_ui_actions_on_details(). */
 787                                         if (!TNY_IS_FOLDER(folder_store)) {
 788                                                 dimmed = TRUE;
 789                                                 modest_dimming_rule_set_notification (rule, "");
 790                                         }
 791
 792                                         g_object_unref (folder_store);
 793                                 }
 794                         }
 795
 796                 }
 797
 798         /* msg view window dimming rules */
 799         } else {
 800
 801                 /* Check dimmed rule */
 802                 if (!dimmed) {
 803                         if (MODEST_IS_MSG_VIEW_WINDOW (win))
 804                                 dimmed = _msg_download_in_progress (MODEST_MSG_VIEW_WINDOW (win));
 805                         if (dimmed)
 806                                 modest_dimming_rule_set_notification (rule, "");
 807                 }
 808         }
 809
 810         return dimmed;
 811 }
 812
 813
 814 gboolean
 815 modest_ui_dimming_rules_on_mark_as_read_msg (ModestWindow *win, gpointer user_data)
 816 {
 817         ModestDimmingRule *rule = NULL;
 818         TnyHeaderFlags flags;
 819         const DimmedState *state = NULL;
 820         gboolean dimmed = FALSE;
 821
 822         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
 823         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 824         rule = MODEST_DIMMING_RULE (user_data);
 825         state = modest_window_get_dimming_state (win);
 826
 827         flags = TNY_HEADER_FLAG_SEEN;
 828
 829         /* Check dimmed rule */
 830         if (!dimmed) {
 831                 dimmed = _invalid_msg_selected (MODEST_MAIN_WINDOW(win), FALSE, user_data);
 832         }
 833         if (!dimmed) {
 834                 dimmed = state->all_marked_as_seen;
 835                 if (dimmed)
 836                         modest_dimming_rule_set_notification (rule, "");
 837         }
 838
 839         return dimmed;
 840 }
 841
 842 gboolean
 843 modest_ui_dimming_rules_on_mark_as_unread_msg (ModestWindow *win, gpointer user_data)
 844 {
 845         ModestDimmingRule *rule = NULL;
 846         TnyHeaderFlags flags;
 847         const DimmedState *state = NULL;
 848         gboolean dimmed = FALSE;
 849
 850         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
 851         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 852         rule = MODEST_DIMMING_RULE (user_data);
 853         state = modest_window_get_dimming_state (win);
 854
 855         flags = TNY_HEADER_FLAG_SEEN;
 856
 857         /* Check dimmed rule */
 858         if (!dimmed)
 859                 dimmed = _invalid_msg_selected (MODEST_MAIN_WINDOW(win), FALSE, user_data);
 860         if (!dimmed) {
 861                 dimmed = !state->any_marked_as_seen;
 862                 if (dimmed)
 863                         modest_dimming_rule_set_notification (rule, "");
 864         }
 865
 866         return dimmed;
 867 }
 868
 869 gboolean
 870 modest_ui_dimming_rules_on_move_to (ModestWindow *win, gpointer user_data)
 871 {
 872         ModestDimmingRule *rule = NULL;
 873         gboolean dimmed = FALSE;
 874
 875         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 876         rule = MODEST_DIMMING_RULE (user_data);
 877
 878         if (MODEST_IS_MAIN_WINDOW (win))
 879                 dimmed = modest_ui_dimming_rules_on_main_window_move_to (win, user_data);
 880         else if (MODEST_IS_MSG_VIEW_WINDOW (win))
 881                  dimmed = modest_ui_dimming_rules_on_view_window_move_to (win, user_data);
 882
 883         return dimmed;
 884 }
 885
 886
 887 gboolean
 888 modest_ui_dimming_rules_on_main_window_move_to (ModestWindow *win, gpointer user_data)
 889 {
 890         GtkWidget *folder_view = NULL;
 891         ModestDimmingRule *rule = NULL;
 892         guint n_messages = 0;
 893         const DimmedState *state = NULL;
 894         gboolean dimmed = FALSE;
 895
 896         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), TRUE);
 897         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 898         rule = MODEST_DIMMING_RULE (user_data);
 899         state = modest_window_get_dimming_state (win);
 900
 901         /* Get the folder view */
 902         folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
 903                                                            MODEST_WIDGET_TYPE_FOLDER_VIEW);
 904
 905
 906         /* Check diming rules for folders transfer  */
 907         if (gtk_widget_is_focus (folder_view)) {
 908                 TnyFolderType types[5];
 909
 910                 types[0] = TNY_FOLDER_TYPE_DRAFTS;
 911                 types[1] = TNY_FOLDER_TYPE_OUTBOX;
 912                 types[2] = TNY_FOLDER_TYPE_SENT;
 913                 types[3] = TNY_FOLDER_TYPE_ROOT;
 914                 types[4] = TNY_FOLDER_TYPE_INBOX;
 915
 916                 /* Apply folder rules */
 917                 if (!dimmed) {
 918                         dimmed = _selected_folder_not_writeable (MODEST_MAIN_WINDOW(win));
 919                         if (dimmed)
 920                                 modest_dimming_rule_set_notification (rule, _("emev_bd_unabletomove_items"));
 921                 }
 922                 if (!dimmed) {
 923                         dimmed = _selected_folder_is_any_of_type (win, types, 5);
 924                         if (dimmed)
 925                                 modest_dimming_rule_set_notification (rule, _("emev_bd_unabletomove_itemsr"));
 926                 }
 927         }
 928
 929         /* Check diming rules for messages transfer  */
 930         if (!dimmed) {
 931                 dimmed = state->already_opened_msg;
 932                 n_messages = state->n_selected;
 933                 if (dimmed) {
 934                         gchar *message = g_strdup_printf(_("emev_bd_unabletomove_items"), n_messages);
 935                         modest_dimming_rule_set_notification (rule, message);
 936                         g_free(message);
 937                 }
 938         }
 939         if (!dimmed) {
 940                 if (!gtk_widget_is_focus (folder_view))
 941                         dimmed = _invalid_msg_selected (MODEST_MAIN_WINDOW(win), FALSE, user_data);
 942
 943         }
 944
 945         return dimmed;
 946 }
 947
 948 gboolean
 949 modest_ui_dimming_rules_on_view_window_move_to (ModestWindow *win, gpointer user_data)
 950 {
 951         ModestDimmingRule *rule = NULL;
 952         gboolean dimmed = FALSE;
 953
 954         g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW(win), FALSE);
 955         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 956         rule = MODEST_DIMMING_RULE (user_data);
 957
 958         /* Check dimmed rule */
 959         if (!dimmed) {
 960                 dimmed = _transfer_mode_enabled (win);
 961                 if (dimmed)
 962                         modest_dimming_rule_set_notification (rule, _("mail_ib_notavailable_downloading"));
 963         }
 964
 965         if (!dimmed) {
 966                 if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
 967                         /* The move_to button should be dimmed when viewing an attachment,
 968                          * but should be enabled when viewing a message from the list,
 969                          * or when viewing a search result.
 970                          */
 971                         if (!modest_msg_view_window_is_search_result (MODEST_MSG_VIEW_WINDOW(win))) {
 972                                 dimmed = !modest_msg_view_window_has_headers_model (MODEST_MSG_VIEW_WINDOW (win));
 973                         }
 974                 }
 975
 976                 if (dimmed)
 977                         modest_dimming_rule_set_notification (rule, _("mcen_ib_unable_to_move_mail_attachment"));
 978         }
 979
 980         return dimmed;
 981 }
 982
 983 gboolean
 984 modest_ui_dimming_rules_on_find_msg (ModestWindow *win, gpointer user_data)
 985 {
 986         ModestDimmingRule *rule = NULL;
 987         gboolean dimmed = FALSE;
 988
 989         g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW(win), FALSE);
 990         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 991         rule = MODEST_DIMMING_RULE (user_data);
 992
 993         /* Check dimmed rule */
 994         if (!dimmed) {
 995                 dimmed = _transfer_mode_enabled (win);
 996                 if (dimmed)
 997                         modest_dimming_rule_set_notification (rule, _("mail_ib_notavailable_downloading"));
 998         }
 999
1000         return dimmed;
1001 }
1002
1003 gboolean
1004 modest_ui_dimming_rules_on_paste_msgs (ModestWindow *win, gpointer user_data)
1005 {
1006         ModestDimmingRule *rule = NULL;
1007         TnyFolderType types[3];
1008         gboolean dimmed = FALSE;
1009
1010         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
1011         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
1012         rule = MODEST_DIMMING_RULE (user_data);
1013
1014         types[0] = TNY_FOLDER_TYPE_DRAFTS;
1015         types[1] = TNY_FOLDER_TYPE_OUTBOX;
1016         types[2] = TNY_FOLDER_TYPE_SENT;
1017
1018         /* Check dimmed rule */
1019         if (!dimmed) {
1020                 dimmed = _clipboard_is_empty (win);
1021                 if (dimmed)
1022                         modest_dimming_rule_set_notification (rule, dgettext("hildon-common-strings", "ecoc_ib_edwin_nothing_to_paste"));
1023         }
1024         if (!dimmed) {
1025                 dimmed = _selected_folder_is_any_of_type (win, types, 3);
1026                 if (dimmed)
1027                         modest_dimming_rule_set_notification (rule, dgettext("hildon-common-strings", "ckct_ib_unable_to_paste_here"));
1028         }
1029         if (!dimmed) {
1030                 dimmed = _selected_folder_not_writeable (MODEST_MAIN_WINDOW(win));
1031                 if (dimmed) {
1032                         modest_dimming_rule_set_notification (rule, dgettext("hildon-common-strings", "ckct_ib_unable_to_paste_here"));
1033                 }
1034         }
1035         if (!dimmed) {
1036                 dimmed = _selected_folder_is_same_as_source (win);
1037                 if (dimmed)
1038                         modest_dimming_rule_set_notification (rule, _("mcen_ib_unable_to_copy_samefolder"));
1039         }
1040
1041         return dimmed;
1042 }
1043
1044
1045 gboolean
1046 modest_ui_dimming_rules_on_select_all (ModestWindow *win, gpointer user_data)
1047 {
1048         ModestDimmingRule *rule = NULL;
1049         gboolean dimmed = FALSE;
1050
1051         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
1052         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
1053         rule = MODEST_DIMMING_RULE (user_data);
1054
1055         /* Check dimmed rule */
1056         if (!dimmed)
1057                 dimmed = _selected_folder_is_empty (MODEST_MAIN_WINDOW(win));
1058
1059         if (!dimmed)
1060                 dimmed = _header_view_is_all_selected (MODEST_MAIN_WINDOW(win));
1061
1062         if (dimmed)
1063                 modest_dimming_rule_set_notification (rule, "");
1064
1065         return dimmed;
1066 }
1067
1068 gboolean
1069 modest_ui_dimming_rules_on_view_attachments (ModestWindow *win, gpointer user_data)
1070 {
1071         ModestDimmingRule *rule = NULL;
1072         gboolean dimmed = FALSE;
1073
1074         g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW(win), FALSE);
1075         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
1076         rule = MODEST_DIMMING_RULE (user_data);
1077
1078         /* Check dimmed rule */
1079         if (!dimmed)
1080                 dimmed = _invalid_attach_selected (win, TRUE, TRUE, FALSE, rule);
1081
1082         if (!dimmed) {
1083                 dimmed = _purged_attach_selected (win, FALSE, NULL);
1084                 if (dimmed) {
1085                         modest_dimming_rule_set_notification (rule, _("mail_ib_attach_not_local"));
1086                 }
1087         }
1088
1089         return dimmed;
1090 }
1091
1092 gboolean
1093 modest_ui_dimming_rules_on_save_attachments (ModestWindow *win, gpointer user_data)
1094 {
1095         ModestDimmingRule *rule = NULL;
1096         gboolean dimmed = FALSE;
1097
1098         g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW(win), FALSE);
1099         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
1100         rule = MODEST_DIMMING_RULE (user_data);
1101
1102         /* Check dimmed rule */
1103         if (!dimmed)
1104                 dimmed = _invalid_attach_selected (win, FALSE, FALSE, FALSE, rule);
1105
1106         if (!dimmed) {
1107                 dimmed = _purged_attach_selected (win, FALSE, NULL);
1108                 if (dimmed) {
1109                         modest_dimming_rule_set_notification (rule, _("mail_ib_attach_not_local"));
1110                 }
1111         }
1112
1113         return dimmed;
1114 }
1115
1116 gboolean
1117 modest_ui_dimming_rules_on_remove_attachments (ModestWindow *win, gpointer user_data)
1118 {
1119         ModestDimmingRule *rule = NULL;
1120         const DimmedState *state = NULL;
1121         gboolean dimmed = FALSE;
1122
1123         g_return_val_if_fail (MODEST_IS_WINDOW(win), FALSE);
1124         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
1125         rule = MODEST_DIMMING_RULE (user_data);
1126         state = modest_window_get_dimming_state (win);
1127
1128         /* Check in main window if there's only one message selected */
1129         if (!dimmed && MODEST_IS_MAIN_WINDOW (win)) {
1130                 dimmed = _invalid_msg_selected (MODEST_MAIN_WINDOW (win), TRUE, rule);
1131         }
1132
1133         /* Check in view window if there's any attachment selected */
1134         if (!dimmed && MODEST_IS_MSG_VIEW_WINDOW (win)) {
1135                 dimmed = _invalid_attach_selected (win, FALSE, FALSE, TRUE, NULL);
1136                 if (dimmed)
1137                         modest_dimming_rule_set_notification (rule, _("FIXME:no attachment selected"));
1138         }
1139
1140         /* cannot purge in editable drafts nor pop folders */
1141         if (!dimmed) {
1142                 dimmed = _invalid_folder_for_purge (win, rule);
1143         }
1144
1145         /* Check if the selected message in main window has attachments */
1146         if (!dimmed && MODEST_IS_MAIN_WINDOW (win)) {
1147                 dimmed = state->any_has_attachments;
1148                 if (dimmed)
1149                         modest_dimming_rule_set_notification (rule, _("mail_ib_unable_to_purge_attachments"));
1150         }
1151
1152         /* Check if all attachments are already purged */
1153         if (!dimmed) {
1154                 dimmed = _purged_attach_selected (win, TRUE, rule);
1155         }
1156
1157         /* Check if the message is already downloaded */
1158         if (!dimmed && MODEST_IS_MAIN_WINDOW (win)) {
1159                 dimmed = !_msg_download_completed (MODEST_MAIN_WINDOW (win));
1160                 if (dimmed)
1161                         modest_dimming_rule_set_notification (rule, _("mail_ib_attach_not_local"));
1162         }
1163
1164
1165         return dimmed;
1166 }
1167
1168 gboolean
1169 modest_ui_dimming_rules_on_undo (ModestWindow *win, gpointer user_data)
1170 {
1171         ModestDimmingRule *rule = NULL;
1172         gboolean dimmed = FALSE;
1173
1174         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
1175         rule = MODEST_DIMMING_RULE (user_data);
1176
1177         /* Check dimmed rule */
1178         if (!dimmed) {
1179                 dimmed = _clipboard_is_empty (win);
1180                 if (dimmed)
1181                         modest_dimming_rule_set_notification (rule, "");
1182         }
1183
1184         return dimmed;
1185 }
1186
1187 gboolean
1188 modest_ui_dimming_rules_on_cut (ModestWindow *win, gpointer user_data)
1189 {
1190         ModestDimmingRule *rule = NULL;
1191         gboolean dimmed = FALSE;
1192
1193         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
1194         rule = MODEST_DIMMING_RULE (user_data);
1195
1196         /* Check common dimming rules */
1197         if (!dimmed) {
1198                 dimmed = _invalid_clipboard_selected (win, rule);
1199         }
1200
1201         /* Check window specific dimming rules */
1202         if (MODEST_IS_MAIN_WINDOW (win)) {
1203                 /* Get focused widget */
1204                 GtkWidget *focused = gtk_window_get_focus (GTK_WINDOW (win));
1205
1206                 if (MODEST_IS_HEADER_VIEW (focused)) {
1207                         if (!dimmed) {
1208                                 dimmed = _selected_folder_is_empty (MODEST_MAIN_WINDOW(win));
1209                                 if (dimmed)
1210                                         modest_dimming_rule_set_notification (rule, "");
1211                         }
1212                         if (!dimmed) {
1213                                 dimmed = _selected_msg_sent_in_progress (win);
1214                                 if (dimmed)
1215                                 modest_dimming_rule_set_notification (rule, _("mcen_ib_unable_to_cut_mess"));
1216                         }
1217                 }
1218                 else if (MODEST_IS_FOLDER_VIEW (focused)) {
1219                         TnyFolderType types[3];
1220
1221                         types[0] = TNY_FOLDER_TYPE_DRAFTS;
1222                         types[1] = TNY_FOLDER_TYPE_OUTBOX;
1223                         types[2] = TNY_FOLDER_TYPE_SENT;
1224
1225                         /* Apply folder rules */
1226                         if (!dimmed) {
1227                                 dimmed = _selected_folder_not_writeable (MODEST_MAIN_WINDOW(win));
1228                                 if (dimmed)
1229                                         modest_dimming_rule_set_notification (rule, _("emev_bd_unabletomove_items"));
1230                         }
1231                         if (!dimmed) {
1232                                 dimmed = _selected_folder_is_root_or_inbox (MODEST_MAIN_WINDOW(win));
1233                                 if (dimmed)
1234                                         modest_dimming_rule_set_notification (rule, _("emev_bd_unabletomove_itemsr"));
1235                         }
1236                         if (!dimmed) {
1237                                 dimmed = _selected_folder_is_any_of_type (win, types, 3);
1238                                 if (dimmed)
1239                                         modest_dimming_rule_set_notification (rule, _("emev_bd_unabletomove_itemsr"));
1240                         }
1241                 }
1242         }
1243
1244         return dimmed;
1245 }
1246
1247 gboolean
1248 modest_ui_dimming_rules_on_copy (ModestWindow *win, gpointer user_data)
1249 {
1250         ModestDimmingRule *rule = NULL;
1251         gboolean dimmed = FALSE;
1252
1253         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
1254         rule = MODEST_DIMMING_RULE (user_data);
1255
1256         /* Check common dimming rules */
1257         if (!dimmed) {
1258                 dimmed = _invalid_clipboard_selected (win, rule);
1259         }
1260
1261         /* Check window specific dimming rules */
1262         if (MODEST_IS_MAIN_WINDOW (win)) {
1263                 /* Get focused widget */
1264                 GtkWidget *focused = gtk_window_get_focus (GTK_WINDOW (win));
1265
1266                 if (MODEST_IS_HEADER_VIEW (focused)) {
1267                         if (!dimmed) {
1268                                 dimmed = _selected_folder_is_empty (MODEST_MAIN_WINDOW(win));
1269                                 if (dimmed)
1270                                         modest_dimming_rule_set_notification (rule, "");
1271                         }
1272                         if (!dimmed) {
1273                                 dimmed = _selected_msg_sent_in_progress (win);
1274                                 if (dimmed)
1275                                         modest_dimming_rule_set_notification (rule, _(""));
1276                         }
1277                 }
1278                 else if (MODEST_IS_FOLDER_VIEW (focused)) {
1279                         if (!dimmed) {
1280                                 dimmed = _selected_folder_is_root (MODEST_MAIN_WINDOW(win));
1281                                 if (dimmed)
1282                                         modest_dimming_rule_set_notification (rule, _(""));
1283                         }
1284                 }
1285         }
1286
1287         return dimmed;
1288 }
1289
1290 gboolean
1291 modest_ui_dimming_rules_on_view_previous (ModestWindow *win, gpointer user_data)
1292 {
1293         ModestDimmingRule *rule = NULL;
1294         gboolean dimmed = FALSE;
1295
1296         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
1297         rule = MODEST_DIMMING_RULE (user_data);
1298
1299         g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW(win), FALSE);
1300
1301         /* Check dimmed rule */
1302         if (!dimmed) {
1303                 dimmed = _transfer_mode_enabled (win);
1304                 if (dimmed)
1305                         modest_dimming_rule_set_notification (
1306                                         rule, _("mail_ib_notavailable_downloading"));
1307         }
1308         if (!dimmed) {
1309                 dimmed = modest_msg_view_window_first_message_selected (
1310                                 MODEST_MSG_VIEW_WINDOW(win));
1311                 modest_dimming_rule_set_notification (rule, NULL);
1312         }
1313
1314         return dimmed;
1315 }
1316
1317 gboolean
1318 modest_ui_dimming_rules_on_view_next (ModestWindow *win, gpointer user_data)
1319 {
1320         ModestDimmingRule *rule = NULL;
1321         gboolean dimmed = FALSE;
1322
1323         g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW(win), FALSE);
1324         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
1325         rule = MODEST_DIMMING_RULE (user_data);
1326
1327         /* Check dimmed rule */
1328         if (!dimmed) {
1329                 dimmed = _transfer_mode_enabled (win);
1330                 if (dimmed)
1331                         modest_dimming_rule_set_notification (rule, _("mail_ib_notavailable_downloading"));
1332         }
1333         if (!dimmed) {
1334                 dimmed = modest_msg_view_window_last_message_selected (MODEST_MSG_VIEW_WINDOW (win));
1335                 modest_dimming_rule_set_notification (rule, NULL);
1336         }
1337
1338         return dimmed;
1339 }
1340
1341
1342 gboolean
1343 modest_ui_dimming_rules_on_tools_smtp_servers (ModestWindow *win, gpointer user_data)
1344 {
1345         const gboolean dimmed =
1346                 !modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(),
1347                         TRUE);
1348
1349         return dimmed;
1350 }
1351
1352 gboolean
1353 modest_ui_dimming_rules_on_cancel_sending (ModestWindow *win, gpointer user_data)
1354 {
1355         ModestDimmingRule *rule = NULL;
1356         TnyFolderType types[1];
1357         guint n_messages = 0;
1358         const DimmedState *state = NULL;
1359         gboolean dimmed = FALSE;
1360
1361         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
1362         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
1363         rule = MODEST_DIMMING_RULE (user_data);
1364         state = modest_window_get_dimming_state (win);
1365
1366         types[0] = TNY_FOLDER_TYPE_OUTBOX;
1367
1368         /* Check dimmed rules */
1369         if (!dimmed) {
1370                 dimmed = state->already_opened_msg;
1371                 n_messages = state->n_selected;
1372                 if (dimmed)
1373                         modest_dimming_rule_set_notification (rule, _("mcen_ib_message_unableto_cancel_send"));
1374         }
1375         if (!dimmed) {
1376                 dimmed = !_selected_folder_is_any_of_type (win, types, 1);
1377                 if (dimmed)
1378                         modest_dimming_rule_set_notification (rule, "");
1379         }
1380         if (!dimmed) {
1381                 dimmed = !_sending_in_progress (win);
1382                 if (dimmed)
1383                         modest_dimming_rule_set_notification (rule, "");
1384         }
1385
1386         return dimmed;
1387 }
1388
1389 gboolean
1390 modest_ui_dimming_rules_on_send_receive (ModestWindow *win, gpointer user_data)
1391 {
1392         ModestDimmingRule *rule = NULL;
1393         gboolean dimmed = FALSE;
1394
1395         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
1396         rule = MODEST_DIMMING_RULE (user_data);
1397
1398         /* Check dimmed rule */
1399         if (!dimmed) {
1400                 dimmed = !modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(),
1401                                                           TRUE);
1402                 if (dimmed)
1403                         modest_dimming_rule_set_notification (rule, _("mcen_nc_no_email_acnts_defined"));
1404         }
1405
1406         return dimmed;
1407 }
1408
1409 gboolean
1410 modest_ui_dimming_rules_on_add_to_contacts (ModestWindow *win, gpointer user_data)
1411 {
1412         ModestDimmingRule *rule = NULL;
1413         gboolean dimmed = FALSE;
1414
1415         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
1416         rule = MODEST_DIMMING_RULE (user_data);
1417
1418         /* Check dimmed rule */
1419         if (!dimmed) {
1420                 GtkClipboard *clipboard = gtk_clipboard_get (GDK_SELECTION_PRIMARY);
1421                 gchar *selection = NULL;
1422                 selection = gtk_clipboard_wait_for_text (clipboard);
1423
1424                 dimmed = !((selection != NULL) && (modest_text_utils_validate_recipient (selection, NULL)));
1425         }
1426
1427         return dimmed;
1428 }
1429
1430 /* *********************** static utility functions ******************** */
1431
1432
1433 static gboolean
1434 _selected_folder_not_writeable (ModestMainWindow *win)
1435 {
1436         GtkWidget *folder_view = NULL;
1437         TnyFolderStore *parent_folder = NULL;
1438         ModestTnyFolderRules rules;
1439         gboolean result = FALSE;
1440
1441         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
1442
1443         /* Get folder view */
1444         folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
1445                                                            MODEST_WIDGET_TYPE_FOLDER_VIEW);
1446         /* If no folder view, always dimmed */
1447         if (!folder_view)
1448                 return TRUE;
1449
1450         /* Get selected folder as parent of new folder to create */
1451         parent_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
1452         if (!(parent_folder && TNY_IS_FOLDER(parent_folder))) {
1453                 if (parent_folder)
1454                         g_object_unref (parent_folder);
1455                 return TRUE;
1456         }
1457
1458         /* Check dimmed rule */
1459         rules = modest_tny_folder_get_rules (TNY_FOLDER (parent_folder));
1460         result = rules & MODEST_FOLDER_RULES_FOLDER_NON_WRITEABLE;
1461
1462         /* free */
1463         g_object_unref (parent_folder);
1464
1465         return result;
1466 }
1467
1468 static gboolean
1469 _selected_folder_is_root_or_inbox (ModestMainWindow *win)
1470 {
1471         TnyFolderType types[2];
1472         gboolean result = FALSE;
1473
1474         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
1475
1476         types[0] = TNY_FOLDER_TYPE_ROOT;
1477         types[1] = TNY_FOLDER_TYPE_INBOX;
1478
1479         /* Check folder type */
1480         result = _selected_folder_is_any_of_type (MODEST_WINDOW(win), types, 2);
1481
1482         /* Check pop and MMC accounts */
1483         if (!result) {
1484                 result = _selected_folder_is_MMC_or_POP_root (win);
1485         }
1486
1487         return result;
1488 }
1489
1490
1491 static gboolean
1492 _selected_folder_is_root (ModestMainWindow *win)
1493 {
1494         TnyFolderType types[1];
1495         gboolean result = FALSE;
1496
1497         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
1498
1499         /* All accounts are root items: */
1500         GtkWidget *folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
1501                                                            MODEST_WIDGET_TYPE_FOLDER_VIEW);
1502         if (folder_view) {
1503                 gboolean is_account = FALSE;
1504                 TnyFolderStore *folder_store =
1505                         modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
1506                 if (folder_store) {
1507                         is_account = TNY_IS_ACCOUNT (folder_store);
1508                         g_object_unref (folder_store);
1509                         folder_store = NULL;
1510                 }
1511
1512                 if (is_account)
1513                         return TRUE;
1514         }
1515
1516         /* Try something more precise: */
1517         types[0] = TNY_FOLDER_TYPE_ROOT;
1518
1519         /* Check folder type */
1520         result = _selected_folder_is_any_of_type (MODEST_WINDOW(win), types, 1);
1521
1522         /* Check pop and MMC accounts */
1523         if (!result) {
1524                 result = _selected_folder_is_MMC_or_POP_root (win);
1525         }
1526
1527         return result;
1528 }
1529
1530 static gboolean
1531 _selected_folder_is_MMC_or_POP_root (ModestMainWindow *win)
1532 {
1533         GtkWidget *folder_view = NULL;
1534         TnyFolderStore *parent_folder = NULL;
1535         gboolean result = FALSE;
1536
1537         folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
1538                                                            MODEST_WIDGET_TYPE_FOLDER_VIEW);
1539         /* Get selected folder as parent of new folder to create */
1540         parent_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
1541         if (!parent_folder)
1542                 return TRUE;
1543
1544         if (TNY_IS_ACCOUNT (parent_folder)) {
1545                 /* If it's the local account then do not dim */
1546                 if (modest_tny_account_is_virtual_local_folders (TNY_ACCOUNT (parent_folder))) {
1547                         result = FALSE;
1548                 } else {
1549                                 /* If it's the MMC root folder then dim it */
1550                         if (!strcmp (tny_account_get_id (TNY_ACCOUNT (parent_folder)), MODEST_MMC_ACCOUNT_ID)) {
1551                                         result = TRUE;
1552                         } else {
1553                                 const gchar *proto_str = tny_account_get_proto (TNY_ACCOUNT (parent_folder));
1554                                 /* If it's POP then dim */
1555                                 result = (modest_protocol_info_get_transport_store_protocol (proto_str) ==
1556                                                   MODEST_PROTOCOL_STORE_POP) ? TRUE : FALSE;
1557                         }
1558                 }
1559         }
1560         g_object_unref (parent_folder);
1561
1562         return result;
1563 }
1564
1565 static gboolean
1566 _header_view_is_all_selected (ModestMainWindow *win)
1567 {
1568         GtkTreeSelection *sel = NULL;
1569         GtkTreeModel *model = NULL;
1570         GtkTreeView *header_view = NULL;
1571         gint count_sel, count_model;
1572
1573         header_view = GTK_TREE_VIEW(modest_main_window_get_child_widget(
1574                         win, MODEST_WIDGET_TYPE_HEADER_VIEW));
1575         if(header_view == NULL)
1576                 return FALSE;
1577
1578         model = gtk_tree_view_get_model(header_view);
1579         if (model == NULL)
1580                 return FALSE;
1581
1582         sel = gtk_tree_view_get_selection(header_view);
1583         if (sel == NULL)
1584                 return FALSE;
1585
1586         /* check if all the headers are selected or not */
1587         count_sel = gtk_tree_selection_count_selected_rows (sel);
1588         count_model = gtk_tree_model_iter_n_children(model, NULL);
1589         if(count_sel == count_model != 0)
1590                 /*all header is selected*/
1591                 return TRUE;
1592
1593         return FALSE;
1594 }
1595
1596 static gboolean
1597 _selected_folder_is_empty (ModestMainWindow *win)
1598 {
1599         GtkWidget *folder_view = NULL;
1600         TnyFolderStore *folder = NULL;
1601         gboolean result = FALSE;
1602
1603         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
1604
1605         /* Get folder view */
1606         folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
1607                                                            MODEST_WIDGET_TYPE_FOLDER_VIEW);
1608         /* If no folder view, always dimmed */
1609         if (!folder_view)
1610                 return TRUE;
1611
1612         /* Get selected folder as parent of new folder to create */
1613         folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
1614         if (!(folder && TNY_IS_FOLDER(folder))) {
1615                 if (folder)
1616                         g_object_unref (folder);
1617                 return TRUE;
1618         }
1619
1620         /* Check folder type */
1621         result = tny_folder_get_all_count (TNY_FOLDER (folder)) == 0;
1622
1623         /* free */
1624         g_object_unref (folder);
1625
1626         return result;
1627 }
1628
1629 static gboolean
1630 _selected_folder_is_same_as_source (ModestWindow *win)
1631 {
1632         ModestEmailClipboard *clipboard = NULL;
1633         GtkWidget *folder_view = NULL;
1634         TnyFolderStore *folder = NULL;
1635         gboolean result = FALSE;
1636
1637         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
1638
1639         /* Get folder view */
1640         folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
1641                                                            MODEST_WIDGET_TYPE_FOLDER_VIEW);
1642         if (!folder_view)
1643                 return FALSE;
1644
1645         /* Get selected folder as destination folder */
1646         folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
1647         if (!(folder && TNY_IS_FOLDER(folder))) {
1648                 result = FALSE;
1649                 goto frees;
1650         }
1651
1652         /* Check clipboard is cleared */
1653         clipboard = modest_runtime_get_email_clipboard ();
1654         if (modest_email_clipboard_cleared (clipboard)) {
1655                 result = FALSE;
1656                 goto frees;
1657         }
1658
1659         /* Check source folder */
1660         result = modest_email_clipboard_check_source_folder (clipboard,
1661                                                              (const TnyFolder *) folder);
1662
1663         /* Free */
1664  frees:
1665         g_object_unref (folder);
1666
1667         return result;
1668 }
1669
1670 static gboolean
1671 _selected_folder_is_any_of_type (ModestWindow *win,
1672                                  TnyFolderType types[],
1673                                  guint ntypes)
1674 {
1675         GtkWidget *folder_view = NULL;
1676         TnyFolderStore *folder = NULL;
1677         TnyFolderType folder_type;
1678         guint i=0;
1679         gboolean result = FALSE;
1680
1681         /*Get current folder */
1682         if (MODEST_IS_MAIN_WINDOW(win)) {
1683
1684                 /* Get folder view */
1685                 folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
1686                                                                    MODEST_WIDGET_TYPE_FOLDER_VIEW);
1687                 /* If no folder view, always dimmed */
1688                 if (!folder_view)
1689                         return FALSE;
1690
1691                 /* Get selected folder as parent of new folder to create */
1692                 folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
1693
1694                 if (!(folder && TNY_IS_FOLDER(folder))) {
1695                         if (folder)
1696                                 g_object_unref (folder);
1697                         return FALSE;
1698                 }
1699
1700                 /* Check folder type */
1701                 result = _folder_is_any_of_type (TNY_FOLDER(folder), types, ntypes);
1702         }
1703         else if (MODEST_IS_MSG_VIEW_WINDOW(win)) {
1704                 folder_type = modest_msg_view_window_get_folder_type (MODEST_MSG_VIEW_WINDOW (win));
1705                 for (i=0; i < ntypes; i++) {
1706                         result = result || folder_type == types[i];
1707                 }
1708         }
1709
1710
1711         /* free */
1712         g_object_unref (folder);
1713
1714         return result;
1715 }
1716
1717 static gboolean
1718 _folder_is_any_of_type (TnyFolder *folder,
1719                         TnyFolderType types[],
1720                         guint ntypes)
1721 {
1722         TnyFolderType folder_type;
1723         gboolean result = FALSE;
1724         guint i;
1725
1726         g_return_val_if_fail (TNY_IS_FOLDER(folder), FALSE);
1727
1728         /* Get folder type */
1729         folder_type = modest_tny_folder_guess_folder_type (folder);
1730
1731         /* Check foler type */
1732         for (i=0; i < ntypes; i++) {
1733                 result = result || folder_type == types[i];
1734         }
1735
1736         return result;
1737 }
1738
1739 static gboolean
1740 _selected_folder_is_snd_level (ModestMainWindow *win)
1741 {
1742         GtkWidget *folder_view = NULL;
1743         GtkTreeSelection *sel = NULL;
1744         GtkTreeModel *model = NULL;
1745         GtkTreePath *path = NULL;
1746         GtkTreeIter iter;
1747         TnyFolderStore *folder = NULL;
1748         gboolean result = FALSE;
1749
1750         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), TRUE);
1751
1752         /*Get curent folder */
1753         folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
1754                                                            MODEST_WIDGET_TYPE_FOLDER_VIEW);
1755         /* If no folder view, always dimmed */
1756         if (!folder_view)
1757                 goto frees;
1758
1759         /* Get selected folder as parent of new folder to create */
1760         folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
1761         if (!(folder && TNY_IS_FOLDER(folder))) {
1762                 goto frees;
1763         }
1764
1765         /* Check folder level */
1766         sel = gtk_tree_view_get_selection (GTK_TREE_VIEW(folder_view));
1767         if (!gtk_tree_selection_get_selected (sel, &model, &iter))
1768                 goto frees;
1769         path = gtk_tree_model_get_path (model, &iter);
1770         result = gtk_tree_path_get_depth (path) > 2;
1771
1772  frees:
1773         if (folder != NULL)
1774                 g_object_unref (folder);
1775         if (path != NULL)
1776                 gtk_tree_path_free (path);
1777
1778         return result;
1779
1780 }
1781
1782 static gboolean
1783 _clipboard_is_empty (ModestWindow *win)
1784 {
1785         gboolean result = FALSE;
1786
1787         if (MODEST_IS_MAIN_WINDOW (win)) {
1788                 ModestEmailClipboard *clipboard = NULL;
1789                 clipboard = modest_runtime_get_email_clipboard ();
1790                 if (modest_email_clipboard_cleared (clipboard))
1791                  result = TRUE;
1792         }
1793
1794         return result;
1795 }
1796
1797 static gboolean
1798 _invalid_clipboard_selected (ModestWindow *win,
1799                        ModestDimmingRule *rule)
1800 {
1801         const DimmedState *state = NULL;
1802         gboolean result = FALSE;
1803
1804         g_return_val_if_fail (MODEST_IS_WINDOW(win), FALSE);
1805         state = modest_window_get_dimming_state (win);
1806
1807         if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
1808                 GtkClipboard *clipboard = NULL;
1809                 gchar *selection = NULL;
1810                 GtkWidget *focused = NULL;
1811
1812                 /* Get clipboard selection*/
1813                 clipboard = gtk_clipboard_get (GDK_SELECTION_PRIMARY);
1814                 selection = gtk_clipboard_wait_for_text (clipboard);
1815
1816                 /* Get focuesed widget */
1817                 focused = gtk_window_get_focus (GTK_WINDOW (win));
1818
1819                 /* Check dimming */
1820                 result = ((selection == NULL) ||
1821                           (MODEST_IS_ATTACHMENTS_VIEW (focused)));
1822
1823                 if (result)
1824                         modest_dimming_rule_set_notification (rule, "");
1825
1826                 if (selection != NULL)
1827                         g_free(selection);
1828         }
1829         else if (MODEST_IS_MAIN_WINDOW (win)) {
1830                 /* Check dimming */
1831                 result = state->n_selected == 0;
1832                 if (result)
1833                         modest_dimming_rule_set_notification (rule, _("mcen_ib_no_message_selected"));
1834         }
1835
1836         return result;
1837 }
1838
1839
1840 static gboolean
1841 _invalid_attach_selected (ModestWindow *win,
1842                           gboolean unique,
1843                           gboolean for_view,
1844                           gboolean for_remove,
1845                           ModestDimmingRule *rule)
1846 {
1847         GList *attachments, *node;
1848         gint n_selected;
1849         TnyHeaderFlags flags;
1850         gboolean nested_attachments = FALSE;
1851         gboolean selected_messages = FALSE;
1852         const DimmedState *state = NULL;
1853         gboolean result = FALSE;
1854
1855         g_return_val_if_fail (MODEST_IS_WINDOW(win), FALSE);
1856         state = modest_window_get_dimming_state (win);
1857
1858         if (MODEST_IS_MAIN_WINDOW (win)) {
1859                 flags = TNY_HEADER_FLAG_ATTACHMENTS;
1860                 if (!result)
1861                         result = !state->any_has_attachments;
1862         }
1863         else if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
1864
1865                 /* Get selected atachments */
1866                 attachments = modest_msg_view_window_get_attachments (MODEST_MSG_VIEW_WINDOW(win));
1867                 n_selected = g_list_length (attachments);
1868
1869                 /* Check unique */
1870                 if (!result) {
1871                         if (unique)
1872                                 result = n_selected != 1;
1873                         else
1874
1875                                 result = n_selected < 1;
1876                 }
1877
1878                 /* Check attached type (view operation not required) */
1879                 if (!result && !for_view)  {
1880                         for (node = attachments; node != NULL && !result; node = g_list_next (node)) {
1881                                 TnyMimePart *mime_part = TNY_MIME_PART (node->data);
1882                                 TnyList *nested_list = tny_simple_list_new ();
1883                                 if (!for_remove && TNY_IS_MSG (mime_part)) {
1884                                         selected_messages = TRUE;
1885                                         result = TRUE;
1886                                 }
1887                                 tny_mime_part_get_parts (mime_part, nested_list);
1888                                 if (!for_remove && tny_list_get_length (nested_list) > 0) {
1889                                         nested_attachments = TRUE;
1890                                         result = TRUE;
1891                                 }
1892                                 g_object_unref (nested_list);
1893                         }
1894                 }
1895
1896                 /* Set notifications */
1897                 if (result && rule != NULL) {
1898                         if (selected_messages) {
1899                                 modest_dimming_rule_set_notification (rule, _("mcen_ib_unable_to_save_attach_mail"));
1900                         } else if (nested_attachments) {
1901                                 modest_dimming_rule_set_notification (rule, _("FIXME:unable to save attachments with nested elements"));
1902                         } else if (n_selected == 0) {
1903                                 modest_dimming_rule_set_notification (rule, _("FIXME:no attachment selected"));
1904                         } else if (unique) {
1905                                 modest_dimming_rule_set_notification (rule, _("mcen_ib_unable_to_display_more"));
1906                         }
1907                 }
1908
1909                 /* Free */
1910                 g_list_free (attachments);
1911         }
1912
1913         return result;
1914 }
1915
1916 static gboolean
1917 _purged_attach_selected (ModestWindow *win, gboolean all, ModestDimmingRule *rule)
1918 {
1919         GList *attachments = NULL, *node;
1920         gint purged = 0;
1921         gint n_attachments = 0;
1922         gboolean result = FALSE;
1923
1924         /* This should check if _all_ the attachments are already purged. If only some
1925          * of them are purged, then it does not cause dim as there's a confirmation dialog
1926          * for removing only local attachments */
1927
1928         /* Get selected atachments */
1929         if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
1930                 attachments = modest_msg_view_window_get_attachments (MODEST_MSG_VIEW_WINDOW(win));
1931         } else if (MODEST_IS_MAIN_WINDOW (win)) {
1932                 /* If we're in main window, we won't know if there are already purged attachments */
1933                 return FALSE;
1934         }
1935
1936         if (attachments == NULL)
1937                 return FALSE;
1938
1939         for (node = attachments; node != NULL; node = g_list_next (node)) {
1940                 TnyMimePart *mime_part = TNY_MIME_PART (node->data);
1941                 if (tny_mime_part_is_purged (mime_part)) {
1942                         purged++;
1943                 }
1944                 n_attachments++;
1945         }
1946
1947         /* Free */
1948         g_list_free (attachments);
1949
1950         if (all)
1951                 result = (purged == n_attachments);
1952         else
1953                 result = (purged > 0);
1954
1955         if (result && (rule != NULL))
1956                 modest_dimming_rule_set_notification (rule, _("mail_ib_attachment_already_purged"));
1957
1958         return result;
1959 }
1960
1961 static gboolean
1962 _invalid_msg_selected (ModestMainWindow *win,
1963                        gboolean unique,
1964                        ModestDimmingRule *rule)
1965 {
1966         GtkWidget *folder_view = NULL;
1967         const DimmedState *state = NULL;
1968         gboolean result = FALSE;
1969
1970         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
1971         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (rule), FALSE);
1972         state = modest_window_get_dimming_state (MODEST_WINDOW(win));
1973
1974         /* Get folder view to check focus */
1975         folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
1976                                                            MODEST_WIDGET_TYPE_FOLDER_VIEW);
1977
1978         /* Check dimmed rule (TODO: check focus on widgets */
1979         if (!result) {
1980                 result = ((state->n_selected == 0 ) ||
1981                           (gtk_widget_is_focus (folder_view)));
1982                 if (result)
1983                         modest_dimming_rule_set_notification (rule, _("mcen_ib_no_message_selected"));
1984         }
1985         if (!result && unique) {
1986                 result = state->n_selected > 1;
1987                 if (result)
1988                         modest_dimming_rule_set_notification (rule, _("mcen_ib_select_one_message"));
1989         }
1990
1991         return result;
1992 }
1993
1994
1995 static gboolean
1996 _msg_download_in_progress (ModestMsgViewWindow *win)
1997 {
1998         gboolean result = FALSE;
1999
2000         g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW (win), FALSE);
2001
2002         result = modest_msg_view_window_toolbar_on_transfer_mode (win);
2003
2004         return result;
2005 }
2006
2007 static gboolean
2008 _msg_download_completed (ModestMainWindow *win)
2009 {
2010         const DimmedState *state = modest_window_get_dimming_state (MODEST_WINDOW(win));
2011         return state->any_marked_as_cached;
2012 }
2013
2014 static void
2015 fill_list_of_caches (gpointer key, gpointer value, gpointer userdata)
2016 {
2017         GSList **send_queues = (GSList **) userdata;
2018         *send_queues = g_slist_prepend (*send_queues, value);
2019 }
2020
2021 static gboolean
2022 _selected_msg_sent_in_progress (ModestWindow *win)
2023 {
2024         const DimmedState *state = modest_window_get_dimming_state (win);
2025         return state->sent_in_progress;
2026 }
2027
2028
2029 static gboolean
2030 _sending_in_progress (ModestWindow *win)
2031 {
2032         gboolean result = FALSE;
2033
2034         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW (win), FALSE);
2035
2036         /* Check if send operation is in progress */
2037         result = modest_main_window_send_receive_in_progress (MODEST_MAIN_WINDOW (win));
2038
2039         return result;
2040 }
2041
2042 static gboolean
2043 _invalid_folder_for_purge (ModestWindow *win,
2044                            ModestDimmingRule *rule)
2045 {
2046         TnyMsg *msg = NULL;
2047         TnyFolder *folder = NULL;
2048         TnyAccount *account = NULL;
2049         gboolean result = FALSE;
2050
2051         if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
2052
2053                 /* Get folder and account of message */
2054                 msg = modest_msg_view_window_get_message (MODEST_MSG_VIEW_WINDOW (win));
2055                 g_return_val_if_fail(msg != NULL, TRUE);
2056                 folder = tny_msg_get_folder (msg);
2057                 if (folder == NULL) {
2058                         modest_dimming_rule_set_notification (rule, _("mail_ib_unable_to_purge_attachments"));
2059                         goto frees;
2060                 }
2061                 g_object_unref (msg);
2062         } else if (MODEST_IS_MAIN_WINDOW (win)) {
2063                 GtkWidget *folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
2064                                                                               MODEST_WIDGET_TYPE_FOLDER_VIEW);
2065                 if (!folder_view)
2066                         return FALSE;
2067                 folder = TNY_FOLDER (modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view)));
2068                 if (folder == NULL || ! TNY_IS_FOLDER (folder))
2069                         goto frees;
2070         } else {
2071                 g_return_val_if_reached (FALSE);
2072         }
2073         account = modest_tny_folder_get_account (folder);
2074         if (account == NULL) goto frees;
2075
2076         /* Check account */
2077         if (modest_tny_account_is_virtual_local_folders (TNY_ACCOUNT (account))) {
2078                 TnyFolderType types[2];
2079                 types[0] = TNY_FOLDER_TYPE_DRAFTS;
2080                 types[1] = TNY_FOLDER_TYPE_OUTBOX;
2081
2082                 if (_selected_folder_is_any_of_type (win, types, 2)) {
2083                         result = TRUE;
2084                         modest_dimming_rule_set_notification (rule, _("mail_ib_unable_to_purge_editable_msg"));
2085                 } else {
2086                         /* We're currently disabling purge in any local store */
2087                         result = TRUE;
2088                         modest_dimming_rule_set_notification (rule, _("mail_ib_unable_to_purge_attachments"));
2089                 }
2090         } else {
2091                 const gchar *proto_str = tny_account_get_proto (TNY_ACCOUNT (account));
2092                 /* If it's POP then dim */
2093                 if (modest_protocol_info_get_transport_store_protocol (proto_str) ==
2094                     MODEST_PROTOCOL_STORE_POP) {
2095                         GList *attachments = NULL;
2096                         gint n_selected = 0;
2097                         result = TRUE;
2098
2099                         /* TODO: This check is here to prevent a gwarning, but this looks like a logic error.
2100                          * murrayc */
2101                         if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
2102                                 attachments = modest_msg_view_window_get_attachments (MODEST_MSG_VIEW_WINDOW(win));
2103                                 n_selected = g_list_length (attachments);
2104                                 g_list_free (attachments);
2105                         }
2106
2107                         modest_dimming_rule_set_notification (rule,
2108                                                               ngettext ("mail_ib_unable_to_pure_attach_pop_mail_singular",
2109                                                                         "mail_ib_unable_to_pure_attach_pop_mail_plural",
2110                                                                         n_selected));
2111                 }
2112         }
2113
2114 frees:
2115         if (folder != NULL)
2116                 g_object_unref (folder);
2117         if (account != NULL)
2118                 g_object_unref (account);
2119
2120         return result;
2121 }
2122
2123 static gboolean
2124 _transfer_mode_enabled (ModestWindow *win)
2125 {
2126         gboolean result = FALSE;
2127
2128         /* Check dimming */
2129         if (MODEST_IS_MSG_VIEW_WINDOW(win)) {
2130                 result = modest_msg_view_window_transfer_mode_enabled (MODEST_MSG_VIEW_WINDOW (win));
2131         } else if (MODEST_IS_MAIN_WINDOW(win)) {
2132                 result = modest_main_window_transfer_mode_enabled (MODEST_MAIN_WINDOW (win));
2133         } else {
2134                 g_warning("_transfer_mode_enabled called with wrong window type");
2135         }
2136
2137         return result;
2138 }
2139