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-runtime.h>
  39
  40
  41 static gboolean _folder_is_any_of_type (TnyFolder *folder, TnyFolderType types[], guint ntypes);
  42 static gboolean _invalid_msg_selected (ModestMainWindow *win, gboolean unique, ModestDimmingRule *rule);
  43 static gboolean _already_opened_msg (ModestWindow *win);
  44 static gboolean _selected_msg_marked_as (ModestWindow *win, TnyHeaderFlags mask, gboolean opposite);
  45 static gboolean _selected_folder_not_writeable (ModestMainWindow *win);
  46 static gboolean _selected_folder_is_any_of_type (ModestMainWindow *win, TnyFolderType types[], guint ntypes);
  47 static gboolean _selected_folder_is_root (ModestMainWindow *win);
  48 static gboolean _selected_folder_is_empty (ModestMainWindow *win);
  49 static gboolean _msg_download_in_progress (ModestMsgViewWindow *win);
  50 static gboolean _msg_download_completed (ModestMainWindow *win);
  51 static gboolean _msg_sent_in_progress (ModestWindow *win);
  52 static gboolean _marked_as_deleted (ModestWindow *win);
  53
  54
  55 gboolean
  56 modest_ui_dimming_rules_on_new_msg (ModestWindow *win, gpointer user_data)
  57 {
  58         gboolean dimmed = FALSE;
  59
  60         g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW(win), FALSE);
  61
  62         /* Check dimmed rule */
  63         if (!dimmed)
  64                 dimmed = _msg_download_in_progress (MODEST_MSG_VIEW_WINDOW(win));
  65
  66         return dimmed;
  67 }
  68
  69 gboolean
  70 modest_ui_dimming_rules_on_new_folder (ModestWindow *win, gpointer user_data)
  71 {
  72         gboolean dimmed = FALSE;
  73         GtkWidget *folder_view = NULL;
  74         TnyFolderStore *parent_folder = NULL;
  75
  76         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
  77
  78
  79         folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
  80                                                            MODEST_WIDGET_TYPE_FOLDER_VIEW);
  81         /* Get selected folder as parent of new folder to create */
  82         parent_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
  83         if (!parent_folder)
  84                 return TRUE;
  85
  86         if (TNY_IS_ACCOUNT (parent_folder)) {
  87                 /* If it's the local account then do not dim */
  88                 if (modest_tny_account_is_virtual_local_folders (
  89                         TNY_ACCOUNT (parent_folder)))
  90                         return FALSE;
  91                 else {
  92                         /* If it's the MMC root folder then dim it */
  93                         if (!strcmp (tny_account_get_id (TNY_ACCOUNT (parent_folder)), MODEST_MMC_ACCOUNT_ID)) {
  94                                 dimmed = TRUE;
  95                         } else {
  96                                 const gchar *proto_str = tny_account_get_proto (TNY_ACCOUNT (parent_folder));
  97                                 /* If it's POP then dim */
  98                                 dimmed = (modest_protocol_info_get_transport_store_protocol (proto_str) ==
  99                                           MODEST_PROTOCOL_STORE_POP) ? TRUE : FALSE;
 100                         }
 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 (MODEST_MAIN_WINDOW(win));
 124
 125         return dimmed;
 126 }
 127
 128 gboolean
 129 modest_ui_dimming_rules_on_rename_folder (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_not_writeable (MODEST_MAIN_WINDOW(win));
 138         if (!dimmed)
 139                 dimmed = _selected_folder_is_root (MODEST_MAIN_WINDOW(win));
 140
 141         return dimmed;
 142 }
 143
 144 gboolean
 145 modest_ui_dimming_rules_on_open_msg (ModestWindow *win, gpointer user_data)
 146 {
 147         ModestDimmingRule *rule = NULL;
 148         gboolean dimmed = FALSE;
 149
 150         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
 151         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 152         rule = MODEST_DIMMING_RULE (user_data);
 153
 154         /* Check dimmed rule */
 155         if (!dimmed)
 156                 dimmed = _invalid_msg_selected (MODEST_MAIN_WINDOW(win), TRUE, user_data);
 157         if (!dimmed) {
 158                 dimmed = _msg_sent_in_progress (win);
 159                 if (dimmed)
 160                         modest_dimming_rule_set_notification (rule, _("TEST"));
 161         }
 162
 163         return dimmed;
 164 }
 165
 166 gboolean
 167 modest_ui_dimming_rules_on_reply_msg (ModestWindow *win, gpointer user_data)
 168 {
 169         ModestDimmingRule *rule = NULL;
 170         gboolean dimmed = FALSE;
 171         TnyFolderType types[3];
 172
 173         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 174         rule = MODEST_DIMMING_RULE (user_data);
 175
 176         /* main window dimming rules */
 177         if (MODEST_IS_MAIN_WINDOW(win)) {
 178
 179                 types[0] = TNY_FOLDER_TYPE_DRAFTS;
 180                 types[1] = TNY_FOLDER_TYPE_OUTBOX;
 181                 types[2] = TNY_FOLDER_TYPE_ROOT;
 182
 183                 /* Check dimmed rule */
 184                 if (!dimmed) {
 185                         dimmed = _selected_folder_is_any_of_type (MODEST_MAIN_WINDOW(win), types, 3);
 186                         if (dimmed)
 187                                 modest_dimming_rule_set_notification (rule, _("mcen_ib_unable_to_reply"));
 188                 }
 189                 if (!dimmed) {
 190                         dimmed = _selected_folder_is_empty (MODEST_MAIN_WINDOW(win));
 191                         if (dimmed)
 192                                 modest_dimming_rule_set_notification (rule, _("mcen_ib_nothing_to_reply"));
 193                 }
 194                 if (!dimmed)
 195                         dimmed = _invalid_msg_selected (MODEST_MAIN_WINDOW(win), TRUE, rule);
 196
 197         /* msg view window dimming rules */
 198         } else if (MODEST_IS_MSG_VIEW_WINDOW(win)) {
 199
 200                 /* Check dimmed rule */
 201                 if (!dimmed)
 202                         dimmed = _msg_download_in_progress (MODEST_MSG_VIEW_WINDOW(win));
 203         }
 204
 205         return dimmed;
 206 }
 207
 208
 209 gboolean
 210 modest_ui_dimming_rules_on_contents_msg (ModestWindow *win, gpointer user_data)
 211 {
 212         gboolean dimmed = FALSE;
 213
 214         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
 215
 216         /* Check dimmed rule */
 217         if (!dimmed)
 218                 dimmed = _invalid_msg_selected (MODEST_MAIN_WINDOW(win), FALSE, user_data);
 219         if (!dimmed)
 220                 dimmed = _msg_download_completed (MODEST_MAIN_WINDOW(win));
 221
 222         return dimmed;
 223 }
 224
 225 gboolean
 226 modest_ui_dimming_rules_always_dimmed (ModestWindow *win, gpointer user_data)
 227 {
 228         gboolean dimmed = FALSE;
 229
 230         g_return_val_if_fail (MODEST_IS_WINDOW(win), FALSE);
 231
 232         /* Check dimmed rule */
 233         if (!dimmed)
 234                 dimmed = TRUE;
 235
 236         return dimmed;
 237 }
 238
 239 gboolean
 240 modest_ui_dimming_rules_on_delete_msg (ModestWindow *win, gpointer user_data)
 241 {
 242         ModestDimmingRule *rule = NULL;
 243         gboolean dimmed = FALSE;
 244
 245         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
 246         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 247         rule = MODEST_DIMMING_RULE (user_data);
 248
 249         /* Check dimmed rule */
 250         if (!dimmed) {
 251                 dimmed = _selected_folder_is_empty (MODEST_MAIN_WINDOW(win));
 252                 if (dimmed)
 253                         modest_dimming_rule_set_notification (rule, _("mcen_ib_nothing_to_del"));
 254         }
 255         if (!dimmed) {
 256                 dimmed = _invalid_msg_selected (MODEST_MAIN_WINDOW(win), FALSE, user_data);
 257                 if (dimmed)
 258                         modest_dimming_rule_set_notification (rule, _("mcen_ib_no_message_selected"));
 259         }
 260         if (!dimmed) {
 261                 dimmed = _already_opened_msg (win);
 262                 if (dimmed)
 263                         modest_dimming_rule_set_notification (rule, _("mcen_nc_unable_to_delete_n_messages"));
 264         }
 265         if (!dimmed) {
 266                 dimmed = _marked_as_deleted (win);
 267                 if (dimmed)
 268                         modest_dimming_rule_set_notification (rule, _("mcen_ib_message_unableto_delete"));
 269         }
 270         if (!dimmed) {
 271                 dimmed = _msg_sent_in_progress (win);
 272                 if (dimmed)
 273                         modest_dimming_rule_set_notification (rule, _("mcen_ib_message_unableto_delete"));
 274         }
 275
 276         return dimmed;
 277 }
 278
 279 gboolean
 280 modest_ui_dimming_rules_on_details (ModestWindow *win, gpointer user_data)
 281 {
 282         gboolean dimmed = FALSE;
 283         GtkWidget *header_view = NULL;
 284
 285         /* main window dimming rules */
 286         if (MODEST_IS_MAIN_WINDOW(win)) {
 287
 288                 /* Check dimmed rule */
 289                 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
 290                                                                    MODEST_WIDGET_TYPE_HEADER_VIEW);
 291
 292                 /* If the header view does not have the focus then do
 293                    not apply msg dimming rules because the action will
 294                    show the folder details that have no dimming
 295                    rule */
 296                 if (gtk_widget_is_focus (header_view)) {
 297                         /* Check dimmed rule */
 298                         if (!dimmed)
 299                                 dimmed = _invalid_msg_selected (MODEST_MAIN_WINDOW(win), TRUE, user_data);
 300                 }
 301
 302         /* msg view window dimming rules */
 303         } else {
 304
 305                 /* Check dimmed rule */
 306                 if (!dimmed)
 307                         dimmed = _msg_download_in_progress (MODEST_MSG_VIEW_WINDOW(win));
 308         }
 309
 310         return dimmed;
 311 }
 312
 313
 314 gboolean
 315 modest_ui_dimming_rules_on_mark_as_read_msg (ModestWindow *win, gpointer user_data)
 316 {
 317         gboolean dimmed = FALSE;
 318         TnyHeaderFlags flags;
 319
 320         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
 321
 322         flags = TNY_HEADER_FLAG_SEEN;
 323
 324         /* Check dimmed rule */
 325         if (!dimmed)
 326                 dimmed = _invalid_msg_selected (MODEST_MAIN_WINDOW(win), FALSE, user_data);
 327         if (!dimmed)
 328                 dimmed = _selected_msg_marked_as (win, flags, FALSE);
 329
 330         return dimmed;
 331 }
 332
 333 gboolean
 334 modest_ui_dimming_rules_on_mark_as_unread_msg (ModestWindow *win, gpointer user_data)
 335 {
 336         gboolean dimmed = FALSE;
 337         TnyHeaderFlags flags;
 338
 339         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
 340
 341         flags = TNY_HEADER_FLAG_SEEN;
 342
 343         /* Check dimmed rule */
 344         if (!dimmed)
 345                 dimmed = _invalid_msg_selected (MODEST_MAIN_WINDOW(win), FALSE, user_data);
 346         if (!dimmed)
 347                 dimmed = _selected_msg_marked_as (win, flags, TRUE);
 348
 349         return dimmed;
 350 }
 351
 352 gboolean
 353 modest_ui_dimming_rules_on_move_to (ModestWindow *win, gpointer user_data)
 354 {
 355         gboolean dimmed = FALSE;
 356
 357         if (MODEST_IS_MAIN_WINDOW (win))
 358                 dimmed = modest_ui_dimming_rules_on_main_window_move_to (win, user_data);
 359         else
 360                 dimmed = modest_ui_dimming_rules_on_view_window_move_to (win, user_data);
 361
 362         return dimmed;
 363 }
 364
 365
 366 gboolean
 367 modest_ui_dimming_rules_on_main_window_move_to (ModestWindow *win, gpointer user_data)
 368 {
 369         GtkWidget *folder_view = NULL;
 370         GtkWidget *header_view = NULL;
 371         gboolean dimmed = FALSE;
 372
 373         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), TRUE);
 374
 375         /* Get the folder view */
 376         folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
 377                                                            MODEST_WIDGET_TYPE_FOLDER_VIEW);
 378
 379         /* Get header view */
 380         header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
 381                                                            MODEST_WIDGET_TYPE_HEADER_VIEW);
 382
 383         /* Check common diming rules */
 384
 385         /* Check diming rules for folder transfer  */
 386         if (gtk_widget_is_focus (folder_view)) {
 387                 if (!dimmed)
 388                         dimmed = _selected_folder_not_writeable(MODEST_MAIN_WINDOW(win));
 389         }
 390         /* Check diming rules for msg transfer  */
 391         else if (gtk_widget_is_focus (header_view)) {
 392                 if (!dimmed)
 393                         dimmed = _invalid_msg_selected (MODEST_MAIN_WINDOW(win), FALSE, user_data);
 394
 395         }
 396
 397         return dimmed;
 398 }
 399
 400 gboolean
 401 modest_ui_dimming_rules_on_view_window_move_to (ModestWindow *win, gpointer user_data)
 402 {
 403         gboolean dimmed = FALSE;
 404
 405         return dimmed;
 406 }
 407
 408 gboolean
 409 modest_ui_dimming_rules_on_paste_msgs (ModestWindow *win, gpointer user_data)
 410 {
 411         TnyFolderType types[3];
 412         gboolean dimmed = FALSE;
 413
 414         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
 415
 416         types[0] = TNY_FOLDER_TYPE_DRAFTS;
 417         types[1] = TNY_FOLDER_TYPE_OUTBOX;
 418         types[2] = TNY_FOLDER_TYPE_SENT;
 419
 420         /* Check dimmed rule */
 421         if (!dimmed)
 422                 dimmed = _selected_folder_is_any_of_type (MODEST_MAIN_WINDOW(win), types, 3);
 423
 424         return dimmed;
 425 }
 426
 427 gboolean
 428 modest_ui_dimming_rules_on_delete_msgs (ModestWindow *win, gpointer user_data)
 429 {
 430         TnyFolderType types[5];
 431         gboolean dimmed = FALSE;
 432
 433         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
 434
 435         types[0] = TNY_FOLDER_TYPE_DRAFTS;
 436         types[1] = TNY_FOLDER_TYPE_OUTBOX;
 437         types[2] = TNY_FOLDER_TYPE_SENT;
 438         types[3] = TNY_FOLDER_TYPE_INBOX;
 439         types[4] = TNY_FOLDER_TYPE_ROOT;
 440
 441         /* Check dimmed rule */
 442         if (!dimmed)
 443                 dimmed = _selected_folder_is_any_of_type (MODEST_MAIN_WINDOW(win), types, 5);
 444
 445         return dimmed;
 446 }
 447
 448 gboolean
 449 modest_ui_dimming_rules_on_select_all (ModestWindow *win, gpointer user_data)
 450 {
 451         gboolean dimmed = FALSE;
 452
 453         /* Check dimmed rule */
 454         if (!dimmed)
 455                 dimmed = _selected_folder_is_empty (MODEST_MAIN_WINDOW(win));
 456
 457         return dimmed;
 458 }
 459
 460
 461 /* *********************** static utility functions ******************** */
 462
 463 static gboolean
 464 _marked_as_deleted (ModestWindow *win)
 465 {
 466         gboolean result = FALSE;
 467         TnyHeaderFlags flags;
 468
 469         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
 470
 471         flags = TNY_HEADER_FLAG_DELETED;
 472
 473         /* Check dimmed rule */
 474         result = _selected_msg_marked_as (win, flags, FALSE);
 475
 476         return result;
 477 }
 478
 479 static gboolean
 480 _selected_folder_not_writeable (ModestMainWindow *win)
 481 {
 482         GtkWidget *folder_view = NULL;
 483         TnyFolderStore *parent_folder = NULL;
 484         ModestTnyFolderRules rules;
 485         gboolean result = FALSE;
 486
 487         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
 488
 489         /* Get folder view */
 490         folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
 491                                                            MODEST_WIDGET_TYPE_FOLDER_VIEW);
 492         /* If no folder view, always dimmed */
 493         if (!folder_view)
 494                 return TRUE;
 495
 496         /* Get selected folder as parent of new folder to create */
 497         parent_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
 498         if (!(parent_folder && TNY_IS_FOLDER(parent_folder)))
 499                 return TRUE;
 500
 501         /* Check dimmed rule */
 502         rules = modest_tny_folder_get_rules (TNY_FOLDER (parent_folder));
 503         result = rules & MODEST_FOLDER_RULES_FOLDER_NON_WRITEABLE;
 504
 505         /* free */
 506         g_object_unref (parent_folder);
 507
 508         return result;
 509 }
 510
 511 static gboolean
 512 _selected_folder_is_root (ModestMainWindow *win)
 513 {
 514         TnyFolderType types[2];
 515         gboolean result = FALSE;
 516
 517         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
 518
 519         types[0] = TNY_FOLDER_TYPE_ROOT;
 520         types[1] = TNY_FOLDER_TYPE_INBOX;
 521
 522         /* Check folder type */
 523         result = _selected_folder_is_any_of_type (win, types, 2);
 524
 525         if (!result) {
 526                 GtkWidget *folder_view = NULL;
 527                 TnyFolderStore *parent_folder = NULL;
 528
 529                 folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
 530                                                                    MODEST_WIDGET_TYPE_FOLDER_VIEW);
 531                 /* Get selected folder as parent of new folder to create */
 532                 parent_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
 533                 if (!parent_folder)
 534                         return TRUE;
 535
 536                 if (TNY_IS_ACCOUNT (parent_folder)) {
 537                         /* If it's the local account then do not dim */
 538                         if (modest_tny_account_is_virtual_local_folders (
 539                                                                          TNY_ACCOUNT (parent_folder)))
 540                                 return FALSE;
 541                         else {
 542                                 /* If it's the MMC root folder then dim it */
 543                                 if (!strcmp (tny_account_get_id (TNY_ACCOUNT (parent_folder)), MODEST_MMC_ACCOUNT_ID)) {
 544                                         result = TRUE;
 545                                 } else {
 546                                         const gchar *proto_str = tny_account_get_proto (TNY_ACCOUNT (parent_folder));
 547                                         /* If it's POP then dim */
 548                                         result = (modest_protocol_info_get_transport_store_protocol (proto_str) ==
 549                                                   MODEST_PROTOCOL_STORE_POP) ? TRUE : FALSE;
 550                                 }
 551                         }
 552                 }
 553         }
 554
 555         return result;
 556 }
 557
 558
 559 static gboolean
 560 _selected_folder_is_empty (ModestMainWindow *win)
 561 {
 562         GtkWidget *folder_view = NULL;
 563         TnyFolderStore *folder = NULL;
 564         gboolean result = FALSE;
 565
 566         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
 567
 568         /* Get folder view */
 569         folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
 570                                                            MODEST_WIDGET_TYPE_FOLDER_VIEW);
 571         /* If no folder view, always dimmed */
 572         if (!folder_view)
 573                 return TRUE;
 574
 575         /* Get selected folder as parent of new folder to create */
 576         folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
 577         if (!(folder && TNY_IS_FOLDER(folder)))
 578                 return TRUE;
 579
 580         /* Check folder type */
 581         result = tny_folder_get_all_count (TNY_FOLDER (folder)) == 0;
 582
 583         /* free */
 584         g_object_unref (folder);
 585
 586         return result;
 587 }
 588
 589 static gboolean
 590 _selected_folder_is_any_of_type (ModestMainWindow *win,
 591                                  TnyFolderType types[],
 592                                  guint ntypes)
 593 {
 594         GtkWidget *folder_view = NULL;
 595         TnyFolderStore *folder = NULL;
 596         gboolean result = FALSE;
 597
 598         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
 599
 600         /* Get folder view */
 601         folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
 602                                                            MODEST_WIDGET_TYPE_FOLDER_VIEW);
 603         /* If no folder view, always dimmed */
 604         if (!folder_view)
 605                 return TRUE;
 606
 607         /* Get selected folder as parent of new folder to create */
 608         folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
 609         if (!(folder && TNY_IS_FOLDER(folder)))
 610                 return TRUE;
 611
 612         /* Check folder type */
 613         result = _folder_is_any_of_type (TNY_FOLDER(folder), types, ntypes);
 614
 615         /* free */
 616         g_object_unref (folder);
 617
 618         return result;
 619 }
 620
 621 static gboolean
 622 _folder_is_any_of_type (TnyFolder *folder,
 623                         TnyFolderType types[],
 624                         guint ntypes)
 625 {
 626         TnyFolderType folder_type;
 627         gboolean result = FALSE;
 628         guint i;
 629
 630         g_return_val_if_fail (TNY_IS_FOLDER(folder), FALSE);
 631
 632         /* Get folder type */
 633         if (modest_tny_folder_is_local_folder (folder))
 634                 folder_type = modest_tny_folder_get_local_folder_type (folder);
 635         else
 636                 folder_type = modest_tny_folder_guess_folder_type (folder);
 637
 638         /* Check foler type */
 639         for (i=0; i < ntypes; i++) {
 640                 result = result || folder_type == types[i];
 641         }
 642
 643         return result;
 644 }
 645
 646
 647
 648 static gboolean
 649 _invalid_msg_selected (ModestMainWindow *win,
 650                        gboolean unique,
 651                        ModestDimmingRule *rule)
 652 {
 653         GtkWidget *header_view = NULL;
 654         GtkWidget *folder_view = NULL;
 655         TnyList *selected_headers = NULL;
 656         gboolean result = FALSE;
 657
 658         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
 659         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (rule), FALSE);
 660
 661         /* Get header view to check selected messages */
 662         header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
 663                                                            MODEST_WIDGET_TYPE_HEADER_VIEW);
 664
 665         /* Get folder view to check focus */
 666         folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
 667                                                            MODEST_WIDGET_TYPE_FOLDER_VIEW);
 668
 669         /* Get selected headers */
 670         selected_headers = modest_header_view_get_selected_headers (MODEST_HEADER_VIEW(header_view));
 671
 672         /* Check dimmed rule (TODO: check focus on widgets */
 673         if (!result) {
 674                 result = ((selected_headers == NULL) ||
 675                           (GTK_WIDGET_HAS_FOCUS (folder_view)));
 676                 if (result)
 677                         modest_dimming_rule_set_notification (rule, _("mcen_ib_no_message_selected"));
 678         }
 679         if (!result && unique) {
 680                 result = tny_list_get_length (selected_headers) > 1;
 681                 if (result)
 682                         modest_dimming_rule_set_notification (rule, _("mcen_ib_select_one_message"));
 683         }
 684
 685         /* free */
 686         if (selected_headers != NULL)
 687                 g_object_unref (selected_headers);
 688
 689         return result;
 690 }
 691
 692 static gboolean
 693 _already_opened_msg (ModestWindow *win)
 694 {
 695         ModestWindow *window = NULL;
 696         ModestWindowMgr *mgr = NULL;
 697         GtkWidget *header_view = NULL;
 698         TnyList *selected_headers = NULL;
 699         TnyIterator *iter = NULL;
 700         TnyHeader *header = NULL;
 701         gboolean result = TRUE;
 702
 703         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
 704
 705         /* Get header view to check selected messages */
 706         header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
 707                                                            MODEST_WIDGET_TYPE_HEADER_VIEW);
 708
 709         /* Get selected headers */
 710         selected_headers = modest_header_view_get_selected_headers (MODEST_HEADER_VIEW(header_view));
 711         if (selected_headers == NULL)
 712                 return FALSE;
 713
 714         /* Check dimmed rule (TODO: check focus on widgets */
 715         mgr = modest_runtime_get_window_mgr ();
 716         iter = tny_list_create_iterator (selected_headers);
 717         while (!tny_iterator_is_done (iter) && result) {
 718                 header = TNY_HEADER (tny_iterator_get_current (iter));
 719                 window = modest_window_mgr_find_window_by_header (mgr, header);
 720                 result = result && (window != NULL);
 721
 722                 g_object_unref (header);
 723                 tny_iterator_next (iter);
 724         }
 725
 726         /* free */
 727         if (selected_headers != NULL)
 728                 g_object_unref (selected_headers);
 729         if (iter != NULL)
 730                 g_object_unref (iter);
 731
 732         return result;
 733 }
 734
 735 static gboolean
 736 _selected_msg_marked_as (ModestWindow *win,
 737                          TnyHeaderFlags mask,
 738                          gboolean opposite)
 739 {
 740         GtkWidget *header_view = NULL;
 741         TnyList *selected_headers = NULL;
 742         TnyIterator *iter = NULL;
 743         TnyHeader *header = NULL;
 744         TnyHeaderFlags flags;
 745         gboolean result = FALSE;
 746
 747         /* Get header view to check selected messages */
 748         header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
 749                                                            MODEST_WIDGET_TYPE_HEADER_VIEW);
 750
 751         /* Get selected headers */
 752         selected_headers = modest_header_view_get_selected_headers (MODEST_HEADER_VIEW(header_view));
 753         if (selected_headers == NULL)
 754                 return TRUE;
 755
 756         /* Call the function for each header */
 757         iter = tny_list_create_iterator (selected_headers);
 758         while (!tny_iterator_is_done (iter) && !result) {
 759                 header = TNY_HEADER (tny_iterator_get_current (iter));
 760
 761                 flags = tny_header_get_flags (header);
 762                 if (opposite)
 763                         result = (flags & mask) == 0;
 764                 else
 765                         result = (flags & mask) != 0;
 766
 767                 g_object_unref (header);
 768                 tny_iterator_next (iter);
 769         }
 770
 771         /* free */
 772         if (selected_headers != NULL)
 773                 g_object_unref (selected_headers);
 774         if (iter != NULL)
 775                 g_object_unref (iter);
 776
 777         return result;
 778 }
 779
 780 static gboolean
 781 _msg_download_in_progress (ModestMsgViewWindow *win)
 782 {
 783         gboolean result = FALSE;
 784
 785         g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW (win), FALSE);
 786
 787         result = modest_msg_view_window_toolbar_on_transfer_mode (win);
 788
 789         return result;
 790 }
 791
 792 static gboolean
 793 _msg_download_completed (ModestMainWindow *win)
 794 {
 795         GtkWidget *header_view = NULL;
 796         TnyList *selected_headers = NULL;
 797         TnyIterator *iter = NULL;
 798         TnyHeader *header = NULL;
 799         TnyHeaderFlags flags;
 800         gboolean result = FALSE;
 801
 802         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW (win), FALSE);
 803
 804
 805         /* Get header view to check selected messages */
 806         header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
 807                                                            MODEST_WIDGET_TYPE_HEADER_VIEW);
 808
 809         /* Get selected headers */
 810         selected_headers = modest_header_view_get_selected_headers (MODEST_HEADER_VIEW(header_view));
 811         if (selected_headers == NULL)
 812                 return TRUE;
 813
 814         /* Check dimmed rule  */
 815         result = TRUE;
 816         iter = tny_list_create_iterator (selected_headers);
 817         while (!tny_iterator_is_done (iter) && result) {
 818                 header = TNY_HEADER (tny_iterator_get_current (iter));
 819
 820                 flags = tny_header_get_flags (header);
 821                 /* TODO: is this the right flag?, it seems that some
 822                    headers that have been previously downloaded do not
 823                    come with it */
 824                 result = (flags & TNY_HEADER_FLAG_CACHED);
 825
 826                 g_object_unref (header);
 827                 tny_iterator_next (iter);
 828         }
 829
 830         g_object_unref (iter);
 831
 832         return result;
 833 }
 834
 835 static gboolean
 836 _msg_sent_in_progress (ModestWindow *win)
 837 {
 838 /*      ModestTnySendQueue *send_queue = NULL; */
 839 /*      GtkWidget *header_view = NULL;  */
 840 /*      ModestTnyAccountStore *acc_store = NULL; */
 841 /*      TnyAccount *account = NULL;      */
 842 /*      TnyList *header_list = NULL; */
 843 /*      TnyIterator *iter = NULL; */
 844 /*      TnyHeader *header = NULL; */
 845 /*      const gchar *account_name = NULL; */
 846         gboolean result = FALSE;
 847 /*      gchar *id = NULL; */
 848
 849 /*      g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW (win), FALSE); */
 850
 851 /*      /\* Get transport account *\/   */
 852 /*      acc_store = modest_runtime_get_account_store(); */
 853 /*      account_name = modest_window_get_active_account (win);   */
 854 /*      account = modest_tny_account_store_get_transport_account_for_open_connection (acc_store, account_name); */
 855
 856 /*      /\* Get send queue for current ransport account *\/  */
 857 /*      send_queue = modest_runtime_get_send_queue (TNY_TRANSPORT_ACCOUNT(account)); */
 858 /*      g_return_val_if_fail (MODEST_IS_TNY_SEND_QUEUE (send_queue), FALSE); */
 859
 860 /*      if (MODEST_IS_MAIN_WINDOW(win)) { */
 861
 862 /*              /\* Get header view to check selected messages *\/ */
 863 /*              header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win), */
 864 /*                                                                 MODEST_WIDGET_TYPE_HEADER_VIEW); */
 865
 866 /*              /\* Get selected headers *\/ */
 867 /*              header_list = modest_header_view_get_selected_headers (MODEST_HEADER_VIEW(header_view)); */
 868
 869 /*              /\* Get message header *\/ */
 870 /*              if (!header_list) return FALSE; */
 871 /*              iter = tny_list_create_iterator (header_list); */
 872 /*              header = TNY_HEADER (tny_iterator_get_current (iter)); */
 873
 874 /*              /\* Get message id *\/ */
 875 /*              id = g_strdup(tny_header_get_message_id (header));               */
 876
 877 /*         } else if (MODEST_IS_MSG_VIEW_WINDOW(win)) { */
 878
 879 /*              /\* Get message header *\/ */
 880 /*              header = modest_msg_view_window_get_header (MODEST_MSG_VIEW_WINDOW(win));                */
 881
 882 /*              /\* Get message id *\/ */
 883 /*              id = g_strdup(tny_header_get_message_id (header));               */
 884 /*      } */
 885
 886 /*      /\* Check if msg id is being processed inside send queue *\/ */
 887 /*      result = modest_tny_send_queue_msg_is_being_sent (send_queue, id); */
 888
 889 /*      /\* Free *\/ */
 890 /*      g_free(id); */
 891 /*      g_object_unref (header); */
 892 /*      g_free(header_list); */
 893 /*      g_free(iter); */
 894
 895         return result;
 896 }
 897