mail/e-mail-config-provider-page.c

   1 /*
   2  * e-mail-config-provider-page.c
   3  *
   4  * This program is free software; you can redistribute it and/or modify it
   5  * under the terms of the GNU Lesser General Public License as published by
   6  * the Free Software Foundation.
   7  *
   8  * This program is distributed in the hope that it will be useful, but
   9  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  10  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  11  * for more details.
  12  *
  13  * You should have received a copy of the GNU Lesser General Public License
  14  * along with this program; if not, see <http://www.gnu.org/licenses/>.
  15  *
  16  */
  17
  18 #include "e-mail-config-provider-page.h"
  19
  20 #include <config.h>
  21 #include <string.h>
  22 #include <glib/gi18n-lib.h>
  23
  24 #include <libebackend/libebackend.h>
  25
  26 #define E_MAIL_CONFIG_PROVIDER_PAGE_GET_PRIVATE(obj) \
  27         (G_TYPE_INSTANCE_GET_PRIVATE \
  28         ((obj), E_TYPE_MAIL_CONFIG_PROVIDER_PAGE, EMailConfigProviderPagePrivate))
  29
  30 #define STANDARD_MARGIN   12
  31 #define DEPENDENCY_MARGIN 24
  32
  33 struct _EMailConfigProviderPagePrivate {
  34         EMailConfigServiceBackend *backend;
  35         gboolean is_empty;
  36 };
  37
  38 enum {
  39         PROP_0,
  40         PROP_BACKEND
  41 };
  42
  43 /* Forward Declarations */
  44 static void     e_mail_config_provider_page_interface_init
  45                                         (EMailConfigPageInterface *iface);
  46
  47 G_DEFINE_TYPE_WITH_CODE (
  48         EMailConfigProviderPage,
  49         e_mail_config_provider_page,
  50         E_TYPE_MAIL_CONFIG_ACTIVITY_PAGE,
  51         G_IMPLEMENT_INTERFACE (
  52                 E_TYPE_EXTENSIBLE, NULL)
  53         G_IMPLEMENT_INTERFACE (
  54                 E_TYPE_MAIL_CONFIG_PAGE,
  55                 e_mail_config_provider_page_interface_init))
  56
  57 static void
  58 mail_config_provider_page_handle_dependency (EMailConfigProviderPage *page,
  59                                              CamelProviderConfEntry *entry,
  60                                              GtkWidget *widget)
  61 {
  62         EMailConfigServiceBackend *backend;
  63         CamelSettings *settings;
  64         GBindingFlags binding_flags = G_BINDING_SYNC_CREATE;
  65         const gchar *depname = entry->depname;
  66         gint margin;
  67
  68         if (depname == NULL)
  69                 return;
  70
  71         if (*depname == '!') {
  72                 binding_flags |= G_BINDING_INVERT_BOOLEAN;
  73                 depname++;
  74         }
  75
  76         backend = e_mail_config_provider_page_get_backend (page);
  77         settings = e_mail_config_service_backend_get_settings (backend);
  78
  79         g_object_bind_property (
  80                 settings, depname,
  81                 widget, "sensitive",
  82                 binding_flags);
  83
  84         /* Further indent the widget to show its dependency. */
  85         margin = gtk_widget_get_margin_left (widget);
  86         gtk_widget_set_margin_left (widget, margin + DEPENDENCY_MARGIN);
  87 }
  88
  89 static void
  90 mail_config_provider_page_add_section (EMailConfigProviderPage *page,
  91                                        CamelProviderConfEntry *entry)
  92 {
  93         EMailConfigServiceBackend *backend;
  94         CamelProvider *provider;
  95         GtkWidget *widget;
  96         gchar *markup;
  97
  98         g_return_if_fail (entry->text != NULL);
  99
 100         backend = e_mail_config_provider_page_get_backend (page);
 101         provider = e_mail_config_service_backend_get_provider (backend);
 102
 103         markup = g_markup_printf_escaped ("<b>%s</b>", entry->text);
 104
 105         widget = gtk_label_new (markup);
 106         gtk_label_set_use_markup (GTK_LABEL (widget), TRUE);
 107         gtk_misc_set_alignment (GTK_MISC (widget), 0.0, 0.5);
 108         gtk_box_pack_start (GTK_BOX (page), widget, FALSE, FALSE, 0);
 109         gtk_widget_show (widget);
 110
 111         /* Skip the top margin if this is the first entry. */
 112         if (entry != provider->extra_conf)
 113                 gtk_widget_set_margin_top (widget, 6);
 114
 115         g_free (markup);
 116 }
 117
 118 static void
 119 mail_config_provider_page_add_checkbox (EMailConfigProviderPage *page,
 120                                         CamelProviderConfEntry *entry)
 121 {
 122         EMailConfigServiceBackend *backend;
 123         CamelSettings *settings;
 124         GtkWidget *widget;
 125
 126         g_return_if_fail (entry->text != NULL);
 127
 128         backend = e_mail_config_provider_page_get_backend (page);
 129         settings = e_mail_config_service_backend_get_settings (backend);
 130
 131         widget = gtk_check_button_new_with_mnemonic (entry->text);
 132         gtk_widget_set_margin_left (widget, STANDARD_MARGIN);
 133         gtk_box_pack_start (GTK_BOX (page), widget, FALSE, FALSE, 0);
 134         gtk_widget_show (widget);
 135
 136         g_object_bind_property (
 137                 settings, entry->name,
 138                 widget, "active",
 139                 G_BINDING_BIDIRECTIONAL |
 140                 G_BINDING_SYNC_CREATE);
 141
 142         mail_config_provider_page_handle_dependency (page, entry, widget);
 143 }
 144
 145 static void
 146 mail_config_provider_page_add_checkspin (EMailConfigProviderPage *page,
 147                                          CamelProviderConfEntry *entry)
 148 {
 149         EMailConfigServiceBackend *backend;
 150         CamelSettings *settings;
 151         GObjectClass *class;
 152         GParamSpec *pspec;
 153         GParamSpec *use_pspec;
 154         GtkAdjustment *adjustment;
 155         GtkWidget *hbox, *spin;
 156         GtkWidget *prefix;
 157         gchar *use_property_name;
 158         gchar *pre, *post;
 159
 160         g_return_if_fail (entry->text != NULL);
 161
 162         backend = e_mail_config_provider_page_get_backend (page);
 163         settings = e_mail_config_service_backend_get_settings (backend);
 164
 165         /* The entry->name property (e.g. "foo") should be numeric for the
 166          * spin button.  If a "use" boolean property exists (e.g. "use-foo")
 167          * then a checkbox is also shown. */
 168
 169         class = G_OBJECT_GET_CLASS (settings);
 170         pspec = g_object_class_find_property (class, entry->name);
 171         g_return_if_fail (pspec != NULL);
 172
 173         use_property_name = g_strconcat ("use-", entry->name, NULL);
 174         use_pspec = g_object_class_find_property (class, use_property_name);
 175         if (use_pspec != NULL && use_pspec->value_type != G_TYPE_BOOLEAN)
 176                 use_pspec = NULL;
 177         g_free (use_property_name);
 178
 179         /* Make sure we can convert to and from doubles. */
 180         g_return_if_fail (
 181                 g_value_type_transformable (
 182                 pspec->value_type, G_TYPE_DOUBLE));
 183         g_return_if_fail (
 184                 g_value_type_transformable (
 185                 G_TYPE_DOUBLE, pspec->value_type));
 186
 187         if (G_IS_PARAM_SPEC_CHAR (pspec)) {
 188                 GParamSpecChar *pspec_char;
 189                 pspec_char = G_PARAM_SPEC_CHAR (pspec);
 190                 adjustment = gtk_adjustment_new (
 191                         (gdouble) pspec_char->default_value,
 192                         (gdouble) pspec_char->minimum,
 193                         (gdouble) pspec_char->maximum,
 194                         1.0, 1.0, 0.0);
 195
 196         } else if (G_IS_PARAM_SPEC_UCHAR (pspec)) {
 197                 GParamSpecUChar *pspec_uchar;
 198                 pspec_uchar = G_PARAM_SPEC_UCHAR (pspec);
 199                 adjustment = gtk_adjustment_new (
 200                         (gdouble) pspec_uchar->default_value,
 201                         (gdouble) pspec_uchar->minimum,
 202                         (gdouble) pspec_uchar->maximum,
 203                         1.0, 1.0, 0.0);
 204
 205         } else if (G_IS_PARAM_SPEC_INT (pspec)) {
 206                 GParamSpecInt *pspec_int;
 207                 pspec_int = G_PARAM_SPEC_INT (pspec);
 208                 adjustment = gtk_adjustment_new (
 209                         (gdouble) pspec_int->default_value,
 210                         (gdouble) pspec_int->minimum,
 211                         (gdouble) pspec_int->maximum,
 212                         1.0, 1.0, 0.0);
 213
 214         } else if (G_IS_PARAM_SPEC_UINT (pspec)) {
 215                 GParamSpecUInt *pspec_uint;
 216                 pspec_uint = G_PARAM_SPEC_UINT (pspec);
 217                 adjustment = gtk_adjustment_new (
 218                         (gdouble) pspec_uint->default_value,
 219                         (gdouble) pspec_uint->minimum,
 220                         (gdouble) pspec_uint->maximum,
 221                         1.0, 1.0, 0.0);
 222
 223         } else if (G_IS_PARAM_SPEC_LONG (pspec)) {
 224                 GParamSpecLong *pspec_long;
 225                 pspec_long = G_PARAM_SPEC_LONG (pspec);
 226                 adjustment = gtk_adjustment_new (
 227                         (gdouble) pspec_long->default_value,
 228                         (gdouble) pspec_long->minimum,
 229                         (gdouble) pspec_long->maximum,
 230                         1.0, 1.0, 0.0);
 231
 232         } else if (G_IS_PARAM_SPEC_ULONG (pspec)) {
 233                 GParamSpecULong *pspec_ulong;
 234                 pspec_ulong = G_PARAM_SPEC_ULONG (pspec);
 235                 adjustment = gtk_adjustment_new (
 236                         (gdouble) pspec_ulong->default_value,
 237                         (gdouble) pspec_ulong->minimum,
 238                         (gdouble) pspec_ulong->maximum,
 239                         1.0, 1.0, 0.0);
 240
 241         } else if (G_IS_PARAM_SPEC_FLOAT (pspec)) {
 242                 GParamSpecFloat *pspec_float;
 243                 pspec_float = G_PARAM_SPEC_FLOAT (pspec);
 244                 adjustment = gtk_adjustment_new (
 245                         (gdouble) pspec_float->default_value,
 246                         (gdouble) pspec_float->minimum,
 247                         (gdouble) pspec_float->maximum,
 248                         1.0, 1.0, 0.0);
 249
 250         } else if (G_IS_PARAM_SPEC_DOUBLE (pspec)) {
 251                 GParamSpecDouble *pspec_double;
 252                 pspec_double = G_PARAM_SPEC_DOUBLE (pspec);
 253                 adjustment = gtk_adjustment_new (
 254                         (gdouble) pspec_double->default_value,
 255                         (gdouble) pspec_double->minimum,
 256                         (gdouble) pspec_double->maximum,
 257                         1.0, 1.0, 0.0);
 258
 259         } else
 260                 g_return_if_reached ();
 261
 262         pre = g_alloca (strlen (entry->text) + 1);
 263         strcpy (pre, entry->text);
 264         post = strstr (pre, "%s");
 265         if (post != NULL) {
 266                 *post = '\0';
 267                 post += 2;
 268         }
 269
 270         hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 3);
 271         gtk_widget_set_margin_left (hbox, STANDARD_MARGIN);
 272         gtk_box_pack_start (GTK_BOX (page), hbox, FALSE, FALSE, 0);
 273         gtk_widget_show (hbox);
 274
 275         if (use_pspec != NULL) {
 276                 prefix = gtk_check_button_new_with_mnemonic (pre);
 277
 278                 g_object_bind_property (
 279                         settings, use_pspec->name,
 280                         prefix, "active",
 281                         G_BINDING_BIDIRECTIONAL |
 282                         G_BINDING_SYNC_CREATE);
 283         } else {
 284                 prefix = gtk_label_new_with_mnemonic (pre);
 285         }
 286         gtk_box_pack_start (GTK_BOX (hbox), prefix, FALSE, TRUE, 0);
 287         gtk_widget_show (prefix);
 288
 289         spin = gtk_spin_button_new (adjustment, 1.0, 0);
 290         gtk_box_pack_start (GTK_BOX (hbox), spin, FALSE, TRUE, 0);
 291         gtk_widget_show (spin);
 292
 293         g_object_bind_property (
 294                 settings, entry->name,
 295                 spin, "value",
 296                 G_BINDING_BIDIRECTIONAL |
 297                 G_BINDING_SYNC_CREATE);
 298
 299         if (use_pspec != NULL)
 300                 g_object_bind_property (
 301                         prefix, "active",
 302                         spin, "sensitive",
 303                         G_BINDING_SYNC_CREATE);
 304
 305         if (post != NULL) {
 306                 GtkWidget *label = gtk_label_new_with_mnemonic (post);
 307                 gtk_label_set_mnemonic_widget (GTK_LABEL (label), prefix);
 308                 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
 309                 gtk_widget_show (label);
 310         }
 311
 312         mail_config_provider_page_handle_dependency (page, entry, hbox);
 313 }
 314
 315 static void
 316 mail_config_provider_page_add_entry (EMailConfigProviderPage *page,
 317                                      CamelProviderConfEntry *entry)
 318 {
 319         EMailConfigServiceBackend *backend;
 320         CamelSettings *settings;
 321         GtkWidget *hbox;
 322         GtkWidget *input;
 323         GtkWidget *label;
 324
 325         g_return_if_fail (entry->text != NULL);
 326
 327         backend = e_mail_config_provider_page_get_backend (page);
 328         settings = e_mail_config_service_backend_get_settings (backend);
 329
 330         hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
 331         gtk_box_set_spacing (GTK_BOX (hbox), 6);
 332         gtk_widget_set_margin_left (hbox, STANDARD_MARGIN);
 333         gtk_box_pack_start (GTK_BOX (page), hbox, FALSE, FALSE, 0);
 334         gtk_widget_show (hbox);
 335
 336         label = gtk_label_new_with_mnemonic (entry->text);
 337         gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
 338         gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
 339         gtk_widget_show (label);
 340
 341         input = gtk_entry_new ();
 342         gtk_label_set_mnemonic_widget (GTK_LABEL (label), input);
 343         gtk_box_pack_start (GTK_BOX (hbox), input, TRUE, TRUE, 0);
 344         gtk_widget_show (input);
 345
 346         e_binding_bind_object_text_property (
 347                 settings, entry->name,
 348                 input, "text",
 349                 G_BINDING_BIDIRECTIONAL |
 350                 G_BINDING_SYNC_CREATE);
 351
 352         g_object_bind_property (
 353                 input, "sensitive",
 354                 label, "sensitive",
 355                 G_BINDING_SYNC_CREATE);
 356
 357         mail_config_provider_page_handle_dependency (page, entry, hbox);
 358 }
 359
 360 static void
 361 mail_config_provider_page_add_options (EMailConfigProviderPage *page,
 362                                        CamelProviderConfEntry *entry)
 363 {
 364         EMailConfigServiceBackend *backend;
 365         CamelProvider *provider;
 366         CamelSettings *settings;
 367         GtkCellRenderer *renderer;
 368         GtkListStore *store;
 369         GtkWidget *hbox;
 370         GtkWidget *combo;
 371         GtkWidget *label;
 372         gchar **tokens;
 373         guint length, ii;
 374
 375         /* The 'value' string is of the format:
 376          *
 377          *   'nick0:caption0:nick1:caption1:...nickN:captionN'
 378          *
 379          * where 'nick' is the nickname a GEnumValue and 'caption'
 380          * is the localized combo box item displayed to the user. */
 381
 382         g_return_if_fail (entry->text != NULL);
 383         g_return_if_fail (entry->value != NULL);
 384
 385         backend = e_mail_config_provider_page_get_backend (page);
 386         provider = e_mail_config_service_backend_get_provider (backend);
 387         settings = e_mail_config_service_backend_get_settings (backend);
 388
 389         hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
 390         gtk_box_set_spacing (GTK_BOX (hbox), 6);
 391         gtk_widget_set_margin_left (hbox, STANDARD_MARGIN);
 392         gtk_box_pack_start (GTK_BOX (page), hbox, FALSE, FALSE, 0);
 393         gtk_widget_show (hbox);
 394
 395         label = gtk_label_new_with_mnemonic (entry->text);
 396         gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
 397         gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
 398         gtk_widget_show (label);
 399
 400         /* 0: 'nick', 1: caption */
 401         store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_STRING);
 402
 403         tokens = g_strsplit (entry->value, ":", -1);
 404         length = g_strv_length (tokens);
 405
 406         /* Take the strings two at a time. */
 407         for (ii = 0; ii + 1 < length; ii += 2) {
 408                 GtkTreeIter iter;
 409                 const gchar *nick;
 410                 const gchar *caption;
 411
 412                 nick = tokens[ii + 0];
 413                 caption = tokens[ii + 1];
 414
 415                 /* Localize the caption. */
 416                 caption = dgettext (provider->translation_domain, caption);
 417
 418                 gtk_list_store_append (store, &iter);
 419                 gtk_list_store_set (store, &iter, 0, nick, 1, caption, -1);
 420         }
 421
 422         g_strfreev (tokens);
 423
 424         combo = gtk_combo_box_new_with_model (GTK_TREE_MODEL (store));
 425         gtk_combo_box_set_id_column (GTK_COMBO_BOX (combo), 0);
 426         gtk_label_set_mnemonic_widget (GTK_LABEL (label), combo);
 427         gtk_box_pack_start (GTK_BOX (hbox), combo, FALSE, FALSE, 0);
 428         gtk_widget_show (combo);
 429
 430         g_object_bind_property_full (
 431                 settings, entry->name,
 432                 combo, "active-id",
 433                 G_BINDING_BIDIRECTIONAL |
 434                 G_BINDING_SYNC_CREATE,
 435                 e_binding_transform_enum_value_to_nick,
 436                 e_binding_transform_enum_nick_to_value,
 437                 NULL, (GDestroyNotify) NULL);
 438
 439         renderer = gtk_cell_renderer_text_new ();
 440         gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo), renderer, TRUE);
 441         gtk_cell_layout_set_attributes (
 442                 GTK_CELL_LAYOUT (combo), renderer, "text", 1, NULL);
 443
 444         mail_config_provider_page_handle_dependency (page, entry, hbox);
 445 }
 446
 447 static void
 448 mail_config_provider_page_add_widgets (EMailConfigProviderPage *page)
 449 {
 450         EMailConfigServiceBackend *backend;
 451         CamelProviderConfEntry *entries;
 452         CamelProvider *provider;
 453         GtkWidget *container;
 454         GtkWidget *widget;
 455         ESource *source;
 456         ESourceExtension *extension;
 457         gboolean first_section = TRUE;
 458         const gchar *extension_name;
 459         const gchar *text;
 460         gchar *markup;
 461         gint ii;
 462
 463         /* XXX We begin the page with our own section header and refresh
 464          *     interval setting, and then skip the CamelProvider's first
 465          *     CAMEL_PROVIDER_CONF_SECTION_START entry.
 466          *
 467          *     This is all very brittle.  I'm convinced that generating
 468          *     a user interface from an array of records like this is a
 469          *     bad idea.  We already have EMailConfigServiceBackend for
 470          *     building provider-specific "Receving Email" and "Sending
 471          *     EMail" pages by hand.  We should do similarly here. */
 472
 473         backend = e_mail_config_provider_page_get_backend (page);
 474         source = e_mail_config_service_backend_get_source (backend);
 475         provider = e_mail_config_service_backend_get_provider (backend);
 476         g_return_if_fail (provider != NULL);
 477
 478         /* XXX I guess refresh options go in the mail account source,
 479          *     even if the source is part of a collection.  I did not
 480          *     think about it too hard, so hopefully this is right. */
 481         extension_name = E_SOURCE_EXTENSION_REFRESH;
 482         extension = e_source_get_extension (source, extension_name);
 483
 484         text = _("Checking for New Mail");
 485         markup = g_markup_printf_escaped ("<b>%s</b>", text);
 486         widget = gtk_label_new (markup);
 487         gtk_label_set_use_markup (GTK_LABEL (widget), TRUE);
 488         gtk_misc_set_alignment (GTK_MISC (widget), 0.0, 0.5);
 489         gtk_box_pack_start (GTK_BOX (page), widget, FALSE, FALSE, 0);
 490         gtk_widget_show (widget);
 491         g_free (markup);
 492
 493         widget = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
 494         gtk_widget_set_margin_left (widget, STANDARD_MARGIN);
 495         gtk_box_pack_start (GTK_BOX (page), widget, FALSE, FALSE, 0);
 496         gtk_widget_show (widget);
 497
 498         container = widget;
 499
 500         text = _("Check for _new messages every");
 501         widget = gtk_check_button_new_with_mnemonic (text);
 502         gtk_box_pack_start (GTK_BOX (container), widget, FALSE, FALSE, 0);
 503         gtk_widget_show (widget);
 504
 505         g_object_bind_property (
 506                 extension, "enabled",
 507                 widget, "active",
 508                 G_BINDING_BIDIRECTIONAL |
 509                 G_BINDING_SYNC_CREATE);
 510
 511         widget = gtk_spin_button_new_with_range (1.0, 1440.0, 1.0);
 512         gtk_box_pack_start (GTK_BOX (container), widget, FALSE, FALSE, 0);
 513         gtk_widget_show (widget);
 514
 515         g_object_bind_property (
 516                 extension, "enabled",
 517                 widget, "sensitive",
 518                 G_BINDING_SYNC_CREATE);
 519
 520         g_object_bind_property (
 521                 extension, "interval-minutes",
 522                 widget, "value",
 523                 G_BINDING_BIDIRECTIONAL |
 524                 G_BINDING_SYNC_CREATE);
 525
 526         widget = gtk_label_new (_("minutes"));
 527         gtk_box_pack_start (GTK_BOX (container), widget, FALSE, FALSE, 0);
 528         gtk_widget_show (widget);
 529
 530         /* Note the "text" member of each CamelProviderConfEntry is
 531          * already localized, so we can use it directly in widgets. */
 532
 533         entries = provider->extra_conf;
 534
 535         /* Loop until we see CAMEL_PROVIDER_CONF_END. */
 536         for (ii = 0; entries[ii].type != CAMEL_PROVIDER_CONF_END; ii++) {
 537
 538                 /* Skip entries with no name. */
 539                 if (entries[ii].name == NULL)
 540                         continue;
 541
 542                 switch (entries[ii].type) {
 543                         case CAMEL_PROVIDER_CONF_SECTION_START:
 544                                 /* Skip the first section start. */
 545                                 if (first_section) {
 546                                         first_section = FALSE;
 547                                         continue;
 548                                 }
 549                                 mail_config_provider_page_add_section (
 550                                         page, &entries[ii]);
 551                                 break;
 552
 553                         case CAMEL_PROVIDER_CONF_CHECKBOX:
 554                                 mail_config_provider_page_add_checkbox (
 555                                         page, &entries[ii]);
 556                                 break;
 557
 558                         case CAMEL_PROVIDER_CONF_CHECKSPIN:
 559                                 mail_config_provider_page_add_checkspin (
 560                                         page, &entries[ii]);
 561                                 break;
 562
 563                         case CAMEL_PROVIDER_CONF_ENTRY:
 564                                 mail_config_provider_page_add_entry (
 565                                         page, &entries[ii]);
 566                                 break;
 567
 568                         case CAMEL_PROVIDER_CONF_OPTIONS:
 569                                 mail_config_provider_page_add_options (
 570                                         page, &entries[ii]);
 571                                 break;
 572
 573                         default:
 574                                 break;  /* skip it */
 575                 }
 576         }
 577 }
 578
 579 static void
 580 mail_config_provider_page_set_backend (EMailConfigProviderPage *page,
 581                                        EMailConfigServiceBackend *backend)
 582 {
 583         g_return_if_fail (E_IS_MAIL_CONFIG_SERVICE_BACKEND (backend));
 584         g_return_if_fail (page->priv->backend == NULL);
 585
 586         page->priv->backend = g_object_ref (backend);
 587 }
 588
 589 static void
 590 mail_config_provider_page_set_property (GObject *object,
 591                                         guint property_id,
 592                                         const GValue *value,
 593                                         GParamSpec *pspec)
 594 {
 595         switch (property_id) {
 596                 case PROP_BACKEND:
 597                         mail_config_provider_page_set_backend (
 598                                 E_MAIL_CONFIG_PROVIDER_PAGE (object),
 599                                 g_value_get_object (value));
 600                         return;
 601         }
 602
 603         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
 604 }
 605
 606 static void
 607 mail_config_provider_page_get_property (GObject *object,
 608                                         guint property_id,
 609                                         GValue *value,
 610                                         GParamSpec *pspec)
 611 {
 612         switch (property_id) {
 613                 case PROP_BACKEND:
 614                         g_value_set_object (
 615                                 value,
 616                                 e_mail_config_provider_page_get_backend (
 617                                 E_MAIL_CONFIG_PROVIDER_PAGE (object)));
 618                         return;
 619         }
 620
 621         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
 622 }
 623
 624 static void
 625 mail_config_provider_page_dispose (GObject *object)
 626 {
 627         EMailConfigProviderPagePrivate *priv;
 628
 629         priv = E_MAIL_CONFIG_PROVIDER_PAGE_GET_PRIVATE (object);
 630
 631         if (priv->backend != NULL) {
 632                 g_object_unref (priv->backend);
 633                 priv->backend = NULL;
 634         }
 635
 636         /* Chain up parent's dispose() method. */
 637         G_OBJECT_CLASS (e_mail_config_provider_page_parent_class)->
 638                 dispose (object);
 639 }
 640
 641 static void
 642 mail_config_provider_page_constructed (GObject *object)
 643 {
 644         EMailConfigProviderPage *page;
 645         EMailConfigServiceBackend *backend;
 646         CamelProvider *provider;
 647
 648         page = E_MAIL_CONFIG_PROVIDER_PAGE (object);
 649
 650         /* Chain up parent's constructed() method. */
 651         G_OBJECT_CLASS (e_mail_config_provider_page_parent_class)->constructed (object);
 652
 653         gtk_box_set_spacing (GTK_BOX (object), 6);
 654
 655         gtk_orientable_set_orientation (
 656                 GTK_ORIENTABLE (object), GTK_ORIENTATION_VERTICAL);
 657
 658         backend = e_mail_config_provider_page_get_backend (page);
 659         provider = e_mail_config_service_backend_get_provider (backend);
 660
 661         if (provider != NULL && provider->extra_conf != NULL)
 662                 mail_config_provider_page_add_widgets (page);
 663         else
 664                 page->priv->is_empty = TRUE;
 665
 666         e_extensible_load_extensions (E_EXTENSIBLE (page));
 667 }
 668
 669 static void
 670 e_mail_config_provider_page_class_init (EMailConfigProviderPageClass *class)
 671 {
 672         GObjectClass *object_class;
 673
 674         g_type_class_add_private (class, sizeof (EMailConfigProviderPagePrivate));
 675
 676         object_class = G_OBJECT_CLASS (class);
 677         object_class->set_property = mail_config_provider_page_set_property;
 678         object_class->get_property = mail_config_provider_page_get_property;
 679         object_class->dispose = mail_config_provider_page_dispose;
 680         object_class->constructed = mail_config_provider_page_constructed;
 681
 682         g_object_class_install_property (
 683                 object_class,
 684                 PROP_BACKEND,
 685                 g_param_spec_object (
 686                         "backend",
 687                         "Backend",
 688                         "Service backend to generate options from",
 689                         E_TYPE_MAIL_CONFIG_SERVICE_BACKEND,
 690                         G_PARAM_READWRITE |
 691                         G_PARAM_CONSTRUCT_ONLY |
 692                         G_PARAM_STATIC_STRINGS));
 693 }
 694
 695 static void
 696 e_mail_config_provider_page_interface_init (EMailConfigPageInterface *iface)
 697 {
 698         iface->title = _("Receiving Options");
 699         iface->sort_order = E_MAIL_CONFIG_PROVIDER_PAGE_SORT_ORDER;
 700 }
 701
 702 static void
 703 e_mail_config_provider_page_init (EMailConfigProviderPage *page)
 704 {
 705         page->priv = E_MAIL_CONFIG_PROVIDER_PAGE_GET_PRIVATE (page);
 706 }
 707
 708 EMailConfigPage *
 709 e_mail_config_provider_page_new (EMailConfigServiceBackend *backend)
 710 {
 711         g_return_val_if_fail (E_IS_MAIL_CONFIG_SERVICE_BACKEND (backend), NULL);
 712
 713         return g_object_new (
 714                 E_TYPE_MAIL_CONFIG_PROVIDER_PAGE,
 715                 "backend", backend, NULL);
 716 }
 717
 718 gboolean
 719 e_mail_config_provider_page_is_empty (EMailConfigProviderPage *page)
 720 {
 721         g_return_val_if_fail (E_IS_MAIL_CONFIG_PROVIDER_PAGE (page), TRUE);
 722
 723         return page->priv->is_empty;
 724 }
 725
 726 EMailConfigServiceBackend *
 727 e_mail_config_provider_page_get_backend (EMailConfigProviderPage *page)
 728 {
 729         g_return_val_if_fail (E_IS_MAIL_CONFIG_PROVIDER_PAGE (page), NULL);
 730
 731         return page->priv->backend;
 732 }
 733