Pileus Git - ~andy/gtk/blob - gtk/gtkfontchooser.c

   1 /* GTK - The GIMP Toolkit
   2  * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
   3  *
   4  * Massively updated for Pango by Owen Taylor, May 2000
   5  * GtkFontSelection widget for Gtk+, by Damon Chaplin, May 1998.
   6  * Based on the GnomeFontSelector widget, by Elliot Lee, but major changes.
   7  * The GnomeFontSelector was derived from app/text_tool.c in the GIMP.
   8  *
   9  * This library is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Lesser General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2 of the License, or (at your option) any later version.
  13  *
  14  * This library is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public
  20  * License along with this library; if not, write to the
  21  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  22  * Boston, MA 02111-1307, USA.
  23  */
  24
  25 /*
  26  * Modified by the GTK+ Team and others 1997-2000.  See the AUTHORS
  27  * file for a list of people on the GTK+ Team.  See the ChangeLog
  28  * files for a list of changes.  These files are distributed with
  29  * GTK+ at ftp://ftp.gtk.org/pub/gtk/.
  30  */
  31
  32 #include "config.h"
  33
  34 #include <stdlib.h>
  35 #include <glib/gprintf.h>
  36 #include <string.h>
  37
  38 #include <atk/atk.h>
  39
  40 #include "gtkfontsel.h"
  41 #include "gtkbutton.h"
  42 #include "gtkcellrenderertext.h"
  43 #include "gtkentry.h"
  44 #include "gtkframe.h"
  45 #include "gtkhbbox.h"
  46 #include "gtkhbox.h"
  47 #include "gtklabel.h"
  48 #include "gtkliststore.h"
  49 #include "gtkrc.h"
  50 #include "gtkstock.h"
  51 #include "gtktable.h"
  52 #include "gtktreeselection.h"
  53 #include "gtktreeview.h"
  54 #include "gtkvbox.h"
  55 #include "gtkscrolledwindow.h"
  56 #include "gtkintl.h"
  57 #include "gtkaccessible.h"
  58 #include "gtkbuildable.h"
  59 #include "gtkprivate.h"
  60
  61
  62 /**
  63  * SECTION:gtkfontsel
  64  * @Short_description: A widget for selecting fonts
  65  * @Title: GtkFontSelection
  66  * @See_also: #GtkFontSelectionDialog
  67  *
  68  * The #GtkFontSelection widget lists the available fonts, styles and sizes,
  69  * allowing the user to select a font.
  70  * It is used in the #GtkFontSelectionDialog widget to provide a dialog box for
  71  * selecting fonts.
  72  *
  73  * To set the font which is initially selected, use
  74  * gtk_font_selection_set_font_name().
  75  *
  76  * To get the selected font use gtk_font_selection_get_font_name().
  77  *
  78  * To change the text which is shown in the preview area, use
  79  * gtk_font_selection_set_preview_text().
  80  */
  81
  82
  83 struct _GtkFontSelectionPrivate
  84 {
  85   GtkWidget *search_entry;
  86   GtkWidget *family_face_list;
  87   GtkWidget *size_slider;
  88   GtkWidget *size_spin;
  89
  90   gint             size;
  91   PangoFontFace   *face;
  92   PangoFontFamily *family;
  93 };
  94
  95
  96 struct _GtkFontSelectionDialogPrivate
  97 {
  98   GtkWidget *fontsel;
  99
 100   GtkWidget *ok_button;
 101   GtkWidget *apply_button;
 102   GtkWidget *cancel_button;
 103 };
 104
 105
 106 /* We don't enable the font and style entries because they don't add
 107  * much in terms of visible effect and have a weird effect on keynav.
 108  * the Windows font selector has entries similarly positioned but they
 109  * act in conjunction with the associated lists to form a single focus
 110  * location.
 111  */
 112 #undef INCLUDE_FONT_ENTRIES
 113
 114 /* This is the default text shown in the preview entry, though the user
 115    can set it. Remember that some fonts only have capital letters. */
 116 #define PREVIEW_TEXT N_("abcdefghijk ABCDEFGHIJK")
 117
 118 #define DEFAULT_FONT_NAME "Sans 10"
 119
 120 /* This is the initial and maximum height of the preview entry (it expands
 121    when large font sizes are selected). Initial height is also the minimum. */
 122 #define INITIAL_PREVIEW_HEIGHT 44
 123 #define MAX_PREVIEW_HEIGHT 300
 124
 125 /* These are the sizes of the font, style & size lists. */
 126 #define FONT_LIST_HEIGHT        136
 127 #define FONT_LIST_WIDTH         190
 128 #define FONT_STYLE_LIST_WIDTH   170
 129 #define FONT_SIZE_LIST_WIDTH    60
 130
 131 /* These are what we use as the standard font sizes, for the size list.
 132  */
 133 static const guint16 font_sizes[] = {
 134   6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 20, 22, 24, 26, 28,
 135   32, 36, 40, 48, 56, 64, 72
 136 };
 137
 138 enum {
 139    PROP_0,
 140    PROP_FONT_NAME,
 141    PROP_PREVIEW_TEXT
 142 };
 143
 144
 145 enum {
 146   FAMILY_COLUMN,
 147   FAMILY_NAME_COLUMN
 148 };
 149
 150 enum {
 151   FACE_COLUMN,
 152   FACE_NAME_COLUMN
 153 };
 154
 155 enum {
 156   SIZE_COLUMN
 157 };
 158
 159 static void    gtk_font_selection_set_property       (GObject         *object,
 160                                                       guint            prop_id,
 161                                                       const GValue    *value,
 162                                                       GParamSpec      *pspec);
 163 static void    gtk_font_selection_get_property       (GObject         *object,
 164                                                       guint            prop_id,
 165                                                       GValue          *value,
 166                                                       GParamSpec      *pspec);
 167 static void    gtk_font_selection_finalize           (GObject         *object);
 168 static void    gtk_font_selection_screen_changed     (GtkWidget       *widget,
 169                                                       GdkScreen       *previous_screen);
 170 static void    gtk_font_selection_style_updated      (GtkWidget      *widget);
 171
 172 static void     gtk_font_selection_ref_family            (GtkFontSelection *fontsel,
 173                                                           PangoFontFamily  *family);
 174 static void     gtk_font_selection_ref_face              (GtkFontSelection *fontsel,
 175                                                           PangoFontFace    *face);
 176
 177 G_DEFINE_TYPE (GtkFontSelection, gtk_font_selection, GTK_TYPE_VBOX)
 178
 179 static void
 180 gtk_font_selection_class_init (GtkFontSelectionClass *klass)
 181 {
 182   GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
 183   GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
 184
 185   gobject_class->finalize = gtk_font_selection_finalize;
 186   gobject_class->set_property = gtk_font_selection_set_property;
 187   gobject_class->get_property = gtk_font_selection_get_property;
 188
 189   widget_class->screen_changed = gtk_font_selection_screen_changed;
 190   widget_class->style_updated = gtk_font_selection_style_updated;
 191
 192   g_object_class_install_property (gobject_class,
 193                                    PROP_FONT_NAME,
 194                                    g_param_spec_string ("font-name",
 195                                                         P_("Font name"),
 196                                                         P_("The string that represents this font"),
 197                                                         DEFAULT_FONT_NAME,
 198                                                         GTK_PARAM_READWRITE));
 199   g_object_class_install_property (gobject_class,
 200                                    PROP_PREVIEW_TEXT,
 201                                    g_param_spec_string ("preview-text",
 202                                                         P_("Preview text"),
 203                                                         P_("The text to display in order to demonstrate the selected font"),
 204                                                         _(PREVIEW_TEXT),
 205                                                         GTK_PARAM_READWRITE));
 206
 207   g_type_class_add_private (klass, sizeof (GtkFontSelectionPrivate));
 208 }
 209
 210 static void
 211 gtk_font_selection_set_property (GObject         *object,
 212                                  guint            prop_id,
 213                                  const GValue    *value,
 214                                  GParamSpec      *pspec)
 215 {
 216   GtkFontSelection *fontsel;
 217
 218   fontsel = GTK_FONT_SELECTION (object);
 219
 220   switch (prop_id)
 221     {
 222     case PROP_FONT_NAME:
 223       gtk_font_selection_set_font_name (fontsel, g_value_get_string (value));
 224       break;
 225     case PROP_PREVIEW_TEXT:
 226       gtk_font_selection_set_preview_text (fontsel, g_value_get_string (value));
 227       break;
 228     default:
 229       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 230       break;
 231     }
 232 }
 233
 234 static void gtk_font_selection_get_property (GObject         *object,
 235                                              guint            prop_id,
 236                                              GValue          *value,
 237                                              GParamSpec      *pspec)
 238 {
 239   GtkFontSelection *fontsel;
 240
 241   fontsel = GTK_FONT_SELECTION (object);
 242
 243   switch (prop_id)
 244     {
 245     case PROP_FONT_NAME:
 246       g_value_take_string (value, gtk_font_selection_get_font_name (fontsel));
 247       break;
 248     case PROP_PREVIEW_TEXT:
 249       g_value_set_string (value, gtk_font_selection_get_preview_text (fontsel));
 250       break;
 251     default:
 252       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 253       break;
 254     }
 255 }
 256
 257 /* Handles key press events on the lists, so that we can trap Enter to
 258  * activate the default button on our own.
 259  */
 260 static gboolean
 261 list_row_activated (GtkWidget *widget)
 262 {
 263   GtkWidget *default_widget, *focus_widget;
 264   GtkWindow *window;
 265
 266   window = GTK_WINDOW (gtk_widget_get_toplevel (GTK_WIDGET (widget)));
 267   if (!gtk_widget_is_toplevel (GTK_WIDGET (window)))
 268     window = NULL;
 269
 270   if (window)
 271     {
 272       default_widget = gtk_window_get_default_widget (window);
 273       focus_widget = gtk_window_get_focus (window);
 274
 275       if (widget != default_widget &&
 276           !(widget == focus_widget && (!default_widget || !gtk_widget_get_sensitive (default_widget))))
 277         gtk_window_activate_default (window);
 278     }
 279
 280   return TRUE;
 281 }
 282
 283 static void
 284 gtk_font_selection_init (GtkFontSelection *fontsel)
 285 {
 286   GtkFontSelectionPrivate *priv;
 287   GtkWidget *scrolled_win;
 288   GtkWidget *text_box;
 289   GtkWidget *table, *label;
 290   GtkWidget *font_label, *style_label;
 291   GtkWidget *vbox;
 292   GtkListStore *model;
 293   GtkTreeViewColumn *column;
 294   GList *focus_chain = NULL;
 295   AtkObject *atk_obj;
 296
 297   fontsel->priv = G_TYPE_INSTANCE_GET_PRIVATE (fontsel,
 298                                                GTK_TYPE_FONT_SELECTION,
 299                                                GtkFontSelectionPrivate);
 300   priv = fontsel->priv;
 301   gtk_widget_push_composite_child ();
 302
 303   priv->search_entry = gtk_entry_new ();
 304   priv->family_face_list = gtk_tree_view_new ();
 305   priv->size_slider = gtk_scale_new_with_range (GTK_ORIENTATION_HORIZONTAL,
 306                                                 font_sizes[0],
 307                                                 font_sizes[(sizeof (font_sizes) /
 308                                                             sizeof (guint16)) - 1],
 309                                                 1);
 310   priv->size_spin = gtk_spin_button_new_with_range (font_sizes[0],
 311                                                 font_sizes[(sizeof (font_sizes) /
 312                                                             sizeof (guint16)) - 1],
 313                                                 1);
 314
 315   gtk_box_pack_start (GTK_BOX (fontsel), priv->search_entry, FALSE, TRUE, 0);
 316
 317   priv->size = 12 * PANGO_SCALE;
 318   priv->face = NULL;
 319   priv->family = NULL;
 320
 321   gtk_widget_show_all (GTK_WIDGET (fontsel));
 322   gtk_widget_hide (GTK_WIDGET (fontsel));
 323
 324   gtk_widget_pop_composite_child();
 325 }
 326
 327 /**
 328  * gtk_font_selection_new:
 329  *
 330  * Creates a new #GtkFontSelection.
 331  *
 332  * Return value: a n ew #GtkFontSelection
 333  */
 334 GtkWidget *
 335 gtk_font_selection_new (void)
 336 {
 337   GtkFontSelection *fontsel;
 338
 339   fontsel = g_object_new (GTK_TYPE_FONT_SELECTION, NULL);
 340
 341   return GTK_WIDGET (fontsel);
 342 }
 343
 344 static void
 345 gtk_font_selection_finalize (GObject *object)
 346 {
 347   GtkFontSelection *fontsel = GTK_FONT_SELECTION (object);
 348
 349   gtk_font_selection_ref_family (fontsel, NULL);
 350   gtk_font_selection_ref_face (fontsel, NULL);
 351
 352   G_OBJECT_CLASS (gtk_font_selection_parent_class)->finalize (object);
 353 }
 354
 355 static void
 356 gtk_font_selection_screen_changed (GtkWidget *widget,
 357                                   GdkScreen *previous_screen)
 358 {
 359   return;
 360 }
 361
 362 static void
 363 gtk_font_selection_style_updated (GtkWidget *widget)
 364 {
 365   GTK_WIDGET_CLASS (gtk_font_selection_parent_class)->style_updated (widget);
 366
 367   return;
 368 }
 369
 370 static void
 371 gtk_font_selection_ref_family (GtkFontSelection *fontsel,
 372                               PangoFontFamily  *family)
 373 {
 374   GtkFontSelectionPrivate *priv = fontsel->priv;
 375 #if 0
 376   if (family)
 377     family = g_object_ref (family);
 378   if (priv->family)
 379     g_object_unref (priv->family);
 380   priv->family = family;
 381 #endif
 382 }
 383
 384 static void
 385 gtk_font_selection_ref_face (GtkFontSelection *fontsel,
 386                                         PangoFontFace    *face)
 387 {
 388   GtkFontSelectionPrivate *priv = fontsel->priv;
 389 #if 0
 390   if (face)
 391     face = g_object_ref (face);
 392   if (priv->face)
 393     g_object_unref (priv->face);
 394   priv->face = face;
 395 #endif
 396 }
 397
 398 /*****************************************************************************
 399  * These functions are the main public interface for getting/setting the font.
 400  *****************************************************************************/
 401
 402 /**
 403  * gtk_font_selection_get_family_list:
 404  * @fontsel: a #GtkFontSelection
 405  *
 406  * This returns the #GtkTreeView that lists font families, for
 407  * example, 'Sans', 'Serif', etc.
 408  *
 409  * Return value: (transfer none): A #GtkWidget that is part of @fontsel
 410  *
 411  * Deprecated: 3.2
 412  */
 413 GtkWidget *
 414 gtk_font_selection_get_family_list (GtkFontSelection *fontsel)
 415 {
 416   g_return_val_if_fail (GTK_IS_FONT_SELECTION (fontsel), NULL);
 417
 418   return NULL;
 419 }
 420
 421 /**
 422  * gtk_font_selection_get_face_list:
 423  * @fontsel: a #GtkFontSelection
 424  *
 425  * This returns the #GtkTreeView which lists all styles available for
 426  * the selected font. For example, 'Regular', 'Bold', etc.
 427  *
 428  * Return value: (transfer none): A #GtkWidget that is part of @fontsel
 429  *
 430  * Deprecated: 3.2
 431  */
 432 GtkWidget *
 433 gtk_font_selection_get_face_list (GtkFontSelection *fontsel)
 434 {
 435   g_return_val_if_fail (GTK_IS_FONT_SELECTION (fontsel), NULL);
 436
 437   return NULL;
 438 }
 439
 440 /**
 441  * gtk_font_selection_get_size_entry:
 442  * @fontsel: a #GtkFontSelection
 443  *
 444  * This returns the #GtkEntry used to allow the user to edit the font
 445  * number manually instead of selecting it from the list of font sizes.
 446  *
 447  * Return value: (transfer none): A #GtkWidget that is part of @fontsel
 448  *
 449  * Deprecated: 3.2
 450  */
 451 GtkWidget *
 452 gtk_font_selection_get_size_entry (GtkFontSelection *fontsel)
 453 {
 454   g_return_val_if_fail (GTK_IS_FONT_SELECTION (fontsel), NULL);
 455
 456   return NULL;
 457 }
 458
 459 /**
 460  * gtk_font_selection_get_size_list:
 461  * @fontsel: a #GtkFontSelection
 462  *
 463  * This returns the #GtkTreeeView used to list font sizes.
 464  *
 465  * Return value: (transfer none): A #GtkWidget that is part of @fontsel
 466  *
 467  * Deprecated: 3.2
 468  */
 469 GtkWidget *
 470 gtk_font_selection_get_size_list (GtkFontSelection *fontsel)
 471 {
 472   g_return_val_if_fail (GTK_IS_FONT_SELECTION (fontsel), NULL);
 473
 474   return NULL;
 475 }
 476
 477 /**
 478  * gtk_font_selection_get_preview_entry:
 479  * @fontsel: a #GtkFontSelection
 480  *
 481  * This returns the #GtkEntry used to display the font as a preview.
 482  *
 483  * Return value: (transfer none): A #GtkWidget that is part of @fontsel
 484  *
 485  * Deprecated: 3.2
 486  */
 487 GtkWidget *
 488 gtk_font_selection_get_preview_entry (GtkFontSelection *fontsel)
 489 {
 490   g_return_val_if_fail (GTK_IS_FONT_SELECTION (fontsel), NULL);
 491
 492   return NULL;
 493 }
 494
 495 /**
 496  * gtk_font_selection_get_family:
 497  * @fontsel: a #GtkFontSelection
 498  *
 499  * Gets the #PangoFontFamily representing the selected font family.
 500  *
 501  * Return value: (transfer none): A #PangoFontFamily representing the
 502  *     selected font family. Font families are a collection of font
 503  *     faces. The returned object is owned by @fontsel and must not
 504  *     be modified or freed.
 505  *
 506  * Since: 2.14
 507  */
 508 PangoFontFamily *
 509 gtk_font_selection_get_family (GtkFontSelection *fontsel)
 510 {
 511   g_return_val_if_fail (GTK_IS_FONT_SELECTION (fontsel), NULL);
 512
 513   return NULL;
 514 }
 515
 516 /**
 517  * gtk_font_selection_get_face:
 518  * @fontsel: a #GtkFontSelection
 519  *
 520  * Gets the #PangoFontFace representing the selected font group
 521  * details (i.e. family, slant, weight, width, etc).
 522  *
 523  * Return value: (transfer none): A #PangoFontFace representing the
 524  *     selected font group details. The returned object is owned by
 525  *     @fontsel and must not be modified or freed.
 526  *
 527  * Since: 2.14
 528  */
 529 PangoFontFace *
 530 gtk_font_selection_get_face (GtkFontSelection *fontsel)
 531 {
 532   g_return_val_if_fail (GTK_IS_FONT_SELECTION (fontsel), NULL);
 533
 534   return NULL;
 535 }
 536
 537 /**
 538  * gtk_font_selection_get_size:
 539  * @fontsel: a #GtkFontSelection
 540  *
 541  * The selected font size.
 542  *
 543  * Return value: A n integer representing the selected font size,
 544  *     or -1 if no font size is selected.
 545  *
 546  * Since: 2.14
 547  **/
 548 gint
 549 gtk_font_selection_get_size (GtkFontSelection *fontsel)
 550 {
 551   g_return_val_if_fail (GTK_IS_FONT_SELECTION (fontsel), -1);
 552
 553   return NULL;
 554 }
 555
 556 /**
 557  * gtk_font_selection_get_font_name:
 558  * @fontsel: a #GtkFontSelection
 559  *
 560  * Gets the currently-selected font name.
 561  *
 562  * Note that this can be a different string than what you set with
 563  * gtk_font_selection_set_font_name(), as the font selection widget may
 564  * normalize font names and thus return a string with a different structure.
 565  * For example, "Helvetica Italic Bold 12" could be normalized to
 566  * "Helvetica Bold Italic 12". Use pango_font_description_equal()
 567  * if you want to compare two font descriptions.
 568  *
 569  * Return value: A string with the name of the current font, or %NULL if
 570  *     no font is selected. You must free this string with g_free().
 571  */
 572 gchar *
 573 gtk_font_selection_get_font_name (GtkFontSelection *fontsel)
 574 {
 575   return NULL;
 576 }
 577
 578 /* This sets the current font, then selecting the appropriate list rows. */
 579
 580 /**
 581  * gtk_font_selection_set_font_name:
 582  * @fontsel: a #GtkFontSelection
 583  * @fontname: a font name like "Helvetica 12" or "Times Bold 18"
 584  *
 585  * Sets the currently-selected font.
 586  *
 587  * Note that the @fontsel needs to know the screen in which it will appear
 588  * for this to work; this can be guaranteed by simply making sure that the
 589  * @fontsel is inserted in a toplevel window before you call this function.
 590  *
 591  * Return value: %TRUE if the font could be set successfully; %FALSE if no
 592  *     such font exists or if the @fontsel doesn't belong to a particular
 593  *     screen yet.
 594  */
 595 gboolean
 596 gtk_font_selection_set_font_name (GtkFontSelection *fontsel,
 597                                   const gchar      *fontname)
 598 {
 599   PangoFontFamily *family = NULL;
 600   PangoFontFace *face = NULL;
 601   PangoFontDescription *new_desc;
 602
 603   g_return_val_if_fail (GTK_IS_FONT_SELECTION (fontsel), FALSE);
 604
 605   return TRUE;
 606 }
 607
 608 /**
 609  * gtk_font_selection_get_preview_text:
 610  * @fontsel: a #GtkFontSelection
 611  *
 612  * Gets the text displayed in the preview area.
 613  *
 614  * Return value: the text displayed in the preview area.
 615  *     This string is owned by the widget and should not be
 616  *     modified or freed
 617  */
 618 G_CONST_RETURN gchar*
 619 gtk_font_selection_get_preview_text (GtkFontSelection *fontsel)
 620 {
 621   return NULL;
 622 }
 623
 624
 625 /**
 626  * gtk_font_selection_set_preview_text:
 627  * @fontsel: a #GtkFontSelection
 628  * @text: the text to display in the preview area
 629  *
 630  * Sets the text displayed in the preview area.
 631  * The @text is used to show how the selected font looks.
 632  */
 633 void
 634 gtk_font_selection_set_preview_text  (GtkFontSelection *fontsel,
 635                                       const gchar      *text)
 636 {
 637   GtkFontSelectionPrivate *priv;
 638
 639   g_return_if_fail (GTK_IS_FONT_SELECTION (fontsel));
 640   g_return_if_fail (text != NULL);
 641
 642   priv = fontsel->priv;
 643 }
 644
 645
 646 /**
 647  * SECTION:gtkfontseldlg
 648  * @Short_description: A dialog box for selecting fonts
 649  * @Title: GtkFontSelectionDialog
 650  * @See_also: #GtkFontSelection, #GtkDialog
 651  *
 652  * The #GtkFontSelectionDialog widget is a dialog box for selecting a font.
 653  *
 654  * To set the font which is initially selected, use
 655  * gtk_font_selection_dialog_set_font_name().
 656  *
 657  * To get the selected font use gtk_font_selection_dialog_get_font_name().
 658  *
 659  * To change the text which is shown in the preview area, use
 660  * gtk_font_selection_dialog_set_preview_text().
 661  *
 662  * <refsect2 id="GtkFontSelectionDialog-BUILDER-UI">
 663  * <title>GtkFontSelectionDialog as GtkBuildable</title>
 664  * The GtkFontSelectionDialog implementation of the GtkBuildable interface
 665  * exposes the embedded #GtkFontSelection as internal child with the
 666  * name "font_selection". It also exposes the buttons with the names
 667  * "ok_button", "cancel_button" and "apply_button".
 668  * </refsect2>
 669  */
 670
 671 static void gtk_font_selection_dialog_buildable_interface_init     (GtkBuildableIface *iface);
 672 static GObject * gtk_font_selection_dialog_buildable_get_internal_child (GtkBuildable *buildable,
 673                                                                           GtkBuilder   *builder,
 674                                                                           const gchar  *childname);
 675
 676 G_DEFINE_TYPE_WITH_CODE (GtkFontSelectionDialog, gtk_font_selection_dialog,
 677                          GTK_TYPE_DIALOG,
 678                          G_IMPLEMENT_INTERFACE (GTK_TYPE_BUILDABLE,
 679                                                 gtk_font_selection_dialog_buildable_interface_init))
 680
 681 static GtkBuildableIface *parent_buildable_iface;
 682
 683 static void
 684 gtk_font_selection_dialog_class_init (GtkFontSelectionDialogClass *klass)
 685 {
 686   g_type_class_add_private (klass, sizeof (GtkFontSelectionDialogPrivate));
 687 }
 688
 689 static void
 690 gtk_font_selection_dialog_init (GtkFontSelectionDialog *fontseldiag)
 691 {
 692   GtkFontSelectionDialogPrivate *priv;
 693   GtkDialog *dialog = GTK_DIALOG (fontseldiag);
 694   GtkWidget *action_area, *content_area;
 695
 696   fontseldiag->priv = G_TYPE_INSTANCE_GET_PRIVATE (fontseldiag,
 697                                                    GTK_TYPE_FONT_SELECTION_DIALOG,
 698                                                    GtkFontSelectionDialogPrivate);
 699   priv = fontseldiag->priv;
 700
 701   content_area = gtk_dialog_get_content_area (dialog);
 702   action_area = gtk_dialog_get_action_area (dialog);
 703
 704   gtk_container_set_border_width (GTK_CONTAINER (dialog), 5);
 705   gtk_box_set_spacing (GTK_BOX (content_area), 2); /* 2 * 5 + 2 = 12 */
 706   gtk_container_set_border_width (GTK_CONTAINER (action_area), 5);
 707   gtk_box_set_spacing (GTK_BOX (action_area), 6);
 708
 709   gtk_widget_push_composite_child ();
 710
 711   gtk_window_set_resizable (GTK_WINDOW (fontseldiag), TRUE);
 712
 713   /* Create the content area */
 714   priv->fontsel = gtk_font_selection_new ();
 715   gtk_container_set_border_width (GTK_CONTAINER (priv->fontsel), 5);
 716   gtk_widget_show (priv->fontsel);
 717   gtk_box_pack_start (GTK_BOX (content_area),
 718                       priv->fontsel, TRUE, TRUE, 0);
 719
 720   /* Create the action area */
 721   priv->cancel_button = gtk_dialog_add_button (dialog,
 722                                                GTK_STOCK_CANCEL,
 723                                                GTK_RESPONSE_CANCEL);
 724
 725   priv->apply_button = gtk_dialog_add_button (dialog,
 726                                               GTK_STOCK_APPLY,
 727                                               GTK_RESPONSE_APPLY);
 728   gtk_widget_hide (priv->apply_button);
 729
 730   priv->ok_button = gtk_dialog_add_button (dialog,
 731                                            GTK_STOCK_OK,
 732                                            GTK_RESPONSE_OK);
 733   gtk_widget_grab_default (priv->ok_button);
 734
 735   gtk_dialog_set_alternative_button_order (GTK_DIALOG (fontseldiag),
 736                                            GTK_RESPONSE_OK,
 737                                            GTK_RESPONSE_APPLY,
 738                                            GTK_RESPONSE_CANCEL,
 739                                            -1);
 740
 741   gtk_window_set_title (GTK_WINDOW (fontseldiag),
 742                         _("Font Selection"));
 743
 744   gtk_widget_pop_composite_child ();
 745 }
 746
 747 /**
 748  * gtk_font_selection_dialog_new:
 749  * @title: the title of the dialog window
 750  *
 751  * Creates a new #GtkFontSelectionDialog.
 752  *
 753  * Return value: a new #GtkFontSelectionDialog
 754  */
 755 GtkWidget*
 756 gtk_font_selection_dialog_new (const gchar *title)
 757 {
 758   GtkFontSelectionDialog *fontseldiag;
 759
 760   fontseldiag = g_object_new (GTK_TYPE_FONT_SELECTION_DIALOG, NULL);
 761
 762   if (title)
 763     gtk_window_set_title (GTK_WINDOW (fontseldiag), title);
 764
 765   return GTK_WIDGET (fontseldiag);
 766 }
 767
 768 /**
 769  * gtk_font_selection_dialog_get_font_selection:
 770  * @fsd: a #GtkFontSelectionDialog
 771  *
 772  * Retrieves the #GtkFontSelection widget embedded in the dialog.
 773  *
 774  * Returns: (transfer none): the embedded #GtkFontSelection
 775  *
 776  * Since: 2.22
 777  **/
 778 GtkWidget*
 779 gtk_font_selection_dialog_get_font_selection (GtkFontSelectionDialog *fsd)
 780 {
 781   g_return_val_if_fail (GTK_IS_FONT_SELECTION_DIALOG (fsd), NULL);
 782
 783   return fsd->priv->fontsel;
 784 }
 785
 786
 787 /**
 788  * gtk_font_selection_dialog_get_ok_button:
 789  * @fsd: a #GtkFontSelectionDialog
 790  *
 791  * Gets the 'OK' button.
 792  *
 793  * Return value: (transfer none): the #GtkWidget used in the dialog
 794  *     for the 'OK' button.
 795  *
 796  * Since: 2.14
 797  */
 798 GtkWidget *
 799 gtk_font_selection_dialog_get_ok_button (GtkFontSelectionDialog *fsd)
 800 {
 801   g_return_val_if_fail (GTK_IS_FONT_SELECTION_DIALOG (fsd), NULL);
 802
 803   return fsd->priv->ok_button;
 804 }
 805
 806 /**
 807  * gtk_font_selection_dialog_get_cancel_button:
 808  * @fsd: a #GtkFontSelectionDialog
 809  *
 810  * Gets the 'Cancel' button.
 811  *
 812  * Return value: (transfer none): the #GtkWidget used in the dialog
 813  *     for the 'Cancel' button.
 814  *
 815  * Since: 2.14
 816  */
 817 GtkWidget *
 818 gtk_font_selection_dialog_get_cancel_button (GtkFontSelectionDialog *fsd)
 819 {
 820   g_return_val_if_fail (GTK_IS_FONT_SELECTION_DIALOG (fsd), NULL);
 821
 822   return fsd->priv->cancel_button;
 823 }
 824
 825 static void
 826 gtk_font_selection_dialog_buildable_interface_init (GtkBuildableIface *iface)
 827 {
 828   parent_buildable_iface = g_type_interface_peek_parent (iface);
 829   iface->get_internal_child = gtk_font_selection_dialog_buildable_get_internal_child;
 830 }
 831
 832 static GObject *
 833 gtk_font_selection_dialog_buildable_get_internal_child (GtkBuildable *buildable,
 834                                                         GtkBuilder   *builder,
 835                                                         const gchar  *childname)
 836 {
 837   GtkFontSelectionDialogPrivate *priv;
 838
 839   priv = GTK_FONT_SELECTION_DIALOG (buildable)->priv;
 840
 841   if (g_strcmp0 (childname, "ok_button") == 0)
 842     return G_OBJECT (priv->ok_button);
 843   else if (g_strcmp0 (childname, "cancel_button") == 0)
 844     return G_OBJECT (priv->cancel_button);
 845   else if (g_strcmp0 (childname, "apply_button") == 0)
 846     return G_OBJECT (priv->apply_button);
 847   else if (g_strcmp0 (childname, "font_selection") == 0)
 848     return G_OBJECT (priv->fontsel);
 849
 850   return parent_buildable_iface->get_internal_child (buildable, builder, childname);
 851 }
 852
 853 /**
 854  * gtk_font_selection_dialog_get_font_name:
 855  * @fsd: a #GtkFontSelectionDialog
 856  *
 857  * Gets the currently-selected font name.
 858  *
 859  * Note that this can be a different string than what you set with
 860  * gtk_font_selection_dialog_set_font_name(), as the font selection widget
 861  * may normalize font names and thus return a string with a different
 862  * structure. For example, "Helvetica Italic Bold 12" could be normalized
 863  * to "Helvetica Bold Italic 12".  Use pango_font_description_equal()
 864  * if you want to compare two font descriptions.
 865  *
 866  * Return value: A string with the name of the current font, or %NULL if no
 867  *     font is selected. You must free this string with g_free().
 868  */
 869 gchar*
 870 gtk_font_selection_dialog_get_font_name (GtkFontSelectionDialog *fsd)
 871 {
 872   GtkFontSelectionDialogPrivate *priv;
 873
 874   g_return_val_if_fail (GTK_IS_FONT_SELECTION_DIALOG (fsd), NULL);
 875
 876   priv = fsd->priv;
 877
 878   return gtk_font_selection_get_font_name (GTK_FONT_SELECTION (priv->fontsel));
 879 }
 880
 881 /**
 882  * gtk_font_selection_dialog_set_font_name:
 883  * @fsd: a #GtkFontSelectionDialog
 884  * @fontname: a font name like "Helvetica 12" or "Times Bold 18"
 885  *
 886  * Sets the currently selected font.
 887  *
 888  * Return value: %TRUE if the font selected in @fsd is now the
 889  *     @fontname specified, %FALSE otherwise.
 890  */
 891 gboolean
 892 gtk_font_selection_dialog_set_font_name (GtkFontSelectionDialog *fsd,
 893                                          const gchar            *fontname)
 894 {
 895   GtkFontSelectionDialogPrivate *priv;
 896
 897   g_return_val_if_fail (GTK_IS_FONT_SELECTION_DIALOG (fsd), FALSE);
 898   g_return_val_if_fail (fontname, FALSE);
 899
 900   priv = fsd->priv;
 901
 902   return gtk_font_selection_set_font_name (GTK_FONT_SELECTION (priv->fontsel), fontname);
 903 }
 904
 905 /**
 906  * gtk_font_selection_dialog_get_preview_text:
 907  * @fsd: a #GtkFontSelectionDialog
 908  *
 909  * Gets the text displayed in the preview area.
 910  *
 911  * Return value: the text displayed in the preview area.
 912  *     This string is owned by the widget and should not be
 913  *     modified or freed
 914  */
 915 G_CONST_RETURN gchar*
 916 gtk_font_selection_dialog_get_preview_text (GtkFontSelectionDialog *fsd)
 917 {
 918   GtkFontSelectionDialogPrivate *priv;
 919
 920   g_return_val_if_fail (GTK_IS_FONT_SELECTION_DIALOG (fsd), NULL);
 921
 922   priv = fsd->priv;
 923
 924   return gtk_font_selection_get_preview_text (GTK_FONT_SELECTION (priv->fontsel));
 925 }
 926
 927 /**
 928  * gtk_font_selection_dialog_set_preview_text:
 929  * @fsd: a #GtkFontSelectionDialog
 930  * @text: the text to display in the preview area
 931  *
 932  * Sets the text displayed in the preview area.
 933  */
 934 void
 935 gtk_font_selection_dialog_set_preview_text (GtkFontSelectionDialog *fsd,
 936                                             const gchar            *text)
 937 {
 938   GtkFontSelectionDialogPrivate *priv;
 939
 940   g_return_if_fail (GTK_IS_FONT_SELECTION_DIALOG (fsd));
 941   g_return_if_fail (text != NULL);
 942
 943   priv = fsd->priv;
 944
 945   gtk_font_selection_set_preview_text (GTK_FONT_SELECTION (priv->fontsel), text);
 946 }