git.maemo.org Git - modest/blob - src/hildon2/modest-country-picker.c

   1 /* Copyright (c) 2008, Nokia Corporation
   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 #ifndef _GNU_SOURCE
  31 #define _GNU_SOURCE /* So we can use the getline() function, which is a convenient GNU extension. */
  32 #endif
  33
  34 #include <stdio.h>
  35
  36 #include "modest-maemo-utils.h"
  37 #include "modest-country-picker.h"
  38 #include <hildon/hildon-touch-selector-entry.h>
  39 #include <gtk/gtkliststore.h>
  40 #include <gtk/gtkcelllayout.h>
  41 #include <gtk/gtkcellrenderertext.h>
  42
  43 #include <stdlib.h>
  44 #include <string.h> /* For memcpy() */
  45 #include <langinfo.h>
  46 #include <locale.h>
  47 #include <libintl.h> /* For dgettext(). */
  48
  49 /* Include config.h so that _() works: */
  50 #ifdef HAVE_CONFIG_H
  51 #include <config.h>
  52 #endif
  53
  54 #define MAX_LINE_LEN 128 /* max length of a line in MCC file */
  55
  56 G_DEFINE_TYPE (ModestCountryPicker, modest_country_picker, HILDON_TYPE_PICKER_BUTTON);
  57
  58 typedef struct
  59 {
  60         gint locale_mcc;
  61 /*      GtkTreeModel *model; */
  62 } ModestCountryPickerPrivate;
  63
  64 #define MODEST_COUNTRY_PICKER_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), \
  65                                                                            MODEST_TYPE_COUNTRY_PICKER, \
  66                                                                            ModestCountryPickerPrivate))
  67
  68 static void
  69 modest_country_picker_get_property (GObject *object, guint property_id,
  70                                     GValue *value, GParamSpec *pspec)
  71 {
  72         switch (property_id) {
  73         default:
  74                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
  75         }
  76 }
  77
  78 static void
  79 modest_country_picker_set_property (GObject *object, guint property_id,
  80                                     const GValue *value, GParamSpec *pspec)
  81 {
  82         switch (property_id) {
  83         default:
  84                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
  85         }
  86 }
  87
  88 static void
  89 modest_country_picker_dispose (GObject *object)
  90 {
  91         if (G_OBJECT_CLASS (modest_country_picker_parent_class)->dispose)
  92                 G_OBJECT_CLASS (modest_country_picker_parent_class)->dispose (object);
  93 }
  94
  95 enum MODEL_COLS {
  96         MODEL_COL_NAME = 0, /* string */
  97         MODEL_COL_MCC  = 1 /* the 'effective mcc' for this country */
  98 };
  99
 100
 101 static void
 102 modest_country_picker_finalize (GObject *object)
 103 {
 104         G_OBJECT_CLASS (modest_country_picker_parent_class)->finalize (object);
 105 }
 106
 107 static void
 108 modest_country_picker_class_init (ModestCountryPickerClass *klass)
 109 {
 110         GObjectClass *object_class = G_OBJECT_CLASS (klass);
 111
 112         g_type_class_add_private (klass, sizeof (ModestCountryPickerPrivate));
 113
 114         object_class->get_property = modest_country_picker_get_property;
 115         object_class->set_property = modest_country_picker_set_property;
 116         object_class->dispose = modest_country_picker_dispose;
 117         object_class->finalize = modest_country_picker_finalize;
 118 }
 119
 120
 121
 122
 123 /* cluster mcc's, based on the list
 124  * http://en.wikipedia.org/wiki/Mobile_country_code
 125  */
 126 static int
 127 effective_mcc (gint mcc)
 128 {
 129         switch (mcc) {
 130         case 405: return 404; /* india */
 131         case 441: return 440; /* japan */
 132         case 235: return 234; /* united kingdom */
 133         case 311:
 134         case 312:
 135         case 313:
 136         case 314:
 137         case 315:
 138         case 316: return 310; /* united states */
 139         default:  return mcc;
 140         }
 141 }
 142
 143
 144 /* each line is of the form:
 145    xxx    logical_id
 146
 147   NOTE: this function is NOT re-entrant, the out-param country
 148   are static strings that should NOT be freed. and will change when
 149   calling this function again
 150
 151   also note, this function will return the "effective mcc", which
 152   is the normalized mcc for a country - ie. even if the there
 153   are multiple entries for the United States with various mccs,
 154   this function will always return 310, even if the real mcc parsed
 155   would be 314. see the 'effective_mcc' function above.
 156 */
 157 static int
 158 parse_mcc_mapping_line (const char* line,  char** country)
 159 {
 160         char mcc[4];  /* the mcc code, always 3 bytes*/
 161         gchar *iter, *tab, *final;
 162
 163         if (!line) {
 164                 *country = NULL;
 165                 return 0;
 166         }
 167
 168         /* Go to the first tab (Country separator) */
 169         tab = g_utf8_strrchr (line, -1, '\t');
 170         *country = g_utf8_find_next_char (tab, NULL);
 171
 172         /* Replace by end of string. We need to use strlen, because
 173            g_utf8_strrchr expects bytes and not UTF8 characters  */
 174         final = g_utf8_strrchr (tab, strlen (tab) + 1, '\n');
 175         if (G_LIKELY (final))
 176                 *final = '\0';
 177         else
 178                 tab[strlen(tab) - 1] = '\0';
 179
 180         /* Get MCC code */
 181         mcc[0] = g_utf8_get_char (line);
 182         iter = g_utf8_find_next_char (line, NULL);
 183         mcc[1] = g_utf8_get_char (iter);
 184         iter = g_utf8_find_next_char (iter, NULL);
 185         mcc[2] = g_utf8_get_char (iter);
 186         mcc[3] = '\0';
 187
 188         return effective_mcc ((int) strtol ((const char*)mcc, NULL, 10));
 189 }
 190
 191 /** Note that the mcc_mapping file is installed
 192  * by the operator-wizard-settings package.
 193  */
 194 static void
 195 load_from_file (ModestCountryPicker *self, GtkListStore *liststore)
 196 {
 197         ModestCountryPickerPrivate *priv = MODEST_COUNTRY_PICKER_GET_PRIVATE (self);
 198         gboolean translated;
 199         char line[MAX_LINE_LEN];
 200         guint previous_mcc = 0;
 201         gchar *territory;
 202
 203         FILE *file = modest_maemo_open_mcc_mapping_file (&translated);
 204         if (!file) {
 205                 g_warning("Could not open mcc_mapping file");
 206                 return;
 207         }
 208
 209         /* Get the territory specified for the current locale */
 210         territory = nl_langinfo (_NL_ADDRESS_COUNTRY_NAME);
 211
 212         while (fgets (line, MAX_LINE_LEN, file) != NULL) {
 213
 214                 int mcc;
 215                 char *country = NULL;
 216                 const gchar *name_translated;
 217
 218                 mcc = parse_mcc_mapping_line (line, &country);
 219                 if (!country || mcc == 0) {
 220                         g_warning ("%s: error parsing line: '%s'", __FUNCTION__, line);
 221                         continue;
 222                 }
 223
 224                 if (mcc == previous_mcc) {
 225                         /* g_warning ("already seen: %s", line); */
 226                         continue;
 227                 }
 228                 previous_mcc = mcc;
 229
 230                 if (!priv->locale_mcc) {
 231                         if (translated) {
 232                                 if (!g_utf8_collate (country, territory))
 233                                         priv->locale_mcc = mcc;
 234                         } else {
 235                                 gchar *translation = dgettext ("osso-countries", country);
 236                                 if (!g_utf8_collate (translation, territory))
 237                                         priv->locale_mcc = mcc;
 238                         }
 239                 }
 240                 name_translated = dgettext ("osso-countries", country);
 241
 242                 /* Add the row to the model: */
 243                 GtkTreeIter iter;
 244                 gtk_list_store_append (liststore, &iter);
 245                 gtk_list_store_set(liststore, &iter, MODEL_COL_MCC, mcc, MODEL_COL_NAME, name_translated, -1);
 246         }
 247         fclose (file);
 248
 249         /* Fallback to Finland */
 250         if (!priv->locale_mcc)
 251                 priv->locale_mcc = 244;
 252
 253         /* Sort the items: */
 254         gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (liststore),
 255                                               MODEL_COL_NAME, GTK_SORT_ASCENDING);
 256 }
 257
 258 static void
 259 modest_country_picker_init (ModestCountryPicker *self)
 260 {
 261         ModestCountryPickerPrivate *priv = MODEST_COUNTRY_PICKER_GET_PRIVATE (self);
 262         priv->locale_mcc = 0;
 263 }
 264
 265 static gchar *
 266 country_picker_print_func (HildonTouchSelector *selector, gpointer userdata)
 267 {
 268         GtkTreeModel *model;
 269         GtkTreeIter iter;
 270         gchar *text = NULL;
 271
 272         /* Always pick the selected country from the tree view and
 273            never from the entry */
 274         model = hildon_touch_selector_get_model (selector, 0);
 275         if (hildon_touch_selector_get_selected (selector, 0, &iter)) {
 276                 gint column;
 277                 GtkWidget *entry;
 278                 const gchar *entry_text;
 279
 280                 column = hildon_touch_selector_entry_get_text_column (HILDON_TOUCH_SELECTOR_ENTRY (selector));
 281                 gtk_tree_model_get (model, &iter, column, &text, -1);
 282
 283                 entry = GTK_WIDGET (hildon_touch_selector_entry_get_entry (HILDON_TOUCH_SELECTOR_ENTRY (selector)));
 284                 entry_text = hildon_entry_get_text (HILDON_ENTRY (entry));
 285                 if (entry_text != NULL && text != NULL && strcmp (entry_text, text)) {
 286                         hildon_entry_set_text (HILDON_ENTRY (entry), text);
 287                 }
 288         }
 289         return text;
 290 }
 291
 292 void
 293 modest_country_picker_load_data(ModestCountryPicker *self)
 294 {
 295         GtkCellRenderer *renderer;
 296         GtkWidget *selector;
 297         GtkListStore *model;
 298         HildonTouchSelectorColumn *column;
 299
 300         /* Create a tree model for the combo box,
 301          * with a string for the name, and an int for the MCC ID.
 302          * This must match our MODEL_COLS enum constants.
 303          */
 304         model = gtk_list_store_new (2,  G_TYPE_STRING, G_TYPE_INT);
 305
 306         /* Country column:
 307          * The ID model column in not shown in the view. */
 308         renderer = gtk_cell_renderer_text_new ();
 309         g_object_set (G_OBJECT (renderer), "ellipsize", PANGO_ELLIPSIZE_END, NULL);
 310
 311         selector = hildon_touch_selector_entry_new ();
 312         hildon_touch_selector_set_print_func (HILDON_TOUCH_SELECTOR (selector), (HildonTouchSelectorPrintFunc) country_picker_print_func);
 313         column = hildon_touch_selector_append_column (HILDON_TOUCH_SELECTOR (selector), GTK_TREE_MODEL (model),
 314                                                       renderer, "text", MODEL_COL_NAME, NULL);
 315         g_object_set (G_OBJECT (column), "text-column", MODEL_COL_NAME, NULL);
 316
 317         /* Fill the model with rows: */
 318         load_from_file (self, model);
 319
 320         /* Set this _after_ loading from file, it makes loading faster */
 321         hildon_touch_selector_set_model (HILDON_TOUCH_SELECTOR (selector),
 322                                          0, GTK_TREE_MODEL (model));
 323         hildon_touch_selector_entry_set_text_column (HILDON_TOUCH_SELECTOR_ENTRY (selector),
 324                                                      MODEL_COL_NAME);
 325         hildon_touch_selector_entry_set_input_mode (HILDON_TOUCH_SELECTOR_ENTRY (selector),
 326                                                     HILDON_GTK_INPUT_MODE_ALPHA |
 327                                                     HILDON_GTK_INPUT_MODE_AUTOCAP);
 328
 329         hildon_picker_button_set_selector (HILDON_PICKER_BUTTON (self), HILDON_TOUCH_SELECTOR (selector));
 330
 331         g_object_unref (model);
 332 }
 333
 334 ModestCountryPicker*
 335 modest_country_picker_new (HildonSizeType size,
 336                            HildonButtonArrangement arrangement)
 337 {
 338         return g_object_new (MODEST_TYPE_COUNTRY_PICKER,
 339                              "arrangement", arrangement,
 340                              "size", size,
 341                              NULL);
 342 }
 343
 344 /**
 345  * Returns the MCC number of the selected country, or 0 if no country was selected.
 346  */
 347 gint
 348 modest_country_picker_get_active_country_mcc (ModestCountryPicker *self)
 349 {
 350         GtkTreeIter active;
 351         gboolean found;
 352
 353         found = hildon_touch_selector_get_selected (hildon_picker_button_get_selector
 354                                                     (HILDON_PICKER_BUTTON (self)), 0, &active);
 355         if (found) {
 356                 gint mcc = 0;
 357                 gtk_tree_model_get (hildon_touch_selector_get_model (hildon_picker_button_get_selector
 358                                                                      (HILDON_PICKER_BUTTON (self)),
 359                                                                      0),
 360                                     &active, MODEL_COL_MCC, &mcc, -1);
 361                 return mcc;
 362         }
 363         return 0; /* Failed. */
 364 }
 365
 366
 367 /**
 368  * Selects the MCC number of the selected country.
 369  * Specify 0 to select no country.
 370  */
 371 gboolean
 372 modest_country_picker_set_active_country_locale (ModestCountryPicker *self)
 373 {
 374         ModestCountryPickerPrivate *priv = MODEST_COUNTRY_PICKER_GET_PRIVATE (self);
 375         GtkWidget *selector;
 376         GtkTreeIter iter;
 377         gint current_mcc;
 378         GtkTreeModel *model;
 379
 380         selector = GTK_WIDGET (hildon_picker_button_get_selector (HILDON_PICKER_BUTTON (self)));
 381         model = hildon_touch_selector_get_model (HILDON_TOUCH_SELECTOR (selector), 0);
 382         if (!gtk_tree_model_get_iter_first (model, &iter))
 383                 return FALSE;
 384         do {
 385                 gtk_tree_model_get (model, &iter, MODEL_COL_MCC, &current_mcc, -1);
 386                 if (priv->locale_mcc == current_mcc) {
 387                         hildon_touch_selector_select_iter (HILDON_TOUCH_SELECTOR (selector), 0,
 388                                                            &iter, TRUE);
 389                         hildon_button_set_value (HILDON_BUTTON (self),
 390                                                  hildon_touch_selector_get_current_text (HILDON_TOUCH_SELECTOR (selector)));
 391                         return TRUE;
 392                 }
 393         } while (gtk_tree_model_iter_next (model, &iter));
 394
 395         return FALSE; /* not found */
 396 }
 397