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