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