vcs.maemo.org Git - hildon/blob - src/hildon-font-selection-dialog.c

   1 /*
   2  * This file is part of hildon-libs
   3  *
   4  * Copyright (C) 2005, 2006 Nokia Corporation, all rights reserved.
   5  *
   6  * Contact: Michael Dominic Kostrzewa <michael.kostrzewa@nokia.com>
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public License
  10  * as published by the Free Software Foundation; version 2.1 of
  11  * the License.
  12  *
  13  * This library is distributed in the hope that it will be useful, but
  14  * WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
  21  * 02110-1301 USA
  22  *
  23  */
  24
  25 /**
  26  * SECTION:hildon-font-selection-dialog
  27  * @short_description: A widget used to allow users to select a font
  28  * with certain properties
  29  *
  30  * Font selection can be made using this widget. Users can select font name,
  31  * size, style, etc. Users can also preview text in the selected font.
  32  */
  33
  34 #include <config.h>
  35 #include <stdlib.h>
  36 #include <string.h>
  37 #include <gtk/gtkstock.h>
  38 #include <gtk/gtkcombobox.h>
  39 #include <gtk/gtktogglebutton.h>
  40 #include <gtk/gtkcheckbutton.h>
  41 #include <gtk/gtklabel.h>
  42 #include <gtk/gtkvbox.h>
  43 #include <gtk/gtkliststore.h>
  44 #include <gtk/gtknotebook.h>
  45 #include <gtk/gtk.h>
  46 #include <glib.h>
  47 #include <gdk/gdkkeysyms.h>
  48 #include "hildon-font-selection-dialog.h"
  49 #include "hildon-caption.h"
  50 #include "hildon-color-selector.h"
  51 #include "hildon-color-button.h"
  52 #include <libintl.h>
  53
  54 #define _(String) dgettext(PACKAGE, String)
  55
  56 #define SUPERSCRIPT_RISE 3333
  57 #define SUBSCRIPT_LOW   -3333
  58 #define ON_BIT  0x01
  59 #define OFF_BIT 0x02
  60
  61 /*
  62  * These are what we use as the standard font sizes, for the size list.
  63  */
  64 static const guint16 font_sizes[] =
  65 {
  66   6, 8, 10, 12, 16, 24, 32
  67 };
  68
  69 #define HILDON_FONT_SELECTION_DIALOG_GET_PRIVATE(obj) \
  70 (G_TYPE_INSTANCE_GET_PRIVATE ((obj), \
  71                               HILDON_TYPE_FONT_SELECTION_DIALOG, \
  72                               HildonFontSelectionDialogPrivate))
  73
  74 /*None of designed api function works, so now it all comes down to
  75  *use properties to achieve what we are supposed to achieve*/
  76 enum
  77 {
  78   PROP_FAMILY = 1,
  79   PROP_FAMILY_SET,
  80   PROP_SIZE,
  81   PROP_SIZE_SET,
  82   PROP_COLOR,
  83   PROP_COLOR_SET,
  84   PROP_BOLD,
  85   PROP_BOLD_SET,
  86   PROP_ITALIC,
  87   PROP_ITALIC_SET,
  88   PROP_UNDERLINE,
  89   PROP_UNDERLINE_SET,
  90   PROP_STRIKETHROUGH,
  91   PROP_STRIKETHROUGH_SET,
  92   PROP_POSITION,
  93   PROP_POSITION_SET,
  94   PROP_PREVIEW_TEXT,
  95   PROP_FONT_SCALING
  96 };
  97
  98 typedef struct
  99 _HildonFontSelectionDialogPrivate HildonFontSelectionDialogPrivate;
 100
 101 struct _HildonFontSelectionDialogPrivate
 102 {
 103   GtkNotebook *notebook;
 104
 105   gchar *preview_text;
 106
 107   /*Tab one*/
 108   GtkWidget *cbx_font_type;
 109   GtkWidget *cbx_font_size;
 110   GtkWidget *font_color_button;
 111
 112   /*Tab two*/
 113   GtkWidget *chk_bold;
 114   GtkWidget *chk_italic;
 115   GtkWidget *chk_underline;
 116
 117   /*Tab three*/
 118   GtkWidget *chk_strikethrough;
 119   GtkWidget *cbx_positioning;
 120
 121   /*Every family*/
 122   PangoFontFamily **families;
 123   gint n_families;
 124
 125   /*color_set is used to show whether the color is inconsistent
 126    * The handler id is used to block the signal emission
 127    * when we change the color setting*/
 128
 129   gboolean color_set;
 130
 131   /* font_scaling is the scaling factor applied to font
 132    * scale in the preview dialog */
 133
 134   gdouble font_scaling;
 135   gulong color_modified_signal_handler;
 136 };
 137
 138 /*combo box active row indicator -2--inconsistent, -1--undefined
 139  * please make sure that you use settings_init settings_apply
 140  * and settings_destroy, dont even try to touch this structure
 141  * without using the three above interface functions, of course
 142  * if you know what you are doing, do as you please ;-)*/
 143 typedef struct
 144 {
 145   HildonFontSelectionDialog
 146                *fsd; /*pointer to our font selection dialog*/
 147
 148   gint         family; /*combo box indicator*/
 149   gint         size; /*combo box indicator*/
 150   GdkColor     *color; /*free after read the setting*/
 151   gboolean     color_inconsist;
 152   gint         weight; /*bit mask*/
 153   gint         style;  /*bit mask*/
 154   gint         underline; /*bit mask*/
 155   gint         strikethrough; /*bit mask*/
 156   gint         position; /*combo box indicator*/
 157
 158 }HildonFontSelectionDialogSettings;
 159
 160 static gboolean
 161               hildon_font_selection_dialog_preview_key_press
 162                                             (GtkWidget * widget,
 163                                              GdkEventKey * event,
 164                                              gpointer unused);
 165
 166 /*Some tools from gtk_font_selection*/
 167 static int    cmp_families                   (const void *a, const void *b);
 168
 169 static void   hildon_font_selection_dialog_show_preview
 170                                              (HildonFontSelectionDialog
 171                                               *fontsel);
 172
 173 static PangoAttrList*
 174               hildon_font_selection_dialog_create_attrlist
 175                                              (HildonFontSelectionDialog
 176                                               *fontsel, guint start_index,
 177                                               guint len);
 178
 179 static void   hildon_font_selection_dialog_show_available_positionings
 180                                              (HildonFontSelectionDialogPrivate
 181                                               *priv);
 182
 183 static void   hildon_font_selection_dialog_show_available_fonts
 184                                              (HildonFontSelectionDialog
 185                                               *fontsel);
 186
 187 static void   hildon_font_selection_dialog_show_available_sizes
 188                                              (HildonFontSelectionDialogPrivate
 189                                               *priv);
 190
 191 static void   hildon_font_selection_dialog_class_init
 192                                              (HildonFontSelectionDialogClass
 193                                               *klass);
 194
 195 static void   hildon_font_selection_dialog_init
 196                                              (HildonFontSelectionDialog
 197                                               *fontseldiag);
 198
 199 static void   hildon_font_selection_dialog_finalize
 200                                              (GObject * object);
 201
 202 static void   hildon_font_selection_dialog_construct_notebook
 203                                              (HildonFontSelectionDialog
 204                                               *fontsel);
 205
 206 static void   color_modified_cb              (HildonColorButton *button,
 207                                               GParamSpec *pspec,
 208                                               gpointer fsd_priv);
 209
 210 static void   add_preview_text_attr          (PangoAttrList *list,
 211                                               PangoAttribute *attr,
 212                                               guint start,
 213                                               guint len);
 214
 215 static void   toggle_clicked                 (GtkButton *button,
 216                                               gpointer unused);
 217
 218
 219
 220 static GtkDialogClass *font_selection_dialog_parent_class = NULL;
 221
 222 GType hildon_font_selection_dialog_get_type(void)
 223 {
 224   static GType font_selection_dialog_type = 0;
 225
 226   if (!font_selection_dialog_type) {
 227     static const GTypeInfo fontsel_diag_info = {
 228       sizeof(HildonFontSelectionDialogClass),
 229       NULL,       /* base_init */
 230       NULL,       /* base_finalize */
 231       (GClassInitFunc) hildon_font_selection_dialog_class_init,
 232       NULL,       /* class_finalize */
 233       NULL,       /* class_data */
 234       sizeof(HildonFontSelectionDialog),
 235       0,  /* n_preallocs */
 236       (GInstanceInitFunc) hildon_font_selection_dialog_init,
 237     };
 238
 239     font_selection_dialog_type =
 240       g_type_register_static(GTK_TYPE_DIALOG,
 241                              "HildonFontSelectionDialog",
 242                              &fontsel_diag_info, 0);
 243   }
 244
 245   return font_selection_dialog_type;
 246 }
 247
 248 static void
 249 hildon_font_selection_dialog_get_property (GObject      *object,
 250                                            guint         prop_id,
 251                                            GValue       *value,
 252                                            GParamSpec   *pspec)
 253 {
 254   gint i;
 255   GdkColor *color = NULL;
 256
 257   HildonFontSelectionDialogPrivate *priv =
 258     HILDON_FONT_SELECTION_DIALOG_GET_PRIVATE(
 259         HILDON_FONT_SELECTION_DIALOG(object));
 260
 261
 262   switch (prop_id)
 263     {
 264     case PROP_FAMILY:
 265       i = gtk_combo_box_get_active(GTK_COMBO_BOX(priv->cbx_font_type));
 266       if(i >= 0 && i < priv->n_families)
 267         g_value_set_string(value,
 268                            pango_font_family_get_name(priv->families[i]));
 269       else
 270         g_value_set_string(value, "Sans");
 271       break;
 272
 273     case PROP_FAMILY_SET:
 274       i = gtk_combo_box_get_active(GTK_COMBO_BOX(priv->cbx_font_type));
 275       if(i >= 0 && i < priv->n_families)
 276         g_value_set_boolean(value, TRUE);
 277       else
 278         g_value_set_boolean(value, FALSE);
 279       break;
 280
 281     case PROP_SIZE:
 282       i = gtk_combo_box_get_active(GTK_COMBO_BOX(priv->cbx_font_size));
 283       if(i >= 0 && i < G_N_ELEMENTS(font_sizes))
 284         g_value_set_int(value, font_sizes[i]);
 285       else
 286         g_value_set_int(value, 16);
 287       break;
 288
 289     case PROP_SIZE_SET:
 290       i = gtk_combo_box_get_active(GTK_COMBO_BOX(priv->cbx_font_size));
 291       if(i >= 0 && i < G_N_ELEMENTS(font_sizes))
 292         g_value_set_boolean(value, TRUE);
 293       else
 294         g_value_set_boolean(value, FALSE);
 295       break;
 296
 297     case PROP_COLOR:
 298       color = hildon_color_button_get_color
 299         (HILDON_COLOR_BUTTON(priv->font_color_button));
 300       g_value_set_boxed(value, (gconstpointer) color);
 301       if(color != NULL)
 302         gdk_color_free(color);
 303       break;
 304
 305     case PROP_COLOR_SET:
 306       g_value_set_boolean(value, priv->color_set);
 307       break;
 308
 309     case PROP_BOLD:
 310       g_value_set_boolean(value,
 311         gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(priv->chk_bold)));
 312       break;
 313
 314     case PROP_BOLD_SET:
 315       g_value_set_boolean(value,
 316         !gtk_toggle_button_get_inconsistent
 317         (GTK_TOGGLE_BUTTON(priv->chk_bold)));
 318       break;
 319
 320     case PROP_ITALIC:
 321       g_value_set_boolean(value,
 322         gtk_toggle_button_get_active
 323         (GTK_TOGGLE_BUTTON(priv->chk_italic)));
 324       break;
 325
 326     case PROP_ITALIC_SET:
 327       g_value_set_boolean(value,
 328         !gtk_toggle_button_get_inconsistent
 329         (GTK_TOGGLE_BUTTON(priv->chk_italic)));
 330       break;
 331
 332     case PROP_UNDERLINE:
 333       g_value_set_boolean(value,
 334         gtk_toggle_button_get_active
 335         (GTK_TOGGLE_BUTTON(priv->chk_underline)));
 336       break;
 337
 338     case PROP_UNDERLINE_SET:
 339       g_value_set_boolean(value,
 340         !gtk_toggle_button_get_inconsistent
 341         (GTK_TOGGLE_BUTTON(priv->chk_underline)));
 342       break;
 343
 344     case PROP_STRIKETHROUGH:
 345       g_value_set_boolean(value,
 346         gtk_toggle_button_get_active
 347         (GTK_TOGGLE_BUTTON(priv->chk_strikethrough)));
 348       break;
 349
 350     case PROP_STRIKETHROUGH_SET:
 351       g_value_set_boolean(value,
 352         !gtk_toggle_button_get_inconsistent
 353         (GTK_TOGGLE_BUTTON(priv->chk_strikethrough)));
 354       break;
 355
 356     case PROP_POSITION:
 357       i = gtk_combo_box_get_active(GTK_COMBO_BOX(priv->cbx_positioning));
 358       if(i == 1)/*super*/
 359         g_value_set_int(value, 1);
 360       else if(i == 2)/*sub*/
 361         g_value_set_int(value, -1);
 362       else
 363         g_value_set_int(value, 0);
 364       break;
 365
 366     case PROP_FONT_SCALING:
 367         g_value_set_double(value, priv->font_scaling);
 368       break;
 369
 370     case PROP_POSITION_SET:
 371       i = gtk_combo_box_get_active(GTK_COMBO_BOX(priv->cbx_positioning));
 372       if(i >= 0 && i < 3)
 373         g_value_set_boolean(value, TRUE);
 374       else
 375         g_value_set_boolean(value, FALSE);
 376       break;
 377
 378     case PROP_PREVIEW_TEXT:
 379         g_value_set_string(value,
 380                 hildon_font_selection_dialog_get_preview_text(
 381                     HILDON_FONT_SELECTION_DIALOG(object)));
 382       break;
 383
 384     default:
 385       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 386       break;
 387     }
 388 }
 389
 390 static void
 391 hildon_font_selection_dialog_set_property (GObject         *object,
 392                                            guint            prop_id,
 393                                            const GValue    *value,
 394                                            GParamSpec      *pspec)
 395 {
 396   gint i, size;
 397   const gchar *str;
 398   gboolean b;
 399   GdkColor *color = NULL;
 400   GdkColor black;
 401
 402   HildonFontSelectionDialogPrivate *priv =
 403     HILDON_FONT_SELECTION_DIALOG_GET_PRIVATE(
 404         HILDON_FONT_SELECTION_DIALOG(object));
 405   black.red = black.green = black.blue = 0;
 406
 407   switch (prop_id)
 408     {
 409     case PROP_FAMILY:
 410       str = g_value_get_string(value);
 411       for(i = 0; i < priv->n_families; i++)
 412         {
 413           if(strcmp(str, pango_font_family_get_name(priv->families[i]))
 414              == 0)
 415             {
 416               gtk_combo_box_set_active(GTK_COMBO_BOX(priv->cbx_font_type), i);
 417               break;
 418             }
 419         }
 420       break;
 421
 422     case PROP_FAMILY_SET:
 423       b = g_value_get_boolean(value);
 424       if(!b)
 425         gtk_combo_box_set_active(GTK_COMBO_BOX(priv->cbx_font_type), -1);
 426       break;
 427
 428     case PROP_SIZE:
 429       size = g_value_get_int(value);
 430       for(i = 0; i < G_N_ELEMENTS(font_sizes); i++)
 431         {
 432           if(size == font_sizes[i])
 433             {
 434               gtk_combo_box_set_active(GTK_COMBO_BOX(priv->cbx_font_size), i);
 435               break;
 436             }
 437         }
 438       break;
 439
 440     case PROP_SIZE_SET:
 441       b = g_value_get_boolean(value);
 442       if(!b)
 443         gtk_combo_box_set_active(GTK_COMBO_BOX(priv->cbx_font_size), -1);
 444       break;
 445
 446     case PROP_COLOR:
 447       color = (GdkColor *) g_value_get_boxed(value);
 448       if(color != NULL)
 449         hildon_color_button_set_color(HILDON_COLOR_BUTTON
 450                                       (priv->font_color_button),
 451                                       color);
 452       else
 453         hildon_color_button_set_color(HILDON_COLOR_BUTTON
 454                                       (priv->font_color_button),
 455                                       &black);
 456       break;
 457
 458     case PROP_COLOR_SET:
 459       priv->color_set = g_value_get_boolean(value);
 460       if(!priv->color_set)
 461         {
 462           /*set color to black, but block our signal handler*/
 463           g_signal_handler_block((gpointer) priv->font_color_button,
 464                                  priv->color_modified_signal_handler);
 465
 466           hildon_color_button_set_color(HILDON_COLOR_BUTTON
 467                                         (priv->font_color_button),
 468                                         &black);
 469
 470           g_signal_handler_unblock((gpointer) priv->font_color_button,
 471                                  priv->color_modified_signal_handler);
 472         }
 473       break;
 474
 475     case PROP_BOLD:
 476       /*this call will make sure that we dont get extra clicked signal*/
 477       gtk_toggle_button_set_inconsistent(GTK_TOGGLE_BUTTON(priv->chk_bold),
 478                                          FALSE);
 479       gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(priv->chk_bold),
 480                                    g_value_get_boolean(value));
 481       break;
 482
 483     case PROP_BOLD_SET:
 484       gtk_toggle_button_set_inconsistent(GTK_TOGGLE_BUTTON(priv->chk_bold),
 485                                          !g_value_get_boolean(value));
 486       break;
 487
 488     case PROP_ITALIC:
 489       gtk_toggle_button_set_inconsistent(GTK_TOGGLE_BUTTON(priv->chk_italic),
 490                                          FALSE);
 491       gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(priv->chk_italic),
 492                                    g_value_get_boolean(value));
 493       break;
 494
 495     case PROP_ITALIC_SET:
 496       gtk_toggle_button_set_inconsistent(GTK_TOGGLE_BUTTON(priv->chk_italic),
 497                                          !g_value_get_boolean(value));
 498       break;
 499
 500     case PROP_UNDERLINE:
 501       gtk_toggle_button_set_inconsistent(GTK_TOGGLE_BUTTON
 502                                          (priv->chk_underline),
 503                                          FALSE);
 504       gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(priv->chk_underline),
 505                                    g_value_get_boolean(value));
 506       break;
 507
 508     case PROP_UNDERLINE_SET:
 509       gtk_toggle_button_set_inconsistent(GTK_TOGGLE_BUTTON(priv->chk_underline),
 510                                          !g_value_get_boolean(value));
 511       break;
 512
 513     case PROP_STRIKETHROUGH:
 514       gtk_toggle_button_set_inconsistent(GTK_TOGGLE_BUTTON
 515                                          (priv->chk_strikethrough),
 516                                          FALSE);
 517       gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(priv->chk_strikethrough),
 518                                    g_value_get_boolean(value));
 519       break;
 520
 521     case PROP_STRIKETHROUGH_SET:
 522       gtk_toggle_button_set_inconsistent(GTK_TOGGLE_BUTTON
 523                                          (priv->chk_strikethrough),
 524                                          !g_value_get_boolean(value));
 525       break;
 526
 527     case PROP_POSITION:
 528       i = g_value_get_int(value);
 529       if( i == 1 )
 530         gtk_combo_box_set_active(GTK_COMBO_BOX(priv->cbx_positioning), 1);
 531       else if(i == -1)
 532         gtk_combo_box_set_active(GTK_COMBO_BOX(priv->cbx_positioning), 2);
 533       else
 534         gtk_combo_box_set_active(GTK_COMBO_BOX(priv->cbx_positioning), 0);
 535       break;
 536
 537     case PROP_FONT_SCALING:
 538       priv->font_scaling = g_value_get_double(value);
 539       break;
 540
 541     case PROP_POSITION_SET:
 542       b = g_value_get_boolean(value);
 543       if(!b)
 544         gtk_combo_box_set_active(GTK_COMBO_BOX(priv->cbx_positioning), -1);
 545       break;
 546
 547     case PROP_PREVIEW_TEXT:
 548       hildon_font_selection_dialog_set_preview_text(
 549               HILDON_FONT_SELECTION_DIALOG(object),
 550               g_value_get_string(value));
 551       break;
 552
 553     default:
 554       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 555       break;
 556     }
 557 }
 558
 559 static void
 560 hildon_font_selection_dialog_class_init(HildonFontSelectionDialogClass *
 561                                         klass)
 562 {
 563   GObjectClass *gobject_class;
 564
 565   font_selection_dialog_parent_class = g_type_class_peek_parent(klass);
 566   gobject_class = G_OBJECT_CLASS(klass);
 567   gobject_class->finalize = hildon_font_selection_dialog_finalize;
 568   gobject_class->get_property = hildon_font_selection_dialog_get_property;
 569   gobject_class->set_property = hildon_font_selection_dialog_set_property;
 570
 571   /* Install property to the class */
 572   g_object_class_install_property(gobject_class, PROP_FAMILY,
 573                                   g_param_spec_string("family",
 574                                   "Font family", "String defines"
 575                                   " the font family", "Sans",
 576                                   G_PARAM_READWRITE));
 577
 578   g_object_class_install_property(gobject_class, PROP_FAMILY_SET,
 579                                   g_param_spec_boolean ("family-set",
 580                                   "family inconsistent state",
 581                                   "Whether the family property"
 582                                   " is inconsistent", FALSE,
 583                                   G_PARAM_READWRITE | G_PARAM_CONSTRUCT));
 584
 585   g_object_class_install_property(gobject_class, PROP_SIZE,
 586                                    g_param_spec_int ("size",
 587                                    "Font size",
 588                                    "Font size in Pt",
 589                                    6, 32, 16,
 590                                    G_PARAM_READWRITE));
 591
 592   g_object_class_install_property(gobject_class, PROP_SIZE_SET,
 593                                   g_param_spec_boolean ("size-set",
 594                                   "size inconsistent state",
 595                                   "Whether the size property"
 596                                   " is inconsistent", FALSE,
 597                                   G_PARAM_READWRITE | G_PARAM_CONSTRUCT));
 598
 599   g_object_class_install_property(gobject_class, PROP_COLOR,
 600                                   g_param_spec_boxed ("color",
 601                                   "text color",
 602                                   "gdk color for the text",
 603                                   GDK_TYPE_COLOR,
 604                                   G_PARAM_READWRITE));
 605
 606   g_object_class_install_property(gobject_class, PROP_COLOR_SET,
 607                                   g_param_spec_boolean ("color-set",
 608                                   "color inconsistent state",
 609                                   "Whether the color property"
 610                                   " is inconsistent", FALSE,
 611                                   G_PARAM_READWRITE | G_PARAM_CONSTRUCT));
 612
 613   g_object_class_install_property(gobject_class, PROP_BOLD,
 614                                   g_param_spec_boolean ("bold",
 615                                   "text weight",
 616                                   "Whether the text is bold",
 617                                   FALSE,
 618                                   G_PARAM_READWRITE));
 619
 620   g_object_class_install_property(gobject_class, PROP_BOLD_SET,
 621                                   g_param_spec_boolean ("bold-set",
 622                                   "bold inconsistent state",
 623                                   "Whether the bold"
 624                                   " is inconsistent", FALSE,
 625                                   G_PARAM_READWRITE | G_PARAM_CONSTRUCT));
 626
 627   g_object_class_install_property(gobject_class, PROP_ITALIC,
 628                                   g_param_spec_boolean ("italic",
 629                                   "text style",
 630                                   "Whether the text is italic",
 631                                   FALSE,
 632                                   G_PARAM_READWRITE));
 633
 634   g_object_class_install_property(gobject_class, PROP_ITALIC_SET,
 635                                   g_param_spec_boolean ("italic-set",
 636                                   "italic inconsistent state",
 637                                   "Whether the italic"
 638                                   " is inconsistent", FALSE,
 639                                   G_PARAM_READWRITE | G_PARAM_CONSTRUCT));
 640
 641   g_object_class_install_property(gobject_class, PROP_UNDERLINE,
 642                                   g_param_spec_boolean ("underline",
 643                                   "text underline",
 644                                   "Whether the text is underlined",
 645                                   FALSE,
 646                                   G_PARAM_READWRITE));
 647
 648   g_object_class_install_property(gobject_class, PROP_UNDERLINE_SET,
 649                                   g_param_spec_boolean ("underline-set",
 650                                   "underline inconsistent state",
 651                                   "Whether the underline"
 652                                   " is inconsistent", FALSE,
 653                                   G_PARAM_READWRITE | G_PARAM_CONSTRUCT));
 654
 655   g_object_class_install_property(gobject_class, PROP_STRIKETHROUGH,
 656                                   g_param_spec_boolean ("strikethrough",
 657                                   "strikethroughed text",
 658                                   "Whether the text is strikethroughed",
 659                                   FALSE,
 660                                   G_PARAM_READWRITE));
 661
 662   g_object_class_install_property(gobject_class, PROP_STRIKETHROUGH_SET,
 663                                   g_param_spec_boolean ("strikethrough-set",
 664                                   "strikethrough inconsistent state",
 665                                   "Whether the strikethrough"
 666                                   " is inconsistent", FALSE,
 667                                   G_PARAM_READWRITE | G_PARAM_CONSTRUCT));
 668
 669   g_object_class_install_property(gobject_class, PROP_POSITION,
 670                                    g_param_spec_int ("position",
 671                                    "Font position",
 672                                    "Font position super or subscript",
 673                                    -1, 1, 0,
 674                                    G_PARAM_READWRITE));
 675
 676   /* FIXME This was introduced in 0.14.1. We don't have documentation for
 677    * properties anyways, but once it's there it needs to be marked as
 678    * Since: 0.14.1 */
 679   g_object_class_install_property(gobject_class, PROP_FONT_SCALING,
 680                                    g_param_spec_double ("font-scaling",
 681                                    "Font scaling",
 682                                    "Font scaling for the preview dialog",
 683                                    0, 10, 1,
 684                                    G_PARAM_READWRITE));
 685
 686   g_object_class_install_property(gobject_class, PROP_POSITION_SET,
 687                                   g_param_spec_boolean ("position-set",
 688                                   "position inconsistent state",
 689                                   "Whether the position"
 690                                   " is inconsistent", FALSE,
 691                                   G_PARAM_READWRITE | G_PARAM_CONSTRUCT));
 692
 693   g_object_class_install_property(gobject_class, PROP_PREVIEW_TEXT,
 694                                   g_param_spec_string("preview-text",
 695                                   "Preview Text",
 696                                   "the text in preview dialog, which does"
 697                                   "not include the reference text",
 698                                   "",
 699                                   G_PARAM_READWRITE));
 700
 701
 702   g_type_class_add_private(klass,
 703                            sizeof(struct _HildonFontSelectionDialogPrivate));
 704 }
 705
 706
 707 static void
 708 hildon_font_selection_dialog_init(HildonFontSelectionDialog *fontseldiag)
 709 {
 710   HildonFontSelectionDialogPrivate *priv =
 711     HILDON_FONT_SELECTION_DIALOG_GET_PRIVATE(fontseldiag);
 712   GtkWidget *preview_button;
 713
 714   priv->notebook = GTK_NOTEBOOK(gtk_notebook_new());
 715
 716   hildon_font_selection_dialog_construct_notebook(fontseldiag);
 717
 718   gtk_box_pack_start(GTK_BOX(GTK_DIALOG(fontseldiag)->vbox),
 719                      GTK_WIDGET(priv->notebook), TRUE, TRUE, 0);
 720
 721   /* Add dialog buttons */
 722   gtk_dialog_add_button(GTK_DIALOG(fontseldiag),
 723                         _("ecdg_bd_font_dialog_ok"),
 724                         GTK_RESPONSE_OK);
 725
 726   preview_button = gtk_button_new_with_label(_("ecdg_bd_font_dialog_preview"));
 727   gtk_box_pack_start(GTK_BOX(GTK_DIALOG(fontseldiag)->action_area),
 728                      preview_button, FALSE, TRUE, 0);
 729   g_signal_connect_swapped(preview_button, "clicked",
 730                            G_CALLBACK
 731                            (hildon_font_selection_dialog_show_preview),
 732                            fontseldiag);
 733   gtk_widget_show(preview_button);
 734
 735   gtk_dialog_add_button(GTK_DIALOG(fontseldiag),
 736                         _("ecdg_bd_font_dialog_cancel"),
 737                         GTK_RESPONSE_CANCEL);
 738
 739   /*Set default preview text*/
 740   priv->preview_text = g_strdup(_("ecdg_fi_preview_font_preview_text"));
 741
 742   gtk_window_set_title(GTK_WINDOW(fontseldiag), _("ecdg_ti_font"));
 743   /*here is the line to make sure that notebook has the default focus*/
 744   gtk_container_set_focus_child(GTK_CONTAINER(GTK_DIALOG(fontseldiag)->vbox),
 745                                 GTK_WIDGET(priv->notebook));
 746 }
 747
 748 static void
 749 hildon_font_selection_dialog_construct_notebook (HildonFontSelectionDialog
 750                                                  *fontsel)
 751 {
 752   gint i;
 753   GtkWidget *vbox_tab[3];
 754   GtkWidget *font_color_box;
 755   GtkWidget *caption_control;
 756   GtkSizeGroup *group;
 757
 758   HildonFontSelectionDialogPrivate *priv =
 759     HILDON_FONT_SELECTION_DIALOG_GET_PRIVATE(fontsel);
 760
 761   for (i = 0; i < 3; i++)
 762     vbox_tab[i] = gtk_vbox_new(TRUE, 0);
 763
 764   group =
 765     GTK_SIZE_GROUP(gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL));
 766
 767   /* Build the first page of the GtkNotebook: font style */
 768   priv->cbx_font_type = gtk_combo_box_new_text();
 769   hildon_font_selection_dialog_show_available_fonts(fontsel);
 770   caption_control = hildon_caption_new(group,
 771                                        _("ecdg_fi_font_font"),
 772                                        priv->cbx_font_type,
 773                                        NULL,
 774                                        HILDON_CAPTION_OPTIONAL);
 775   gtk_box_pack_start(GTK_BOX(vbox_tab[0]), caption_control,
 776                      FALSE, FALSE, 0);
 777
 778   priv->cbx_font_size = gtk_combo_box_new_text();
 779   hildon_font_selection_dialog_show_available_sizes(priv);
 780   caption_control = hildon_caption_new(group,
 781                                        _("ecdg_fi_font_size"),
 782                                        priv->cbx_font_size,
 783                                        NULL,
 784                                        HILDON_CAPTION_OPTIONAL);
 785   gtk_box_pack_start(GTK_BOX(vbox_tab[0]), caption_control,
 786                      FALSE, FALSE, 0);
 787
 788   font_color_box = gtk_hbox_new(FALSE, 0);
 789   priv->font_color_button = hildon_color_button_new();
 790   priv->color_set = FALSE;
 791   priv->font_scaling = 1.0;
 792   priv->color_modified_signal_handler =
 793     g_signal_connect(G_OBJECT(priv->font_color_button), "notify::color",
 794                      G_CALLBACK(color_modified_cb), (gpointer) priv);
 795   gtk_box_pack_start(GTK_BOX(font_color_box),
 796                      priv->font_color_button, FALSE, FALSE, 0);
 797
 798   caption_control =
 799     hildon_caption_new(group, _("ecdg_fi_font_colour_selector"),
 800                        font_color_box,
 801                        NULL, HILDON_CAPTION_OPTIONAL);
 802
 803   gtk_box_pack_start(GTK_BOX(vbox_tab[0]), caption_control,
 804                      FALSE, FALSE, 0);
 805
 806   /* Build the second page of the GtkNotebook: font formatting */
 807   priv->chk_bold = gtk_check_button_new();
 808   caption_control = hildon_caption_new(group,
 809                                        _("ecdg_fi_font_bold"),
 810                                        priv->chk_bold,
 811                                        NULL,
 812                                        HILDON_CAPTION_OPTIONAL);
 813   gtk_box_pack_start(GTK_BOX(vbox_tab[1]), caption_control,
 814                      FALSE, FALSE, 0);
 815   g_signal_connect(G_OBJECT(priv->chk_bold), "clicked",
 816                    G_CALLBACK(toggle_clicked), NULL);
 817
 818   priv->chk_italic = gtk_check_button_new();
 819   caption_control =
 820     hildon_caption_new(group, _("ecdg_fi_font_italic"),
 821                        priv->chk_italic,
 822                        NULL, HILDON_CAPTION_OPTIONAL);
 823   gtk_box_pack_start(GTK_BOX(vbox_tab[1]), caption_control,
 824                      FALSE, FALSE, 0);
 825   g_signal_connect(G_OBJECT(priv->chk_italic), "clicked",
 826                    G_CALLBACK(toggle_clicked), NULL);
 827
 828   priv->chk_underline = gtk_check_button_new();
 829   caption_control =
 830     hildon_caption_new(group, _("ecdg_fi_font_underline"),
 831                        priv->chk_underline, NULL,
 832                        HILDON_CAPTION_OPTIONAL);
 833   gtk_box_pack_start(GTK_BOX(vbox_tab[1]), caption_control,
 834                      FALSE, FALSE, 0);
 835   g_signal_connect(G_OBJECT(priv->chk_underline), "clicked",
 836                    G_CALLBACK(toggle_clicked), NULL);
 837
 838   /* Build the third page of the GtkNotebook: other font properties */
 839   priv->chk_strikethrough = gtk_check_button_new();
 840   caption_control =
 841     hildon_caption_new(group, _("ecdg_fi_font_strikethrough"),
 842                        priv->chk_strikethrough, NULL,
 843                        HILDON_CAPTION_OPTIONAL);
 844   gtk_box_pack_start(GTK_BOX(vbox_tab[2]), caption_control,
 845                      FALSE, FALSE, 0);
 846   g_signal_connect(G_OBJECT(priv->chk_strikethrough), "clicked",
 847                    G_CALLBACK(toggle_clicked), NULL);
 848
 849   priv->cbx_positioning = gtk_combo_box_new_text();
 850   hildon_font_selection_dialog_show_available_positionings(priv);
 851   caption_control =
 852     hildon_caption_new(group, _("ecdg_fi_font_special"),
 853                        priv->cbx_positioning, NULL,
 854                        HILDON_CAPTION_OPTIONAL);
 855   gtk_box_pack_start(GTK_BOX(vbox_tab[2]), caption_control,
 856                      FALSE, FALSE, 0);
 857
 858   /* Populate notebook */
 859   gtk_notebook_insert_page(priv->notebook, vbox_tab[0], NULL, 0);
 860   gtk_notebook_insert_page(priv->notebook, vbox_tab[1], NULL, 1);
 861   gtk_notebook_insert_page(priv->notebook, vbox_tab[2], NULL, 2);
 862   gtk_notebook_set_tab_label_text(priv->notebook, vbox_tab[0],
 863                                   _("ecdg_ti_font_dialog_style"));
 864   gtk_notebook_set_tab_label_text(priv->notebook, vbox_tab[1],
 865                                   _("ecdg_ti_font_dialog_format"));
 866   gtk_notebook_set_tab_label_text(priv->notebook, vbox_tab[2],
 867                                   _("ecdg_ti_font_dialog_other"));
 868
 869   gtk_widget_show_all(GTK_WIDGET(priv->notebook));
 870 }
 871
 872 static void
 873 color_modified_cb(HildonColorButton *button,
 874                   GParamSpec *pspec,
 875                   gpointer fsd_priv)
 876 {
 877   HildonFontSelectionDialogPrivate *priv =
 878           (HildonFontSelectionDialogPrivate *) fsd_priv;
 879
 880   priv->color_set = TRUE;
 881 }
 882
 883 static void
 884 hildon_font_selection_dialog_finalize(GObject * object)
 885 {
 886   HildonFontSelectionDialogPrivate *priv;
 887   HildonFontSelectionDialog *fontsel;
 888
 889   g_assert(HILDON_IS_FONT_SELECTION_DIALOG(object));
 890   fontsel = HILDON_FONT_SELECTION_DIALOG(object);
 891
 892   priv = HILDON_FONT_SELECTION_DIALOG_GET_PRIVATE(fontsel);
 893
 894   g_free(priv->preview_text);
 895   g_free(priv->families);
 896
 897   if (G_OBJECT_CLASS(font_selection_dialog_parent_class)->finalize)
 898     G_OBJECT_CLASS(font_selection_dialog_parent_class)->finalize(object);
 899 }
 900
 901 static int
 902 cmp_families(const void *a, const void *b)
 903 {
 904   const char *a_name =
 905     pango_font_family_get_name(*(PangoFontFamily **) a);
 906   const char *b_name =
 907     pango_font_family_get_name(*(PangoFontFamily **) b);
 908
 909   return g_utf8_collate(a_name, b_name);
 910 }
 911
 912 /* Exits the preview dialog with GTK_RESPONSE_CANCEL if Esc key
 913  * was pressed */
 914 static gboolean
 915 hildon_font_selection_dialog_preview_key_press(GtkWidget   * widget,
 916                                                GdkEventKey * event,
 917                                                gpointer      unused)
 918 {
 919   g_assert(widget);
 920   g_assert(event);
 921
 922   if (event->keyval == GDK_Escape)
 923     {
 924       gtk_dialog_response(GTK_DIALOG(widget), GTK_RESPONSE_CANCEL);
 925       return TRUE;
 926     }
 927
 928   return FALSE;
 929 }
 930
 931 static void
 932 add_preview_text_attr(PangoAttrList *list, PangoAttribute *attr,
 933                       guint start, guint len)
 934 {
 935   attr->start_index = start;
 936   attr->end_index = start + len;
 937   pango_attr_list_insert(list, attr);
 938 }
 939
 940 static PangoAttrList*
 941 hildon_font_selection_dialog_create_attrlist(HildonFontSelectionDialog *
 942                                          fontsel, guint start_index, guint len)
 943 {
 944   PangoAttrList *list;
 945   PangoAttribute *attr;
 946   gint size, position;
 947   gboolean family_set, size_set, color_set, bold, bold_set,
 948            italic, italic_set, underline, underline_set,
 949            strikethrough, strikethrough_set, position_set;
 950   GdkColor *color = NULL;
 951   gchar *family = NULL;
 952   gdouble font_scaling = 1.0;
 953
 954   list = pango_attr_list_new();
 955
 956   g_object_get(G_OBJECT(fontsel),
 957                "family", &family, "family-set", &family_set,
 958                "size", &size, "size-set", &size_set,
 959                "color", &color, "color-set", &color_set,
 960                "bold", &bold, "bold-set", &bold_set,
 961                "italic", &italic, "italic-set", &italic_set,
 962                "underline", &underline, "underline-set", &underline_set,
 963                "strikethrough", &strikethrough, "strikethrough-set",
 964                &strikethrough_set, "position", &position,
 965                "position-set", &position_set,
 966                "font-scaling", &font_scaling,
 967                NULL);
 968
 969   /*family*/
 970   if(family_set)
 971     {
 972       attr = pango_attr_family_new(family);
 973       add_preview_text_attr(list, attr, start_index, len);
 974     }
 975   g_free(family);
 976
 977   /*size*/
 978   if(size_set)
 979     {
 980       attr = pango_attr_size_new(size * PANGO_SCALE);
 981       add_preview_text_attr(list, attr, start_index, len);
 982     }
 983
 984   /*color*/
 985   if(color_set)
 986     {
 987       attr = pango_attr_foreground_new(color->red, color->green, color->blue);
 988       add_preview_text_attr(list, attr, start_index, len);
 989     }
 990
 991   if(color != NULL)
 992     gdk_color_free(color);
 993
 994   /*weight*/
 995   if(bold_set)
 996     {
 997       if(bold)
 998         attr = pango_attr_weight_new(PANGO_WEIGHT_BOLD);
 999       else
1000         attr = pango_attr_weight_new(PANGO_WEIGHT_NORMAL);
1001
1002       add_preview_text_attr(list, attr, start_index, len);
1003     }
1004
1005   /*style*/
1006   if(italic_set)
1007     {
1008       if(italic)
1009         attr = pango_attr_style_new(PANGO_STYLE_ITALIC);
1010       else
1011         attr = pango_attr_style_new(PANGO_STYLE_NORMAL);
1012
1013       add_preview_text_attr(list, attr, start_index, len);
1014     }
1015
1016   /*underline*/
1017   if(underline_set)
1018     {
1019       if(underline)
1020         attr = pango_attr_underline_new(PANGO_UNDERLINE_SINGLE);
1021       else
1022         attr = pango_attr_underline_new(PANGO_UNDERLINE_NONE);
1023
1024       add_preview_text_attr(list, attr, start_index, len);
1025     }
1026
1027   /*strikethrough*/
1028   if(strikethrough_set)
1029     {
1030       if(strikethrough)
1031         attr = pango_attr_strikethrough_new(TRUE);
1032       else
1033         attr = pango_attr_strikethrough_new(FALSE);
1034
1035       add_preview_text_attr(list, attr, start_index, len);
1036     }
1037
1038   /*position*/
1039   if(position_set)
1040     {
1041       switch(position)
1042         {
1043         case 1: /*super*/
1044           attr = pango_attr_rise_new(SUPERSCRIPT_RISE);
1045           break;
1046         case -1: /*sub*/
1047           attr = pango_attr_rise_new(SUBSCRIPT_LOW);
1048           break;
1049         default: /*normal*/
1050           attr = pango_attr_rise_new(0);
1051           break;
1052         }
1053
1054       add_preview_text_attr(list, attr, start_index, len);
1055     }
1056
1057   /*font scaling for preview*/
1058   if(font_scaling)
1059     {
1060       attr = pango_attr_scale_new(font_scaling);
1061       add_preview_text_attr(list, attr, 0, len + start_index);
1062     }
1063
1064   return list;
1065 }
1066
1067 static void
1068 hildon_font_selection_dialog_show_preview(HildonFontSelectionDialog *
1069                                           fontsel)
1070 {
1071   HildonFontSelectionDialogPrivate *priv =
1072     HILDON_FONT_SELECTION_DIALOG_GET_PRIVATE(fontsel);
1073   gint size;
1074   gboolean family_set, size_set;
1075   PangoAttribute *attr;
1076   PangoAttrList *list;
1077   GtkWidget *preview_dialog;
1078   GtkWidget *preview_label;
1079   gchar *str = NULL;
1080   gboolean position_set = FALSE;
1081   gint position = 0;
1082   gboolean show_ref = FALSE;
1083
1084   g_object_get(G_OBJECT(fontsel), "position-set", &position_set, NULL);
1085   if (position_set) {
1086     g_object_get(G_OBJECT(fontsel), "position", &position, NULL);
1087     if (position == 1 || position == -1)
1088       show_ref = TRUE;
1089   }
1090
1091   /*Preview dialog init*/
1092   preview_dialog=
1093     gtk_dialog_new_with_buttons(_("ecdg_ti_preview_font"), NULL,
1094                                 GTK_DIALOG_MODAL |
1095                                 GTK_DIALOG_DESTROY_WITH_PARENT |
1096                                 GTK_DIALOG_NO_SEPARATOR,
1097                                 _("ecdg_bd_font_dialog_ok"),
1098                                 GTK_RESPONSE_ACCEPT,
1099                                 NULL);
1100
1101   str = (show_ref) ? g_strconcat(_("ecdg_fi_preview_font_preview_reference"), priv->preview_text, 0) :
1102                      g_strdup (priv->preview_text);
1103
1104   preview_label = gtk_label_new(str);
1105   gtk_label_set_line_wrap(GTK_LABEL(preview_label), TRUE);
1106
1107   g_free(str);
1108   str = NULL;
1109
1110   gtk_container_add(GTK_CONTAINER(GTK_DIALOG(preview_dialog)->vbox),
1111                     preview_label);
1112
1113
1114   /* set keypress handler (ESC hardkey) */
1115   g_signal_connect(G_OBJECT(preview_dialog), "key-press-event",
1116                   G_CALLBACK(hildon_font_selection_dialog_preview_key_press),
1117                   NULL);
1118
1119
1120   /*Set the font*/
1121   list = (show_ref) ? hildon_font_selection_dialog_create_attrlist(fontsel,
1122       strlen(_("ecdg_fi_preview_font_preview_reference")),
1123       strlen(priv->preview_text)) :
1124       hildon_font_selection_dialog_create_attrlist(fontsel,
1125       0,
1126       strlen(priv->preview_text));
1127
1128   g_object_get(G_OBJECT(fontsel), "family", &str, "family-set",
1129                &family_set, "size", &size, "size-set", &size_set,
1130                NULL);
1131
1132   /* FIXME: This is a slightly ugly hack to force the width of the window so that
1133    * the whole text fits with various font sizes. It's being done in such a way,
1134    * because of some GtkLabel wrapping issues and other mysterious bugs related to
1135    * truncating ellipsizing. Needs a rethink in future. (MDK) */
1136
1137   gint dialog_width = (size_set && size > 24) ? 600 : 500;
1138   gtk_window_set_default_size (GTK_WINDOW(preview_dialog), dialog_width, -1);
1139
1140   /*make reference text to have the same fontface and size*/
1141   if(family_set)
1142     {
1143       attr = pango_attr_family_new(str);
1144       add_preview_text_attr(list, attr, 0, strlen(_("ecdg_fi_preview_font_preview_reference")));
1145     }
1146   g_free(str);
1147
1148   /*size*/
1149   if(size_set)
1150     {
1151       attr = pango_attr_size_new(size * PANGO_SCALE);
1152       add_preview_text_attr(list, attr, 0, strlen(_("ecdg_fi_preview_font_preview_reference")));
1153     }
1154
1155   gtk_label_set_attributes(GTK_LABEL(preview_label), list);
1156   pango_attr_list_unref(list);
1157
1158   /*And show the dialog*/
1159   gtk_window_set_transient_for(GTK_WINDOW(preview_dialog),
1160                                GTK_WINDOW(fontsel));
1161
1162   gtk_widget_show_all(preview_dialog);
1163   gtk_dialog_run(GTK_DIALOG(preview_dialog));
1164   gtk_widget_destroy(preview_dialog);
1165 }
1166
1167
1168 static gboolean is_internal_font(const gchar * name){
1169   return strcmp(name, "DeviceSymbols") == 0
1170       || strcmp(name, "Nokia Smiley" ) == 0
1171       || strcmp(name, "NewCourier" ) == 0
1172       || strcmp(name, "NewTimes" ) == 0
1173       || strcmp(name, "SwissA" ) == 0
1174       || strcmp(name, "Nokia Sans"   ) == 0
1175       || strcmp(name, "Nokia Sans Cn") == 0;
1176 }
1177
1178 static void filter_out_internal_fonts(PangoFontFamily **families, int *n_families){
1179   int i;
1180   int n; /* counts valid fonts */
1181   const gchar * name = NULL;
1182
1183   for(i = 0, n = 0; i < *n_families; i++){
1184
1185     name = pango_font_family_get_name(families[i]);
1186
1187     if(!is_internal_font(name)){
1188
1189       if(i!=n){ /* there are filtered out families */
1190         families[n] = families[i]; /* shift the current family */
1191       }
1192
1193       n++; /* count one more valid */
1194     }
1195   }/* foreach font family */
1196
1197   *n_families = n;
1198 }
1199
1200
1201 static void
1202 hildon_font_selection_dialog_show_available_fonts(HildonFontSelectionDialog
1203                                                   *fontsel)
1204
1205 {
1206   gint i;
1207
1208   HildonFontSelectionDialogPrivate *priv =
1209     HILDON_FONT_SELECTION_DIALOG_GET_PRIVATE(fontsel);
1210
1211   pango_context_list_families(gtk_widget_get_pango_context
1212                               (GTK_WIDGET(fontsel)), &priv->families,
1213                               &priv->n_families);
1214
1215   filter_out_internal_fonts(priv->families, &priv->n_families);
1216
1217   qsort(priv->families, priv->n_families, sizeof(PangoFontFamily *),
1218         cmp_families);
1219
1220
1221   for (i = 0; i < priv->n_families; i++)
1222     {
1223       const gchar *name = pango_font_family_get_name(priv->families[i]);
1224
1225       gtk_combo_box_append_text(GTK_COMBO_BOX(priv->cbx_font_type),
1226                                 name);
1227     }
1228 }
1229
1230
1231 static void
1232 hildon_font_selection_dialog_show_available_positionings
1233                                              (HildonFontSelectionDialogPrivate
1234                                               *priv)
1235 {
1236   gtk_combo_box_append_text(GTK_COMBO_BOX(priv->cbx_positioning),
1237                             _("ecdg_va_font_printpos_1"));
1238   gtk_combo_box_append_text(GTK_COMBO_BOX(priv->cbx_positioning),
1239                             _("ecdg_va_font_printpos_2"));
1240   gtk_combo_box_append_text(GTK_COMBO_BOX(priv->cbx_positioning),
1241                             _("ecdg_va_font_printpos_3"));
1242 }
1243
1244 /*Loads the sizes from a pre-allocated table*/
1245 static void
1246 hildon_font_selection_dialog_show_available_sizes
1247                                              (HildonFontSelectionDialogPrivate
1248                                               *priv)
1249 {
1250   gchar *size_str;
1251   gint i;
1252
1253   for (i = 0; i < G_N_ELEMENTS(font_sizes); i++)
1254     {
1255       size_str = g_strdup_printf ("%i%s",
1256                                   font_sizes[i],
1257                                   _("ecdg_va_font_size_trailer"));
1258
1259       gtk_combo_box_append_text(GTK_COMBO_BOX(priv->cbx_font_size),
1260                                 size_str);
1261       g_free (size_str);
1262     }
1263 }
1264
1265 static void
1266 toggle_clicked(GtkButton *button, gpointer unused)
1267 {
1268   GtkToggleButton *t_b = GTK_TOGGLE_BUTTON(button);
1269
1270   /*we have to remove the inconsistent state ourselves*/
1271   if(gtk_toggle_button_get_inconsistent(t_b))
1272     {
1273       gtk_toggle_button_set_inconsistent(t_b, FALSE);
1274       gtk_toggle_button_set_active(t_b, FALSE);
1275     }
1276 }
1277
1278 /*******************/
1279 /*Public functions*/
1280 /*******************/
1281
1282 /**
1283  * hildon_font_selection_dialog_new:
1284  * @parent: the parent window
1285  * @title: the title of font selection dialog
1286  *
1287  * If NULL is passed for title, then default title
1288  * "Font" will be used.
1289  *
1290  * Returns: a new #HildonFontSelectionDialog
1291  */
1292 GtkWidget *
1293 hildon_font_selection_dialog_new(GtkWindow * parent,
1294                                  const gchar * title)
1295 {
1296   HildonFontSelectionDialog *fontseldiag;
1297
1298   fontseldiag = g_object_new(HILDON_TYPE_FONT_SELECTION_DIALOG,
1299                              "has-separator", FALSE, NULL);
1300
1301   if (title)
1302     gtk_window_set_title(GTK_WINDOW(fontseldiag), title);
1303
1304   if (parent)
1305     gtk_window_set_transient_for(GTK_WINDOW(fontseldiag), parent);
1306
1307   return GTK_WIDGET(fontseldiag);
1308 }
1309
1310 /**
1311  * hildon_font_selection_dialog_get_preview_text:
1312  * @fsd: the font selection dialog
1313  *
1314  * Gets the text in preview dialog, which does not include the
1315  * reference text. The returned string must be freed by the user.
1316  *
1317  * Returns: a string pointer
1318  */
1319 gchar *
1320 hildon_font_selection_dialog_get_preview_text(HildonFontSelectionDialog * fsd)
1321 {
1322   HildonFontSelectionDialogPrivate *priv;
1323
1324   g_return_val_if_fail(HILDON_IS_FONT_SELECTION_DIALOG(fsd), FALSE);
1325   priv = HILDON_FONT_SELECTION_DIALOG_GET_PRIVATE(fsd);
1326   return g_strdup(priv->preview_text);
1327 }
1328
1329 /**
1330  * hildon_font_selection_dialog_set_preview_text:
1331  * @fsd: the font selection dialog
1332  * @text: the text to be displayed in the preview dialog
1333  *
1334  * The default preview text is
1335  * "The quick brown fox jumped over the lazy dogs"
1336  */
1337 void
1338 hildon_font_selection_dialog_set_preview_text(HildonFontSelectionDialog *
1339                                               fsd, const gchar * text)
1340 {
1341    HildonFontSelectionDialogPrivate *priv = NULL;
1342
1343    g_return_if_fail(HILDON_IS_FONT_SELECTION_DIALOG(fsd));
1344    g_return_if_fail(text);
1345
1346    priv = HILDON_FONT_SELECTION_DIALOG_GET_PRIVATE(fsd);
1347
1348    g_free(priv->preview_text);
1349    priv->preview_text = g_strdup(text);
1350    g_object_notify (G_OBJECT (fsd), "preview-text");
1351 }