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