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-text-utils.h"
  39 #include <widgets/modest-attachments-view.h>
  40 #include <modest-runtime.h>
  41 #include <tny-simple-list.h>
  42
  43
  44 static gboolean _folder_is_any_of_type (TnyFolder *folder, TnyFolderType types[], guint ntypes);
  45 static gboolean _invalid_msg_selected (ModestMainWindow *win, gboolean unique, ModestDimmingRule *rule);
  46 static gboolean _invalid_attach_selected (ModestWindow *win, gboolean unique, gboolean for_view, ModestDimmingRule *rule);
  47 static gboolean _invalid_clipboard_selected (ModestWindow *win);
  48 static gboolean _already_opened_msg (ModestWindow *win, guint *n_messages);
  49 static gboolean _selected_msg_marked_as (ModestWindow *win, TnyHeaderFlags mask, gboolean opposite);
  50 static gboolean _selected_folder_not_writeable (ModestMainWindow *win);
  51 static gboolean _selected_folder_is_any_of_type (ModestWindow *win, TnyFolderType types[], guint ntypes);
  52 static gboolean _selected_folder_is_root_or_inbox (ModestMainWindow *win);
  53 static gboolean _selected_folder_is_MMC_or_POP_root (ModestMainWindow *win);
  54 static gboolean _selected_folder_is_root (ModestMainWindow *win);
  55 static gboolean _selected_folder_is_empty (ModestMainWindow *win);
  56 static gboolean _selected_folder_is_same_as_source (ModestWindow *win);
  57 static gboolean _msg_download_in_progress (ModestMsgViewWindow *win);
  58 static gboolean _msg_download_completed (ModestMainWindow *win);
  59 static gboolean _selected_msg_sent_in_progress (ModestWindow *win);
  60 static gboolean _sending_in_progress (ModestWindow *win);
  61 static gboolean _marked_as_deleted (ModestWindow *win);
  62 static gboolean _invalid_attachment_for_purge (ModestWindow *win, ModestDimmingRule *rule);
  63
  64
  65 gboolean
  66 modest_ui_dimming_rules_on_new_msg (ModestWindow *win, gpointer user_data)
  67 {
  68         gboolean dimmed = FALSE;
  69
  70         g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW(win), FALSE);
  71
  72         /* Check dimmed rule */
  73         if (!dimmed)
  74                 dimmed = _msg_download_in_progress (MODEST_MSG_VIEW_WINDOW(win));
  75
  76         return dimmed;
  77 }
  78
  79 gboolean
  80 modest_ui_dimming_rules_on_new_folder (ModestWindow *win, gpointer user_data)
  81 {
  82         gboolean dimmed = FALSE;
  83         GtkWidget *folder_view = NULL;
  84         TnyFolderStore *parent_folder = NULL;
  85
  86         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
  87
  88
  89         folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
  90                                                            MODEST_WIDGET_TYPE_FOLDER_VIEW);
  91         /* Get selected folder as parent of new folder to create */
  92         parent_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
  93         if (!parent_folder)
  94                 return TRUE;
  95
  96         if (TNY_IS_ACCOUNT (parent_folder)) {
  97                 /* If it's the local account then do not dim */
  98                 if (modest_tny_account_is_virtual_local_folders (TNY_ACCOUNT (parent_folder))) {
  99                         dimmed = FALSE;
 100                 } else {
 101                         const gchar *proto_str = tny_account_get_proto (TNY_ACCOUNT (parent_folder));
 102                         /* If it's POP then dim */
 103                         dimmed = (modest_protocol_info_get_transport_store_protocol (proto_str) ==
 104                                   MODEST_PROTOCOL_STORE_POP) ? TRUE : FALSE;
 105                 }
 106         } else {
 107                 /* TODO: the specs say that only one level of subfolder is allowed, is this true ? */
 108
 109                 TnyFolderType types[3];
 110
 111                 types[0] = TNY_FOLDER_TYPE_DRAFTS;
 112                 types[1] = TNY_FOLDER_TYPE_OUTBOX;
 113                 types[2] = TNY_FOLDER_TYPE_SENT;
 114
 115                 /* Apply folder rules */
 116                 if (!dimmed)
 117                         dimmed = _selected_folder_not_writeable (MODEST_MAIN_WINDOW(win));
 118                 if (!dimmed)
 119                         dimmed = _selected_folder_is_any_of_type (win, types, 3);
 120         }
 121         g_object_unref (parent_folder);
 122
 123         return dimmed;
 124 }
 125
 126 gboolean
 127 modest_ui_dimming_rules_on_delete_folder (ModestWindow *win, gpointer user_data)
 128 {
 129         gboolean dimmed = FALSE;
 130         TnyFolderType types[5];
 131
 132         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
 133
 134         types[0] = TNY_FOLDER_TYPE_DRAFTS;
 135         types[1] = TNY_FOLDER_TYPE_OUTBOX;
 136         types[2] = TNY_FOLDER_TYPE_SENT;
 137         types[3] = TNY_FOLDER_TYPE_INBOX;
 138         types[4] = TNY_FOLDER_TYPE_ROOT;
 139
 140         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
 141
 142         /* Check dimmed rule */
 143         if (!dimmed)
 144                 dimmed = _selected_folder_not_writeable (MODEST_MAIN_WINDOW(win));
 145         if (!dimmed)
 146                 dimmed = _selected_folder_is_any_of_type (win, types, 5);
 147         if (!dimmed)
 148                 dimmed = _selected_folder_is_root_or_inbox (MODEST_MAIN_WINDOW(win));
 149         if (!dimmed)
 150                 dimmed = _selected_folder_is_MMC_or_POP_root (MODEST_MAIN_WINDOW(win));
 151
 152         return dimmed;
 153 }
 154
 155 gboolean
 156 modest_ui_dimming_rules_on_sort (ModestWindow *win, gpointer user_data)
 157 {
 158         gboolean dimmed = FALSE;
 159
 160         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
 161
 162         /* Check dimmed rule */
 163         if (!dimmed)
 164                 dimmed = _selected_folder_is_root (MODEST_MAIN_WINDOW(win));
 165
 166         return dimmed;
 167
 168 }
 169
 170 gboolean
 171 modest_ui_dimming_rules_on_rename_folder (ModestWindow *win, gpointer user_data)
 172 {
 173         gboolean dimmed = FALSE;
 174         TnyFolderType types[3];
 175
 176         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
 177
 178         types[0] = TNY_FOLDER_TYPE_DRAFTS;
 179         types[1] = TNY_FOLDER_TYPE_OUTBOX;
 180         types[2] = TNY_FOLDER_TYPE_SENT;
 181
 182         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
 183
 184         /* Check dimmed rule */
 185         if (!dimmed)
 186                 dimmed = _selected_folder_not_writeable (MODEST_MAIN_WINDOW(win));
 187         if (!dimmed)
 188                 dimmed = _selected_folder_is_root_or_inbox (MODEST_MAIN_WINDOW(win));
 189         if (!dimmed)
 190                 dimmed = _selected_folder_is_any_of_type (win, types, 3);
 191
 192         return dimmed;
 193 }
 194
 195 gboolean
 196 modest_ui_dimming_rules_on_open_msg (ModestWindow *win, gpointer user_data)
 197 {
 198         ModestDimmingRule *rule = NULL;
 199         gboolean dimmed = FALSE;
 200
 201         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
 202         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 203         rule = MODEST_DIMMING_RULE (user_data);
 204
 205         /* Check dimmed rule */
 206         if (!dimmed)
 207                 dimmed = _invalid_msg_selected (MODEST_MAIN_WINDOW(win), TRUE, user_data);
 208         if (!dimmed) {
 209                 dimmed = _selected_msg_sent_in_progress (win);
 210                 if (dimmed)
 211                         modest_dimming_rule_set_notification (rule, _("mcen_ib_unable_to_open_while_sent"));
 212         }
 213
 214         return dimmed;
 215 }
 216
 217 gboolean
 218 modest_ui_dimming_rules_on_reply_msg (ModestWindow *win, gpointer user_data)
 219 {
 220         ModestDimmingRule *rule = NULL;
 221         gboolean dimmed = FALSE;
 222         TnyFolderType types[3];
 223
 224         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 225         rule = MODEST_DIMMING_RULE (user_data);
 226
 227         /* main window dimming rules */
 228         if (MODEST_IS_MAIN_WINDOW(win)) {
 229
 230                 types[0] = TNY_FOLDER_TYPE_DRAFTS;
 231                 types[1] = TNY_FOLDER_TYPE_OUTBOX;
 232                 types[2] = TNY_FOLDER_TYPE_ROOT;
 233
 234                 /* Check dimmed rule */
 235                 if (!dimmed) {
 236                         dimmed = _selected_folder_is_any_of_type (win, types, 3);
 237                         if (dimmed)
 238                                 modest_dimming_rule_set_notification (rule, _("mcen_ib_unable_to_reply"));
 239                 }
 240                 if (!dimmed) {
 241                         dimmed = _selected_folder_is_empty (MODEST_MAIN_WINDOW(win));
 242                         if (dimmed)
 243                                 modest_dimming_rule_set_notification (rule, _("mcen_ib_nothing_to_reply"));
 244                 }
 245                 if (!dimmed)
 246                         dimmed = _invalid_msg_selected (MODEST_MAIN_WINDOW(win), TRUE, rule);
 247
 248         /* msg view window dimming rules */
 249         } else if (MODEST_IS_MSG_VIEW_WINDOW(win)) {
 250
 251                 /* Check dimmed rule */
 252                 if (!dimmed)
 253                         dimmed = _msg_download_in_progress (MODEST_MSG_VIEW_WINDOW(win));
 254         }
 255
 256         return dimmed;
 257 }
 258
 259
 260 gboolean
 261 modest_ui_dimming_rules_on_contents_msg (ModestWindow *win, gpointer user_data)
 262 {
 263         gboolean dimmed = FALSE;
 264
 265         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
 266
 267         /* Check dimmed rule */
 268         if (!dimmed)
 269                 dimmed = _invalid_msg_selected (MODEST_MAIN_WINDOW(win), FALSE, user_data);
 270         if (!dimmed)
 271                 dimmed = _msg_download_completed (MODEST_MAIN_WINDOW(win));
 272
 273         return dimmed;
 274 }
 275
 276 gboolean
 277 modest_ui_dimming_rules_always_dimmed (ModestWindow *win, gpointer user_data)
 278 {
 279         gboolean dimmed = FALSE;
 280
 281         g_return_val_if_fail (MODEST_IS_WINDOW(win), FALSE);
 282
 283         /* Check dimmed rule */
 284         if (!dimmed)
 285                 dimmed = TRUE;
 286
 287         return dimmed;
 288 }
 289
 290 gboolean
 291 modest_ui_dimming_rules_on_delete_msg (ModestWindow *win, gpointer user_data)
 292 {
 293         ModestDimmingRule *rule = NULL;
 294         guint n_messages = 0;
 295         gboolean dimmed = FALSE;
 296
 297         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 298         rule = MODEST_DIMMING_RULE (user_data);
 299
 300         /* Check dimmed rule */
 301         if (MODEST_IS_MAIN_WINDOW (win)) {
 302                 if (!dimmed) {
 303                         dimmed = _selected_folder_is_empty (MODEST_MAIN_WINDOW(win));
 304                         if (dimmed)
 305                                 modest_dimming_rule_set_notification (rule, _CS("ckct_ib_nothing_to_delete"));
 306                 }
 307                 if (!dimmed) {
 308                         dimmed = _invalid_msg_selected (MODEST_MAIN_WINDOW(win), FALSE, user_data);
 309                         if (dimmed)
 310                                 modest_dimming_rule_set_notification (rule, _("mcen_ib_no_message_selected"));
 311                 }
 312                 if (!dimmed) {
 313                         dimmed = _already_opened_msg (win, &n_messages);
 314                         if (dimmed) {
 315                                 gchar *num = g_strdup_printf ("%d", n_messages);
 316                                 gchar *message = g_strdup_printf(_("mcen_nc_unable_to_delete_n_messages"), n_messages);
 317                                 modest_dimming_rule_set_notification (rule, message);
 318                                 g_free(message);
 319                                 g_free(num);
 320                         }
 321                 }
 322                 if (!dimmed) {
 323                         dimmed = _marked_as_deleted (win);
 324                         if (dimmed)
 325                                 modest_dimming_rule_set_notification (rule, _("mcen_ib_message_unableto_delete"));
 326                 }
 327                 if (!dimmed) {
 328                         dimmed = _selected_msg_sent_in_progress (win);
 329                         if (dimmed)
 330                                 modest_dimming_rule_set_notification (rule, _("mcen_ib_message_unableto_delete"));
 331                 }
 332         }
 333         else if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
 334                 if (!dimmed) {
 335                         dimmed = !modest_msg_view_window_has_headers_model (MODEST_MSG_VIEW_WINDOW(win));
 336                         if (dimmed) {
 337                                 gchar *message = g_strdup_printf(_("mcen_nc_unable_to_delete_n_messages"), "1");
 338                                 modest_dimming_rule_set_notification (rule, message);
 339                                 g_free(message);
 340                         }
 341                 }
 342         }
 343
 344         return dimmed;
 345 }
 346
 347 gboolean
 348 modest_ui_dimming_rules_on_details (ModestWindow *win, gpointer user_data)
 349 {
 350         gboolean dimmed = FALSE;
 351         GtkWidget *header_view = NULL;
 352
 353         /* main window dimming rules */
 354         if (MODEST_IS_MAIN_WINDOW(win)) {
 355
 356                 /* Check dimmed rule */
 357                 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
 358                                                                    MODEST_WIDGET_TYPE_HEADER_VIEW);
 359
 360                 /* If the header view has the focus: */
 361                 if (header_view && gtk_widget_is_focus (header_view)) {
 362                         /* Check dimmed rule */
 363                         if (!dimmed)
 364                                 dimmed = _invalid_msg_selected (MODEST_MAIN_WINDOW(win), TRUE, user_data);
 365                 }
 366                 else {
 367                         /* If the folder view has the focus: */
 368                         GtkWidget *folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
 369                                 MODEST_WIDGET_TYPE_FOLDER_VIEW);
 370                         if (folder_view && gtk_widget_is_focus (folder_view)) {
 371                                 TnyFolderStore *folder_store
 372                                         = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
 373                                 if (folder_store) {
 374                                         /* Only enable for folders, not accounts,
 375                                          * though the UI spec is not clear about that.
 376                                          * If we enable this for accounts then we must
 377                                          * add code to handle them in modest_ui_actions_on_details(). */
 378                                         if (!TNY_IS_FOLDER(folder_store))
 379                                                 dimmed = TRUE;
 380
 381                                         g_object_unref (folder_store);
 382                                 }
 383                         }
 384
 385                 }
 386
 387         /* msg view window dimming rules */
 388         } else {
 389
 390                 /* Check dimmed rule */
 391                 if (!dimmed)
 392                         dimmed = _msg_download_in_progress (MODEST_MSG_VIEW_WINDOW(win));
 393         }
 394
 395         return dimmed;
 396 }
 397
 398
 399 gboolean
 400 modest_ui_dimming_rules_on_mark_as_read_msg (ModestWindow *win, gpointer user_data)
 401 {
 402         gboolean dimmed = FALSE;
 403         TnyHeaderFlags flags;
 404
 405         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
 406
 407         flags = TNY_HEADER_FLAG_SEEN;
 408
 409         /* Check dimmed rule */
 410         if (!dimmed)
 411                 dimmed = _invalid_msg_selected (MODEST_MAIN_WINDOW(win), FALSE, user_data);
 412         if (!dimmed)
 413                 dimmed = _selected_msg_marked_as (win, flags, FALSE);
 414
 415         return dimmed;
 416 }
 417
 418 gboolean
 419 modest_ui_dimming_rules_on_mark_as_unread_msg (ModestWindow *win, gpointer user_data)
 420 {
 421         gboolean dimmed = FALSE;
 422         TnyHeaderFlags flags;
 423
 424         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
 425
 426         flags = TNY_HEADER_FLAG_SEEN;
 427
 428         /* Check dimmed rule */
 429         if (!dimmed)
 430                 dimmed = _invalid_msg_selected (MODEST_MAIN_WINDOW(win), FALSE, user_data);
 431         if (!dimmed)
 432                 dimmed = _selected_msg_marked_as (win, flags, TRUE);
 433
 434         return dimmed;
 435 }
 436
 437 gboolean
 438 modest_ui_dimming_rules_on_move_to (ModestWindow *win, gpointer user_data)
 439 {
 440         gboolean dimmed = FALSE;
 441
 442         if (MODEST_IS_MAIN_WINDOW (win))
 443                 dimmed = modest_ui_dimming_rules_on_main_window_move_to (win, user_data);
 444         else if (MODEST_IS_MSG_VIEW_WINDOW (win))
 445                  dimmed = modest_ui_dimming_rules_on_view_window_move_to (win, user_data);
 446
 447         return dimmed;
 448 }
 449
 450
 451 gboolean
 452 modest_ui_dimming_rules_on_main_window_move_to (ModestWindow *win, gpointer user_data)
 453 {
 454         GtkWidget *folder_view = NULL;
 455         GtkWidget *header_view = NULL;
 456         ModestDimmingRule *rule = NULL;
 457         const gchar *message = NULL;
 458         gboolean dimmed = FALSE;
 459
 460         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), TRUE);
 461         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 462         rule = MODEST_DIMMING_RULE (user_data);
 463
 464         /* Get the folder view */
 465         folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
 466                                                            MODEST_WIDGET_TYPE_FOLDER_VIEW);
 467
 468         /* Get header view */
 469         header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
 470                                                            MODEST_WIDGET_TYPE_HEADER_VIEW);
 471
 472         /* Check diming rules for folders and messages transfer  */
 473         if (!dimmed) {
 474                 dimmed = _selected_folder_not_writeable(MODEST_MAIN_WINDOW(win));
 475                 if (dimmed) {
 476                         if (gtk_widget_is_focus (folder_view))
 477                                 message = _("mail_in_ui_folder_move_target_error");
 478                         else
 479                                 message = ngettext ("mail_in_ui_folder_move_target_error", "mail_in_ui_folder_move_targets_error",
 480                                                     modest_header_view_count_selected_headers (MODEST_HEADER_VIEW(header_view)) > 1);
 481                 }
 482         }
 483         if (!dimmed) {
 484                 dimmed = _invalid_msg_selected (MODEST_MAIN_WINDOW(win), FALSE, user_data);
 485
 486         }
 487
 488         return dimmed;
 489 }
 490
 491 gboolean
 492 modest_ui_dimming_rules_on_view_window_move_to (ModestWindow *win, gpointer user_data)
 493 {
 494         ModestDimmingRule *rule = NULL;
 495         gboolean dimmed = FALSE;
 496
 497         g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW(win), FALSE);
 498         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 499         rule = MODEST_DIMMING_RULE (user_data);
 500
 501         /* Check dimmed rule */
 502         if (!dimmed) {
 503                 dimmed = !modest_msg_view_window_has_headers_model (MODEST_MSG_VIEW_WINDOW(win));
 504                 if (dimmed)
 505                         modest_dimming_rule_set_notification (rule, _("mcen_ib_unable_to_move_mail_attachment"));
 506
 507         }
 508
 509         return dimmed;
 510 }
 511
 512 gboolean
 513 modest_ui_dimming_rules_on_paste_msgs (ModestWindow *win, gpointer user_data)
 514 {
 515         ModestDimmingRule *rule = NULL;
 516         TnyFolderType types[3];
 517         gboolean dimmed = FALSE;
 518
 519         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
 520         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 521         rule = MODEST_DIMMING_RULE (user_data);
 522
 523         types[0] = TNY_FOLDER_TYPE_DRAFTS;
 524         types[1] = TNY_FOLDER_TYPE_OUTBOX;
 525         types[2] = TNY_FOLDER_TYPE_SENT;
 526
 527         /* Check dimmed rule */
 528         if (!dimmed)
 529                 dimmed = _invalid_clipboard_selected (win);
 530         if (!dimmed)
 531                 dimmed = _selected_folder_is_any_of_type (win, types, 3);
 532         if (!dimmed) {
 533                 dimmed = _selected_folder_is_same_as_source (win);
 534                 if (dimmed)
 535                         modest_dimming_rule_set_notification (rule, _("mcen_ib_unable_to_copy_samefolder"));
 536         }
 537
 538         return dimmed;
 539 }
 540
 541
 542 gboolean
 543 modest_ui_dimming_rules_on_select_all (ModestWindow *win, gpointer user_data)
 544 {
 545         ModestDimmingRule *rule = NULL;
 546         gboolean dimmed = FALSE;
 547
 548         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
 549         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 550         rule = MODEST_DIMMING_RULE (user_data);
 551
 552         /* Check dimmed rule */
 553         if (!dimmed)
 554                 dimmed = _selected_folder_is_empty (MODEST_MAIN_WINDOW(win));
 555
 556         return dimmed;
 557 }
 558
 559 gboolean
 560 modest_ui_dimming_rules_on_view_attachments (ModestWindow *win, gpointer user_data)
 561 {
 562         ModestDimmingRule *rule = NULL;
 563         gboolean dimmed = FALSE;
 564
 565         g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW(win), FALSE);
 566         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 567         rule = MODEST_DIMMING_RULE (user_data);
 568
 569         /* Check dimmed rule */
 570         if (!dimmed)
 571                 dimmed = _invalid_attach_selected (win, TRUE, TRUE, rule);
 572
 573         return dimmed;
 574 }
 575
 576 gboolean
 577 modest_ui_dimming_rules_on_save_attachments (ModestWindow *win, gpointer user_data)
 578 {
 579         ModestDimmingRule *rule = NULL;
 580         gboolean dimmed = FALSE;
 581
 582         g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW(win), FALSE);
 583         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 584         rule = MODEST_DIMMING_RULE (user_data);
 585
 586         /* Check dimmed rule */
 587         if (!dimmed)
 588                 dimmed = _invalid_attach_selected (win, FALSE, FALSE, rule);
 589
 590         return dimmed;
 591 }
 592
 593 gboolean
 594 modest_ui_dimming_rules_on_remove_attachments (ModestWindow *win, gpointer user_data)
 595 {
 596         ModestDimmingRule *rule = NULL;
 597         gboolean dimmed = FALSE;
 598
 599         g_return_val_if_fail (MODEST_IS_WINDOW(win), FALSE);
 600         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 601         rule = MODEST_DIMMING_RULE (user_data);
 602
 603         /* Check dimmed rule */
 604         if (!dimmed) {
 605                 dimmed = _invalid_attach_selected (win, TRUE, TRUE, rule);
 606         }
 607         if (!dimmed) {
 608                 dimmed = _invalid_attachment_for_purge (win, rule);
 609         }
 610
 611
 612         return dimmed;
 613 }
 614
 615 gboolean
 616 modest_ui_dimming_rules_on_copy (ModestWindow *win, gpointer user_data)
 617 {
 618         gboolean dimmed = FALSE;
 619
 620         g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW(win), FALSE);
 621
 622         /* Check dimmed rule */
 623         if (!dimmed)
 624                 dimmed = _invalid_clipboard_selected (win);
 625
 626         return dimmed;
 627 }
 628
 629 gboolean
 630 modest_ui_dimming_rules_on_view_previous (ModestWindow *win, gpointer user_data)
 631 {
 632         gboolean dimmed = FALSE;
 633
 634         g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW(win), FALSE);
 635
 636         /* Check dimmed rule */
 637         if (!dimmed)
 638                 dimmed = modest_msg_view_window_first_message_selected (MODEST_MSG_VIEW_WINDOW(win));
 639
 640         return dimmed;
 641 }
 642
 643 gboolean
 644 modest_ui_dimming_rules_on_view_next (ModestWindow *win, gpointer user_data)
 645 {
 646         gboolean dimmed = FALSE;
 647
 648         g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW(win), FALSE);
 649
 650         /* Check dimmed rule */
 651         if (!dimmed)
 652                 dimmed = modest_msg_view_window_last_message_selected (MODEST_MSG_VIEW_WINDOW(win));
 653
 654         return dimmed;
 655 }
 656
 657
 658 gboolean
 659 modest_ui_dimming_rules_on_tools_smtp_servers (ModestWindow *win, gpointer user_data)
 660 {
 661         const gboolean dimmed =
 662                 !modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(),
 663                         TRUE);
 664
 665         return dimmed;
 666 }
 667
 668 gboolean
 669 modest_ui_dimming_rules_on_cancel_sending (ModestWindow *win, gpointer user_data)
 670 {
 671         gboolean dimmed = FALSE;
 672
 673         /* Check dimmed rule */
 674         if (!dimmed)
 675                 dimmed = !_sending_in_progress (win);
 676
 677         return dimmed;
 678 }
 679
 680 gboolean
 681 modest_ui_dimming_rules_on_send_receive (ModestWindow *win, gpointer user_data)
 682 {
 683         ModestDimmingRule *rule = NULL;
 684         gboolean dimmed = FALSE;
 685
 686         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 687         rule = MODEST_DIMMING_RULE (user_data);
 688
 689         /* Check dimmed rule */
 690         if (!dimmed) {
 691                 dimmed = !modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(),
 692                                                           TRUE);
 693                 if (dimmed)
 694                         modest_dimming_rule_set_notification (rule, _("mcen_nc_no_email_acnts_defined"));
 695         }
 696
 697         return dimmed;
 698 }
 699
 700 gboolean
 701 modest_ui_dimming_rules_on_add_to_contacts (ModestWindow *win, gpointer user_data)
 702 {
 703         ModestDimmingRule *rule = NULL;
 704         gboolean dimmed = FALSE;
 705
 706         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 707         rule = MODEST_DIMMING_RULE (user_data);
 708
 709         /* Check dimmed rule */
 710         if (!dimmed) {
 711                 GtkClipboard *clipboard = gtk_clipboard_get (GDK_SELECTION_PRIMARY);
 712                 gchar *selection = NULL;
 713                 selection = gtk_clipboard_wait_for_text (clipboard);
 714
 715                 dimmed = !((selection != NULL) && (modest_text_utils_validate_recipient (selection)));
 716         }
 717
 718         return dimmed;
 719 }
 720
 721 /* *********************** static utility functions ******************** */
 722
 723 static gboolean
 724 _marked_as_deleted (ModestWindow *win)
 725 {
 726         gboolean result = FALSE;
 727         TnyHeaderFlags flags;
 728
 729         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
 730
 731         flags = TNY_HEADER_FLAG_DELETED;
 732
 733         /* Check dimmed rule */
 734         result = _selected_msg_marked_as (win, flags, FALSE);
 735
 736         return result;
 737 }
 738
 739 static gboolean
 740 _selected_folder_not_writeable (ModestMainWindow *win)
 741 {
 742         GtkWidget *folder_view = NULL;
 743         TnyFolderStore *parent_folder = NULL;
 744         ModestTnyFolderRules rules;
 745         gboolean result = FALSE;
 746
 747         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
 748
 749         /* Get folder view */
 750         folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
 751                                                            MODEST_WIDGET_TYPE_FOLDER_VIEW);
 752         /* If no folder view, always dimmed */
 753         if (!folder_view)
 754                 return TRUE;
 755
 756         /* Get selected folder as parent of new folder to create */
 757         parent_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
 758         if (!(parent_folder && TNY_IS_FOLDER(parent_folder))) {
 759                 if (parent_folder)
 760                         g_object_unref (parent_folder);
 761                 return TRUE;
 762         }
 763
 764         /* Check dimmed rule */
 765         rules = modest_tny_folder_get_rules (TNY_FOLDER (parent_folder));
 766         result = rules & MODEST_FOLDER_RULES_FOLDER_NON_WRITEABLE;
 767
 768         /* free */
 769         g_object_unref (parent_folder);
 770
 771         return result;
 772 }
 773
 774 static gboolean
 775 _selected_folder_is_root_or_inbox (ModestMainWindow *win)
 776 {
 777         TnyFolderType types[2];
 778         gboolean result = FALSE;
 779
 780         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
 781
 782         types[0] = TNY_FOLDER_TYPE_ROOT;
 783         types[1] = TNY_FOLDER_TYPE_INBOX;
 784
 785         /* Check folder type */
 786         result = _selected_folder_is_any_of_type (MODEST_WINDOW(win), types, 2);
 787
 788         /* Check pop and MMC accounts */
 789         if (!result) {
 790                 result = _selected_folder_is_MMC_or_POP_root (win);
 791         }
 792
 793         return result;
 794 }
 795
 796
 797 static gboolean
 798 _selected_folder_is_root (ModestMainWindow *win)
 799 {
 800         TnyFolderType types[1];
 801         gboolean result = FALSE;
 802
 803         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
 804
 805         types[0] = TNY_FOLDER_TYPE_ROOT;
 806
 807         /* Check folder type */
 808         result = _selected_folder_is_any_of_type (MODEST_WINDOW(win), types, 1);
 809
 810         /* Check pop and MMC accounts */
 811         if (!result) {
 812                 result = _selected_folder_is_MMC_or_POP_root (win);
 813         }
 814
 815         return result;
 816 }
 817
 818 static gboolean
 819 _selected_folder_is_MMC_or_POP_root (ModestMainWindow *win)
 820 {
 821         GtkWidget *folder_view = NULL;
 822         TnyFolderStore *parent_folder = NULL;
 823         gboolean result = FALSE;
 824
 825         folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
 826                                                            MODEST_WIDGET_TYPE_FOLDER_VIEW);
 827         /* Get selected folder as parent of new folder to create */
 828         parent_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
 829         if (!parent_folder)
 830                 return TRUE;
 831
 832         if (TNY_IS_ACCOUNT (parent_folder)) {
 833                 /* If it's the local account then do not dim */
 834                 if (modest_tny_account_is_virtual_local_folders (TNY_ACCOUNT (parent_folder))) {
 835                         result = FALSE;
 836                 } else {
 837                                 /* If it's the MMC root folder then dim it */
 838                         if (!strcmp (tny_account_get_id (TNY_ACCOUNT (parent_folder)), MODEST_MMC_ACCOUNT_ID)) {
 839                                         result = TRUE;
 840                         } else {
 841                                 const gchar *proto_str = tny_account_get_proto (TNY_ACCOUNT (parent_folder));
 842                                 /* If it's POP then dim */
 843                                 result = (modest_protocol_info_get_transport_store_protocol (proto_str) ==
 844                                                   MODEST_PROTOCOL_STORE_POP) ? TRUE : FALSE;
 845                         }
 846                 }
 847         }
 848         g_object_unref (parent_folder);
 849
 850         return result;
 851 }
 852
 853
 854
 855
 856 static gboolean
 857 _selected_folder_is_empty (ModestMainWindow *win)
 858 {
 859         GtkWidget *folder_view = NULL;
 860         TnyFolderStore *folder = NULL;
 861         gboolean result = FALSE;
 862
 863         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
 864
 865         /* Get folder view */
 866         folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
 867                                                            MODEST_WIDGET_TYPE_FOLDER_VIEW);
 868         /* If no folder view, always dimmed */
 869         if (!folder_view)
 870                 return TRUE;
 871
 872         /* Get selected folder as parent of new folder to create */
 873         folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
 874         if (!(folder && TNY_IS_FOLDER(folder))) {
 875                 if (folder)
 876                         g_object_unref (folder);
 877                 return TRUE;
 878         }
 879
 880         /* Check folder type */
 881         result = tny_folder_get_all_count (TNY_FOLDER (folder)) == 0;
 882
 883         /* free */
 884         g_object_unref (folder);
 885
 886         return result;
 887 }
 888
 889 static gboolean
 890 _selected_folder_is_same_as_source (ModestWindow *win)
 891 {
 892         ModestEmailClipboard *clipboard = NULL;
 893         GtkWidget *folder_view = NULL;
 894         TnyFolderStore *folder = NULL;
 895         gboolean result = FALSE;
 896
 897         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
 898
 899         /* Get folder view */
 900         folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
 901                                                            MODEST_WIDGET_TYPE_FOLDER_VIEW);
 902         if (!folder_view)
 903                 return FALSE;
 904
 905         /* Get selected folder as destination folder */
 906         folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
 907         if (!(folder && TNY_IS_FOLDER(folder))) {
 908                 result = FALSE;
 909                 goto frees;
 910         }
 911
 912         /* Check clipboard is cleared */
 913         clipboard = modest_runtime_get_email_clipboard ();
 914         if (modest_email_clipboard_cleared (clipboard)) {
 915                 result = FALSE;
 916                 goto frees;
 917         }
 918
 919         /* Check source folder */
 920         result = modest_email_clipboard_check_source_folder (clipboard,
 921                                                              (const TnyFolder *) folder);
 922
 923         /* Free */
 924  frees:
 925         g_object_unref (folder);
 926
 927         return result;
 928 }
 929
 930 static gboolean
 931 _selected_folder_is_any_of_type (ModestWindow *win,
 932                                  TnyFolderType types[],
 933                                  guint ntypes)
 934 {
 935         GtkWidget *folder_view = NULL;
 936         TnyFolderStore *folder = NULL;
 937         TnyFolderType folder_type;
 938         guint i=0;
 939         gboolean result = FALSE;
 940
 941         /*Get curent folder */
 942         if (MODEST_IS_MAIN_WINDOW(win)) {
 943
 944                 /* Get folder view */
 945                 folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
 946                                                                    MODEST_WIDGET_TYPE_FOLDER_VIEW);
 947                 /* If no folder view, always dimmed */
 948                 if (!folder_view)
 949                         return TRUE;
 950
 951                 /* Get selected folder as parent of new folder to create */
 952                 folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
 953
 954                 if (!(folder && TNY_IS_FOLDER(folder))) {
 955                         if (folder)
 956                                 g_object_unref (folder);
 957                         return TRUE;
 958                 }
 959
 960                 /* Check folder type */
 961                 result = _folder_is_any_of_type (TNY_FOLDER(folder), types, ntypes);
 962         }
 963         else if (MODEST_IS_MSG_VIEW_WINDOW(win)) {
 964                 folder_type = modest_msg_view_window_get_folder_type (MODEST_MSG_VIEW_WINDOW (win));
 965                 for (i=0; i < ntypes; i++) {
 966                         result = result || folder_type == types[i];
 967                 }
 968         }
 969
 970
 971         /* free */
 972         g_object_unref (folder);
 973
 974         return result;
 975 }
 976
 977 static gboolean
 978 _folder_is_any_of_type (TnyFolder *folder,
 979                         TnyFolderType types[],
 980                         guint ntypes)
 981 {
 982         TnyFolderType folder_type;
 983         gboolean result = FALSE;
 984         guint i;
 985
 986         g_return_val_if_fail (TNY_IS_FOLDER(folder), FALSE);
 987
 988         /* Get folder type */
 989         if (modest_tny_folder_is_local_folder (folder))
 990                 folder_type = modest_tny_folder_get_local_folder_type (folder);
 991         else
 992                 folder_type = modest_tny_folder_guess_folder_type (folder);
 993
 994         /* Check foler type */
 995         for (i=0; i < ntypes; i++) {
 996                 result = result || folder_type == types[i];
 997         }
 998
 999         return result;
1000 }
1001
1002
1003
1004 static gboolean
1005 _invalid_clipboard_selected (ModestWindow *win)
1006 {
1007         gboolean result = FALSE;
1008
1009         if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
1010                 GtkClipboard *clipboard = NULL;
1011                 gchar *selection = NULL;
1012                 GtkWidget *focused = NULL;
1013
1014                 /* Get clipboard selection*/
1015                 clipboard = gtk_clipboard_get (GDK_SELECTION_PRIMARY);
1016                 selection = gtk_clipboard_wait_for_text (clipboard);
1017
1018                 /* Get focuesed widget */
1019                 focused = gtk_window_get_focus (GTK_WINDOW (win));
1020
1021                 /* Check dimming */
1022                 result = ((selection == NULL) ||
1023                           (MODEST_IS_ATTACHMENTS_VIEW (focused)));
1024         }
1025         else if (MODEST_IS_MAIN_WINDOW (win)) {
1026                 ModestEmailClipboard *clipboard = NULL;
1027
1028                 clipboard = modest_runtime_get_email_clipboard ();
1029                 if (modest_email_clipboard_cleared (clipboard))
1030                         result = TRUE;
1031         }
1032
1033         return result;
1034 }
1035
1036
1037 static gboolean
1038 _invalid_attach_selected (ModestWindow *win,
1039                           gboolean unique,
1040                           gboolean for_view,
1041                           ModestDimmingRule *rule)
1042 {
1043         GList *attachments, *node;
1044         gint n_selected;
1045         TnyHeaderFlags flags;
1046         gboolean nested_attachments = FALSE;
1047         gboolean selected_messages = FALSE;
1048         gboolean result = FALSE;
1049
1050         if (MODEST_IS_MAIN_WINDOW (win)) {
1051                 flags = TNY_HEADER_FLAG_ATTACHMENTS;
1052                 if (!result)
1053                         result = _selected_msg_marked_as (win, flags, TRUE);
1054         }
1055         else if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
1056
1057                 /* Get selected atachments */
1058                 attachments = modest_msg_view_window_get_attachments (MODEST_MSG_VIEW_WINDOW(win));
1059                 n_selected = g_list_length (attachments);
1060
1061                 /* Check unique */
1062                 if (!result) {
1063                         if (unique)
1064                                 result = n_selected != 1;
1065                         else
1066
1067                                 result = n_selected < 1;
1068                 }
1069
1070                 /* Check attached type (view operation not required) */
1071                 if (!result && !for_view)  {
1072                         for (node = attachments; node != NULL && !result; node = g_list_next (node)) {
1073                                 TnyMimePart *mime_part = TNY_MIME_PART (node->data);
1074                                 TnyList *nested_list = tny_simple_list_new ();
1075                                 if (TNY_IS_MSG (mime_part)) {
1076                                         selected_messages = TRUE;
1077                                         result = TRUE;
1078                                 }
1079                                 tny_mime_part_get_parts (mime_part, nested_list);
1080                                 if (tny_list_get_length (nested_list) > 0) {
1081                                 nested_attachments = TRUE;
1082                                 result = TRUE;
1083                                 }
1084                                 g_object_unref (nested_list);
1085                         }
1086                 }
1087
1088                 /* Set notifications */
1089                 if (result && rule != NULL) {
1090                         if (selected_messages) {
1091                                 modest_dimming_rule_set_notification (rule, _("mcen_ib_unable_to_save_attach_mail"));
1092                         } else if (nested_attachments) {
1093                                 modest_dimming_rule_set_notification (rule, _("FIXME:unable to save attachments with nested elements"));
1094                         } else if (n_selected == 0) {
1095                                 modest_dimming_rule_set_notification (rule, _("FIXME:no attachment selected"));
1096                         } else if (unique) {
1097                                 modest_dimming_rule_set_notification (rule, _("mcen_ib_unable_to_display_more"));
1098                         }
1099                 }
1100
1101                 /* Free */
1102                 g_list_free (attachments);
1103         }
1104
1105         return result;
1106 }
1107
1108 static gboolean
1109 _invalid_msg_selected (ModestMainWindow *win,
1110                        gboolean unique,
1111                        ModestDimmingRule *rule)
1112 {
1113         GtkWidget *header_view = NULL;
1114         GtkWidget *folder_view = NULL;
1115         gboolean selected_headers = FALSE;
1116         gboolean result = FALSE;
1117
1118         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
1119         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (rule), FALSE);
1120
1121         /* Get header view to check selected messages */
1122         header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
1123                                                            MODEST_WIDGET_TYPE_HEADER_VIEW);
1124
1125         /* Get folder view to check focus */
1126         folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
1127                                                            MODEST_WIDGET_TYPE_FOLDER_VIEW);
1128
1129         /* Get selected headers */
1130         selected_headers = modest_header_view_has_selected_headers (MODEST_HEADER_VIEW(header_view));
1131
1132         /* Check dimmed rule (TODO: check focus on widgets */
1133         if (!result) {
1134                 result = ((!selected_headers) ||
1135                           (gtk_widget_is_focus (folder_view)));
1136                 if (result)
1137                         modest_dimming_rule_set_notification (rule, _("mcen_ib_no_message_selected"));
1138         }
1139         if (!result && unique) {
1140                 result = modest_header_view_count_selected_headers (MODEST_HEADER_VIEW(header_view)) > 1;
1141                 if (result)
1142                         modest_dimming_rule_set_notification (rule, _("mcen_ib_select_one_message"));
1143         }
1144
1145         return result;
1146 }
1147
1148 static gboolean
1149 _already_opened_msg (ModestWindow *win,
1150                      guint *n_messages)
1151 {
1152         ModestWindow *window = NULL;
1153         ModestWindowMgr *mgr = NULL;
1154         GtkWidget *header_view = NULL;
1155         TnyList *selected_headers = NULL;
1156         TnyIterator *iter = NULL;
1157         TnyHeader *header = NULL;
1158         gboolean result = TRUE;
1159
1160         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
1161
1162         /* Get header view to check selected messages */
1163         header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
1164                                                            MODEST_WIDGET_TYPE_HEADER_VIEW);
1165
1166
1167         /* Check no selection */
1168         if (!modest_header_view_has_selected_headers (MODEST_HEADER_VIEW(header_view)))
1169             return FALSE;
1170
1171         /* Get selected headers */
1172         selected_headers = modest_header_view_get_selected_headers (MODEST_HEADER_VIEW(header_view));
1173         if (selected_headers == NULL)
1174                 return FALSE;
1175
1176         *n_messages = tny_list_get_length (selected_headers);
1177
1178         /* Check dimmed rule (TODO: check focus on widgets */
1179         mgr = modest_runtime_get_window_mgr ();
1180         iter = tny_list_create_iterator (selected_headers);
1181         while (!tny_iterator_is_done (iter) && result) {
1182                 header = TNY_HEADER (tny_iterator_get_current (iter));
1183                 window = modest_window_mgr_find_window_by_header (mgr, header);
1184                 result = result && (window != NULL);
1185
1186                 g_object_unref (header);
1187                 tny_iterator_next (iter);
1188         }
1189
1190         /* free */
1191         if (selected_headers != NULL)
1192                 g_object_unref (selected_headers);
1193         if (iter != NULL)
1194                 g_object_unref (iter);
1195
1196         return result;
1197 }
1198
1199 static gboolean
1200 _selected_msg_marked_as (ModestWindow *win,
1201                          TnyHeaderFlags mask,
1202                          gboolean opposite)
1203 {
1204         GtkWidget *header_view = NULL;
1205         TnyList *selected_headers = NULL;
1206         TnyIterator *iter = NULL;
1207         TnyHeader *header = NULL;
1208         TnyHeaderFlags flags;
1209         gboolean result = FALSE;
1210
1211         /* Get header view to check selected messages */
1212         header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
1213                                                            MODEST_WIDGET_TYPE_HEADER_VIEW);
1214
1215         /* Check no selection */
1216         if (!modest_header_view_has_selected_headers (MODEST_HEADER_VIEW(header_view)))
1217             return TRUE;
1218
1219         /* Get selected headers */
1220         selected_headers = modest_header_view_get_selected_headers (MODEST_HEADER_VIEW(header_view));
1221         if (selected_headers == NULL)
1222                 return TRUE;
1223
1224         /* Call the function for each header */
1225         iter = tny_list_create_iterator (selected_headers);
1226         while (!tny_iterator_is_done (iter) && !result) {
1227                 header = TNY_HEADER (tny_iterator_get_current (iter));
1228
1229                 flags = tny_header_get_flags (header);
1230                 if (opposite)
1231                         result = (flags & mask) == 0;
1232                 else
1233                         result = (flags & mask) != 0;
1234
1235                 g_object_unref (header);
1236                 tny_iterator_next (iter);
1237         }
1238
1239         /* free */
1240         if (selected_headers != NULL)
1241                 g_object_unref (selected_headers);
1242         if (iter != NULL)
1243                 g_object_unref (iter);
1244
1245         return result;
1246 }
1247
1248 static gboolean
1249 _msg_download_in_progress (ModestMsgViewWindow *win)
1250 {
1251         gboolean result = FALSE;
1252
1253         g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW (win), FALSE);
1254
1255         result = modest_msg_view_window_toolbar_on_transfer_mode (win);
1256
1257         return result;
1258 }
1259
1260 static gboolean
1261 _msg_download_completed (ModestMainWindow *win)
1262 {
1263         GtkWidget *header_view = NULL;
1264         TnyList *selected_headers = NULL;
1265         TnyIterator *iter = NULL;
1266         TnyHeader *header = NULL;
1267         TnyHeaderFlags flags;
1268         gboolean result = FALSE;
1269
1270         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW (win), FALSE);
1271
1272
1273         /* Get header view to check selected messages */
1274         header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
1275                                                            MODEST_WIDGET_TYPE_HEADER_VIEW);
1276
1277         /* Check no selection */
1278         if (!modest_header_view_has_selected_headers (MODEST_HEADER_VIEW(header_view)))
1279             return TRUE;
1280
1281         /* Get selected headers */
1282         selected_headers = modest_header_view_get_selected_headers (MODEST_HEADER_VIEW(header_view));
1283         if (selected_headers == NULL)
1284                 return TRUE;
1285
1286         /* Check dimmed rule  */
1287         result = TRUE;
1288         iter = tny_list_create_iterator (selected_headers);
1289         while (!tny_iterator_is_done (iter) && result) {
1290                 header = TNY_HEADER (tny_iterator_get_current (iter));
1291
1292                 flags = tny_header_get_flags (header);
1293                 /* TODO: is this the right flag?, it seems that some
1294                    headers that have been previously downloaded do not
1295                    come with it */
1296                 result = (flags & TNY_HEADER_FLAG_CACHED);
1297
1298                 g_object_unref (header);
1299                 tny_iterator_next (iter);
1300         }
1301
1302         g_object_unref (iter);
1303
1304         return result;
1305 }
1306
1307 static gboolean
1308 _selected_msg_sent_in_progress (ModestWindow *win)
1309 {
1310         ModestTnySendQueue *send_queue = NULL;
1311         GtkWidget *header_view = NULL;
1312         ModestTnyAccountStore *acc_store = NULL;
1313         TnyAccount *account = NULL;
1314         TnyList *header_list = NULL;
1315         TnyIterator *iter = NULL;
1316         TnyHeader *header = NULL;
1317         const gchar *account_name = NULL;
1318         gboolean result = FALSE;
1319         gchar *id = NULL;
1320
1321         /* Get transport account */
1322         acc_store = modest_runtime_get_account_store();
1323         account_name = modest_window_get_active_account (win);
1324
1325         /* If no account defined, this action must be always dimmed  */
1326         if (account_name == NULL) return FALSE;
1327         account = modest_tny_account_store_get_transport_account_for_open_connection (acc_store, account_name);
1328         if (!TNY_IS_TRANSPORT_ACCOUNT (account)) return FALSE;
1329
1330         /* Get send queue for current ransport account */
1331         send_queue = modest_runtime_get_send_queue (TNY_TRANSPORT_ACCOUNT(account));
1332         g_return_val_if_fail (MODEST_IS_TNY_SEND_QUEUE (send_queue), FALSE);
1333
1334         if (MODEST_IS_MAIN_WINDOW(win)) {
1335
1336                 /* Get header view to check selected messages */
1337                 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
1338                                                                    MODEST_WIDGET_TYPE_HEADER_VIEW);
1339
1340                 /* Check no selection */
1341                 if (!modest_header_view_has_selected_headers (MODEST_HEADER_VIEW(header_view)))
1342                     return FALSE;
1343
1344                 /* Get selected headers */
1345                 header_list = modest_header_view_get_selected_headers (MODEST_HEADER_VIEW(header_view));
1346
1347                 /* Get message header */
1348                 if (!header_list) return FALSE;
1349                 iter = tny_list_create_iterator (header_list);
1350                 header = TNY_HEADER (tny_iterator_get_current (iter));
1351
1352                 /* Get message id */
1353                 id = g_strdup(tny_header_get_message_id (header));
1354
1355         } else if (MODEST_IS_MSG_VIEW_WINDOW(win)) {
1356
1357                 /* Get message header */
1358                 header = modest_msg_view_window_get_header (MODEST_MSG_VIEW_WINDOW(win));
1359
1360                 /* Get message id */
1361                 id = g_strdup(tny_header_get_message_id (header));
1362         }
1363
1364         /* Check if msg id is being processed inside send queue */
1365         result = modest_tny_send_queue_msg_is_being_sent (send_queue, id);
1366
1367         /* Free */
1368         g_free(id);
1369         g_object_unref (header);
1370         g_object_unref(header_list);
1371         g_object_unref(iter);
1372
1373         return result;
1374 }
1375
1376
1377 static gboolean
1378 _sending_in_progress (ModestWindow *win)
1379 {
1380         ModestTnySendQueue *send_queue = NULL;
1381         ModestTnyAccountStore *acc_store = NULL;
1382         TnyAccount *account = NULL;
1383         const gchar *account_name = NULL;
1384         gboolean result = FALSE;
1385
1386         /* Get transport account */
1387         acc_store = modest_runtime_get_account_store();
1388         account_name = modest_window_get_active_account (win);
1389
1390         /* If no account defined, this action must be always dimmed  */
1391         if (account_name == NULL) return FALSE;
1392         account = modest_tny_account_store_get_transport_account_for_open_connection (acc_store, account_name);
1393         if (!TNY_IS_TRANSPORT_ACCOUNT (account)) return FALSE;
1394
1395         /* Get send queue for current ransport account */
1396         send_queue = modest_runtime_get_send_queue (TNY_TRANSPORT_ACCOUNT(account));
1397         g_return_val_if_fail (MODEST_IS_TNY_SEND_QUEUE (send_queue), FALSE);
1398
1399         /* Check if send queue is perfimring any send operation */
1400         result = modest_tny_send_queue_sending_in_progress (send_queue);
1401
1402         return result;
1403 }
1404
1405 static gboolean
1406 _invalid_attachment_for_purge (ModestWindow *win,
1407                                ModestDimmingRule *rule)
1408 {
1409         TnyMsg *msg = NULL;
1410         TnyFolder *folder = NULL;
1411         TnyAccount *account = NULL;
1412         gboolean result = TRUE;
1413
1414         if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
1415
1416                 /* Get folder and account of message */
1417                 msg = modest_msg_view_window_get_message (MODEST_MSG_VIEW_WINDOW (win));
1418                 g_return_val_if_fail(msg != NULL, TRUE);
1419                 folder = tny_msg_get_folder (msg);
1420                 if (folder == NULL) {
1421                         modest_dimming_rule_set_notification (rule, _("mail_ib_unable_to_purge_attachments"));
1422                         goto frees;
1423                 }
1424                 account = modest_tny_folder_get_account (folder);
1425                 if (account == NULL) goto frees;
1426
1427                 /* Check account */
1428                 if (!modest_tny_account_is_virtual_local_folders (TNY_ACCOUNT (account))) {
1429                         const gchar *proto_str = tny_account_get_proto (TNY_ACCOUNT (account));
1430                         /* If it's POP then dim */
1431                         if (modest_protocol_info_get_transport_store_protocol (proto_str) ==
1432                             MODEST_PROTOCOL_STORE_POP) {
1433                                 GList *attachments;
1434                                 gint n_selected;
1435                                 result = TRUE;
1436                                 attachments = modest_msg_view_window_get_attachments (MODEST_MSG_VIEW_WINDOW(win));
1437                                 n_selected = g_list_length (attachments);
1438                                 g_list_free (attachments);
1439
1440                                 modest_dimming_rule_set_notification (rule,
1441                                                                       ngettext ("mail_ib_unable_to_pure_attach_pop_mail_singular",
1442                                                                                 "mail_ib_unable_to_pure_attach_pop_mail_plural",
1443                                                                                 n_selected));
1444                         }
1445                 }
1446         }
1447
1448  frees:
1449         if (msg != NULL)
1450                 g_object_unref (msg);
1451         if (folder != NULL)
1452                 g_object_unref (folder);
1453         if (account != NULL)
1454                 g_object_unref (account);
1455
1456         return result;
1457 }
1458