git.maemo.org Git - modest/blob - src/widgets/modest-toolkit-factory.c

   1 /* Copyright (c) 2009, Igalia
   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 #include <glib/gi18n.h>
  31 #ifdef MODEST_TOOLKIT_HILDON2
  32 #include <hildon/hildon.h>
  33 #include <hildon/hildon-file-chooser-dialog.h>
  34 #include <modest-number-editor.h>
  35 #include <modest-ui-constants.h>
  36 #endif
  37 #include "modest-toolkit-factory.h"
  38
  39 #ifndef MODEST_TOOLKIT_HILDON2
  40 #define USE_SCROLLED_WINDOW
  41 #define USE_GTK_FIND_TOOLBAR
  42 #define USE_GTK_CHECK_BUTTON
  43 #define USE_GTK_CHECK_MENU
  44 #define USE_GTK_ENTRY
  45 #define USE_GTK_FILE_CHOOSER
  46 #define USE_COUNTRY_COMBOBOX
  47 #define USE_SERVERSECURITY_PICKER
  48 #endif
  49
  50 #ifdef USE_SCROLLED_WINDOW
  51 #include <modest-scrolled-window-scrollable.h>
  52 #else
  53 #include <modest-hildon-pannable-area-scrollable.h>
  54 #endif
  55
  56 #ifdef USE_GTK_TOOLBAR
  57 #include <modest-find-toolbar.h>
  58 #else
  59 #include <modest-hildon-find-toolbar.h>
  60 #endif
  61
  62 #ifdef USE_COUNTRY_COMBOBOX
  63 #include <modest-country-combo-box.h>
  64 #else
  65 #include <modest-country-picker.h>
  66 #endif
  67
  68 #ifdef USE_PROVIDER_COMBOBOX
  69 #include <modest-provider-combo-box.h>
  70 #else
  71 #include <modest-provider-picker.h>
  72 #endif
  73
  74 #ifdef USE_SERVERTYPE_COMBOBOX
  75 #include <modest-servertype-combo-box.h>
  76 #else
  77 #include <modest-servertype-picker.h>
  78 #endif
  79
  80 #ifdef USE_SERVERSECURITY_COMBOBOX
  81 #include <modest-serversecurity-combo-box.h>
  82 #else
  83 #include <modest-serversecurity-picker.h>
  84 #endif
  85
  86 static void modest_toolkit_factory_class_init (ModestToolkitFactoryClass *klass);
  87 static void modest_toolkit_factory_init (ModestToolkitFactory *self);
  88
  89 /* GObject interface */
  90 static GtkWidget * modest_toolkit_factory_create_scrollable_default           (ModestToolkitFactory *self);
  91 static GtkWidget * modest_toolkit_factory_create_check_button_default         (ModestToolkitFactory *self,
  92                                                                                const gchar *label);
  93 static GtkWidget * modest_toolkit_factory_create_check_menu_default           (ModestToolkitFactory *self,
  94                                                                                const gchar *label);
  95 static GtkWidget * modest_toolkit_factory_create_isearch_toolbar_default      (ModestToolkitFactory *self,
  96                                                                                const gchar *label);
  97 static GtkWidget * modest_toolkit_factory_create_entry_default                (ModestToolkitFactory *self);
  98 static GtkWidget * modest_toolkit_factory_create_number_entry_default         (ModestToolkitFactory *self,
  99                                                                                gint min,
 100                                                                                gint max);
 101 static GtkWidget * modest_toolkit_factory_create_file_chooser_dialog_default  (ModestToolkitFactory *self,
 102                                                                                const gchar *title,
 103                                                                                GtkWindow *parent,
 104                                                                                GtkFileChooserAction action);
 105 static GtkWidget * modest_toolkit_factory_create_country_selector_default     (ModestToolkitFactory *self);
 106 static GtkWidget * modest_toolkit_factory_create_provider_selector_default    (ModestToolkitFactory *self);
 107 static GtkWidget * modest_toolkit_factory_create_servertype_selector_default  (ModestToolkitFactory *self,
 108                                                                                gboolean filter_providers);
 109 static GtkWidget * modest_toolkit_factory_create_serversecurity_selector_default (ModestToolkitFactory *self);
 110 /* globals */
 111 static GObjectClass *parent_class = NULL;
 112
 113 G_DEFINE_TYPE    (ModestToolkitFactory,
 114                   modest_toolkit_factory,
 115                   G_TYPE_OBJECT);
 116
 117 ModestToolkitFactory *
 118 modest_toolkit_factory_get_instance                            (void)
 119 {
 120     GObject* self = g_object_new (MODEST_TYPE_TOOLKIT_FACTORY, NULL);
 121
 122     return (ModestToolkitFactory *) self;
 123 }
 124
 125 static void
 126 modest_toolkit_factory_class_init (ModestToolkitFactoryClass *klass)
 127 {
 128         parent_class = g_type_class_peek_parent (klass);
 129
 130         klass->create_scrollable = modest_toolkit_factory_create_scrollable_default;
 131         klass->create_check_button = modest_toolkit_factory_create_check_button_default;
 132         klass->create_check_menu = modest_toolkit_factory_create_check_menu_default;
 133         klass->create_isearch_toolbar = modest_toolkit_factory_create_isearch_toolbar_default;
 134         klass->create_entry = modest_toolkit_factory_create_entry_default;
 135         klass->create_number_entry = modest_toolkit_factory_create_number_entry_default;
 136         klass->create_file_chooser_dialog = modest_toolkit_factory_create_file_chooser_dialog_default;
 137         klass->create_country_selector = modest_toolkit_factory_create_country_selector_default;
 138         klass->create_provider_selector = modest_toolkit_factory_create_provider_selector_default;
 139         klass->create_servertype_selector = modest_toolkit_factory_create_servertype_selector_default;
 140         klass->create_serversecurity_selector = modest_toolkit_factory_create_serversecurity_selector_default;
 141 }
 142
 143 static void
 144 modest_toolkit_factory_init (ModestToolkitFactory *self)
 145 {
 146 }
 147
 148 GtkWidget *
 149 modest_toolkit_factory_create_scrollable (ModestToolkitFactory *self)
 150 {
 151         return MODEST_TOOLKIT_FACTORY_GET_CLASS (self)->create_scrollable (self);
 152 }
 153
 154 static GtkWidget *
 155 modest_toolkit_factory_create_scrollable_default (ModestToolkitFactory *self)
 156 {
 157 #ifdef USE_SCROLLED_WINDOW
 158         return modest_scrolled_window_scrollable_new ();
 159 #else
 160         return modest_hildon_pannable_area_scrollable_new ();
 161 #endif
 162 }
 163
 164 GtkWidget *
 165 modest_toolkit_factory_create_check_button (ModestToolkitFactory *self, const gchar *label)
 166 {
 167         return MODEST_TOOLKIT_FACTORY_GET_CLASS (self)->create_check_button (self, label);
 168 }
 169
 170 static GtkWidget *
 171 modest_toolkit_factory_create_check_button_default (ModestToolkitFactory *self, const gchar *label)
 172 {
 173         GtkWidget *result;
 174 #ifdef USE_GTK_CHECK_BUTTON
 175         result = gtk_check_button_new_with_label (label);
 176 #else
 177         result = hildon_check_button_new (HILDON_SIZE_FINGER_HEIGHT);
 178         gtk_button_set_label (GTK_BUTTON (result), label);
 179         gtk_button_set_alignment (GTK_BUTTON (result), 0.0, 0.5);
 180 #endif
 181         return result;
 182 }
 183
 184 GtkWidget *
 185 modest_toolkit_factory_create_check_menu (ModestToolkitFactory *self, const gchar *label)
 186 {
 187         return MODEST_TOOLKIT_FACTORY_GET_CLASS (self)->create_check_menu (self, label);
 188 }
 189
 190 static GtkWidget *
 191 modest_toolkit_factory_create_check_menu_default (ModestToolkitFactory *self, const gchar *label)
 192 {
 193         GtkWidget *result;
 194 #ifdef USE_GTK_CHECK_MENU
 195         result = gtk_check_menu_item_new_with_label (label);
 196 #else
 197         result = hildon_check_button_new (0);
 198         gtk_button_set_label (GTK_BUTTON (result), label);
 199         gtk_button_set_alignment (GTK_BUTTON (result), 0.5, 0.5);
 200 #endif
 201         return result;
 202 }
 203
 204 gboolean
 205 modest_togglable_get_active (GtkWidget *widget)
 206 {
 207         if (GTK_IS_CHECK_MENU_ITEM (widget)) {
 208                 return gtk_check_menu_item_get_active (GTK_CHECK_MENU_ITEM (widget));
 209         } else if (GTK_IS_TOGGLE_BUTTON (widget)) {
 210                 return gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget));
 211 #ifdef MODEST_TOOLKIT_HILDON2
 212         } else if (HILDON_IS_CHECK_BUTTON (widget)) {
 213                 return hildon_check_button_get_active (HILDON_CHECK_BUTTON (widget));
 214 #endif
 215         } else {
 216                 g_return_val_if_reached (FALSE);
 217         }
 218 }
 219
 220 void
 221 modest_togglable_set_active (GtkWidget *widget, gboolean active)
 222 {
 223         if (GTK_IS_CHECK_MENU_ITEM (widget)) {
 224                 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (widget), active);
 225         } else if (GTK_IS_TOGGLE_BUTTON (widget)) {
 226                 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), active);
 227 #ifdef MODEST_TOOLKIT_HILDON2
 228         } else if (HILDON_IS_CHECK_BUTTON (widget)) {
 229                 hildon_check_button_set_active (HILDON_CHECK_BUTTON (widget), active);
 230 #endif
 231         }
 232 }
 233
 234 gboolean
 235 modest_is_togglable (GtkWidget *widget)
 236 {
 237         return GTK_IS_CHECK_MENU_ITEM (widget)
 238                 || GTK_IS_TOGGLE_BUTTON (widget)
 239 #ifdef MODEST_TOOLKIT_HILDON2
 240                 || HILDON_IS_CHECK_BUTTON (widget)
 241 #endif
 242                 ;
 243 }
 244
 245 GtkWidget *
 246 modest_toolkit_factory_create_isearch_toolbar (ModestToolkitFactory *self, const gchar *label)
 247 {
 248         return MODEST_TOOLKIT_FACTORY_GET_CLASS (self)->create_isearch_toolbar (self, label);
 249 }
 250
 251 static GtkWidget *
 252 modest_toolkit_factory_create_isearch_toolbar_default (ModestToolkitFactory *self, const gchar *label)
 253 {
 254         GtkWidget *result;
 255 #ifdef USE_GTK_FIND_TOOLBAR
 256         result = modest_find_toolbar_new (label);
 257 #else
 258         result = modest_hildon_find_toolbar_new (label);
 259 #endif
 260         return result;
 261 }
 262
 263 GtkWidget *
 264 modest_toolkit_factory_create_entry (ModestToolkitFactory *self)
 265 {
 266         return MODEST_TOOLKIT_FACTORY_GET_CLASS (self)->create_entry (self);
 267 }
 268
 269 static GtkWidget *
 270 modest_toolkit_factory_create_entry_default (ModestToolkitFactory *self)
 271 {
 272 #ifdef USE_GTK_ENTRY
 273         return gtk_entry_new ();
 274 #else
 275         return hildon_entry_new (HILDON_SIZE_FINGER_HEIGHT | HILDON_SIZE_AUTO_WIDTH);
 276 #endif
 277 }
 278
 279 void
 280 modest_entry_set_text (GtkWidget *widget, const gchar *text)
 281 {
 282 #ifdef MODEST_TOOLKIT_HILDON2
 283         hildon_entry_set_text (HILDON_ENTRY (widget), text);
 284 #else
 285         gtk_entry_set_text (GTK_ENTRY (widget), text);
 286 #endif
 287 }
 288
 289 const gchar *
 290 modest_entry_get_text (GtkWidget *widget)
 291 {
 292 #ifdef MODEST_TOOLKIT_HILDON2
 293         return hildon_entry_get_text (HILDON_ENTRY (widget));
 294 #else
 295         return gtk_entry_set_text (GTK_ENTRY (widget));
 296 #endif
 297 }
 298
 299 void
 300 modest_entry_set_hint (GtkWidget *widget, const gchar *hint)
 301 {
 302 #ifdef MODEST_TOOLKIT_HILDON2
 303         hildon_entry_set_placeholder (HILDON_ENTRY (widget), hint);
 304 #else
 305         gtk_widget_set_tooltip_text (widget, hint);
 306 #endif
 307 }
 308
 309 gboolean
 310 modest_is_entry (GtkWidget *widget)
 311 {
 312 #ifdef MODEST_TOOLKIT_HILDON2
 313         return HILDON_IS_ENTRY (widget);
 314 #else
 315         return GTK_IS_ENTRY (widget);
 316 #endif
 317 }
 318
 319 GtkWidget *
 320 modest_toolkit_factory_create_number_entry (ModestToolkitFactory *self, gint min, gint max)
 321 {
 322         return MODEST_TOOLKIT_FACTORY_GET_CLASS (self)->create_number_entry (self, min, max);
 323 }
 324
 325 static GtkWidget *
 326 modest_toolkit_factory_create_number_entry_default (ModestToolkitFactory *self, gint min, gint max)
 327 {
 328         GtkWidget *result;
 329 #ifdef USE_GTK_SPIN_BUTTON
 330         result = gtk_spin_button_new_with_range (min, max, 1.0);
 331         gtk_spin_button_set_digits (GTK_SPIN_BUTTON (result), 0);
 332 #else
 333         result = modest_number_editor_new (min, max);
 334 #endif
 335         return result;
 336 }
 337
 338 void
 339 modest_number_entry_set_value (GtkWidget *widget, gint value)
 340 {
 341 #ifdef USE_GTK_SPIN_BUTTON
 342         gtk_spin_button_set_value (GTK_SPIN_BUTTON (widget), value);
 343 #else
 344         modest_number_editor_set_value (MODEST_NUMBER_EDITOR (widget), value);
 345 #endif
 346 }
 347
 348 gint
 349 modest_number_entry_get_value (GtkWidget *widget)
 350 {
 351 #ifdef USE_GTK_SPIN_BUTTON
 352         return gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (widget));
 353 #else
 354         return modest_number_editor_get_value (MODEST_NUMBER_EDITOR (widget));
 355 #endif
 356 }
 357
 358 gboolean
 359 modest_number_entry_is_valid (GtkWidget *widget)
 360 {
 361 #ifdef USE_GTK_SPIN_BUTTON
 362         return TRUE;
 363 #else
 364         return modest_number_editor_is_valid (MODEST_NUMBER_EDITOR (widget));
 365 #endif
 366 }
 367
 368 gboolean
 369 modest_is_number_entry (GtkWidget *widget)
 370 {
 371 #ifdef USE_GTK_SPIN_BUTTON
 372         return GTK_IS_SPIN_BUTTON (widget);
 373 #else
 374         return MODEST_IS_NUMBER_EDITOR (widget);
 375 #endif
 376 }
 377
 378 GtkWidget *
 379 modest_toolkit_factory_create_file_chooser_dialog (ModestToolkitFactory *self,
 380                                                    const gchar *title,
 381                                                    GtkWindow *parent,
 382                                                    GtkFileChooserAction action)
 383 {
 384         return MODEST_TOOLKIT_FACTORY_GET_CLASS (self)->create_file_chooser_dialog (self, title, parent, action);
 385 }
 386
 387 static GtkWidget *
 388 modest_toolkit_factory_create_file_chooser_dialog_default (ModestToolkitFactory *self,
 389                                                            const gchar *title,
 390                                                            GtkWindow *parent,
 391                                                            GtkFileChooserAction action)
 392 {
 393         GtkWidget *result;
 394 #ifdef USE_GTK_FILE_CHOOSER
 395         result = gtk_file_chooser_dialog_new (title, parent, action,
 396                                               (action == GTK_FILE_CHOOSER_ACTION_OPEN) ? GTK_STOCK_OPEN : GTK_STOCK_SAVE,
 397                                               GTK_RESPONSE_OK,
 398                                               GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
 399                                               NULL);
 400 #else
 401         result = hildon_file_chooser_dialog_new (parent, action);
 402         gtk_window_set_title ((GtkWindow *) result, title);
 403 #endif
 404         return result;
 405 }
 406
 407 GtkWidget *
 408 modest_toolkit_factory_create_country_selector (ModestToolkitFactory *self)
 409 {
 410         return MODEST_TOOLKIT_FACTORY_GET_CLASS (self)->create_country_selector (self);
 411 }
 412
 413 static GtkWidget *
 414 modest_toolkit_factory_create_country_selector_default (ModestToolkitFactory *self)
 415 {
 416         GtkWidget *result;
 417 #ifdef USE_COUNTRY_COMBOBOX
 418         result = modest_country_combo_box_new ();
 419 #else
 420         result = GTK_WIDGET (modest_country_picker_new (MODEST_EDITABLE_SIZE,
 421                                                         HILDON_BUTTON_ARRANGEMENT_HORIZONTAL));
 422 #endif
 423         return result;
 424 }
 425
 426 gint
 427 modest_country_selector_get_active_country_mcc (GtkWidget *widget)
 428 {
 429 #ifdef USE_COUNTRY_COMBOBOX
 430         return modest_country_combo_box_get_active_country_mcc (MODEST_COUNTRY_COMBO_BOX (widget));
 431 #else
 432         return modest_country_picker_get_active_country_mcc (MODEST_COUNTRY_PICKER (widget));
 433 #endif
 434 }
 435
 436 void
 437 modest_country_selector_load_data (GtkWidget *widget)
 438 {
 439 #ifdef USE_COUNTRY_COMBOBOX
 440         modest_country_combo_box_load_data (MODEST_COUNTRY_COMBO_BOX (widget));
 441 #else
 442         modest_country_picker_load_data (MODEST_COUNTRY_PICKER (widget));
 443 #endif
 444 }
 445
 446 gboolean
 447 modest_country_selector_set_active_country_locale (GtkWidget *widget)
 448 {
 449 #ifdef USE_COUNTRY_COMBOBOX
 450         return modest_country_combo_box_set_active_country_locale (MODEST_COUNTRY_COMBO_BOX (widget));
 451 #else
 452         return modest_country_picker_set_active_country_locale (MODEST_COUNTRY_PICKER (widget));
 453 #endif
 454 }
 455
 456 GtkWidget *
 457 modest_toolkit_factory_create_provider_selector (ModestToolkitFactory *self)
 458 {
 459         return MODEST_TOOLKIT_FACTORY_GET_CLASS (self)->create_provider_selector (self);
 460 }
 461
 462 static GtkWidget *
 463 modest_toolkit_factory_create_provider_selector_default (ModestToolkitFactory *self)
 464 {
 465         GtkWidget *result;
 466 #ifdef USE_PROVIDER_COMBOBOX
 467         result = modest_provider_combo_box_new ();
 468 #else
 469         result = GTK_WIDGET (modest_provider_picker_new (MODEST_EDITABLE_SIZE,
 470                                                          HILDON_BUTTON_ARRANGEMENT_HORIZONTAL));
 471 #endif
 472         return result;
 473 }
 474
 475 void
 476 modest_provider_selector_fill (GtkWidget *widget,
 477                                ModestPresets *presets,
 478                                gint mcc)
 479 {
 480 #ifdef USE_PROVIDER_COMBOBOX
 481         modest_provider_combo_box_fill (MODEST_PROVIDER_COMBO_BOX (widget),
 482                                         presets,
 483                                         mcc);
 484 #else
 485         modest_provider_picker_fill (MODEST_PROVIDER_PICKER (widget),
 486                                      presets,
 487                                      mcc);
 488 #endif
 489 }
 490
 491 gchar *
 492 modest_provider_selector_get_active_provider_id (GtkWidget *widget)
 493 {
 494 #ifdef USE_PROVIDER_COMBOBOX
 495         return modest_provider_combo_box_get_active_provider_id (MODEST_PROVIDER_COMBO_BOX (widget));
 496 #else
 497         return modest_provider_picker_get_active_provider_id (MODEST_PROVIDER_PICKER (widget));
 498 #endif
 499 }
 500
 501 gchar *
 502 modest_provider_selector_get_active_provider_label (GtkWidget *widget)
 503 {
 504 #ifdef USE_PROVIDER_COMBOBOX
 505
 506         return modest_provider_combo_box_get_active_provider_label (MODEST_PROVIDER_COMBO_BOX (widget));
 507 #else
 508         GtkWidget *selector;
 509
 510         selector = GTK_WIDGET (hildon_picker_button_get_selector (HILDON_PICKER_BUTTON (widget)));
 511         return g_strdup (hildon_touch_selector_get_current_text (HILDON_TOUCH_SELECTOR (selector)));
 512 #endif
 513 }
 514
 515 ModestProviderSelectorIdType
 516 modest_provider_selector_get_active_id_type (GtkWidget *widget)
 517 {
 518         ModestProviderSelectorIdType result;
 519 #ifdef USE_PROVIDER_COMBOBOX
 520         ModestProviderComboBoxIdType id_type;
 521
 522         id_type = modest_provider_combo_box_get_active_id_type (MODEST_PROVIDER_COMBO_BOX (widget));
 523         switch (id_type) {
 524         case MODEST_PROVIDER_COMBO_BOX_ID_PROVIDER:
 525                 result = MODEST_PROVIDER_SELECTOR_ID_PROVIDER;
 526                 break;
 527         case MODEST_PROVIDER_COMBO_BOX_ID_OTHER:
 528                 result = MODEST_PROVIDER_SELECTOR_ID_OTHER;
 529                 break;
 530         case MODEST_PROVIDER_COMBO_BOX_ID_PLUGIN_PROTOCOL:
 531                 result = MODEST_PROVIDER_SELECTOR_ID_PLUGIN_PROTOCOL;
 532                 break;
 533         default:
 534                 result = MODEST_PROVIDER_SELECTOR_ID_OTHER;
 535         }
 536         return result;
 537 #else
 538         ModestProviderPickerIdType id_type;
 539
 540         id_type = modest_provider_picker_get_active_id_type (MODEST_PROVIDER_PICKER (widget));
 541         switch (id_type) {
 542         case MODEST_PROVIDER_PICKER_ID_PROVIDER:
 543                 result = MODEST_PROVIDER_SELECTOR_ID_PROVIDER;
 544                 break;
 545         case MODEST_PROVIDER_PICKER_ID_OTHER:
 546                 result = MODEST_PROVIDER_SELECTOR_ID_OTHER;
 547                 break;
 548         case MODEST_PROVIDER_PICKER_ID_PLUGIN_PROTOCOL:
 549                 result = MODEST_PROVIDER_SELECTOR_ID_PLUGIN_PROTOCOL;
 550                 break;
 551         default:
 552                 result = MODEST_PROVIDER_SELECTOR_ID_OTHER;
 553         }
 554 #endif
 555         return result;
 556 }
 557
 558 void
 559 modest_provider_selector_set_others_provider (GtkWidget *self)
 560 {
 561 #ifdef USE_PROVIDER_COMBOBOX
 562         modest_provider_combo_box_set_others_provider (MODEST_PROVIDER_COMBO_BOX (self));
 563 #else
 564         modest_provider_picker_set_others_provider (MODEST_PROVIDER_PICKER (self));
 565 #endif
 566 }
 567
 568 GtkWidget *
 569 modest_toolkit_factory_create_servertype_selector (ModestToolkitFactory *self, gboolean filter_providers)
 570 {
 571         return MODEST_TOOLKIT_FACTORY_GET_CLASS (self)->create_servertype_selector (self, filter_providers);
 572 }
 573
 574 static GtkWidget *
 575 modest_toolkit_factory_create_servertype_selector_default (ModestToolkitFactory *self, gboolean filter_providers)
 576 {
 577         GtkWidget *result;
 578 #ifdef USE_PROVIDER_COMBOBOX
 579         result = GTK_WIDGET (modest_servertype_combo_box_new (filter_providers));
 580 #else
 581         result = GTK_WIDGET (modest_servertype_picker_new (MODEST_EDITABLE_SIZE,
 582                                                          HILDON_BUTTON_ARRANGEMENT_HORIZONTAL,
 583                                                          filter_providers));
 584 #endif
 585         return result;
 586 }
 587
 588 ModestProtocolType
 589 modest_servertype_selector_get_active_servertype (GtkWidget *self)
 590 {
 591 #ifdef USE_SERVERTYPE_COMBOBOX
 592         return modest_servertype_combo_box_get_active_servertype (MODEST_SERVERTYPE_COMBO_BOX (self));
 593 #else
 594         return modest_servertype_picker_get_active_servertype (MODEST_SERVERTYPE_PICKER (self));
 595 #endif
 596 }
 597
 598 void
 599 modest_servertype_selector_set_active_servertype (GtkWidget *self,
 600                                                   ModestProtocolType protocol_type_id)
 601 {
 602 #ifdef USE_SERVERTYPE_COMBOBOX
 603         modest_servertype_combo_box_set_active_servertype (MODEST_SERVERTYPE_COMBO_BOX (self), protocol_type_id);
 604 #else
 605         modest_servertype_picker_set_active_servertype (MODEST_SERVERTYPE_PICKER (self), protocol_type_id);
 606 #endif
 607 }
 608
 609 GtkWidget *
 610 modest_toolkit_factory_create_serversecurity_selector (ModestToolkitFactory *self)
 611 {
 612         return MODEST_TOOLKIT_FACTORY_GET_CLASS (self)->create_serversecurity_selector (self);
 613 }
 614
 615 static GtkWidget *
 616 modest_toolkit_factory_create_serversecurity_selector_default (ModestToolkitFactory *self)
 617 {
 618         GtkWidget *result;
 619 #ifdef USE_PROVIDER_COMBOBOX
 620         result = GTK_WIDGET (modest_serversecurity_combo_box_new ());
 621 #else
 622         result = GTK_WIDGET (modest_serversecurity_picker_new (MODEST_EDITABLE_SIZE,
 623                                                                HILDON_BUTTON_ARRANGEMENT_HORIZONTAL));
 624 #endif
 625         return result;
 626 }
 627
 628 void
 629 modest_serversecurity_selector_fill (GtkWidget *combobox,
 630                                      ModestProtocolType protocol)
 631 {
 632 #ifdef USE_SERVERSECURITY_COMBOBOX
 633         modest_serversecurity_combo_box_fill (MODEST_SERVERSECURITY_COMBO_BOX (combobox),
 634                                               protocol);
 635 #else
 636         modest_serversecurity_picker_fill (MODEST_SERVERSECURITY_PICKER (combobox),
 637                                            protocol);
 638 #endif
 639 }
 640
 641 ModestProtocolType
 642 modest_serversecurity_selector_get_active_serversecurity (GtkWidget *combobox)
 643 {
 644 #ifdef USE_SERVERSECURITY_COMBOBOX
 645         return modest_serversecurity_combo_box_get_active_serversecurity (MODEST_SERVERSECURITY_COMBO_BOX (combobox));
 646 #else
 647         return modest_serversecurity_picker_get_active_serversecurity (MODEST_SERVERSECURITY_PICKER (combobox));
 648 #endif
 649 }
 650
 651 gboolean
 652 modest_serversecurity_selector_set_active_serversecurity (GtkWidget *combobox,
 653                                                           ModestProtocolType serversecurity)
 654 {
 655 #ifdef USE_SERVERSECURITY_COMBOBOX
 656         return modest_serversecurity_combo_box_set_active_serversecurity (MODEST_SERVERSECURITY_COMBO_BOX (combobox),
 657                                                                           serversecurity);
 658 #else
 659         return modest_serversecurity_picker_set_active_serversecurity (MODEST_SERVERSECURITY_PICKER (combobox),
 660                                                                        serversecurity);
 661 #endif
 662 }
 663
 664 gint
 665 modest_serversecurity_selector_get_active_serversecurity_port (GtkWidget *combobox)
 666 {
 667 #ifdef USE_SERVERSECURITY_COMBOBOX
 668         return modest_serversecurity_combo_box_get_active_serversecurity_port (MODEST_SERVERSECURITY_COMBO_BOX (combobox));
 669 #else
 670         return modest_serversecurity_picker_get_active_serversecurity_port (MODEST_SERVERSECURITY_PICKER (combobox));
 671 #endif
 672 }