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