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