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