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