camel/camel-imapx-settings.c

   1 /*
   2  * camel-imapx-settings.c
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) version 3.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with the program; if not, see <http://www.gnu.org/licenses/>
  16  *
  17  */
  18
  19 #include "camel-imapx-settings.h"
  20
  21 #define MIN_CONCURRENT_CONNECTIONS 1
  22 #define MAX_CONCURRENT_CONNECTIONS 7
  23
  24 #define CAMEL_IMAPX_SETTINGS_GET_PRIVATE(obj) \
  25         (G_TYPE_INSTANCE_GET_PRIVATE \
  26         ((obj), CAMEL_TYPE_IMAPX_SETTINGS, CamelIMAPXSettingsPrivate))
  27
  28 struct _CamelIMAPXSettingsPrivate {
  29         GMutex property_lock;
  30         gchar *namespace;
  31         gchar *shell_command;
  32
  33         guint batch_fetch_count;
  34         guint concurrent_connections;
  35
  36         gboolean check_all;
  37         gboolean check_subscribed;
  38         gboolean filter_all;
  39         gboolean filter_junk;
  40         gboolean filter_junk_inbox;
  41         gboolean use_idle;
  42         gboolean use_mobile_mode;
  43         gboolean use_namespace;
  44         gboolean use_qresync;
  45         gboolean use_shell_command;
  46         gboolean use_subscriptions;
  47
  48         CamelSortType fetch_order;
  49 };
  50
  51 enum {
  52         PROP_0,
  53         PROP_AUTH_MECHANISM,
  54         PROP_BATCH_FETCH_COUNT,
  55         PROP_CHECK_ALL,
  56         PROP_CHECK_SUBSCRIBED,
  57         PROP_CONCURRENT_CONNECTIONS,
  58         PROP_FETCH_ORDER,
  59         PROP_FILTER_ALL,
  60         PROP_FILTER_JUNK,
  61         PROP_FILTER_JUNK_INBOX,
  62         PROP_HOST,
  63         PROP_MOBILE_MODE,
  64         PROP_NAMESPACE,
  65         PROP_PORT,
  66         PROP_SECURITY_METHOD,
  67         PROP_SHELL_COMMAND,
  68         PROP_USER,
  69         PROP_USE_IDLE,
  70         PROP_USE_NAMESPACE,
  71         PROP_USE_QRESYNC,
  72         PROP_USE_SHELL_COMMAND,
  73         PROP_USE_SUBSCRIPTIONS
  74 };
  75
  76 G_DEFINE_TYPE_WITH_CODE (
  77         CamelIMAPXSettings,
  78         camel_imapx_settings,
  79         CAMEL_TYPE_OFFLINE_SETTINGS,
  80         G_IMPLEMENT_INTERFACE (
  81                 CAMEL_TYPE_NETWORK_SETTINGS, NULL))
  82
  83 static void
  84 imapx_settings_set_property (GObject *object,
  85                              guint property_id,
  86                              const GValue *value,
  87                              GParamSpec *pspec)
  88 {
  89         switch (property_id) {
  90                 case PROP_AUTH_MECHANISM:
  91                         camel_network_settings_set_auth_mechanism (
  92                                 CAMEL_NETWORK_SETTINGS (object),
  93                                 g_value_get_string (value));
  94                         return;
  95
  96                 case PROP_BATCH_FETCH_COUNT:
  97                         camel_imapx_settings_set_batch_fetch_count (
  98                                 CAMEL_IMAPX_SETTINGS (object),
  99                                 g_value_get_uint (value));
 100                         return;
 101
 102                 case PROP_CHECK_ALL:
 103                         camel_imapx_settings_set_check_all (
 104                                 CAMEL_IMAPX_SETTINGS (object),
 105                                 g_value_get_boolean (value));
 106                         return;
 107
 108                 case PROP_CHECK_SUBSCRIBED:
 109                         camel_imapx_settings_set_check_subscribed (
 110                                 CAMEL_IMAPX_SETTINGS (object),
 111                                 g_value_get_boolean (value));
 112                         return;
 113
 114                 case PROP_CONCURRENT_CONNECTIONS:
 115                         camel_imapx_settings_set_concurrent_connections (
 116                                 CAMEL_IMAPX_SETTINGS (object),
 117                                 g_value_get_uint (value));
 118                         return;
 119
 120                 case PROP_FETCH_ORDER:
 121                         camel_imapx_settings_set_fetch_order (
 122                                 CAMEL_IMAPX_SETTINGS (object),
 123                                 g_value_get_enum (value));
 124                         return;
 125
 126                 case PROP_FILTER_ALL:
 127                         camel_imapx_settings_set_filter_all (
 128                                 CAMEL_IMAPX_SETTINGS (object),
 129                                 g_value_get_boolean (value));
 130                         return;
 131
 132                 case PROP_FILTER_JUNK:
 133                         camel_imapx_settings_set_filter_junk (
 134                                 CAMEL_IMAPX_SETTINGS (object),
 135                                 g_value_get_boolean (value));
 136                         return;
 137
 138                 case PROP_FILTER_JUNK_INBOX:
 139                         camel_imapx_settings_set_filter_junk_inbox (
 140                                 CAMEL_IMAPX_SETTINGS (object),
 141                                 g_value_get_boolean (value));
 142                         return;
 143
 144                 case PROP_HOST:
 145                         camel_network_settings_set_host (
 146                                 CAMEL_NETWORK_SETTINGS (object),
 147                                 g_value_get_string (value));
 148                         return;
 149
 150                 case PROP_MOBILE_MODE:
 151                         camel_imapx_settings_set_mobile_mode (
 152                                 CAMEL_IMAPX_SETTINGS (object),
 153                                 g_value_get_boolean (value));
 154                         return;
 155
 156                 case PROP_NAMESPACE:
 157                         camel_imapx_settings_set_namespace (
 158                                 CAMEL_IMAPX_SETTINGS (object),
 159                                 g_value_get_string (value));
 160                         return;
 161
 162                 case PROP_PORT:
 163                         camel_network_settings_set_port (
 164                                 CAMEL_NETWORK_SETTINGS (object),
 165                                 g_value_get_uint (value));
 166                         return;
 167
 168                 case PROP_SECURITY_METHOD:
 169                         camel_network_settings_set_security_method (
 170                                 CAMEL_NETWORK_SETTINGS (object),
 171                                 g_value_get_enum (value));
 172                         return;
 173
 174                 case PROP_SHELL_COMMAND:
 175                         camel_imapx_settings_set_shell_command (
 176                                 CAMEL_IMAPX_SETTINGS (object),
 177                                 g_value_get_string (value));
 178                         return;
 179
 180                 case PROP_USER:
 181                         camel_network_settings_set_user (
 182                                 CAMEL_NETWORK_SETTINGS (object),
 183                                 g_value_get_string (value));
 184                         return;
 185
 186                 case PROP_USE_IDLE:
 187                         camel_imapx_settings_set_use_idle (
 188                                 CAMEL_IMAPX_SETTINGS (object),
 189                                 g_value_get_boolean (value));
 190                         return;
 191
 192                 case PROP_USE_NAMESPACE:
 193                         camel_imapx_settings_set_use_namespace (
 194                                 CAMEL_IMAPX_SETTINGS (object),
 195                                 g_value_get_boolean (value));
 196                         return;
 197
 198                 case PROP_USE_QRESYNC:
 199                         camel_imapx_settings_set_use_qresync (
 200                                 CAMEL_IMAPX_SETTINGS (object),
 201                                 g_value_get_boolean (value));
 202                         return;
 203
 204                 case PROP_USE_SHELL_COMMAND:
 205                         camel_imapx_settings_set_use_shell_command (
 206                                 CAMEL_IMAPX_SETTINGS (object),
 207                                 g_value_get_boolean (value));
 208                         return;
 209
 210                 case PROP_USE_SUBSCRIPTIONS:
 211                         camel_imapx_settings_set_use_subscriptions (
 212                                 CAMEL_IMAPX_SETTINGS (object),
 213                                 g_value_get_boolean (value));
 214                         return;
 215         }
 216
 217         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
 218 }
 219
 220 static void
 221 imapx_settings_get_property (GObject *object,
 222                              guint property_id,
 223                              GValue *value,
 224                              GParamSpec *pspec)
 225 {
 226         switch (property_id) {
 227                 case PROP_AUTH_MECHANISM:
 228                         g_value_take_string (
 229                                 value,
 230                                 camel_network_settings_dup_auth_mechanism (
 231                                 CAMEL_NETWORK_SETTINGS (object)));
 232                         return;
 233
 234                 case PROP_BATCH_FETCH_COUNT:
 235                         g_value_set_uint (
 236                                 value,
 237                                 camel_imapx_settings_get_batch_fetch_count (
 238                                 CAMEL_IMAPX_SETTINGS (object)));
 239                         return;
 240
 241                 case PROP_CHECK_ALL:
 242                         g_value_set_boolean (
 243                                 value,
 244                                 camel_imapx_settings_get_check_all (
 245                                 CAMEL_IMAPX_SETTINGS (object)));
 246                         return;
 247
 248                 case PROP_CHECK_SUBSCRIBED:
 249                         g_value_set_boolean (
 250                                 value,
 251                                 camel_imapx_settings_get_check_subscribed (
 252                                 CAMEL_IMAPX_SETTINGS (object)));
 253                         return;
 254
 255                 case PROP_CONCURRENT_CONNECTIONS:
 256                         g_value_set_uint (
 257                                 value,
 258                                 camel_imapx_settings_get_concurrent_connections (
 259                                 CAMEL_IMAPX_SETTINGS (object)));
 260                         return;
 261
 262                 case PROP_FETCH_ORDER:
 263                         g_value_set_enum (
 264                                 value,
 265                                 camel_imapx_settings_get_fetch_order (
 266                                 CAMEL_IMAPX_SETTINGS (object)));
 267                         return;
 268
 269                 case PROP_FILTER_ALL:
 270                         g_value_set_boolean (
 271                                 value,
 272                                 camel_imapx_settings_get_filter_all (
 273                                 CAMEL_IMAPX_SETTINGS (object)));
 274                         return;
 275
 276                 case PROP_FILTER_JUNK:
 277                         g_value_set_boolean (
 278                                 value,
 279                                 camel_imapx_settings_get_filter_junk (
 280                                 CAMEL_IMAPX_SETTINGS (object)));
 281                         return;
 282
 283                 case PROP_FILTER_JUNK_INBOX:
 284                         g_value_set_boolean (
 285                                 value,
 286                                 camel_imapx_settings_get_filter_junk_inbox (
 287                                 CAMEL_IMAPX_SETTINGS (object)));
 288                         return;
 289
 290                 case PROP_HOST:
 291                         g_value_take_string (
 292                                 value,
 293                                 camel_network_settings_dup_host (
 294                                 CAMEL_NETWORK_SETTINGS (object)));
 295                         return;
 296
 297                 case PROP_MOBILE_MODE:
 298                         g_value_set_boolean (
 299                                 value,
 300                                 camel_imapx_settings_get_mobile_mode (
 301                                 CAMEL_IMAPX_SETTINGS (object)));
 302                         return;
 303
 304                 case PROP_NAMESPACE:
 305                         g_value_take_string (
 306                                 value,
 307                                 camel_imapx_settings_dup_namespace (
 308                                 CAMEL_IMAPX_SETTINGS (object)));
 309                         return;
 310
 311                 case PROP_PORT:
 312                         g_value_set_uint (
 313                                 value,
 314                                 camel_network_settings_get_port (
 315                                 CAMEL_NETWORK_SETTINGS (object)));
 316                         return;
 317
 318                 case PROP_SECURITY_METHOD:
 319                         g_value_set_enum (
 320                                 value,
 321                                 camel_network_settings_get_security_method (
 322                                 CAMEL_NETWORK_SETTINGS (object)));
 323                         return;
 324
 325                 case PROP_SHELL_COMMAND:
 326                         g_value_take_string (
 327                                 value,
 328                                 camel_imapx_settings_dup_shell_command (
 329                                 CAMEL_IMAPX_SETTINGS (object)));
 330                         return;
 331
 332                 case PROP_USER:
 333                         g_value_take_string (
 334                                 value,
 335                                 camel_network_settings_dup_user (
 336                                 CAMEL_NETWORK_SETTINGS (object)));
 337                         return;
 338
 339                 case PROP_USE_IDLE:
 340                         g_value_set_boolean (
 341                                 value,
 342                                 camel_imapx_settings_get_use_idle (
 343                                 CAMEL_IMAPX_SETTINGS (object)));
 344                         return;
 345
 346                 case PROP_USE_NAMESPACE:
 347                         g_value_set_boolean (
 348                                 value,
 349                                 camel_imapx_settings_get_use_namespace (
 350                                 CAMEL_IMAPX_SETTINGS (object)));
 351                         return;
 352
 353                 case PROP_USE_QRESYNC:
 354                         g_value_set_boolean (
 355                                 value,
 356                                 camel_imapx_settings_get_use_qresync (
 357                                 CAMEL_IMAPX_SETTINGS (object)));
 358                         return;
 359
 360                 case PROP_USE_SHELL_COMMAND:
 361                         g_value_set_boolean (
 362                                 value,
 363                                 camel_imapx_settings_get_use_shell_command (
 364                                 CAMEL_IMAPX_SETTINGS (object)));
 365                         return;
 366
 367                 case PROP_USE_SUBSCRIPTIONS:
 368                         g_value_set_boolean (
 369                                 value,
 370                                 camel_imapx_settings_get_use_subscriptions (
 371                                 CAMEL_IMAPX_SETTINGS (object)));
 372                         return;
 373         }
 374
 375         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
 376 }
 377
 378 static void
 379 imapx_settings_finalize (GObject *object)
 380 {
 381         CamelIMAPXSettingsPrivate *priv;
 382
 383         priv = CAMEL_IMAPX_SETTINGS_GET_PRIVATE (object);
 384
 385         g_mutex_clear (&priv->property_lock);
 386
 387         g_free (priv->namespace);
 388         g_free (priv->shell_command);
 389
 390         /* Chain up to parent's finalize() method. */
 391         G_OBJECT_CLASS (camel_imapx_settings_parent_class)->finalize (object);
 392 }
 393
 394 static void
 395 camel_imapx_settings_class_init (CamelIMAPXSettingsClass *class)
 396 {
 397         GObjectClass *object_class;
 398
 399         g_type_class_add_private (class, sizeof (CamelIMAPXSettingsPrivate));
 400
 401         object_class = G_OBJECT_CLASS (class);
 402         object_class->set_property = imapx_settings_set_property;
 403         object_class->get_property = imapx_settings_get_property;
 404         object_class->finalize = imapx_settings_finalize;
 405
 406         /* Inherited from CamelNetworkSettings. */
 407         g_object_class_override_property (
 408                 object_class,
 409                 PROP_AUTH_MECHANISM,
 410                 "auth-mechanism");
 411
 412         g_object_class_install_property (
 413                 object_class,
 414                 PROP_BATCH_FETCH_COUNT,
 415                 g_param_spec_uint (
 416                         "batch-fetch-count",
 417                         "Batch Fetch Count",
 418                         "Number of envelopes to fetch at once",
 419                         0,
 420                         G_MAXUINT,
 421                         500,
 422                         G_PARAM_READWRITE |
 423                         G_PARAM_CONSTRUCT |
 424                         G_PARAM_STATIC_STRINGS));
 425
 426         g_object_class_install_property (
 427                 object_class,
 428                 PROP_CHECK_ALL,
 429                 g_param_spec_boolean (
 430                         "check-all",
 431                         "Check All",
 432                         "Check all folders for new messages",
 433                         FALSE,
 434                         G_PARAM_READWRITE |
 435                         G_PARAM_CONSTRUCT |
 436                         G_PARAM_STATIC_STRINGS));
 437
 438         g_object_class_install_property (
 439                 object_class,
 440                 PROP_CHECK_SUBSCRIBED,
 441                 g_param_spec_boolean (
 442                         "check-subscribed",
 443                         "Check Subscribed",
 444                         "Check only subscribed folders for new messages",
 445                         FALSE,
 446                         G_PARAM_READWRITE |
 447                         G_PARAM_CONSTRUCT |
 448                         G_PARAM_STATIC_STRINGS));
 449
 450         g_object_class_install_property (
 451                 object_class,
 452                 PROP_CONCURRENT_CONNECTIONS,
 453                 g_param_spec_uint (
 454                         "concurrent-connections",
 455                         "Concurrent Connections",
 456                         "Number of concurrent IMAP connections to use",
 457                         MIN_CONCURRENT_CONNECTIONS,
 458                         MAX_CONCURRENT_CONNECTIONS,
 459                         5,
 460                         G_PARAM_READWRITE |
 461                         G_PARAM_CONSTRUCT |
 462                         G_PARAM_STATIC_STRINGS));
 463
 464         g_object_class_install_property (
 465                 object_class,
 466                 PROP_FETCH_ORDER,
 467                 g_param_spec_enum (
 468                         "fetch-order",
 469                         "Fetch Order",
 470                         "Order in which new messages should be fetched",
 471                         CAMEL_TYPE_SORT_TYPE,
 472                         CAMEL_SORT_ASCENDING,
 473                         G_PARAM_READWRITE |
 474                         G_PARAM_CONSTRUCT |
 475                         G_PARAM_STATIC_STRINGS));
 476
 477         g_object_class_install_property (
 478                 object_class,
 479                 PROP_FILTER_ALL,
 480                 g_param_spec_boolean (
 481                         "filter-all",
 482                         "Filter All",
 483                         "Whether to apply filters in all folders",
 484                         FALSE,
 485                         G_PARAM_READWRITE |
 486                         G_PARAM_CONSTRUCT |
 487                         G_PARAM_STATIC_STRINGS));
 488
 489         g_object_class_install_property (
 490                 object_class,
 491                 PROP_FILTER_JUNK,
 492                 g_param_spec_boolean (
 493                         "filter-junk",
 494                         "Filter Junk",
 495                         "Whether to filter junk from all folders",
 496                         FALSE,
 497                         G_PARAM_READWRITE |
 498                         G_PARAM_CONSTRUCT |
 499                         G_PARAM_STATIC_STRINGS));
 500
 501         g_object_class_install_property (
 502                 object_class,
 503                 PROP_FILTER_JUNK_INBOX,
 504                 g_param_spec_boolean (
 505                         "filter-junk-inbox",
 506                         "Filter Junk Inbox",
 507                         "Whether to filter junk from Inbox only",
 508                         FALSE,
 509                         G_PARAM_READWRITE |
 510                         G_PARAM_CONSTRUCT |
 511                         G_PARAM_STATIC_STRINGS));
 512
 513         g_object_class_install_property (
 514                 object_class,
 515                 PROP_MOBILE_MODE,
 516                 g_param_spec_boolean (
 517                         "mobile-mode",
 518                         "Mobile Mode",
 519                         "Mobile mode which adjusts the IMAPX for Mobile clients",
 520                         FALSE,
 521                         G_PARAM_READWRITE |
 522                         G_PARAM_CONSTRUCT |
 523                         G_PARAM_STATIC_STRINGS));
 524
 525         /* Inherited from CamelNetworkSettings. */
 526         g_object_class_override_property (
 527                 object_class,
 528                 PROP_HOST,
 529                 "host");
 530
 531         g_object_class_install_property (
 532                 object_class,
 533                 PROP_NAMESPACE,
 534                 g_param_spec_string (
 535                         "namespace",
 536                         "Namespace",
 537                         "Custom IMAP namespace",
 538                         NULL,
 539                         G_PARAM_READWRITE |
 540                         G_PARAM_CONSTRUCT |
 541                         G_PARAM_STATIC_STRINGS));
 542
 543         /* Inherited from CamelNetworkSettings. */
 544         g_object_class_override_property (
 545                 object_class,
 546                 PROP_PORT,
 547                 "port");
 548
 549         /* Inherited from CamelNetworkSettings. */
 550         g_object_class_override_property (
 551                 object_class,
 552                 PROP_SECURITY_METHOD,
 553                 "security-method");
 554
 555         g_object_class_install_property (
 556                 object_class,
 557                 PROP_SHELL_COMMAND,
 558                 g_param_spec_string (
 559                         "shell-command",
 560                         "Shell Command",
 561                         "Shell command for connecting to the server",
 562                         "ssh -C -l %u %h exec /usr/sbin/imapd",
 563                         G_PARAM_READWRITE |
 564                         G_PARAM_CONSTRUCT |
 565                         G_PARAM_STATIC_STRINGS));
 566
 567         /* Inherited from CamelNetworkSettings. */
 568         g_object_class_override_property (
 569                 object_class,
 570                 PROP_USER,
 571                 "user");
 572
 573         g_object_class_install_property (
 574                 object_class,
 575                 PROP_USE_IDLE,
 576                 g_param_spec_boolean (
 577                         "use-idle",
 578                         "Use IDLE",
 579                         "Whether to use the IDLE IMAP extension",
 580                         TRUE,
 581                         G_PARAM_READWRITE |
 582                         G_PARAM_CONSTRUCT |
 583                         G_PARAM_STATIC_STRINGS));
 584
 585         g_object_class_install_property (
 586                 object_class,
 587                 PROP_USE_NAMESPACE,
 588                 g_param_spec_boolean (
 589                         "use-namespace",
 590                         "Use Namespace",
 591                         "Whether to use a custom IMAP namespace",
 592                         FALSE,
 593                         G_PARAM_READWRITE |
 594                         G_PARAM_CONSTRUCT |
 595                         G_PARAM_STATIC_STRINGS));
 596
 597         g_object_class_install_property (
 598                 object_class,
 599                 PROP_USE_QRESYNC,
 600                 g_param_spec_boolean (
 601                         "use-qresync",
 602                         "Use QRESYNC",
 603                         "Whether to use the QRESYNC IMAP extension",
 604                         TRUE,
 605                         G_PARAM_READWRITE |
 606                         G_PARAM_CONSTRUCT |
 607                         G_PARAM_STATIC_STRINGS));
 608
 609         g_object_class_install_property (
 610                 object_class,
 611                 PROP_USE_SHELL_COMMAND,
 612                 g_param_spec_boolean (
 613                         "use-shell-command",
 614                         "Use Shell Command",
 615                         "Whether to use a custom shell "
 616                         "command to connect to the server",
 617                         FALSE,
 618                         G_PARAM_READWRITE |
 619                         G_PARAM_CONSTRUCT |
 620                         G_PARAM_STATIC_STRINGS));
 621
 622         g_object_class_install_property (
 623                 object_class,
 624                 PROP_USE_SUBSCRIPTIONS,
 625                 g_param_spec_boolean (
 626                         "use-subscriptions",
 627                         "Use Subscriptions",
 628                         "Whether to honor folder subscriptions",
 629                         TRUE,
 630                         G_PARAM_READWRITE |
 631                         G_PARAM_CONSTRUCT |
 632                         G_PARAM_STATIC_STRINGS));
 633 }
 634
 635 static void
 636 camel_imapx_settings_init (CamelIMAPXSettings *settings)
 637 {
 638         settings->priv = CAMEL_IMAPX_SETTINGS_GET_PRIVATE (settings);
 639         g_mutex_init (&settings->priv->property_lock);
 640 }
 641
 642 /**
 643  * camel_imapx_settings_get_batch_fetch_count:
 644  * @settings: a #CamelIMAPXSettings
 645  *
 646  * Returns the number of message envelopes to fetch at once.
 647  *
 648  * This is a tunable performance parameter and probably should not be
 649  * exposed in a graphical user interface.
 650  *
 651  * Returns: number of message envelopes to fetch at once
 652  *
 653  * Since: 3.2
 654  **/
 655 guint
 656 camel_imapx_settings_get_batch_fetch_count (CamelIMAPXSettings *settings)
 657 {
 658         g_return_val_if_fail (CAMEL_IS_IMAPX_SETTINGS (settings), 0);
 659
 660         return settings->priv->batch_fetch_count;
 661 }
 662
 663 /**
 664  * camel_imapx_settings_set_batch_fetch_count:
 665  * @settings: a #CamelIMAPXSettings
 666  * @batch_fetch_count: number of message envelopes to fetch at once
 667  *
 668  * Sets the number of message envelopes to fetch at once.
 669  *
 670  * This is a tunable performance parameter and probably should not be
 671  * exposed in a graphical user interface.
 672  *
 673  * Since: 3.2
 674  **/
 675 void
 676 camel_imapx_settings_set_batch_fetch_count (CamelIMAPXSettings *settings,
 677                                             guint batch_fetch_count)
 678 {
 679         g_return_if_fail (CAMEL_IS_IMAPX_SETTINGS (settings));
 680
 681         if (settings->priv->batch_fetch_count == batch_fetch_count)
 682                 return;
 683
 684         settings->priv->batch_fetch_count = batch_fetch_count;
 685
 686         g_object_notify (G_OBJECT (settings), "batch-fetch-count");
 687 }
 688
 689 /**
 690  * camel_imapx_settings_get_check_all:
 691  * @settings: a #CamelIMAPXSettings
 692  *
 693  * Returns whether to check all folders for new messages.
 694  *
 695  * Returns: whether to check all folders for new messages
 696  *
 697  * Since: 3.2
 698  **/
 699 gboolean
 700 camel_imapx_settings_get_check_all (CamelIMAPXSettings *settings)
 701 {
 702         g_return_val_if_fail (CAMEL_IS_IMAPX_SETTINGS (settings), FALSE);
 703
 704         return settings->priv->check_all;
 705 }
 706
 707 /**
 708  * camel_imapx_settings_set_check_all:
 709  * @settings: a #CamelIMAPXSettings
 710  * @check_all: whether to check all folders for new messages
 711  *
 712  * Sets whether to check all folders for new messages.
 713  *
 714  * Since: 3.2
 715  **/
 716 void
 717 camel_imapx_settings_set_check_all (CamelIMAPXSettings *settings,
 718                                     gboolean check_all)
 719 {
 720         g_return_if_fail (CAMEL_IS_IMAPX_SETTINGS (settings));
 721
 722         if (settings->priv->check_all == check_all)
 723                 return;
 724
 725         settings->priv->check_all = check_all;
 726
 727         g_object_notify (G_OBJECT (settings), "check-all");
 728 }
 729
 730 /**
 731  * camel_imapx_settings_get_check_subscribed:
 732  * @settings: a #CamelIMAPXSettings
 733  *
 734  * Returns whether to check only subscribed folders for new messages.
 735  * Note that #CamelIMAPXSettings:check-all, if %TRUE, overrides this setting.
 736  *
 737  * Returns: whether to check only subscribed folders for new messages
 738  *
 739  * Since: 3.2
 740  **/
 741 gboolean
 742 camel_imapx_settings_get_check_subscribed (CamelIMAPXSettings *settings)
 743 {
 744         g_return_val_if_fail (CAMEL_IS_IMAPX_SETTINGS (settings), FALSE);
 745
 746         return settings->priv->check_subscribed;
 747 }
 748
 749 /**
 750  * camel_imapx_settings_set_check_subscribed:
 751  * @settings: a #CamelIMAPXSettings
 752  * @check_subscribed: whether to check only subscribed folders for new messages
 753  *
 754  * Sets whether to check only subscribed folders for new messages.  Note
 755  * that #CamelIMAPXSettings:check-all, if %TRUE, overrides this setting.
 756  *
 757  * Since: 3.2
 758  **/
 759 void
 760 camel_imapx_settings_set_check_subscribed (CamelIMAPXSettings *settings,
 761                                            gboolean check_subscribed)
 762 {
 763         g_return_if_fail (CAMEL_IS_IMAPX_SETTINGS (settings));
 764
 765         if (settings->priv->check_subscribed == check_subscribed)
 766                 return;
 767
 768         settings->priv->check_subscribed = check_subscribed;
 769
 770         g_object_notify (G_OBJECT (settings), "check-subscribed");
 771 }
 772
 773 /**
 774  * camel_imapx_settings_get_concurrent_connections:
 775  * @settings: a #CamelIMAPXSettings
 776  *
 777  * Returns the number of concurrent network connections to the IMAP server
 778  * to use for faster command/response processing.
 779  *
 780  * Returns: the number of concurrent connections to use
 781  *
 782  * Since: 3.2
 783  **/
 784 guint
 785 camel_imapx_settings_get_concurrent_connections (CamelIMAPXSettings *settings)
 786 {
 787         g_return_val_if_fail (CAMEL_IS_IMAPX_SETTINGS (settings), 1);
 788
 789         return settings->priv->concurrent_connections;
 790 }
 791
 792 /**
 793  * camel_imapx_settings_set_concurrent_connections:
 794  * @settings: a #CamelIMAPXSettings
 795  * @concurrent_connections: the number of concurrent connections to use
 796  *
 797  * Sets the number of concurrent network connections to the IMAP server to
 798  * use for faster command/response processing.
 799  *
 800  * The minimum number of connections is 1, the maximum is 7.  The
 801  * @concurrent_connections value will be clamped to these limits if
 802  * necessary.
 803  *
 804  * Since: 3.2
 805  **/
 806 void
 807 camel_imapx_settings_set_concurrent_connections (CamelIMAPXSettings *settings,
 808                                                  guint concurrent_connections)
 809 {
 810         g_return_if_fail (CAMEL_IS_IMAPX_SETTINGS (settings));
 811
 812         concurrent_connections = CLAMP (
 813                 concurrent_connections,
 814                 MIN_CONCURRENT_CONNECTIONS,
 815                 MAX_CONCURRENT_CONNECTIONS);
 816
 817         if (settings->priv->concurrent_connections == concurrent_connections)
 818                 return;
 819
 820         settings->priv->concurrent_connections = concurrent_connections;
 821
 822         g_object_notify (G_OBJECT (settings), "concurrent-connections");
 823 }
 824
 825 /**
 826  * camel_imapx_settings_get_fetch_order:
 827  * @settings: a #CamelIMAPXSettings
 828  *
 829  * Returns the order in which new messages should be fetched.
 830  *
 831  * Returns: the order in which new messages should be fetched
 832  *
 833  * Since: 3.2
 834  **/
 835 CamelSortType
 836 camel_imapx_settings_get_fetch_order (CamelIMAPXSettings *settings)
 837 {
 838         g_return_val_if_fail (
 839                 CAMEL_IS_IMAPX_SETTINGS (settings),
 840                 CAMEL_SORT_ASCENDING);
 841
 842         return settings->priv->fetch_order;
 843 }
 844
 845 /**
 846  * camel_imapx_settings_set_fetch_order:
 847  * @settings: a #CamelIMAPXSettings
 848  * @fetch_order: the order in which new messages should be fetched
 849  *
 850  * Sets the order in which new messages should be fetched.
 851  *
 852  * Since: 3.2
 853  **/
 854 void
 855 camel_imapx_settings_set_fetch_order (CamelIMAPXSettings *settings,
 856                                       CamelSortType fetch_order)
 857 {
 858         g_return_if_fail (CAMEL_IS_IMAPX_SETTINGS (settings));
 859
 860         if (settings->priv->fetch_order == fetch_order)
 861                 return;
 862
 863         settings->priv->fetch_order = fetch_order;
 864
 865         g_object_notify (G_OBJECT (settings), "fetch-order");
 866 }
 867
 868 /**
 869  * camel_imapx_settings_get_filter_all:
 870  * @settings: a #CamelIMAPXSettings
 871  *
 872  * Returns whether apply filters in all folders.
 873  *
 874  * Returns: whether to apply filters in all folders
 875  *
 876  * Since: 3.4
 877  **/
 878 gboolean
 879 camel_imapx_settings_get_filter_all (CamelIMAPXSettings *settings)
 880 {
 881         g_return_val_if_fail (CAMEL_IS_IMAPX_SETTINGS (settings), FALSE);
 882
 883         return settings->priv->filter_all;
 884 }
 885
 886 /**
 887  * camel_imapx_settings_set_filter_all:
 888  * @settings: a #CamelIMAPXSettings
 889  * @filter_all: whether to apply filters in all folders
 890  *
 891  * Sets whether to apply filters in all folders.
 892  *
 893  * Since: 3.4
 894  **/
 895 void
 896 camel_imapx_settings_set_filter_all (CamelIMAPXSettings *settings,
 897                                      gboolean filter_all)
 898 {
 899         g_return_if_fail (CAMEL_IS_IMAPX_SETTINGS (settings));
 900
 901         if (settings->priv->filter_all == filter_all)
 902                 return;
 903
 904         settings->priv->filter_all = filter_all;
 905
 906         g_object_notify (G_OBJECT (settings), "filter-all");
 907 }
 908
 909 /**
 910  * camel_imapx_settings_get_filter_junk:
 911  * @settings: a #CamelIMAPXSettings
 912  *
 913  * Returns whether to automatically find and tag junk messages amongst new
 914  * messages in all folders.
 915  *
 916  * Returns: whether to filter junk in all folders
 917  *
 918  * Since: 3.2
 919  **/
 920 gboolean
 921 camel_imapx_settings_get_filter_junk (CamelIMAPXSettings *settings)
 922 {
 923         g_return_val_if_fail (CAMEL_IS_IMAPX_SETTINGS (settings), FALSE);
 924
 925         return settings->priv->filter_junk;
 926 }
 927
 928 /**
 929  * camel_imapx_settings_set_filter_junk:
 930  * @settings: a #CamelIMAPXSettings
 931  * @filter_junk: whether to filter junk in all folders
 932  *
 933  * Sets whether to automatically find and tag junk messages amongst new
 934  * messages in all folders.
 935  *
 936  * Since: 3.2
 937  **/
 938 void
 939 camel_imapx_settings_set_filter_junk (CamelIMAPXSettings *settings,
 940                                       gboolean filter_junk)
 941 {
 942         g_return_if_fail (CAMEL_IS_IMAPX_SETTINGS (settings));
 943
 944         if (settings->priv->filter_junk == filter_junk)
 945                 return;
 946
 947         settings->priv->filter_junk = filter_junk;
 948
 949         g_object_notify (G_OBJECT (settings), "filter-junk");
 950 }
 951
 952 /**
 953  * camel_imapx_settings_get_filter_junk_inbox:
 954  * @settings: a #CamelIMAPXSettings
 955  *
 956  * Returns whether to automatically find and tag junk messages amongst new
 957  * messages in the Inbox folder only.
 958  *
 959  * Returns: whether to filter junk in Inbox only
 960  *
 961  * Since: 3.2
 962  **/
 963 gboolean
 964 camel_imapx_settings_get_filter_junk_inbox (CamelIMAPXSettings *settings)
 965 {
 966         g_return_val_if_fail (CAMEL_IS_IMAPX_SETTINGS (settings), FALSE);
 967
 968         return settings->priv->filter_junk_inbox;
 969 }
 970
 971 /**
 972  * camel_imapx_settings_set_filter_junk_inbox:
 973  * @settings: a #CamelIMAPXSettings
 974  * @filter_junk_inbox: whether to filter junk in Inbox only
 975  *
 976  * Sets whether to automatically find and tag junk messages amongst new
 977  * messages in the Inbox folder only.
 978  *
 979  * Since: 3.2
 980  **/
 981 void
 982 camel_imapx_settings_set_filter_junk_inbox (CamelIMAPXSettings *settings,
 983                                             gboolean filter_junk_inbox)
 984 {
 985         g_return_if_fail (CAMEL_IS_IMAPX_SETTINGS (settings));
 986
 987         if (settings->priv->filter_junk_inbox == filter_junk_inbox)
 988                 return;
 989
 990         settings->priv->filter_junk_inbox = filter_junk_inbox;
 991
 992         g_object_notify (G_OBJECT (settings), "filter-junk-inbox");
 993 }
 994
 995 /**
 996  * camel_imapx_settings_get_mobile_mode:
 997  * @settings: a #CamelIMAPXSettings
 998  *
 999  * Returns whether the backend is operating in mobile mode.
1000  *
1001  * Since: 3.2
1002  **/
1003 gboolean
1004 camel_imapx_settings_get_mobile_mode (CamelIMAPXSettings *settings)
1005 {
1006         g_return_val_if_fail (
1007                 CAMEL_IS_IMAPX_SETTINGS (settings),
1008                 CAMEL_SORT_ASCENDING);
1009
1010         return settings->priv->use_mobile_mode;
1011 }
1012
1013 /**
1014  * camel_imapx_settings_set_mobile_mode:
1015  * @settings: a #CamelIMAPXSettings
1016  * @mobile_mode: whether to operate in mobile mode.
1017  *
1018  * Sets the mode of operation as mobile or not for the backend.
1019  *
1020  * Since: 3.2
1021  **/
1022 void
1023 camel_imapx_settings_set_mobile_mode (CamelIMAPXSettings *settings,
1024                                       gboolean mobile_mode)
1025 {
1026         g_return_if_fail (CAMEL_IS_IMAPX_SETTINGS (settings));
1027
1028         if (settings->priv->use_mobile_mode == mobile_mode)
1029                 return;
1030
1031         settings->priv->use_mobile_mode = mobile_mode;
1032
1033         g_object_notify (G_OBJECT (settings), "mobile-mode");
1034 }
1035
1036 /**
1037  * camel_imapx_settings_get_namespace:
1038  * @settings: a #CamelIMAPXSettings
1039  *
1040  * Returns the custom IMAP namespace in which to find folders.
1041  *
1042  * Returns: the custom IMAP namespace, or %NULL
1043  *
1044  * Since: 3.2
1045  **/
1046 const gchar *
1047 camel_imapx_settings_get_namespace (CamelIMAPXSettings *settings)
1048 {
1049         g_return_val_if_fail (CAMEL_IS_IMAPX_SETTINGS (settings), NULL);
1050
1051         return settings->priv->namespace;
1052 }
1053
1054 /**
1055  * camel_imapx_settings_dup_namespace:
1056  * @settings: a #CamelIMAPXSettings
1057  *
1058  * Thread-safe variation of camel_imapx_settings_get_namespace().
1059  * Use this function when accessing @settings from multiple threads.
1060  *
1061  * The returned string should be freed with g_free() when no longer needed.
1062  *
1063  * Returns: a newly-allocated copy of #CamelIMAPXSettings:namespace
1064  *
1065  * Since: 3.4
1066  **/
1067 gchar *
1068 camel_imapx_settings_dup_namespace (CamelIMAPXSettings *settings)
1069 {
1070         const gchar *protected;
1071         gchar *duplicate;
1072
1073         g_return_val_if_fail (CAMEL_IS_IMAPX_SETTINGS (settings), NULL);
1074
1075         g_mutex_lock (&settings->priv->property_lock);
1076
1077         protected = camel_imapx_settings_get_namespace (settings);
1078         duplicate = g_strdup (protected);
1079
1080         g_mutex_unlock (&settings->priv->property_lock);
1081
1082         return duplicate;
1083 }
1084
1085 /**
1086  * camel_imapx_settings_set_namespace:
1087  * @settings: a #CamelIMAPXSettings
1088  * @namespace_: an IMAP namespace, or %NULL
1089  *
1090  * Sets the custom IMAP namespace in which to find folders.  If @namespace_
1091  * is %NULL, the default namespace is used.
1092  *
1093  * Since: 3.2
1094  **/
1095 void
1096 camel_imapx_settings_set_namespace (CamelIMAPXSettings *settings,
1097                                     const gchar *namespace_)
1098 {
1099         g_return_if_fail (CAMEL_IS_IMAPX_SETTINGS (settings));
1100
1101         /* The default namespace is an empty string. */
1102         if (namespace_ == NULL)
1103                 namespace_ = "";
1104
1105         g_mutex_lock (&settings->priv->property_lock);
1106
1107         if (g_strcmp0 (settings->priv->namespace, namespace_) == 0) {
1108                 g_mutex_unlock (&settings->priv->property_lock);
1109                 return;
1110         }
1111
1112         g_free (settings->priv->namespace);
1113         settings->priv->namespace = g_strdup (namespace_);
1114
1115         g_mutex_unlock (&settings->priv->property_lock);
1116
1117         g_object_notify (G_OBJECT (settings), "namespace");
1118 }
1119
1120 /**
1121  * camel_imapx_settings_get_shell_command:
1122  * @settings: a #CamelIMAPXSettings
1123  *
1124  * Returns an optional shell command used to establish an input/output
1125  * stream with an IMAP server.  Normally the input/output stream is
1126  * established through a network socket.
1127  *
1128  * This option is useful only to a select few advanced users who likely
1129  * administer their own IMAP server.  Most users will not understand what
1130  * this option menas or how to use it.  Probably not worth exposing in a
1131  * graphical interface.
1132  *
1133  * Returns: shell command for connecting to the server, or %NULL
1134  *
1135  * Since: 3.2
1136  **/
1137 const gchar *
1138 camel_imapx_settings_get_shell_command (CamelIMAPXSettings *settings)
1139 {
1140         g_return_val_if_fail (CAMEL_IS_IMAPX_SETTINGS (settings), NULL);
1141
1142         return settings->priv->shell_command;
1143 }
1144
1145 /**
1146  * camel_imapx_settings_dup_shell_command:
1147  * @settings: a #CamelIMAPXSettings
1148  *
1149  * Thread-safe variation of camel_imapx_settings_get_shell_command().
1150  * Use this function when accessing @settings from multiple threads.
1151  *
1152  * The returned string should be freed with g_free() when no longer needed.
1153  *
1154  * Returns: a newly-allocated copy of #CamelIMAPXSettings:shell-command
1155  *
1156  * Since: 3.4
1157  **/
1158 gchar *
1159 camel_imapx_settings_dup_shell_command (CamelIMAPXSettings *settings)
1160 {
1161         const gchar *protected;
1162         gchar *duplicate;
1163
1164         g_return_val_if_fail (CAMEL_IS_IMAPX_SETTINGS (settings), NULL);
1165
1166         g_mutex_lock (&settings->priv->property_lock);
1167
1168         protected = camel_imapx_settings_get_shell_command (settings);
1169         duplicate = g_strdup (protected);
1170
1171         g_mutex_unlock (&settings->priv->property_lock);
1172
1173         return duplicate;
1174 }
1175
1176 /**
1177  * camel_imapx_settings_set_shell_command:
1178  * @settings: a #CamelIMAPXSettings
1179  * @shell_command: shell command for connecting to the server, or %NULL
1180  *
1181  * Sets an optional shell command used to establish an input/output stream
1182  * with an IMAP server.  Normally the input/output stream is established
1183  * through a network socket.
1184  *
1185  * This option is useful only to a select few advanced users who likely
1186  * administer their own IMAP server.  Most users will not understand what
1187  * this option means or how to use it.  Probably not worth exposing in a
1188  * graphical interface.
1189  *
1190  * Since: 3.2
1191  **/
1192 void
1193 camel_imapx_settings_set_shell_command (CamelIMAPXSettings *settings,
1194                                         const gchar *shell_command)
1195 {
1196         g_return_if_fail (CAMEL_IS_IMAPX_SETTINGS (settings));
1197
1198         /* An empty string is equivalent to NULL. */
1199         if (shell_command != NULL && *shell_command == '\0')
1200                 shell_command = NULL;
1201
1202         g_mutex_lock (&settings->priv->property_lock);
1203
1204         if (g_strcmp0 (settings->priv->shell_command, shell_command) == 0) {
1205                 g_mutex_unlock (&settings->priv->property_lock);
1206                 return;
1207         }
1208
1209         g_free (settings->priv->shell_command);
1210         settings->priv->shell_command = g_strdup (shell_command);
1211
1212         g_mutex_unlock (&settings->priv->property_lock);
1213
1214         g_object_notify (G_OBJECT (settings), "shell-command");
1215 }
1216
1217 /**
1218  * camel_imapx_settings_get_use_idle:
1219  * @settings: a #CamelIMAPXSettings
1220  *
1221  * Returns whether to use the IMAP IDLE extension if the server supports
1222  * it.  See RFC 2177 for more details.
1223  *
1224  * Returns: whether to use the IDLE extension
1225  *
1226  * Since: 3.2
1227  **/
1228 gboolean
1229 camel_imapx_settings_get_use_idle (CamelIMAPXSettings *settings)
1230 {
1231         g_return_val_if_fail (CAMEL_IS_IMAPX_SETTINGS (settings), FALSE);
1232
1233         return settings->priv->use_idle;
1234 }
1235
1236 /**
1237  * camel_imapx_settings_set_use_idle:
1238  * @settings: a #CamelIMAPXSettings
1239  * @use_idle: whether to use the IDLE extension
1240  *
1241  * Sets whether to use the IMAP IDLE extension if the server supports it.
1242  * See RFC 2177 for more details.
1243  *
1244  * Since: 3.2
1245  **/
1246 void
1247 camel_imapx_settings_set_use_idle (CamelIMAPXSettings *settings,
1248                                    gboolean use_idle)
1249 {
1250         g_return_if_fail (CAMEL_IS_IMAPX_SETTINGS (settings));
1251
1252         if (settings->priv->use_idle == use_idle)
1253                 return;
1254
1255         settings->priv->use_idle = use_idle;
1256
1257         g_object_notify (G_OBJECT (settings), "use-idle");
1258 }
1259
1260 /**
1261  * camel_imapx_settings_get_use_namespace:
1262  * @settings: a #CamelIMAPXSettings
1263  *
1264  * Returns whether to use a custom IMAP namespace to find folders.  The
1265  * namespace itself is given by the #CamelIMAPStore:namespace property.
1266  *
1267  * Returns: whether to use a custom IMAP namespace
1268  *
1269  * Since: 3.2
1270  **/
1271 gboolean
1272 camel_imapx_settings_get_use_namespace (CamelIMAPXSettings *settings)
1273 {
1274         g_return_val_if_fail (CAMEL_IS_IMAPX_SETTINGS (settings), FALSE);
1275
1276         return settings->priv->use_namespace;
1277 }
1278
1279 /**
1280  * camel_imapx_settings_set_use_namespace:
1281  * @settings: a #CamelIMAPXSettings
1282  * @use_namespace: whether to use a custom IMAP namespace
1283  *
1284  * Sets whether to use a custom IMAP namespace to find folders.  The
1285  * namespace itself is given by the #CamelIMAPXSettings:namespace property.
1286  *
1287  * Since: 3.2
1288  **/
1289 void
1290 camel_imapx_settings_set_use_namespace (CamelIMAPXSettings *settings,
1291                                         gboolean use_namespace)
1292 {
1293         g_return_if_fail (CAMEL_IS_IMAPX_SETTINGS (settings));
1294
1295         if (settings->priv->use_namespace == use_namespace)
1296                 return;
1297
1298         settings->priv->use_namespace = use_namespace;
1299
1300         g_object_notify (G_OBJECT (settings), "use-namespace");
1301 }
1302
1303 /**
1304  * camel_imapx_settings_get_use_qresync:
1305  * @settings: a #CamelIMAPXSettings
1306  *
1307  * Returns whether to use the Quick Mailbox Resynchronization (QRESYNC)
1308  * IMAP extension if the server supports it.  See RFC 5162 for more
1309  * details.
1310  *
1311  * Returns: whether to use the QRESYNC extension
1312  *
1313  * Since: 3.2
1314  **/
1315 gboolean
1316 camel_imapx_settings_get_use_qresync (CamelIMAPXSettings *settings)
1317 {
1318         g_return_val_if_fail (CAMEL_IS_IMAPX_SETTINGS (settings), FALSE);
1319
1320         return settings->priv->use_qresync;
1321 }
1322
1323 /**
1324  * camel_imapx_settings_set_use_qresync:
1325  * @settings: a #CamelIMAPXSettings
1326  * @use_qresync: whether to use the QRESYNC extension
1327  *
1328  * Sets whether to use the Quick Mailbox Resynchronization (QRESYNC)
1329  * IMAP extension if the server supports it.  See RFC 5162 for more
1330  * details.
1331  *
1332  * Since: 3.2
1333  **/
1334 void
1335 camel_imapx_settings_set_use_qresync (CamelIMAPXSettings *settings,
1336                                       gboolean use_qresync)
1337 {
1338         g_return_if_fail (CAMEL_IS_IMAPX_SETTINGS (settings));
1339
1340         if (settings->priv->use_qresync == use_qresync)
1341                 return;
1342
1343         settings->priv->use_qresync = use_qresync;
1344
1345         g_object_notify (G_OBJECT (settings), "use-qresync");
1346 }
1347
1348 /**
1349  * camel_imapx_settings_get_use_shell_command:
1350  * @settings: a #CamelIMAPXSettings
1351  *
1352  * Returns whether to use a custom shell command to establish an input/output
1353  * stream with an IMAP server, instead of the more common method of opening a
1354  * network socket.  The shell command itself is given by the
1355  * #CamelIMAPXSettings:shell-command property.
1356  *
1357  * This option is useful only to a select few advanced users who likely
1358  * administer their own IMAP server.  Most users will not understand what
1359  * this option means or how to use it.  Probably not worth exposing in a
1360  * graphical interface.
1361  *
1362  * Returns: whether to use a custom shell command to connect to the server
1363  *
1364  * Since: 3.2
1365  **/
1366 gboolean
1367 camel_imapx_settings_get_use_shell_command (CamelIMAPXSettings *settings)
1368 {
1369         g_return_val_if_fail (CAMEL_IS_IMAPX_SETTINGS (settings), FALSE);
1370
1371         return settings->priv->use_shell_command;
1372 }
1373
1374 /**
1375  * camel_imapx_settings_set_use_shell_command:
1376  * @settings: a #CamelIMAPXSettings
1377  * @use_shell_command: whether to use a custom shell command to connect
1378  *                     to the server
1379  *
1380  * Sets whether to use a custom shell command to establish an input/output
1381  * stream with an IMAP server, instead of the more common method of opening
1382  * a network socket.  The shell command itself is given by the
1383  * #CamelIMAPXSettings:shell-command property.
1384  *
1385  * This option is useful only to a select few advanced users who likely
1386  * administer their own IMAP server.  Most users will not understand what
1387  * this option means or how to use it.  Probably not worth exposing in a
1388  * graphical interface.
1389  *
1390  * Since: 3.2
1391  **/
1392 void
1393 camel_imapx_settings_set_use_shell_command (CamelIMAPXSettings *settings,
1394                                             gboolean use_shell_command)
1395 {
1396         g_return_if_fail (CAMEL_IS_IMAPX_SETTINGS (settings));
1397
1398         if (settings->priv->use_shell_command == use_shell_command)
1399                 return;
1400
1401         settings->priv->use_shell_command = use_shell_command;
1402
1403         g_object_notify (G_OBJECT (settings), "use-shell-command");
1404 }
1405
1406 /**
1407  * camel_imapx_settings_get_use_subscriptions:
1408  * @settings: a #CamelIMAPXSettings
1409  *
1410  * Returns whether to list and operate only on subscribed folders, or to
1411  * list and operate on all available folders regardless of subscriptions.
1412  *
1413  * Returns: whether to honor folder subscriptions
1414  *
1415  * Since: 3.2
1416  **/
1417 gboolean
1418 camel_imapx_settings_get_use_subscriptions (CamelIMAPXSettings *settings)
1419 {
1420         g_return_val_if_fail (CAMEL_IS_IMAPX_SETTINGS (settings), FALSE);
1421
1422         return settings->priv->use_subscriptions;
1423 }
1424
1425 /**
1426  * camel_imapx_settings_set_use_subscriptions:
1427  * @settings: a #CamelIMAPXSettings
1428  * @use_subscriptions: whether to honor folder subscriptions
1429  *
1430  * Sets whether to list and operate only on subscribed folders, or to
1431  * list and operate on all available folders regardless of subscriptions.
1432  *
1433  * Since: 3.2
1434  **/
1435 void
1436 camel_imapx_settings_set_use_subscriptions (CamelIMAPXSettings *settings,
1437                                             gboolean use_subscriptions)
1438 {
1439         g_return_if_fail (CAMEL_IS_IMAPX_SETTINGS (settings));
1440
1441         if (settings->priv->use_subscriptions == use_subscriptions)
1442                 return;
1443
1444         settings->priv->use_subscriptions = use_subscriptions;
1445
1446         g_object_notify (G_OBJECT (settings), "use-subscriptions");
1447 }
1448