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 */
 173         final = g_utf8_strrchr (tab, g_utf8_strlen (tab, 100) + 1, '\n');
 174         *final = '\0';
 175
 176         /* Get MCC code */
 177         mcc[0] = g_utf8_get_char (line);
 178         iter = g_utf8_find_next_char (line, NULL);
 179         mcc[1] = g_utf8_get_char (iter);
 180         iter = g_utf8_find_next_char (iter, NULL);
 181         mcc[2] = g_utf8_get_char (iter);
 182         mcc[3] = '\0';
 183
 184         return effective_mcc ((int) strtol ((const char*)mcc, NULL, 10));
 185 }
 186
 187 /** Note that the mcc_mapping file is installed
 188  * by the operator-wizard-settings package.
 189  */
 190 static void
 191 load_from_file (ModestCountryPicker *self, GtkListStore *liststore)
 192 {
 193         ModestCountryPickerPrivate *priv = MODEST_COUNTRY_PICKER_GET_PRIVATE (self);
 194         gboolean translated;
 195         char line[MAX_LINE_LEN];
 196         guint previous_mcc = 0;
 197         gchar *territory;
 198
 199         FILE *file = modest_maemo_open_mcc_mapping_file (&translated);
 200         if (!file) {
 201                 g_warning("Could not open mcc_mapping file");
 202                 return;
 203         }
 204
 205         /* Get the territory specified for the current locale */
 206         territory = nl_langinfo (_NL_ADDRESS_COUNTRY_NAME);
 207
 208         while (fgets (line, MAX_LINE_LEN, file) != NULL) {
 209
 210                 int mcc;
 211                 char *country = NULL;
 212                 const gchar *name_translated;
 213
 214                 mcc = parse_mcc_mapping_line (line, &country);
 215                 if (!country || mcc == 0) {
 216                         g_warning ("%s: error parsing line: '%s'", __FUNCTION__, line);
 217                         continue;
 218                 }
 219
 220                 if (mcc == previous_mcc) {
 221                         /* g_warning ("already seen: %s", line); */
 222                         continue;
 223                 }
 224                 previous_mcc = mcc;
 225
 226                 if (!priv->locale_mcc) {
 227                         if (translated) {
 228                                 if (!g_utf8_collate (country, territory))
 229                                         priv->locale_mcc = mcc;
 230                         } else {
 231                                 gchar *translation = dgettext ("osso-countries", country);
 232                                 if (!g_utf8_collate (translation, territory))
 233                                         priv->locale_mcc = mcc;
 234                         }
 235                 }
 236                 name_translated = dgettext ("osso-countries", country);
 237
 238                 /* Add the row to the model: */
 239                 GtkTreeIter iter;
 240                 gtk_list_store_append (liststore, &iter);
 241                 gtk_list_store_set(liststore, &iter, MODEL_COL_MCC, mcc, MODEL_COL_NAME, name_translated, -1);
 242         }
 243         fclose (file);
 244
 245         /* Fallback to Finland */
 246         if (!priv->locale_mcc)
 247                 priv->locale_mcc = 244;
 248
 249         /* Sort the items: */
 250         gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (liststore),
 251                                               MODEL_COL_NAME, GTK_SORT_ASCENDING);
 252 }
 253
 254 static void
 255 modest_country_picker_init (ModestCountryPicker *self)
 256 {
 257         ModestCountryPickerPrivate *priv = MODEST_COUNTRY_PICKER_GET_PRIVATE (self);
 258         priv->locale_mcc = 0;
 259 }
 260
 261 void
 262 modest_country_picker_load_data(ModestCountryPicker *self)
 263 {
 264         GtkCellRenderer *renderer;
 265         GtkWidget *selector;
 266         GtkListStore *model;
 267         HildonTouchSelectorColumn *column;
 268
 269         /* Create a tree model for the combo box,
 270          * with a string for the name, and an int for the MCC ID.
 271          * This must match our MODEL_COLS enum constants.
 272          */
 273         model = gtk_list_store_new (2,  G_TYPE_STRING, G_TYPE_INT);
 274
 275         /* Country column:
 276          * The ID model column in not shown in the view. */
 277         renderer = gtk_cell_renderer_text_new ();
 278         g_object_set (G_OBJECT (renderer), "ellipsize", PANGO_ELLIPSIZE_END, NULL);
 279
 280         selector = hildon_touch_selector_entry_new ();
 281         column = hildon_touch_selector_append_column (HILDON_TOUCH_SELECTOR (selector), GTK_TREE_MODEL (model),
 282                                                       renderer, "text", MODEL_COL_NAME, NULL);
 283         g_object_set (G_OBJECT (column), "text-column", MODEL_COL_NAME, NULL);
 284
 285         /* Fill the model with rows: */
 286         load_from_file (self, model);
 287
 288         /* Set this _after_ loading from file, it makes loading faster */
 289         hildon_touch_selector_set_model (HILDON_TOUCH_SELECTOR (selector),
 290                                          0, GTK_TREE_MODEL (model));
 291         hildon_touch_selector_entry_set_text_column (HILDON_TOUCH_SELECTOR_ENTRY (selector),
 292                                                      MODEL_COL_NAME);
 293
 294         hildon_picker_button_set_selector (HILDON_PICKER_BUTTON (self), HILDON_TOUCH_SELECTOR (selector));
 295
 296         g_object_unref (model);
 297 }
 298
 299 ModestCountryPicker*
 300 modest_country_picker_new (HildonSizeType size,
 301                            HildonButtonArrangement arrangement)
 302 {
 303         return g_object_new (MODEST_TYPE_COUNTRY_PICKER,
 304                              "arrangement", arrangement,
 305                              "size", size,
 306                              NULL);
 307 }
 308
 309 /**
 310  * Returns the MCC number of the selected country, or 0 if no country was selected.
 311  */
 312 gint
 313 modest_country_picker_get_active_country_mcc (ModestCountryPicker *self)
 314 {
 315         GtkTreeIter active;
 316         gboolean found;
 317
 318         found = hildon_touch_selector_get_selected (hildon_picker_button_get_selector
 319                                                     (HILDON_PICKER_BUTTON (self)), 0, &active);
 320         if (found) {
 321                 gint mcc = 0;
 322                 gtk_tree_model_get (hildon_touch_selector_get_model (hildon_picker_button_get_selector
 323                                                                      (HILDON_PICKER_BUTTON (self)),
 324                                                                      0),
 325                                     &active, MODEL_COL_MCC, &mcc, -1);
 326                 return mcc;
 327         }
 328         return 0; /* Failed. */
 329 }
 330
 331
 332 /**
 333  * Selects the MCC number of the selected country.
 334  * Specify 0 to select no country.
 335  */
 336 gboolean
 337 modest_country_picker_set_active_country_locale (ModestCountryPicker *self)
 338 {
 339         ModestCountryPickerPrivate *priv = MODEST_COUNTRY_PICKER_GET_PRIVATE (self);
 340         GtkWidget *selector;
 341         GtkTreeIter iter;
 342         gint current_mcc;
 343         GtkTreeModel *model;
 344
 345         selector = GTK_WIDGET (hildon_picker_button_get_selector (HILDON_PICKER_BUTTON (self)));
 346         model = hildon_touch_selector_get_model (HILDON_TOUCH_SELECTOR (selector), 0);
 347         if (!gtk_tree_model_get_iter_first (model, &iter))
 348                 return FALSE;
 349         do {
 350                 gtk_tree_model_get (model, &iter, MODEL_COL_MCC, &current_mcc, -1);
 351                 if (priv->locale_mcc == current_mcc) {
 352                         hildon_touch_selector_select_iter (HILDON_TOUCH_SELECTOR (selector), 0,
 353                                                            &iter, TRUE);
 354                         hildon_button_set_value (HILDON_BUTTON (self),
 355                                                  hildon_touch_selector_get_current_text (HILDON_TOUCH_SELECTOR (selector)));
 356                         return TRUE;
 357                 }
 358         } while (gtk_tree_model_iter_next (model, &iter));
 359
 360         return FALSE; /* not found */
 361 }
 362