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 static gchar *
 262 country_picker_print_func (HildonTouchSelector *selector)
 263 {
 264         GtkTreeModel *model;
 265         GtkTreeIter iter;
 266         gchar *text = NULL;
 267
 268         /* Always pick the selected country from the tree view and
 269            never from the entry */
 270         model = hildon_touch_selector_get_model (selector, 0);
 271         if (hildon_touch_selector_get_selected (selector, 0, &iter)) {
 272                 gint column;
 273
 274                 column = hildon_touch_selector_entry_get_text_column (HILDON_TOUCH_SELECTOR_ENTRY (selector));
 275                 gtk_tree_model_get (model, &iter, column, &text, -1);
 276         }
 277         return text;
 278 }
 279
 280 void
 281 modest_country_picker_load_data(ModestCountryPicker *self)
 282 {
 283         GtkCellRenderer *renderer;
 284         GtkWidget *selector;
 285         GtkListStore *model;
 286         HildonTouchSelectorColumn *column;
 287
 288         /* Create a tree model for the combo box,
 289          * with a string for the name, and an int for the MCC ID.
 290          * This must match our MODEL_COLS enum constants.
 291          */
 292         model = gtk_list_store_new (2,  G_TYPE_STRING, G_TYPE_INT);
 293
 294         /* Country column:
 295          * The ID model column in not shown in the view. */
 296         renderer = gtk_cell_renderer_text_new ();
 297         g_object_set (G_OBJECT (renderer), "ellipsize", PANGO_ELLIPSIZE_END, NULL);
 298
 299         selector = hildon_touch_selector_entry_new ();
 300         hildon_touch_selector_set_print_func (HILDON_TOUCH_SELECTOR (selector), country_picker_print_func);
 301         column = hildon_touch_selector_append_column (HILDON_TOUCH_SELECTOR (selector), GTK_TREE_MODEL (model),
 302                                                       renderer, "text", MODEL_COL_NAME, NULL);
 303         g_object_set (G_OBJECT (column), "text-column", MODEL_COL_NAME, NULL);
 304
 305         /* Fill the model with rows: */
 306         load_from_file (self, model);
 307
 308         /* Set this _after_ loading from file, it makes loading faster */
 309         hildon_touch_selector_set_model (HILDON_TOUCH_SELECTOR (selector),
 310                                          0, GTK_TREE_MODEL (model));
 311         hildon_touch_selector_entry_set_text_column (HILDON_TOUCH_SELECTOR_ENTRY (selector),
 312                                                      MODEL_COL_NAME);
 313         hildon_touch_selector_entry_set_input_mode (HILDON_TOUCH_SELECTOR_ENTRY (selector),
 314                                                     HILDON_GTK_INPUT_MODE_ALPHA |
 315                                                     HILDON_GTK_INPUT_MODE_AUTOCAP);
 316
 317         hildon_picker_button_set_selector (HILDON_PICKER_BUTTON (self), HILDON_TOUCH_SELECTOR (selector));
 318
 319         g_object_unref (model);
 320 }
 321
 322 ModestCountryPicker*
 323 modest_country_picker_new (HildonSizeType size,
 324                            HildonButtonArrangement arrangement)
 325 {
 326         return g_object_new (MODEST_TYPE_COUNTRY_PICKER,
 327                              "arrangement", arrangement,
 328                              "size", size,
 329                              NULL);
 330 }
 331
 332 /**
 333  * Returns the MCC number of the selected country, or 0 if no country was selected.
 334  */
 335 gint
 336 modest_country_picker_get_active_country_mcc (ModestCountryPicker *self)
 337 {
 338         GtkTreeIter active;
 339         gboolean found;
 340
 341         found = hildon_touch_selector_get_selected (hildon_picker_button_get_selector
 342                                                     (HILDON_PICKER_BUTTON (self)), 0, &active);
 343         if (found) {
 344                 gint mcc = 0;
 345                 gtk_tree_model_get (hildon_touch_selector_get_model (hildon_picker_button_get_selector
 346                                                                      (HILDON_PICKER_BUTTON (self)),
 347                                                                      0),
 348                                     &active, MODEL_COL_MCC, &mcc, -1);
 349                 return mcc;
 350         }
 351         return 0; /* Failed. */
 352 }
 353
 354
 355 /**
 356  * Selects the MCC number of the selected country.
 357  * Specify 0 to select no country.
 358  */
 359 gboolean
 360 modest_country_picker_set_active_country_locale (ModestCountryPicker *self)
 361 {
 362         ModestCountryPickerPrivate *priv = MODEST_COUNTRY_PICKER_GET_PRIVATE (self);
 363         GtkWidget *selector;
 364         GtkTreeIter iter;
 365         gint current_mcc;
 366         GtkTreeModel *model;
 367
 368         selector = GTK_WIDGET (hildon_picker_button_get_selector (HILDON_PICKER_BUTTON (self)));
 369         model = hildon_touch_selector_get_model (HILDON_TOUCH_SELECTOR (selector), 0);
 370         if (!gtk_tree_model_get_iter_first (model, &iter))
 371                 return FALSE;
 372         do {
 373                 gtk_tree_model_get (model, &iter, MODEL_COL_MCC, &current_mcc, -1);
 374                 if (priv->locale_mcc == current_mcc) {
 375                         hildon_touch_selector_select_iter (HILDON_TOUCH_SELECTOR (selector), 0,
 376                                                            &iter, TRUE);
 377                         hildon_button_set_value (HILDON_BUTTON (self),
 378                                                  hildon_touch_selector_get_current_text (HILDON_TOUCH_SELECTOR (selector)));
 379                         return TRUE;
 380                 }
 381         } while (gtk_tree_model_iter_next (model, &iter));
 382
 383         return FALSE; /* not found */
 384 }
 385