git.maemo.org Git - modest/blob - src/modest-ui-dimming-rules.c

   1 /* Copyright (c) 2006, Nokia Corporation
   2  * All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions are
   6  * met:
   7  *
   8  * * Redistributions of source code must retain the above copyright
   9  *   notice, this list of conditions and the following disclaimer.
  10  * * Redistributions in binary form must reproduce the above copyright
  11  *   notice, this list of conditions and the following disclaimer in the
  12  *   documentation and/or other materials provided with the distribution.
  13  * * Neither the name of the Nokia Corporation nor the names of its
  14  *   contributors may be used to endorse or promote products derived from
  15  *   this software without specific prior written permission.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
  18  * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  19  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
  20  * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
  21  * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  22  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  23  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  24  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  25  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  26  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  27  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  28  */
  29
  30 #ifdef HAVE_CONFIG_H
  31 #include <config.h>
  32 #endif /*HAVE_CONFIG_H*/
  33
  34 #include <string.h>
  35 #include "modest-ui-dimming-rules.h"
  36 #include "modest-dimming-rule.h"
  37 #include "modest-tny-folder.h"
  38 #include "modest-text-utils.h"
  39 #include <widgets/modest-attachments-view.h>
  40 #include <modest-runtime.h>
  41 #include <tny-simple-list.h>
  42
  43
  44 static gboolean _folder_is_any_of_type (TnyFolder *folder, TnyFolderType types[], guint ntypes);
  45 static gboolean _invalid_msg_selected (ModestMainWindow *win, gboolean unique, ModestDimmingRule *rule);
  46 static gboolean _invalid_attach_selected (ModestWindow *win, gboolean unique, gboolean for_view, ModestDimmingRule *rule);
  47 static gboolean _purged_attach_selected (ModestWindow *win);
  48 static gboolean _clipboard_is_empty (ModestWindow *win);
  49 static gboolean _invalid_clipboard_selected (ModestWindow *win, ModestDimmingRule *rule);
  50 static gboolean _already_opened_msg (ModestWindow *win, guint *n_messages);
  51 static gboolean _selected_msg_marked_as (ModestWindow *win, TnyHeaderFlags mask, gboolean opposite);
  52 static gboolean _selected_folder_not_writeable (ModestMainWindow *win);
  53 static gboolean _selected_folder_is_snd_level (ModestMainWindow *win);
  54 static gboolean _selected_folder_is_any_of_type (ModestWindow *win, TnyFolderType types[], guint ntypes);
  55 static gboolean _selected_folder_is_root_or_inbox (ModestMainWindow *win);
  56 static gboolean _selected_folder_is_MMC_or_POP_root (ModestMainWindow *win);
  57 static gboolean _selected_folder_is_root (ModestMainWindow *win);
  58 static gboolean _selected_folder_is_empty (ModestMainWindow *win);
  59 static gboolean _selected_folder_is_same_as_source (ModestWindow *win);
  60 static gboolean _msg_download_in_progress (ModestMsgViewWindow *win);
  61 static gboolean _msg_download_completed (ModestMainWindow *win);
  62 static gboolean _selected_msg_sent_in_progress (ModestWindow *win);
  63 static gboolean _sending_in_progress (ModestWindow *win);
  64 static gboolean _marked_as_deleted (ModestWindow *win);
  65 static gboolean _invalid_attachment_for_purge (ModestWindow *win, ModestDimmingRule *rule);
  66
  67
  68 gboolean
  69 modest_ui_dimming_rules_on_new_msg (ModestWindow *win, gpointer user_data)
  70 {
  71         ModestDimmingRule *rule = NULL;
  72         gboolean dimmed = FALSE;
  73
  74         g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW(win), FALSE);
  75         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
  76         rule = MODEST_DIMMING_RULE (user_data);
  77
  78         /* Check dimmed rule */
  79         if (!dimmed) {
  80                 dimmed = _msg_download_in_progress (MODEST_MSG_VIEW_WINDOW(win));
  81                 if (dimmed)
  82                         modest_dimming_rule_set_notification (rule, "");
  83         }
  84
  85         return dimmed;
  86 }
  87
  88 gboolean
  89 modest_ui_dimming_rules_on_csm_new_folder (ModestWindow *win, gpointer user_data)
  90 {
  91         ModestDimmingRule *rule = NULL;
  92         gboolean dimmed = FALSE;
  93
  94         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
  95         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
  96         rule = MODEST_DIMMING_RULE (user_data);
  97
  98         /* Check common new folder menu item dimming rules */
  99         dimmed = modest_ui_dimming_rules_on_new_folder (win, user_data);
 100
 101         /* Check CSM specific dimming rules */
 102         if (!dimmed) {
 103                 dimmed = _selected_folder_is_snd_level (MODEST_MAIN_WINDOW(win));
 104                 if (dimmed)
 105                         modest_dimming_rule_set_notification (rule, _("mail_in_ui_folder_create_error"));
 106         }
 107
 108         return dimmed;
 109 }
 110
 111 gboolean
 112 modest_ui_dimming_rules_on_new_folder (ModestWindow *win, gpointer user_data)
 113 {
 114         ModestDimmingRule *rule = NULL;
 115         GtkWidget *folder_view = NULL;
 116         TnyFolderStore *parent_folder = NULL;
 117         gboolean dimmed = FALSE;
 118
 119         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
 120         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 121         rule = MODEST_DIMMING_RULE (user_data);
 122
 123         /* Get selected folder as parent of new folder to create */
 124         folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
 125                                                            MODEST_WIDGET_TYPE_FOLDER_VIEW);
 126         parent_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
 127         if (!parent_folder)
 128                 return TRUE;
 129
 130         if (TNY_IS_ACCOUNT (parent_folder)) {
 131                 /* If it's the local account then do not dim */
 132                 if (modest_tny_account_is_virtual_local_folders (TNY_ACCOUNT (parent_folder))) {
 133                         dimmed = FALSE;
 134                 } else {
 135                         const gchar *proto_str = tny_account_get_proto (TNY_ACCOUNT (parent_folder));
 136                         /* If it's POP then dim */
 137                         dimmed = (modest_protocol_info_get_transport_store_protocol (proto_str) ==
 138                                   MODEST_PROTOCOL_STORE_POP) ? TRUE : FALSE;
 139                         if (dimmed)
 140                                 modest_dimming_rule_set_notification (rule, _("mail_in_ui_folder_create_error"));
 141                 }
 142         } else {
 143                 /* TODO: the specs say that only one level of subfolder is allowed, is this true ? */
 144
 145                 TnyFolderType types[3];
 146
 147                 types[0] = TNY_FOLDER_TYPE_DRAFTS;
 148                 types[1] = TNY_FOLDER_TYPE_OUTBOX;
 149                 types[2] = TNY_FOLDER_TYPE_SENT;
 150
 151                 /* Apply folder rules */
 152                 if (!dimmed) {
 153                         dimmed = _selected_folder_not_writeable (MODEST_MAIN_WINDOW(win));
 154                         if (dimmed)
 155                                 modest_dimming_rule_set_notification (rule, _("mail_in_ui_folder_create_error"));
 156                 }
 157                 if (!dimmed) {
 158                         dimmed = _selected_folder_is_any_of_type (win, types, 3);
 159                         if (dimmed)
 160                                 modest_dimming_rule_set_notification (rule, _("mail_in_ui_folder_create_error"));
 161                 }
 162         }
 163         g_object_unref (parent_folder);
 164
 165         return dimmed;
 166 }
 167
 168 gboolean
 169 modest_ui_dimming_rules_on_delete_folder (ModestWindow *win, gpointer user_data)
 170 {
 171         ModestDimmingRule *rule = NULL;
 172         TnyFolderType types[5];
 173         gboolean dimmed = FALSE;
 174
 175         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
 176         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 177         rule = MODEST_DIMMING_RULE (user_data);
 178
 179         types[0] = TNY_FOLDER_TYPE_DRAFTS;
 180         types[1] = TNY_FOLDER_TYPE_OUTBOX;
 181         types[2] = TNY_FOLDER_TYPE_SENT;
 182         types[3] = TNY_FOLDER_TYPE_INBOX;
 183         types[4] = TNY_FOLDER_TYPE_ROOT;
 184
 185
 186         /* Check dimmed rule */
 187         if (!dimmed) {
 188                 dimmed = _selected_folder_not_writeable (MODEST_MAIN_WINDOW(win));
 189                 if (dimmed)
 190                         modest_dimming_rule_set_notification (rule, _("mail_in_ui_folder_delete_error"));
 191         }
 192         if (!dimmed) {
 193                 dimmed = _selected_folder_is_any_of_type (win, types, 5);
 194                 if (dimmed)
 195                         modest_dimming_rule_set_notification (rule, _("mail_in_ui_folder_delete_error"));
 196         }
 197         if (!dimmed) {
 198                 dimmed = _selected_folder_is_root_or_inbox (MODEST_MAIN_WINDOW(win));
 199                 if (dimmed)
 200                         modest_dimming_rule_set_notification (rule, _("mail_in_ui_folder_delete_error"));
 201         }
 202         if (!dimmed) {
 203                 dimmed = _selected_folder_is_MMC_or_POP_root (MODEST_MAIN_WINDOW(win));
 204                 if (dimmed)
 205                         modest_dimming_rule_set_notification (rule, _("mail_in_ui_folder_delete_error"));
 206         }
 207
 208         return dimmed;
 209 }
 210
 211 gboolean
 212 modest_ui_dimming_rules_on_sort (ModestWindow *win, gpointer user_data)
 213 {
 214         ModestDimmingRule *rule = NULL;
 215         gboolean dimmed = FALSE;
 216
 217         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
 218         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 219         rule = MODEST_DIMMING_RULE (user_data);
 220
 221         /* Check dimmed rule */
 222         if (!dimmed) {
 223                 dimmed = _selected_folder_is_root (MODEST_MAIN_WINDOW(win));
 224                 if (dimmed)
 225                         modest_dimming_rule_set_notification (rule, "");
 226         }
 227
 228         return dimmed;
 229
 230 }
 231
 232 gboolean
 233 modest_ui_dimming_rules_on_rename_folder (ModestWindow *win, gpointer user_data)
 234 {
 235         ModestDimmingRule *rule = NULL;
 236         TnyFolderType types[3];
 237         gboolean dimmed = FALSE;
 238
 239         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
 240         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 241         rule = MODEST_DIMMING_RULE (user_data);
 242
 243         types[0] = TNY_FOLDER_TYPE_DRAFTS;
 244         types[1] = TNY_FOLDER_TYPE_OUTBOX;
 245         types[2] = TNY_FOLDER_TYPE_SENT;
 246
 247         /* Check dimmed rule */
 248         if (!dimmed) {
 249                 dimmed = _selected_folder_not_writeable (MODEST_MAIN_WINDOW(win));
 250                 if (dimmed)
 251                         modest_dimming_rule_set_notification (rule, "");
 252         }
 253         if (!dimmed) {
 254                 dimmed = _selected_folder_is_root_or_inbox (MODEST_MAIN_WINDOW(win));
 255                 if (dimmed)
 256                         modest_dimming_rule_set_notification (rule, "");
 257         }
 258         if (!dimmed) {
 259                 dimmed = _selected_folder_is_any_of_type (win, types, 3);
 260                 if (dimmed)
 261                         modest_dimming_rule_set_notification (rule, "");
 262         }
 263
 264         return dimmed;
 265 }
 266
 267 gboolean
 268 modest_ui_dimming_rules_on_open_msg (ModestWindow *win, gpointer user_data)
 269 {
 270         ModestDimmingRule *rule = NULL;
 271         gboolean dimmed = FALSE;
 272
 273         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
 274         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 275         rule = MODEST_DIMMING_RULE (user_data);
 276
 277         /* Check dimmed rule */
 278         if (!dimmed) {
 279                 dimmed = _invalid_msg_selected (MODEST_MAIN_WINDOW(win), TRUE, user_data);
 280         }
 281         if (!dimmed) {
 282                 dimmed = _selected_msg_sent_in_progress (win);
 283                 if (dimmed)
 284                         modest_dimming_rule_set_notification (rule, _("mcen_ib_unable_to_open_while_sent"));
 285         }
 286
 287         return dimmed;
 288 }
 289
 290 gboolean
 291 modest_ui_dimming_rules_on_reply_msg (ModestWindow *win, gpointer user_data)
 292 {
 293         ModestDimmingRule *rule = NULL;
 294         gboolean dimmed = FALSE;
 295         TnyFolderType types[3];
 296
 297         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 298         rule = MODEST_DIMMING_RULE (user_data);
 299
 300         /* main window dimming rules */
 301         if (MODEST_IS_MAIN_WINDOW(win)) {
 302
 303                 types[0] = TNY_FOLDER_TYPE_DRAFTS;
 304                 types[1] = TNY_FOLDER_TYPE_OUTBOX;
 305                 types[2] = TNY_FOLDER_TYPE_ROOT;
 306
 307                 /* Check dimmed rule */
 308                 if (!dimmed) {
 309                         dimmed = _selected_folder_is_any_of_type (win, types, 3);
 310                         if (dimmed)
 311                                 modest_dimming_rule_set_notification (rule, _("mcen_ib_unable_to_reply"));
 312                 }
 313                 if (!dimmed) {
 314                         dimmed = _selected_folder_is_empty (MODEST_MAIN_WINDOW(win));
 315                         if (dimmed)
 316                                 modest_dimming_rule_set_notification (rule, _("mcen_ib_nothing_to_reply"));
 317                 }
 318                 if (!dimmed) {
 319                         dimmed = _invalid_msg_selected (MODEST_MAIN_WINDOW(win), TRUE, rule);
 320                 }
 321         /* msg view window dimming rules */
 322         } else if (MODEST_IS_MSG_VIEW_WINDOW(win)) {
 323
 324                 /* Check dimmed rule */
 325                 if (!dimmed) {
 326                         dimmed = _msg_download_in_progress (MODEST_MSG_VIEW_WINDOW(win));
 327                         if (dimmed)
 328                                 modest_dimming_rule_set_notification (rule, "");
 329                 }
 330         }
 331
 332         return dimmed;
 333 }
 334
 335
 336 gboolean
 337 modest_ui_dimming_rules_on_contents_msg (ModestWindow *win, gpointer user_data)
 338 {
 339         ModestDimmingRule *rule = NULL;
 340         gboolean dimmed = FALSE;
 341
 342         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
 343         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 344         rule = MODEST_DIMMING_RULE (user_data);
 345
 346         /* Check dimmed rule */
 347         if (!dimmed) {
 348                 dimmed = _invalid_msg_selected (MODEST_MAIN_WINDOW(win), FALSE, user_data);
 349         }
 350         if (!dimmed) {
 351                 dimmed = _msg_download_completed (MODEST_MAIN_WINDOW(win));
 352                 if (dimmed)
 353                         modest_dimming_rule_set_notification (rule, "");
 354         }
 355
 356         return dimmed;
 357 }
 358
 359 gboolean
 360 modest_ui_dimming_rules_always_dimmed (ModestWindow *win, gpointer user_data)
 361 {
 362         gboolean dimmed = FALSE;
 363
 364         g_return_val_if_fail (MODEST_IS_WINDOW(win), FALSE);
 365
 366         /* Check dimmed rule */
 367         if (!dimmed)
 368                 dimmed = TRUE;
 369
 370         return dimmed;
 371 }
 372
 373 gboolean
 374 modest_ui_dimming_rules_on_delete_msg (ModestWindow *win, gpointer user_data)
 375 {
 376         ModestDimmingRule *rule = NULL;
 377         guint n_messages = 0;
 378         gboolean dimmed = FALSE;
 379
 380         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 381         rule = MODEST_DIMMING_RULE (user_data);
 382
 383         /* Check dimmed rule */
 384         if (MODEST_IS_MAIN_WINDOW (win)) {
 385                 if (!dimmed) {
 386                         dimmed = _selected_folder_is_empty (MODEST_MAIN_WINDOW(win));
 387                         if (dimmed)
 388                                 modest_dimming_rule_set_notification (rule, _CS("ckct_ib_nothing_to_delete"));
 389                 }
 390                 if (!dimmed) {
 391                         dimmed = _invalid_msg_selected (MODEST_MAIN_WINDOW(win), FALSE, user_data);
 392                 }
 393                 if (!dimmed) {
 394                         dimmed = _already_opened_msg (win, &n_messages);
 395                         if (dimmed) {
 396                                 gchar *num = g_strdup_printf ("%d", n_messages);
 397                                 gchar *message = g_strdup_printf(_("mcen_nc_unable_to_delete_n_messages"), num);
 398 /*                              modest_dimming_rule_set_notification (rule, _("mcen_nc_unable_to_delete_n_messages")); */
 399                                 modest_dimming_rule_set_notification (rule, message);
 400                                 g_free(message);
 401                                 g_free(num);
 402                         }
 403                 }
 404                 if (!dimmed) {
 405                         dimmed = _marked_as_deleted (win);
 406                         if (dimmed)
 407                                 modest_dimming_rule_set_notification (rule, _("mcen_ib_message_unableto_delete"));
 408                 }
 409                 if (!dimmed) {
 410                         dimmed = _selected_msg_sent_in_progress (win);
 411                         if (dimmed)
 412                                 modest_dimming_rule_set_notification (rule, _("mcen_ib_message_unableto_delete"));
 413                 }
 414         }
 415         else if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
 416                 if (!dimmed) {
 417                         dimmed = !modest_msg_view_window_has_headers_model (MODEST_MSG_VIEW_WINDOW(win));
 418                         if (dimmed) {
 419                                 gchar *num = g_strdup("1");
 420                                 gchar *message = g_strdup_printf(_("mcen_nc_unable_to_delete_n_messages"), num);
 421 /*                              modest_dimming_rule_set_notification (rule, _("mcen_nc_unable_to_delete_n_messages")); */
 422                                 modest_dimming_rule_set_notification (rule, message);
 423                                 g_free(message);
 424                                 g_free(num);
 425                         }
 426                 }
 427         }
 428
 429         return dimmed;
 430 }
 431
 432 gboolean
 433 modest_ui_dimming_rules_on_details (ModestWindow *win, gpointer user_data)
 434 {
 435         ModestDimmingRule *rule = NULL;
 436         GtkWidget *header_view = NULL;
 437         gboolean dimmed = FALSE;
 438
 439         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 440         rule = MODEST_DIMMING_RULE (user_data);
 441
 442         /* main window dimming rules */
 443         if (MODEST_IS_MAIN_WINDOW(win)) {
 444
 445                 /* Check dimmed rule */
 446                 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
 447                                                                    MODEST_WIDGET_TYPE_HEADER_VIEW);
 448
 449                 /* If the header view has the focus: */
 450                 if (header_view && gtk_widget_is_focus (header_view)) {
 451                         /* Check dimmed rule */
 452                         if (!dimmed)
 453                                 dimmed = _invalid_msg_selected (MODEST_MAIN_WINDOW(win), TRUE, user_data);
 454                 }
 455                 else {
 456                         /* If the folder view has the focus: */
 457                         GtkWidget *folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
 458                                 MODEST_WIDGET_TYPE_FOLDER_VIEW);
 459                         if (folder_view && gtk_widget_is_focus (folder_view)) {
 460                                 TnyFolderStore *folder_store
 461                                         = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
 462                                 if (folder_store) {
 463                                         /* Only enable for folders, not accounts,
 464                                          * though the UI spec is not clear about that.
 465                                          * If we enable this for accounts then we must
 466                                          * add code to handle them in modest_ui_actions_on_details(). */
 467                                         if (!TNY_IS_FOLDER(folder_store)) {
 468                                                 dimmed = TRUE;
 469                                                 modest_dimming_rule_set_notification (rule, "");
 470                                         }
 471
 472                                         g_object_unref (folder_store);
 473                                 }
 474                         }
 475
 476                 }
 477
 478         /* msg view window dimming rules */
 479         } else {
 480
 481                 /* Check dimmed rule */
 482                 if (!dimmed) {
 483                         dimmed = _msg_download_in_progress (MODEST_MSG_VIEW_WINDOW(win));
 484                         if (dimmed)
 485                                 modest_dimming_rule_set_notification (rule, "");
 486                 }
 487         }
 488
 489         return dimmed;
 490 }
 491
 492
 493 gboolean
 494 modest_ui_dimming_rules_on_mark_as_read_msg (ModestWindow *win, gpointer user_data)
 495 {
 496         ModestDimmingRule *rule = NULL;
 497         TnyHeaderFlags flags;
 498         gboolean dimmed = FALSE;
 499
 500         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
 501         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 502         rule = MODEST_DIMMING_RULE (user_data);
 503
 504         flags = TNY_HEADER_FLAG_SEEN;
 505
 506         /* Check dimmed rule */
 507         if (!dimmed) {
 508                 dimmed = _invalid_msg_selected (MODEST_MAIN_WINDOW(win), FALSE, user_data);
 509         }
 510         if (!dimmed) {
 511                 dimmed = _selected_msg_marked_as (win, flags, FALSE);
 512                 if (dimmed)
 513                         modest_dimming_rule_set_notification (rule, "");
 514         }
 515
 516         return dimmed;
 517 }
 518
 519 gboolean
 520 modest_ui_dimming_rules_on_mark_as_unread_msg (ModestWindow *win, gpointer user_data)
 521 {
 522         ModestDimmingRule *rule = NULL;
 523         TnyHeaderFlags flags;
 524         gboolean dimmed = FALSE;
 525
 526         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
 527         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 528         rule = MODEST_DIMMING_RULE (user_data);
 529
 530         flags = TNY_HEADER_FLAG_SEEN;
 531
 532         /* Check dimmed rule */
 533         if (!dimmed)
 534                 dimmed = _invalid_msg_selected (MODEST_MAIN_WINDOW(win), FALSE, user_data);
 535         if (!dimmed) {
 536                 dimmed = _selected_msg_marked_as (win, flags, TRUE);
 537                 if (dimmed)
 538                         modest_dimming_rule_set_notification (rule, "");
 539         }
 540
 541         return dimmed;
 542 }
 543
 544 gboolean
 545 modest_ui_dimming_rules_on_move_to (ModestWindow *win, gpointer user_data)
 546 {
 547         ModestDimmingRule *rule = NULL;
 548         gboolean dimmed = FALSE;
 549
 550         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 551         rule = MODEST_DIMMING_RULE (user_data);
 552
 553         if (MODEST_IS_MAIN_WINDOW (win))
 554                 dimmed = modest_ui_dimming_rules_on_main_window_move_to (win, user_data);
 555         else if (MODEST_IS_MSG_VIEW_WINDOW (win))
 556                  dimmed = modest_ui_dimming_rules_on_view_window_move_to (win, user_data);
 557
 558         return dimmed;
 559 }
 560
 561
 562 gboolean
 563 modest_ui_dimming_rules_on_main_window_move_to (ModestWindow *win, gpointer user_data)
 564 {
 565         GtkWidget *folder_view = NULL;
 566         GtkWidget *header_view = NULL;
 567         ModestDimmingRule *rule = NULL;
 568         gboolean dimmed = FALSE;
 569
 570         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), TRUE);
 571         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 572         rule = MODEST_DIMMING_RULE (user_data);
 573
 574         /* Get the folder view */
 575         folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
 576                                                            MODEST_WIDGET_TYPE_FOLDER_VIEW);
 577
 578         /* Get header view */
 579         header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
 580                                                            MODEST_WIDGET_TYPE_HEADER_VIEW);
 581
 582         /* Check diming rules for folders and messages transfer  */
 583         if (!dimmed) {
 584                 dimmed = _invalid_msg_selected (MODEST_MAIN_WINDOW(win), FALSE, user_data);
 585
 586         }
 587
 588         return dimmed;
 589 }
 590
 591 gboolean
 592 modest_ui_dimming_rules_on_view_window_move_to (ModestWindow *win, gpointer user_data)
 593 {
 594         ModestDimmingRule *rule = NULL;
 595         gboolean dimmed = FALSE;
 596
 597         g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW(win), FALSE);
 598         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 599         rule = MODEST_DIMMING_RULE (user_data);
 600
 601         /* Check dimmed rule */
 602         if (!dimmed) {
 603                 dimmed = !modest_msg_view_window_has_headers_model (MODEST_MSG_VIEW_WINDOW(win));
 604                 if (dimmed)
 605                         modest_dimming_rule_set_notification (rule, _("mcen_ib_unable_to_move_mail_attachment"));
 606
 607         }
 608
 609         return dimmed;
 610 }
 611
 612 gboolean
 613 modest_ui_dimming_rules_on_paste_msgs (ModestWindow *win, gpointer user_data)
 614 {
 615         ModestDimmingRule *rule = NULL;
 616         TnyFolderType types[3];
 617         gboolean dimmed = FALSE;
 618
 619         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
 620         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 621         rule = MODEST_DIMMING_RULE (user_data);
 622
 623         types[0] = TNY_FOLDER_TYPE_DRAFTS;
 624         types[1] = TNY_FOLDER_TYPE_OUTBOX;
 625         types[2] = TNY_FOLDER_TYPE_SENT;
 626
 627         /* Check dimmed rule */
 628         if (!dimmed) {
 629                 dimmed = _clipboard_is_empty (win);
 630                 if (dimmed)
 631                         modest_dimming_rule_set_notification (rule, "");
 632         }
 633         if (!dimmed) {
 634                 dimmed = _selected_folder_is_any_of_type (win, types, 3);
 635                 if (dimmed)
 636                         modest_dimming_rule_set_notification (rule, _("ckct_ib_unable_to_paste_here"));
 637         }
 638         if (!dimmed) {
 639                 dimmed = _selected_folder_is_same_as_source (win);
 640                 if (dimmed)
 641                         modest_dimming_rule_set_notification (rule, _("mcen_ib_unable_to_copy_samefolder"));
 642         }
 643
 644         return dimmed;
 645 }
 646
 647
 648 gboolean
 649 modest_ui_dimming_rules_on_select_all (ModestWindow *win, gpointer user_data)
 650 {
 651         ModestDimmingRule *rule = NULL;
 652         gboolean dimmed = FALSE;
 653
 654         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
 655         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 656         rule = MODEST_DIMMING_RULE (user_data);
 657
 658         /* Check dimmed rule */
 659         if (!dimmed) {
 660                 dimmed = _selected_folder_is_empty (MODEST_MAIN_WINDOW(win));
 661                 if (dimmed)
 662                         modest_dimming_rule_set_notification (rule, "");
 663         }
 664
 665         return dimmed;
 666 }
 667
 668 gboolean
 669 modest_ui_dimming_rules_on_view_attachments (ModestWindow *win, gpointer user_data)
 670 {
 671         ModestDimmingRule *rule = NULL;
 672         gboolean dimmed = FALSE;
 673
 674         g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW(win), FALSE);
 675         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 676         rule = MODEST_DIMMING_RULE (user_data);
 677
 678         /* Check dimmed rule */
 679         if (!dimmed)
 680                 dimmed = _invalid_attach_selected (win, TRUE, TRUE, rule);
 681
 682         return dimmed;
 683 }
 684
 685 gboolean
 686 modest_ui_dimming_rules_on_save_attachments (ModestWindow *win, gpointer user_data)
 687 {
 688         ModestDimmingRule *rule = NULL;
 689         gboolean dimmed = FALSE;
 690
 691         g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW(win), FALSE);
 692         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 693         rule = MODEST_DIMMING_RULE (user_data);
 694
 695         /* Check dimmed rule */
 696         if (!dimmed)
 697                 dimmed = _invalid_attach_selected (win, FALSE, FALSE, rule);
 698
 699         return dimmed;
 700 }
 701
 702 gboolean
 703 modest_ui_dimming_rules_on_remove_attachments (ModestWindow *win, gpointer user_data)
 704 {
 705         ModestDimmingRule *rule = NULL;
 706         gboolean dimmed = FALSE;
 707
 708         g_return_val_if_fail (MODEST_IS_WINDOW(win), FALSE);
 709         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 710         rule = MODEST_DIMMING_RULE (user_data);
 711
 712         /* Check dimmed rule */
 713         if (!dimmed) {
 714                 dimmed = _purged_attach_selected (win);
 715                 if (dimmed)
 716                         modest_dimming_rule_set_notification (rule, _("mail_ib_attachment_already_purged"));
 717         }
 718
 719         if (!dimmed) {
 720                 dimmed = _invalid_attachment_for_purge (win, rule);
 721         }
 722
 723
 724         return dimmed;
 725 }
 726
 727 gboolean
 728 modest_ui_dimming_rules_on_undo (ModestWindow *win, gpointer user_data)
 729 {
 730         ModestDimmingRule *rule = NULL;
 731         gboolean dimmed = FALSE;
 732
 733         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 734         rule = MODEST_DIMMING_RULE (user_data);
 735
 736         /* Check dimmed rule */
 737         if (!dimmed) {
 738                 dimmed = _clipboard_is_empty (win);
 739                 if (dimmed)
 740                         modest_dimming_rule_set_notification (rule, "");
 741         }
 742
 743         return dimmed;
 744 }
 745
 746 gboolean
 747 modest_ui_dimming_rules_on_cut (ModestWindow *win, gpointer user_data)
 748 {
 749         ModestDimmingRule *rule = NULL;
 750         gboolean dimmed = FALSE;
 751
 752         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 753         rule = MODEST_DIMMING_RULE (user_data);
 754
 755         /* Check common dimming rules */
 756         if (!dimmed) {
 757                 dimmed = _invalid_clipboard_selected (win, rule);
 758         }
 759
 760         /* Check window specific dimming rules */
 761         if (MODEST_IS_MAIN_WINDOW (win)) {
 762                 if (!dimmed) {
 763                         dimmed = _selected_folder_not_writeable (MODEST_MAIN_WINDOW(win));
 764                         if (dimmed)
 765                                 modest_dimming_rule_set_notification (rule, _("mcen_ib_message_unableto_delete"));
 766                 }
 767                 if (!dimmed) {
 768                         dimmed = _selected_folder_is_empty (MODEST_MAIN_WINDOW(win));
 769                         if (dimmed)
 770                                 modest_dimming_rule_set_notification (rule, "");
 771                 }
 772                 if (!dimmed) {
 773                         dimmed = _selected_msg_sent_in_progress (win);
 774                         if (dimmed)
 775                                 modest_dimming_rule_set_notification (rule, _("mcen_ib_unable_to_cut_mess"));
 776                 }
 777         }
 778
 779         return dimmed;
 780 }
 781
 782 gboolean
 783 modest_ui_dimming_rules_on_copy (ModestWindow *win, gpointer user_data)
 784 {
 785         ModestDimmingRule *rule = NULL;
 786         gboolean dimmed = FALSE;
 787
 788         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 789         rule = MODEST_DIMMING_RULE (user_data);
 790
 791         /* Check common dimming rules */
 792         if (!dimmed) {
 793                 dimmed = _invalid_clipboard_selected (win, rule);
 794         }
 795
 796         /* Check window specific dimming rules */
 797         if (MODEST_IS_MAIN_WINDOW (win)) {
 798                 if (!dimmed) {
 799                         dimmed = _selected_folder_is_empty (MODEST_MAIN_WINDOW(win));
 800                         if (dimmed)
 801                                 modest_dimming_rule_set_notification (rule, "");
 802                 }
 803                 if (!dimmed) {
 804                         dimmed = _selected_msg_sent_in_progress (win);
 805                         if (dimmed)
 806                                 modest_dimming_rule_set_notification (rule, _("mcen_ib_unable_to_cut_mess"));
 807                 }
 808         }
 809
 810         return dimmed;
 811 }
 812
 813 gboolean
 814 modest_ui_dimming_rules_on_view_previous (ModestWindow *win, gpointer user_data)
 815 {
 816         ModestDimmingRule *rule = NULL;
 817         gboolean dimmed = FALSE;
 818
 819         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 820         rule = MODEST_DIMMING_RULE (user_data);
 821
 822         g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW(win), FALSE);
 823
 824         /* Check dimmed rule */
 825         if (!dimmed) {
 826                 dimmed = modest_msg_view_window_first_message_selected (MODEST_MSG_VIEW_WINDOW(win));
 827                 if (dimmed)
 828                         modest_dimming_rule_set_notification (rule, "");
 829         }
 830
 831         return dimmed;
 832 }
 833
 834 gboolean
 835 modest_ui_dimming_rules_on_view_next (ModestWindow *win, gpointer user_data)
 836 {
 837         ModestDimmingRule *rule = NULL;
 838         gboolean dimmed = FALSE;
 839
 840         g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW(win), FALSE);
 841         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 842         rule = MODEST_DIMMING_RULE (user_data);
 843
 844         /* Check dimmed rule */
 845         if (!dimmed) {
 846                 dimmed = modest_msg_view_window_last_message_selected (MODEST_MSG_VIEW_WINDOW(win));
 847                 if (dimmed)
 848                         modest_dimming_rule_set_notification (rule, "");
 849         }
 850
 851         return dimmed;
 852 }
 853
 854
 855 gboolean
 856 modest_ui_dimming_rules_on_tools_smtp_servers (ModestWindow *win, gpointer user_data)
 857 {
 858         const gboolean dimmed =
 859                 !modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(),
 860                         TRUE);
 861
 862         return dimmed;
 863 }
 864
 865 gboolean
 866 modest_ui_dimming_rules_on_cancel_sending (ModestWindow *win, gpointer user_data)
 867 {
 868         gboolean dimmed = FALSE;
 869
 870         /* Check dimmed rule */
 871         if (!dimmed)
 872                 dimmed = !_sending_in_progress (win);
 873
 874         return dimmed;
 875 }
 876
 877 gboolean
 878 modest_ui_dimming_rules_on_send_receive (ModestWindow *win, gpointer user_data)
 879 {
 880         ModestDimmingRule *rule = NULL;
 881         gboolean dimmed = FALSE;
 882
 883         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 884         rule = MODEST_DIMMING_RULE (user_data);
 885
 886         /* Check dimmed rule */
 887         if (!dimmed) {
 888                 dimmed = !modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(),
 889                                                           TRUE);
 890                 if (dimmed)
 891                         modest_dimming_rule_set_notification (rule, _("mcen_nc_no_email_acnts_defined"));
 892         }
 893
 894         return dimmed;
 895 }
 896
 897 gboolean
 898 modest_ui_dimming_rules_on_add_to_contacts (ModestWindow *win, gpointer user_data)
 899 {
 900         ModestDimmingRule *rule = NULL;
 901         gboolean dimmed = FALSE;
 902
 903         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (user_data), FALSE);
 904         rule = MODEST_DIMMING_RULE (user_data);
 905
 906         /* Check dimmed rule */
 907         if (!dimmed) {
 908                 GtkClipboard *clipboard = gtk_clipboard_get (GDK_SELECTION_PRIMARY);
 909                 gchar *selection = NULL;
 910                 selection = gtk_clipboard_wait_for_text (clipboard);
 911
 912                 dimmed = !((selection != NULL) && (modest_text_utils_validate_recipient (selection)));
 913         }
 914
 915         return dimmed;
 916 }
 917
 918 /* *********************** static utility functions ******************** */
 919
 920 static gboolean
 921 _marked_as_deleted (ModestWindow *win)
 922 {
 923         gboolean result = FALSE;
 924         TnyHeaderFlags flags;
 925
 926         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
 927
 928         flags = TNY_HEADER_FLAG_DELETED;
 929
 930         /* Check dimmed rule */
 931         result = _selected_msg_marked_as (win, flags, FALSE);
 932
 933         return result;
 934 }
 935
 936 static gboolean
 937 _selected_folder_not_writeable (ModestMainWindow *win)
 938 {
 939         GtkWidget *folder_view = NULL;
 940         TnyFolderStore *parent_folder = NULL;
 941         ModestTnyFolderRules rules;
 942         gboolean result = FALSE;
 943
 944         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
 945
 946         /* Get folder view */
 947         folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
 948                                                            MODEST_WIDGET_TYPE_FOLDER_VIEW);
 949         /* If no folder view, always dimmed */
 950         if (!folder_view)
 951                 return TRUE;
 952
 953         /* Get selected folder as parent of new folder to create */
 954         parent_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
 955         if (!(parent_folder && TNY_IS_FOLDER(parent_folder))) {
 956                 if (parent_folder)
 957                         g_object_unref (parent_folder);
 958                 return TRUE;
 959         }
 960
 961         /* Check dimmed rule */
 962         rules = modest_tny_folder_get_rules (TNY_FOLDER (parent_folder));
 963         result = rules & MODEST_FOLDER_RULES_FOLDER_NON_WRITEABLE;
 964
 965         /* free */
 966         g_object_unref (parent_folder);
 967
 968         return result;
 969 }
 970
 971 static gboolean
 972 _selected_folder_is_root_or_inbox (ModestMainWindow *win)
 973 {
 974         TnyFolderType types[2];
 975         gboolean result = FALSE;
 976
 977         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
 978
 979         types[0] = TNY_FOLDER_TYPE_ROOT;
 980         types[1] = TNY_FOLDER_TYPE_INBOX;
 981
 982         /* Check folder type */
 983         result = _selected_folder_is_any_of_type (MODEST_WINDOW(win), types, 2);
 984
 985         /* Check pop and MMC accounts */
 986         if (!result) {
 987                 result = _selected_folder_is_MMC_or_POP_root (win);
 988         }
 989
 990         return result;
 991 }
 992
 993
 994 static gboolean
 995 _selected_folder_is_root (ModestMainWindow *win)
 996 {
 997         TnyFolderType types[1];
 998         gboolean result = FALSE;
 999
1000         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
1001
1002         types[0] = TNY_FOLDER_TYPE_ROOT;
1003
1004         /* Check folder type */
1005         result = _selected_folder_is_any_of_type (MODEST_WINDOW(win), types, 1);
1006
1007         /* Check pop and MMC accounts */
1008         if (!result) {
1009                 result = _selected_folder_is_MMC_or_POP_root (win);
1010         }
1011
1012         return result;
1013 }
1014
1015 static gboolean
1016 _selected_folder_is_MMC_or_POP_root (ModestMainWindow *win)
1017 {
1018         GtkWidget *folder_view = NULL;
1019         TnyFolderStore *parent_folder = NULL;
1020         gboolean result = FALSE;
1021
1022         folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
1023                                                            MODEST_WIDGET_TYPE_FOLDER_VIEW);
1024         /* Get selected folder as parent of new folder to create */
1025         parent_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
1026         if (!parent_folder)
1027                 return TRUE;
1028
1029         if (TNY_IS_ACCOUNT (parent_folder)) {
1030                 /* If it's the local account then do not dim */
1031                 if (modest_tny_account_is_virtual_local_folders (TNY_ACCOUNT (parent_folder))) {
1032                         result = FALSE;
1033                 } else {
1034                                 /* If it's the MMC root folder then dim it */
1035                         if (!strcmp (tny_account_get_id (TNY_ACCOUNT (parent_folder)), MODEST_MMC_ACCOUNT_ID)) {
1036                                         result = TRUE;
1037                         } else {
1038                                 const gchar *proto_str = tny_account_get_proto (TNY_ACCOUNT (parent_folder));
1039                                 /* If it's POP then dim */
1040                                 result = (modest_protocol_info_get_transport_store_protocol (proto_str) ==
1041                                                   MODEST_PROTOCOL_STORE_POP) ? TRUE : FALSE;
1042                         }
1043                 }
1044         }
1045         g_object_unref (parent_folder);
1046
1047         return result;
1048 }
1049
1050
1051
1052
1053 static gboolean
1054 _selected_folder_is_empty (ModestMainWindow *win)
1055 {
1056         GtkWidget *folder_view = NULL;
1057         TnyFolderStore *folder = NULL;
1058         gboolean result = FALSE;
1059
1060         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
1061
1062         /* Get folder view */
1063         folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
1064                                                            MODEST_WIDGET_TYPE_FOLDER_VIEW);
1065         /* If no folder view, always dimmed */
1066         if (!folder_view)
1067                 return TRUE;
1068
1069         /* Get selected folder as parent of new folder to create */
1070         folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
1071         if (!(folder && TNY_IS_FOLDER(folder))) {
1072                 if (folder)
1073                         g_object_unref (folder);
1074                 return TRUE;
1075         }
1076
1077         /* Check folder type */
1078         result = tny_folder_get_all_count (TNY_FOLDER (folder)) == 0;
1079
1080         /* free */
1081         g_object_unref (folder);
1082
1083         return result;
1084 }
1085
1086 static gboolean
1087 _selected_folder_is_same_as_source (ModestWindow *win)
1088 {
1089         ModestEmailClipboard *clipboard = NULL;
1090         GtkWidget *folder_view = NULL;
1091         TnyFolderStore *folder = NULL;
1092         gboolean result = FALSE;
1093
1094         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
1095
1096         /* Get folder view */
1097         folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
1098                                                            MODEST_WIDGET_TYPE_FOLDER_VIEW);
1099         if (!folder_view)
1100                 return FALSE;
1101
1102         /* Get selected folder as destination folder */
1103         folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
1104         if (!(folder && TNY_IS_FOLDER(folder))) {
1105                 result = FALSE;
1106                 goto frees;
1107         }
1108
1109         /* Check clipboard is cleared */
1110         clipboard = modest_runtime_get_email_clipboard ();
1111         if (modest_email_clipboard_cleared (clipboard)) {
1112                 result = FALSE;
1113                 goto frees;
1114         }
1115
1116         /* Check source folder */
1117         result = modest_email_clipboard_check_source_folder (clipboard,
1118                                                              (const TnyFolder *) folder);
1119
1120         /* Free */
1121  frees:
1122         g_object_unref (folder);
1123
1124         return result;
1125 }
1126
1127 static gboolean
1128 _selected_folder_is_any_of_type (ModestWindow *win,
1129                                  TnyFolderType types[],
1130                                  guint ntypes)
1131 {
1132         GtkWidget *folder_view = NULL;
1133         TnyFolderStore *folder = NULL;
1134         TnyFolderType folder_type;
1135         guint i=0;
1136         gboolean result = FALSE;
1137
1138         /*Get curent folder */
1139         if (MODEST_IS_MAIN_WINDOW(win)) {
1140
1141                 /* Get folder view */
1142                 folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
1143                                                                    MODEST_WIDGET_TYPE_FOLDER_VIEW);
1144                 /* If no folder view, always dimmed */
1145                 if (!folder_view)
1146                         return TRUE;
1147
1148                 /* Get selected folder as parent of new folder to create */
1149                 folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
1150
1151                 if (!(folder && TNY_IS_FOLDER(folder))) {
1152                         if (folder)
1153                                 g_object_unref (folder);
1154                         return TRUE;
1155                 }
1156
1157                 /* Check folder type */
1158                 result = _folder_is_any_of_type (TNY_FOLDER(folder), types, ntypes);
1159         }
1160         else if (MODEST_IS_MSG_VIEW_WINDOW(win)) {
1161                 folder_type = modest_msg_view_window_get_folder_type (MODEST_MSG_VIEW_WINDOW (win));
1162                 for (i=0; i < ntypes; i++) {
1163                         result = result || folder_type == types[i];
1164                 }
1165         }
1166
1167
1168         /* free */
1169         g_object_unref (folder);
1170
1171         return result;
1172 }
1173
1174 static gboolean
1175 _folder_is_any_of_type (TnyFolder *folder,
1176                         TnyFolderType types[],
1177                         guint ntypes)
1178 {
1179         TnyFolderType folder_type;
1180         gboolean result = FALSE;
1181         guint i;
1182
1183         g_return_val_if_fail (TNY_IS_FOLDER(folder), FALSE);
1184
1185         /* Get folder type */
1186         if (modest_tny_folder_is_local_folder (folder))
1187                 folder_type = modest_tny_folder_get_local_folder_type (folder);
1188         else
1189                 folder_type = modest_tny_folder_guess_folder_type (folder);
1190
1191         /* Check foler type */
1192         for (i=0; i < ntypes; i++) {
1193                 result = result || folder_type == types[i];
1194         }
1195
1196         return result;
1197 }
1198
1199 static gboolean
1200 _selected_folder_is_snd_level (ModestMainWindow *win)
1201 {
1202         GtkWidget *folder_view = NULL;
1203         GtkTreeSelection *sel = NULL;
1204         GtkTreeModel *model = NULL;
1205         GtkTreePath *path = NULL;
1206         GtkTreeIter iter;
1207         TnyFolderStore *folder = NULL;
1208         gboolean result = FALSE;
1209
1210         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), TRUE);
1211
1212         /*Get curent folder */
1213         folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
1214                                                            MODEST_WIDGET_TYPE_FOLDER_VIEW);
1215         /* If no folder view, always dimmed */
1216         if (!folder_view)
1217                 goto frees;
1218
1219         /* Get selected folder as parent of new folder to create */
1220         folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
1221         if (!(folder && TNY_IS_FOLDER(folder))) {
1222                 goto frees;
1223         }
1224
1225         /* Check folder level */
1226         sel = gtk_tree_view_get_selection (GTK_TREE_VIEW(folder_view));
1227         if (!gtk_tree_selection_get_selected (sel, &model, &iter))
1228                 goto frees;
1229         path = gtk_tree_model_get_path (model, &iter);
1230         result = gtk_tree_path_get_depth (path) > 2;
1231
1232  frees:
1233         if (folder != NULL)
1234                 g_object_unref (folder);
1235         if (path != NULL)
1236                 gtk_tree_path_free (path);
1237
1238         return result;
1239
1240 }
1241
1242 static gboolean
1243 _clipboard_is_empty (ModestWindow *win)
1244 {
1245         gboolean result = FALSE;
1246
1247         if (MODEST_IS_MAIN_WINDOW (win)) {
1248                 ModestEmailClipboard *clipboard = NULL;
1249                 clipboard = modest_runtime_get_email_clipboard ();
1250                 if (modest_email_clipboard_cleared (clipboard))
1251                  result = TRUE;
1252         }
1253
1254         return result;
1255 }
1256
1257 static gboolean
1258 _invalid_clipboard_selected (ModestWindow *win,
1259                        ModestDimmingRule *rule)
1260 {
1261         gboolean result = FALSE;
1262
1263         if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
1264                 GtkClipboard *clipboard = NULL;
1265                 gchar *selection = NULL;
1266                 GtkWidget *focused = NULL;
1267
1268                 /* Get clipboard selection*/
1269                 clipboard = gtk_clipboard_get (GDK_SELECTION_PRIMARY);
1270                 selection = gtk_clipboard_wait_for_text (clipboard);
1271
1272                 /* Get focuesed widget */
1273                 focused = gtk_window_get_focus (GTK_WINDOW (win));
1274
1275                 /* Check dimming */
1276                 result = ((selection == NULL) ||
1277                           (MODEST_IS_ATTACHMENTS_VIEW (focused)));
1278
1279                 if (result)
1280                         modest_dimming_rule_set_notification (rule, _(""));
1281         }
1282         else if (MODEST_IS_MAIN_WINDOW (win)) {
1283                 GtkWidget *header_view = NULL;
1284
1285                 /* Get header view to check selected messages */
1286                 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
1287                                                                    MODEST_WIDGET_TYPE_HEADER_VIEW);
1288
1289                 /* Check dimming */
1290                 result = !modest_header_view_has_selected_headers (MODEST_HEADER_VIEW(header_view));
1291                 if (result)
1292                         modest_dimming_rule_set_notification (rule, _("mcen_ib_select_one_message"));
1293         }
1294
1295         return result;
1296 }
1297
1298
1299 static gboolean
1300 _invalid_attach_selected (ModestWindow *win,
1301                           gboolean unique,
1302                           gboolean for_view,
1303                           ModestDimmingRule *rule)
1304 {
1305         GList *attachments, *node;
1306         gint n_selected;
1307         TnyHeaderFlags flags;
1308         gboolean nested_attachments = FALSE;
1309         gboolean selected_messages = FALSE;
1310         gboolean result = FALSE;
1311
1312         if (MODEST_IS_MAIN_WINDOW (win)) {
1313                 flags = TNY_HEADER_FLAG_ATTACHMENTS;
1314                 if (!result)
1315                         result = _selected_msg_marked_as (win, flags, TRUE);
1316         }
1317         else if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
1318
1319                 /* Get selected atachments */
1320                 attachments = modest_msg_view_window_get_attachments (MODEST_MSG_VIEW_WINDOW(win));
1321                 n_selected = g_list_length (attachments);
1322
1323                 /* Check unique */
1324                 if (!result) {
1325                         if (unique)
1326                                 result = n_selected != 1;
1327                         else
1328
1329                                 result = n_selected < 1;
1330                 }
1331
1332                 /* Check attached type (view operation not required) */
1333                 if (!result && !for_view)  {
1334                         for (node = attachments; node != NULL && !result; node = g_list_next (node)) {
1335                                 TnyMimePart *mime_part = TNY_MIME_PART (node->data);
1336                                 TnyList *nested_list = tny_simple_list_new ();
1337                                 if (TNY_IS_MSG (mime_part)) {
1338                                         selected_messages = TRUE;
1339                                         result = TRUE;
1340                                 }
1341                                 tny_mime_part_get_parts (mime_part, nested_list);
1342                                 if (tny_list_get_length (nested_list) > 0) {
1343                                 nested_attachments = TRUE;
1344                                 result = TRUE;
1345                                 }
1346                                 g_object_unref (nested_list);
1347                         }
1348                 }
1349
1350                 /* Set notifications */
1351                 if (result && rule != NULL) {
1352                         if (selected_messages) {
1353                                 modest_dimming_rule_set_notification (rule, _("mcen_ib_unable_to_save_attach_mail"));
1354                         } else if (nested_attachments) {
1355                                 modest_dimming_rule_set_notification (rule, _("FIXME:unable to save attachments with nested elements"));
1356                         } else if (n_selected == 0) {
1357                                 modest_dimming_rule_set_notification (rule, _("FIXME:no attachment selected"));
1358                         } else if (unique) {
1359                                 modest_dimming_rule_set_notification (rule, _("mcen_ib_unable_to_display_more"));
1360                         }
1361                 }
1362
1363                 /* Free */
1364                 g_list_free (attachments);
1365         }
1366
1367         return result;
1368 }
1369
1370 static gboolean
1371 _purged_attach_selected (ModestWindow *win)
1372 {
1373         GList *attachments, *node;
1374         gint n_selected;
1375         gboolean result = FALSE;
1376
1377         if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
1378
1379                 /* Get selected atachments */
1380                 attachments = modest_msg_view_window_get_attachments (MODEST_MSG_VIEW_WINDOW(win));
1381                 n_selected = g_list_length (attachments);
1382
1383                 for (node = attachments; node != NULL && !result; node = g_list_next (node)) {
1384                         TnyMimePart *mime_part = TNY_MIME_PART (node->data);
1385                         if (tny_mime_part_is_purged (mime_part)) {
1386                                 result = TRUE;
1387                                 break;
1388                         }
1389                 }
1390
1391                 /* Free */
1392                 g_list_free (attachments);
1393         }
1394
1395         return result;
1396 }
1397
1398 static gboolean
1399 _invalid_msg_selected (ModestMainWindow *win,
1400                        gboolean unique,
1401                        ModestDimmingRule *rule)
1402 {
1403         GtkWidget *header_view = NULL;
1404         GtkWidget *folder_view = NULL;
1405         gboolean selected_headers = FALSE;
1406         gboolean result = FALSE;
1407
1408         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
1409         g_return_val_if_fail (MODEST_IS_DIMMING_RULE (rule), FALSE);
1410
1411         /* Get header view to check selected messages */
1412         header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
1413                                                            MODEST_WIDGET_TYPE_HEADER_VIEW);
1414
1415         /* Get folder view to check focus */
1416         folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
1417                                                            MODEST_WIDGET_TYPE_FOLDER_VIEW);
1418
1419         /* Get selected headers */
1420         selected_headers = modest_header_view_has_selected_headers (MODEST_HEADER_VIEW(header_view));
1421
1422         /* Check dimmed rule (TODO: check focus on widgets */
1423         if (!result) {
1424                 result = ((!selected_headers) ||
1425                           (gtk_widget_is_focus (folder_view)));
1426                 if (result)
1427                         modest_dimming_rule_set_notification (rule, _("mcen_ib_no_message_selected"));
1428         }
1429         if (!result && unique) {
1430                 result = modest_header_view_count_selected_headers (MODEST_HEADER_VIEW(header_view)) > 1;
1431                 if (result)
1432                         modest_dimming_rule_set_notification (rule, _("mcen_ib_select_one_message"));
1433         }
1434
1435         return result;
1436 }
1437
1438 static gboolean
1439 _already_opened_msg (ModestWindow *win,
1440                      guint *n_messages)
1441 {
1442         ModestWindow *window = NULL;
1443         ModestWindowMgr *mgr = NULL;
1444         GtkWidget *header_view = NULL;
1445         TnyList *selected_headers = NULL;
1446         TnyIterator *iter = NULL;
1447         TnyHeader *header = NULL;
1448         gboolean result = TRUE;
1449
1450         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(win), FALSE);
1451
1452         /* Get header view to check selected messages */
1453         header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
1454                                                            MODEST_WIDGET_TYPE_HEADER_VIEW);
1455
1456
1457         /* Check no selection */
1458         if (!modest_header_view_has_selected_headers (MODEST_HEADER_VIEW(header_view)))
1459             return FALSE;
1460
1461         /* Get selected headers */
1462         selected_headers = modest_header_view_get_selected_headers (MODEST_HEADER_VIEW(header_view));
1463         if (selected_headers == NULL)
1464                 return FALSE;
1465
1466         *n_messages = tny_list_get_length (selected_headers);
1467
1468         /* Check dimmed rule (TODO: check focus on widgets */
1469         mgr = modest_runtime_get_window_mgr ();
1470         iter = tny_list_create_iterator (selected_headers);
1471         while (!tny_iterator_is_done (iter) && result) {
1472                 header = TNY_HEADER (tny_iterator_get_current (iter));
1473                 window = modest_window_mgr_find_window_by_header (mgr, header);
1474                 result = result && (window != NULL);
1475
1476                 g_object_unref (header);
1477                 tny_iterator_next (iter);
1478         }
1479
1480         /* free */
1481         if (selected_headers != NULL)
1482                 g_object_unref (selected_headers);
1483         if (iter != NULL)
1484                 g_object_unref (iter);
1485
1486         return result;
1487 }
1488
1489 static gboolean
1490 _selected_msg_marked_as (ModestWindow *win,
1491                          TnyHeaderFlags mask,
1492                          gboolean opposite)
1493 {
1494         GtkWidget *header_view = NULL;
1495         TnyList *selected_headers = NULL;
1496         TnyIterator *iter = NULL;
1497         TnyHeader *header = NULL;
1498         TnyHeaderFlags flags;
1499         gboolean result = FALSE;
1500
1501         /* Get header view to check selected messages */
1502         header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
1503                                                            MODEST_WIDGET_TYPE_HEADER_VIEW);
1504
1505         /* Check no selection */
1506         if (!modest_header_view_has_selected_headers (MODEST_HEADER_VIEW(header_view)))
1507             return TRUE;
1508
1509         /* Get selected headers */
1510         selected_headers = modest_header_view_get_selected_headers (MODEST_HEADER_VIEW(header_view));
1511         if (selected_headers == NULL)
1512                 return TRUE;
1513
1514         /* Call the function for each header */
1515         iter = tny_list_create_iterator (selected_headers);
1516         while (!tny_iterator_is_done (iter) && !result) {
1517                 header = TNY_HEADER (tny_iterator_get_current (iter));
1518
1519                 flags = tny_header_get_flags (header);
1520                 if (opposite)
1521                         result = (flags & mask) == 0;
1522                 else
1523                         result = (flags & mask) != 0;
1524
1525                 g_object_unref (header);
1526                 tny_iterator_next (iter);
1527         }
1528
1529         /* free */
1530         if (selected_headers != NULL)
1531                 g_object_unref (selected_headers);
1532         if (iter != NULL)
1533                 g_object_unref (iter);
1534
1535         return result;
1536 }
1537
1538 static gboolean
1539 _msg_download_in_progress (ModestMsgViewWindow *win)
1540 {
1541         gboolean result = FALSE;
1542
1543         g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW (win), FALSE);
1544
1545         result = modest_msg_view_window_toolbar_on_transfer_mode (win);
1546
1547         return result;
1548 }
1549
1550 static gboolean
1551 _msg_download_completed (ModestMainWindow *win)
1552 {
1553         GtkWidget *header_view = NULL;
1554         TnyList *selected_headers = NULL;
1555         TnyIterator *iter = NULL;
1556         TnyHeader *header = NULL;
1557         TnyHeaderFlags flags;
1558         gboolean result = FALSE;
1559
1560         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW (win), FALSE);
1561
1562
1563         /* Get header view to check selected messages */
1564         header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
1565                                                            MODEST_WIDGET_TYPE_HEADER_VIEW);
1566
1567         /* Check no selection */
1568         if (!modest_header_view_has_selected_headers (MODEST_HEADER_VIEW(header_view)))
1569             return TRUE;
1570
1571         /* Get selected headers */
1572         selected_headers = modest_header_view_get_selected_headers (MODEST_HEADER_VIEW(header_view));
1573         if (selected_headers == NULL)
1574                 return TRUE;
1575
1576         /* Check dimmed rule  */
1577         result = TRUE;
1578         iter = tny_list_create_iterator (selected_headers);
1579         while (!tny_iterator_is_done (iter) && result) {
1580                 header = TNY_HEADER (tny_iterator_get_current (iter));
1581
1582                 flags = tny_header_get_flags (header);
1583                 /* TODO: is this the right flag?, it seems that some
1584                    headers that have been previously downloaded do not
1585                    come with it */
1586                 result = (flags & TNY_HEADER_FLAG_CACHED);
1587
1588                 g_object_unref (header);
1589                 tny_iterator_next (iter);
1590         }
1591
1592         g_object_unref (iter);
1593
1594         return result;
1595 }
1596
1597 static gboolean
1598 _selected_msg_sent_in_progress (ModestWindow *win)
1599 {
1600         ModestTnySendQueue *send_queue = NULL;
1601         GtkWidget *header_view = NULL;
1602         ModestTnyAccountStore *acc_store = NULL;
1603         TnyAccount *account = NULL;
1604         TnyList *header_list = NULL;
1605         TnyIterator *iter = NULL;
1606         TnyHeader *header = NULL;
1607         const gchar *account_name = NULL;
1608         gboolean result = FALSE;
1609         gchar *id = NULL;
1610
1611         /* Get transport account */
1612         acc_store = modest_runtime_get_account_store();
1613         account_name = modest_window_get_active_account (win);
1614
1615         /* If no account defined, this action must be always dimmed  */
1616         if (account_name == NULL) return FALSE;
1617         account = modest_tny_account_store_get_transport_account_for_open_connection (acc_store, account_name);
1618         if (!TNY_IS_TRANSPORT_ACCOUNT (account)) return FALSE;
1619
1620         /* Get send queue for current ransport account */
1621         send_queue = modest_runtime_get_send_queue (TNY_TRANSPORT_ACCOUNT(account));
1622         g_return_val_if_fail (MODEST_IS_TNY_SEND_QUEUE (send_queue), FALSE);
1623
1624         if (MODEST_IS_MAIN_WINDOW(win)) {
1625
1626                 /* Get header view to check selected messages */
1627                 header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
1628                                                                    MODEST_WIDGET_TYPE_HEADER_VIEW);
1629
1630                 /* Check no selection */
1631                 if (!modest_header_view_has_selected_headers (MODEST_HEADER_VIEW(header_view)))
1632                     return FALSE;
1633
1634                 /* Get selected headers */
1635                 header_list = modest_header_view_get_selected_headers (MODEST_HEADER_VIEW(header_view));
1636
1637                 /* Get message header */
1638                 if (!header_list) return FALSE;
1639                 iter = tny_list_create_iterator (header_list);
1640                 header = TNY_HEADER (tny_iterator_get_current (iter));
1641
1642                 /* Get message id */
1643                 id = g_strdup(tny_header_get_message_id (header));
1644
1645         } else if (MODEST_IS_MSG_VIEW_WINDOW(win)) {
1646
1647                 /* Get message header */
1648                 header = modest_msg_view_window_get_header (MODEST_MSG_VIEW_WINDOW(win));
1649
1650                 /* Get message id */
1651                 id = g_strdup(tny_header_get_message_id (header));
1652         }
1653
1654         /* Check if msg id is being processed inside send queue */
1655         result = modest_tny_send_queue_msg_is_being_sent (send_queue, id);
1656
1657         /* Free */
1658         g_free(id);
1659         g_object_unref (header);
1660         g_object_unref(header_list);
1661         g_object_unref(iter);
1662
1663         return result;
1664 }
1665
1666
1667 static gboolean
1668 _sending_in_progress (ModestWindow *win)
1669 {
1670         ModestTnySendQueue *send_queue = NULL;
1671         ModestTnyAccountStore *acc_store = NULL;
1672         TnyAccount *account = NULL;
1673         const gchar *account_name = NULL;
1674         gboolean result = FALSE;
1675
1676         /* Get transport account */
1677         acc_store = modest_runtime_get_account_store();
1678         account_name = modest_window_get_active_account (win);
1679
1680         /* If no account defined, this action must be always dimmed  */
1681         if (account_name == NULL) return FALSE;
1682         account = modest_tny_account_store_get_transport_account_for_open_connection (acc_store, account_name);
1683         if (!TNY_IS_TRANSPORT_ACCOUNT (account)) return FALSE;
1684
1685         /* Get send queue for current ransport account */
1686         send_queue = modest_runtime_get_send_queue (TNY_TRANSPORT_ACCOUNT(account));
1687         g_return_val_if_fail (MODEST_IS_TNY_SEND_QUEUE (send_queue), FALSE);
1688
1689         /* Check if send queue is perfimring any send operation */
1690         result = modest_tny_send_queue_sending_in_progress (send_queue);
1691
1692         return result;
1693 }
1694
1695 static gboolean
1696 _invalid_attachment_for_purge (ModestWindow *win,
1697                                ModestDimmingRule *rule)
1698 {
1699         TnyMsg *msg = NULL;
1700         TnyFolder *folder = NULL;
1701         TnyAccount *account = NULL;
1702         gboolean result = FALSE;
1703
1704         if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
1705
1706                 /* Get folder and account of message */
1707                 msg = modest_msg_view_window_get_message (MODEST_MSG_VIEW_WINDOW (win));
1708                 g_return_val_if_fail(msg != NULL, TRUE);
1709                 folder = tny_msg_get_folder (msg);
1710                 if (folder == NULL) {
1711                         modest_dimming_rule_set_notification (rule, _("mail_ib_unable_to_purge_attachments"));
1712                         goto frees;
1713                 }
1714                 account = modest_tny_folder_get_account (folder);
1715                 if (account == NULL) goto frees;
1716
1717                 /* Check account */
1718                 if (!modest_tny_account_is_virtual_local_folders (TNY_ACCOUNT (account))) {
1719                         const gchar *proto_str = tny_account_get_proto (TNY_ACCOUNT (account));
1720                         /* If it's POP then dim */
1721                         if (modest_protocol_info_get_transport_store_protocol (proto_str) ==
1722                             MODEST_PROTOCOL_STORE_POP) {
1723                                 GList *attachments;
1724                                 gint n_selected;
1725                                 result = TRUE;
1726                                 attachments = modest_msg_view_window_get_attachments (MODEST_MSG_VIEW_WINDOW(win));
1727                                 n_selected = g_list_length (attachments);
1728                                 g_list_free (attachments);
1729
1730                                 modest_dimming_rule_set_notification (rule,
1731                                                                       ngettext ("mail_ib_unable_to_pure_attach_pop_mail_singular",
1732                                                                                 "mail_ib_unable_to_pure_attach_pop_mail_plural",
1733                                                                                 n_selected));
1734                         }
1735                 }
1736         }
1737
1738  frees:
1739         if (msg != NULL)
1740                 g_object_unref (msg);
1741         if (folder != NULL)
1742                 g_object_unref (folder);
1743         if (account != NULL)
1744                 g_object_unref (account);
1745
1746         return result;
1747 }
1748