* GTK+ at ftp://ftp.gtk.org/pub/gtk/.
*/
+#include "config.h"
#include <stdlib.h>
-#include <stdio.h>
+#include <glib/gprintf.h>
#include <string.h>
-#include <ctype.h>
+
+#include <atk/atk.h>
#include "gdk/gdk.h"
#include "gdk/gdkkeysyms.h"
#include "gtkfontsel.h"
#include "gtkbutton.h"
-#include "gtkclist.h"
+#include "gtkcellrenderertext.h"
#include "gtkentry.h"
#include "gtkframe.h"
#include "gtkhbbox.h"
#include "gtkhbox.h"
#include "gtklabel.h"
+#include "gtkliststore.h"
#include "gtkrc.h"
-#include "gtksignal.h"
#include "gtkstock.h"
#include "gtktable.h"
+#include "gtktreeselection.h"
+#include "gtktreeview.h"
#include "gtkvbox.h"
#include "gtkscrolledwindow.h"
#include "gtkintl.h"
+#include "gtkaccessible.h"
+#include "gtkprivate.h"
+#include "gtkbuildable.h"
+#include "gtkalias.h"
+
+/* We don't enable the font and style entries because they don't add
+ * much in terms of visible effect and have a weird effect on keynav.
+ * the Windows font selector has entries similarly positioned but they
+ * act in conjunction with the associated lists to form a single focus
+ * location.
+ */
+#undef INCLUDE_FONT_ENTRIES
/* This is the default text shown in the preview entry, though the user
can set it. Remember that some fonts only have capital letters. */
-#define PREVIEW_TEXT "abcdefghijk ABCDEFGHIJK"
+#define PREVIEW_TEXT N_("abcdefghijk ABCDEFGHIJK")
+
+#define DEFAULT_FONT_NAME "Sans 10"
/* This is the initial and maximum height of the preview entry (it expands
when large font sizes are selected). Initial height is also the minimum. */
#define INITIAL_PREVIEW_HEIGHT 44
#define MAX_PREVIEW_HEIGHT 300
-/* These are the sizes of the font, style & size clists. */
+/* These are the sizes of the font, style & size lists. */
#define FONT_LIST_HEIGHT 136
#define FONT_LIST_WIDTH 190
#define FONT_STYLE_LIST_WIDTH 170
#define FONT_SIZE_LIST_WIDTH 60
-/* These are what we use as the standard font sizes, for the size clist.
+/* These are what we use as the standard font sizes, for the size list.
*/
static const guint16 font_sizes[] = {
- 8, 9, 10, 11, 12, 13, 14, 16, 18, 20, 22, 24, 26, 28,
+ 6, 7, 8, 9, 10, 11, 12, 13, 14, 16, 18, 20, 22, 24, 26, 28,
32, 36, 40, 48, 56, 64, 72
};
-static void gtk_font_selection_class_init (GtkFontSelectionClass *klass);
-static void gtk_font_selection_init (GtkFontSelection *fontsel);
+enum {
+ PROP_0,
+ PROP_FONT_NAME,
+ PROP_FONT,
+ PROP_PREVIEW_TEXT
+};
+
+
+enum {
+ FAMILY_COLUMN,
+ FAMILY_NAME_COLUMN
+};
+
+enum {
+ FACE_COLUMN,
+ FACE_NAME_COLUMN
+};
+
+enum {
+ SIZE_COLUMN
+};
+
+static void gtk_font_selection_set_property (GObject *object,
+ guint prop_id,
+ const GValue *value,
+ GParamSpec *pspec);
+static void gtk_font_selection_get_property (GObject *object,
+ guint prop_id,
+ GValue *value,
+ GParamSpec *pspec);
static void gtk_font_selection_finalize (GObject *object);
+static void gtk_font_selection_screen_changed (GtkWidget *widget,
+ GdkScreen *previous_screen);
/* These are the callbacks & related functions. */
-static void gtk_font_selection_select_font (GtkWidget *w,
- gint row,
- gint column,
- GdkEventButton *bevent,
+static void gtk_font_selection_select_font (GtkTreeSelection *selection,
gpointer data);
-static gint gtk_font_selection_on_clist_key_press (GtkWidget *clist,
- GdkEventKey *event,
- GtkFontSelection *fs);
-static gboolean gtk_font_selection_select_next (GtkFontSelection *fs,
- GtkWidget *clist,
- gint step);
-
static void gtk_font_selection_show_available_fonts (GtkFontSelection *fs);
static void gtk_font_selection_show_available_styles (GtkFontSelection *fs);
static void gtk_font_selection_select_best_style (GtkFontSelection *fs,
gboolean use_first);
-static void gtk_font_selection_select_style (GtkWidget *w,
- gint row,
- gint column,
- GdkEventButton *bevent,
+static void gtk_font_selection_select_style (GtkTreeSelection *selection,
gpointer data);
static void gtk_font_selection_select_best_size (GtkFontSelection *fs);
-static void gtk_font_selection_show_available_sizes (GtkFontSelection *fs);
-static gint gtk_font_selection_size_key_press (GtkWidget *w,
- GdkEventKey *event,
+static void gtk_font_selection_show_available_sizes (GtkFontSelection *fs,
+ gboolean first_time);
+static void gtk_font_selection_size_activate (GtkWidget *w,
+ gpointer data);
+static gboolean gtk_font_selection_size_focus_out (GtkWidget *w,
+ GdkEventFocus *event,
gpointer data);
-static void gtk_font_selection_select_size (GtkWidget *w,
- gint row,
- gint column,
- GdkEventButton *bevent,
+static void gtk_font_selection_select_size (GtkTreeSelection *selection,
gpointer data);
-static void gtk_font_selection_expose_list (GtkWidget *w,
- GdkEventExpose *event,
+static void gtk_font_selection_scroll_on_map (GtkWidget *w,
gpointer data);
+static void gtk_font_selection_preview_changed (GtkWidget *entry,
+ GtkFontSelection *fontsel);
/* Misc. utility functions. */
-static void gtk_font_selection_load_font (GtkFontSelection *fs);
+static void gtk_font_selection_load_font (GtkFontSelection *fs);
static void gtk_font_selection_update_preview (GtkFontSelection *fs);
-/* FontSelectionDialog */
-static void gtk_font_selection_dialog_class_init (GtkFontSelectionDialogClass *klass);
-static void gtk_font_selection_dialog_init (GtkFontSelectionDialog *fontseldiag);
+static GdkFont* gtk_font_selection_get_font_internal (GtkFontSelection *fontsel);
-static gint gtk_font_selection_dialog_on_configure(GtkWidget *widget,
- GdkEventConfigure *event,
- GtkFontSelectionDialog *fsd);
+G_DEFINE_TYPE (GtkFontSelection, gtk_font_selection, GTK_TYPE_VBOX)
-static GtkWindowClass *font_selection_parent_class = NULL;
-static GtkVBoxClass *font_selection_dialog_parent_class = NULL;
+static void
+gtk_font_selection_class_init (GtkFontSelectionClass *klass)
+{
+ GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
+ GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
+
+ gobject_class->set_property = gtk_font_selection_set_property;
+ gobject_class->get_property = gtk_font_selection_get_property;
+
+ widget_class->screen_changed = gtk_font_selection_screen_changed;
+
+ g_object_class_install_property (gobject_class,
+ PROP_FONT_NAME,
+ g_param_spec_string ("font-name",
+ P_("Font name"),
+ P_("The string that represents this font"),
+ DEFAULT_FONT_NAME,
+ GTK_PARAM_READWRITE));
+ g_object_class_install_property (gobject_class,
+ PROP_FONT,
+ g_param_spec_boxed ("font",
+ P_("Font"),
+ P_("The GdkFont that is currently selected"),
+ GDK_TYPE_FONT,
+ GTK_PARAM_READABLE));
+ g_object_class_install_property (gobject_class,
+ PROP_PREVIEW_TEXT,
+ g_param_spec_string ("preview-text",
+ P_("Preview text"),
+ P_("The text to display in order to demonstrate the selected font"),
+ _(PREVIEW_TEXT),
+ GTK_PARAM_READWRITE));
+ gobject_class->finalize = gtk_font_selection_finalize;
+}
-GtkType
-gtk_font_selection_get_type()
+static void
+gtk_font_selection_set_property (GObject *object,
+ guint prop_id,
+ const GValue *value,
+ GParamSpec *pspec)
{
- static GtkType font_selection_type = 0;
-
- if(!font_selection_type)
+ GtkFontSelection *fontsel;
+
+ fontsel = GTK_FONT_SELECTION (object);
+
+ switch (prop_id)
{
- static const GtkTypeInfo fontsel_type_info =
- {
- "GtkFontSelection",
- sizeof (GtkFontSelection),
- sizeof (GtkFontSelectionClass),
- (GtkClassInitFunc) gtk_font_selection_class_init,
- (GtkObjectInitFunc) gtk_font_selection_init,
- /* reserved_1 */ NULL,
- /* reserved_2 */ NULL,
- (GtkClassInitFunc) NULL,
- };
-
- font_selection_type = gtk_type_unique (GTK_TYPE_VBOX,
- &fontsel_type_info);
+ case PROP_FONT_NAME:
+ gtk_font_selection_set_font_name (fontsel, g_value_get_string (value));
+ break;
+ case PROP_PREVIEW_TEXT:
+ gtk_font_selection_set_preview_text (fontsel, g_value_get_string (value));
+ break;
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+ break;
}
-
- return font_selection_type;
}
-static void
-gtk_font_selection_class_init(GtkFontSelectionClass *klass)
+static void gtk_font_selection_get_property (GObject *object,
+ guint prop_id,
+ GValue *value,
+ GParamSpec *pspec)
{
- GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
+ GtkFontSelection *fontsel;
+
+ fontsel = GTK_FONT_SELECTION (object);
+
+ switch (prop_id)
+ {
+ case PROP_FONT_NAME:
+ g_value_take_string (value, gtk_font_selection_get_font_name (fontsel));
+ break;
+ case PROP_FONT:
+ g_value_set_boxed (value, gtk_font_selection_get_font_internal (fontsel));
+ break;
+ case PROP_PREVIEW_TEXT:
+ g_value_set_string (value, gtk_font_selection_get_preview_text (fontsel));
+ break;
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+ break;
+ }
+}
+
+/* Handles key press events on the lists, so that we can trap Enter to
+ * activate the default button on our own.
+ */
+static gboolean
+list_row_activated (GtkWidget *widget)
+{
+ GtkWindow *window;
- font_selection_parent_class = gtk_type_class (GTK_TYPE_VBOX);
+ window = GTK_WINDOW (gtk_widget_get_toplevel (GTK_WIDGET (widget)));
+ if (!GTK_WIDGET_TOPLEVEL (window))
+ window = NULL;
- gobject_class->finalize = gtk_font_selection_finalize;
+ if (window
+ && widget != window->default_widget
+ && !(widget == window->focus_widget &&
+ (!window->default_widget || !GTK_WIDGET_SENSITIVE (window->default_widget))))
+ {
+ gtk_window_activate_default (window);
+ }
+
+ return TRUE;
}
static void
-gtk_font_selection_init(GtkFontSelection *fontsel)
+gtk_font_selection_init (GtkFontSelection *fontsel)
{
GtkWidget *scrolled_win;
- GtkWidget *text_frame;
GtkWidget *text_box;
GtkWidget *table, *label;
+ GtkWidget *font_label, *style_label;
+ GtkWidget *vbox;
+ GtkListStore *model;
+ GtkTreeViewColumn *column;
+ GList *focus_chain = NULL;
+ AtkObject *atk_obj;
- fontsel->font_desc = pango_font_description_from_string ("sans 12");
+ gtk_widget_push_composite_child ();
+
+ gtk_box_set_spacing (GTK_BOX (fontsel), 12);
+ fontsel->size = 12 * PANGO_SCALE;
/* Create the table of font, style & size. */
table = gtk_table_new (3, 3, FALSE);
gtk_widget_show (table);
- gtk_table_set_col_spacings(GTK_TABLE(table), 8);
+ gtk_table_set_row_spacings (GTK_TABLE (table), 6);
+ gtk_table_set_col_spacings (GTK_TABLE (table), 12);
gtk_box_pack_start (GTK_BOX (fontsel), table, TRUE, TRUE, 0);
+#ifdef INCLUDE_FONT_ENTRIES
fontsel->font_entry = gtk_entry_new ();
- gtk_entry_set_editable(GTK_ENTRY(fontsel->font_entry), FALSE);
- gtk_widget_set_usize (fontsel->font_entry, 20, -1);
+ gtk_editable_set_editable (GTK_EDITABLE (fontsel->font_entry), FALSE);
+ gtk_widget_set_size_request (fontsel->font_entry, 20, -1);
gtk_widget_show (fontsel->font_entry);
gtk_table_attach (GTK_TABLE (table), fontsel->font_entry, 0, 1, 1, 2,
GTK_FILL, 0, 0, 0);
fontsel->font_style_entry = gtk_entry_new ();
- gtk_entry_set_editable (GTK_ENTRY(fontsel->font_style_entry), FALSE);
- gtk_widget_set_usize (fontsel->font_style_entry, 20, -1);
+ gtk_editable_set_editable (GTK_EDITABLE (fontsel->font_style_entry), FALSE);
+ gtk_widget_set_size_request (fontsel->font_style_entry, 20, -1);
gtk_widget_show (fontsel->font_style_entry);
gtk_table_attach (GTK_TABLE (table), fontsel->font_style_entry, 1, 2, 1, 2,
GTK_FILL, 0, 0, 0);
+#endif /* INCLUDE_FONT_ENTRIES */
fontsel->size_entry = gtk_entry_new ();
- gtk_widget_set_usize (fontsel->size_entry, 20, -1);
+ gtk_widget_set_size_request (fontsel->size_entry, 20, -1);
gtk_widget_show (fontsel->size_entry);
gtk_table_attach (GTK_TABLE (table), fontsel->size_entry, 2, 3, 1, 2,
GTK_FILL, 0, 0, 0);
- gtk_signal_connect (GTK_OBJECT (fontsel->size_entry), "key_press_event",
- (GtkSignalFunc) gtk_font_selection_size_key_press,
- fontsel);
-
- fontsel->font_label = gtk_label_new_with_mnemonic (_("_Family:"));
- gtk_label_set_mnemonic_widget (GTK_LABEL (fontsel->font_label),
- fontsel->font_entry);
- gtk_misc_set_alignment (GTK_MISC (fontsel->font_label), 0.0, 0.5);
- gtk_widget_show (fontsel->font_label);
- gtk_table_attach (GTK_TABLE (table), fontsel->font_label, 0, 1, 0, 1,
+ g_signal_connect (fontsel->size_entry, "activate",
+ G_CALLBACK (gtk_font_selection_size_activate),
+ fontsel);
+ g_signal_connect_after (fontsel->size_entry, "focus_out_event",
+ G_CALLBACK (gtk_font_selection_size_focus_out),
+ fontsel);
+
+ font_label = gtk_label_new_with_mnemonic (_("_Family:"));
+ gtk_misc_set_alignment (GTK_MISC (font_label), 0.0, 0.5);
+ gtk_widget_show (font_label);
+ gtk_table_attach (GTK_TABLE (table), font_label, 0, 1, 0, 1,
GTK_FILL, 0, 0, 0);
- label = gtk_label_new_with_mnemonic (_("_Style:"));
- gtk_label_set_mnemonic_widget (GTK_LABEL (label),
- fontsel->font_style_entry);
- gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
- gtk_widget_show (label);
- gtk_table_attach (GTK_TABLE (table), label, 1, 2, 0, 1,
+
+ style_label = gtk_label_new_with_mnemonic (_("_Style:"));
+ gtk_misc_set_alignment (GTK_MISC (style_label), 0.0, 0.5);
+ gtk_widget_show (style_label);
+ gtk_table_attach (GTK_TABLE (table), style_label, 1, 2, 0, 1,
GTK_FILL, 0, 0, 0);
+
label = gtk_label_new_with_mnemonic (_("Si_ze:"));
gtk_label_set_mnemonic_widget (GTK_LABEL (label),
fontsel->size_entry);
GTK_FILL, 0, 0, 0);
- /* Create the clists */
- fontsel->font_clist = gtk_clist_new (1);
- gtk_clist_column_titles_hide (GTK_CLIST (fontsel->font_clist));
- gtk_clist_set_column_auto_resize (GTK_CLIST (fontsel->font_clist), 0, TRUE);
+ /* Create the lists */
+
+ model = gtk_list_store_new (2,
+ G_TYPE_OBJECT, /* FAMILY_COLUMN */
+ G_TYPE_STRING); /* FAMILY_NAME_COLUMN */
+ fontsel->family_list = gtk_tree_view_new_with_model (GTK_TREE_MODEL (model));
+ g_object_unref (model);
+
+ g_signal_connect (fontsel->family_list, "row_activated",
+ G_CALLBACK (list_row_activated), fontsel);
+
+ column = gtk_tree_view_column_new_with_attributes ("Family",
+ gtk_cell_renderer_text_new (),
+ "text", FAMILY_NAME_COLUMN,
+ NULL);
+ gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
+ gtk_tree_view_append_column (GTK_TREE_VIEW (fontsel->family_list), column);
+
+ gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (fontsel->family_list), FALSE);
+ gtk_tree_selection_set_mode (gtk_tree_view_get_selection (GTK_TREE_VIEW (fontsel->family_list)),
+ GTK_SELECTION_BROWSE);
+
+ gtk_label_set_mnemonic_widget (GTK_LABEL (font_label), fontsel->family_list);
+
scrolled_win = gtk_scrolled_window_new (NULL, NULL);
- gtk_widget_set_usize (scrolled_win, FONT_LIST_WIDTH, FONT_LIST_HEIGHT);
- gtk_container_add (GTK_CONTAINER (scrolled_win), fontsel->font_clist);
+ gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled_win), GTK_SHADOW_IN);
+ gtk_widget_set_size_request (scrolled_win,
+ FONT_LIST_WIDTH, FONT_LIST_HEIGHT);
+ gtk_container_add (GTK_CONTAINER (scrolled_win), fontsel->family_list);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
- gtk_widget_show(fontsel->font_clist);
- gtk_widget_show(scrolled_win);
+ gtk_widget_show (fontsel->family_list);
+ gtk_widget_show (scrolled_win);
- gtk_table_attach (GTK_TABLE (table), scrolled_win, 0, 1, 2, 3,
+ gtk_table_attach (GTK_TABLE (table), scrolled_win, 0, 1, 1, 3,
GTK_EXPAND | GTK_FILL,
GTK_EXPAND | GTK_FILL, 0, 0);
+ focus_chain = g_list_append (focus_chain, scrolled_win);
+
+ model = gtk_list_store_new (2,
+ G_TYPE_OBJECT, /* FACE_COLUMN */
+ G_TYPE_STRING); /* FACE_NAME_COLUMN */
+ fontsel->face_list = gtk_tree_view_new_with_model (GTK_TREE_MODEL (model));
+ g_object_unref (model);
+ g_signal_connect (fontsel->face_list, "row-activated",
+ G_CALLBACK (list_row_activated), fontsel);
+
+ gtk_label_set_mnemonic_widget (GTK_LABEL (style_label), fontsel->face_list);
+
+ column = gtk_tree_view_column_new_with_attributes ("Face",
+ gtk_cell_renderer_text_new (),
+ "text", FACE_NAME_COLUMN,
+ NULL);
+ gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
+ gtk_tree_view_append_column (GTK_TREE_VIEW (fontsel->face_list), column);
+
+ gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (fontsel->face_list), FALSE);
+ gtk_tree_selection_set_mode (gtk_tree_view_get_selection (GTK_TREE_VIEW (fontsel->face_list)),
+ GTK_SELECTION_BROWSE);
- fontsel->font_style_clist = gtk_clist_new (1);
- gtk_clist_column_titles_hide (GTK_CLIST (fontsel->font_style_clist));
- gtk_clist_set_column_auto_resize (GTK_CLIST (fontsel->font_style_clist),
- 0, TRUE);
scrolled_win = gtk_scrolled_window_new (NULL, NULL);
- gtk_widget_set_usize (scrolled_win, FONT_STYLE_LIST_WIDTH, -1);
- gtk_container_add (GTK_CONTAINER (scrolled_win), fontsel->font_style_clist);
+ gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled_win), GTK_SHADOW_IN);
+ gtk_widget_set_size_request (scrolled_win,
+ FONT_STYLE_LIST_WIDTH, FONT_LIST_HEIGHT);
+ gtk_container_add (GTK_CONTAINER (scrolled_win), fontsel->face_list);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
- gtk_widget_show(fontsel->font_style_clist);
- gtk_widget_show(scrolled_win);
- gtk_table_attach (GTK_TABLE (table), scrolled_win, 1, 2, 2, 3,
+ gtk_widget_show (fontsel->face_list);
+ gtk_widget_show (scrolled_win);
+ gtk_table_attach (GTK_TABLE (table), scrolled_win, 1, 2, 1, 3,
GTK_EXPAND | GTK_FILL,
GTK_EXPAND | GTK_FILL, 0, 0);
+ focus_chain = g_list_append (focus_chain, scrolled_win);
+
+ focus_chain = g_list_append (focus_chain, fontsel->size_entry);
+
+ model = gtk_list_store_new (1, G_TYPE_INT);
+ fontsel->size_list = gtk_tree_view_new_with_model (GTK_TREE_MODEL (model));
+ g_object_unref (model);
+ g_signal_connect (fontsel->size_list, "row-activated",
+ G_CALLBACK (list_row_activated), fontsel);
+
+ column = gtk_tree_view_column_new_with_attributes ("Size",
+ gtk_cell_renderer_text_new (),
+ "text", SIZE_COLUMN,
+ NULL);
+ gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
+ gtk_tree_view_append_column (GTK_TREE_VIEW (fontsel->size_list), column);
+
+ gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (fontsel->size_list), FALSE);
+ gtk_tree_selection_set_mode (gtk_tree_view_get_selection (GTK_TREE_VIEW (fontsel->size_list)),
+ GTK_SELECTION_BROWSE);
- fontsel->size_clist = gtk_clist_new (1);
- gtk_clist_column_titles_hide (GTK_CLIST(fontsel->size_clist));
- gtk_clist_set_column_width (GTK_CLIST(fontsel->size_clist), 0, 20);
scrolled_win = gtk_scrolled_window_new (NULL, NULL);
- gtk_widget_set_usize (scrolled_win, FONT_SIZE_LIST_WIDTH, -1);
- gtk_container_add (GTK_CONTAINER (scrolled_win), fontsel->size_clist);
+ gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled_win), GTK_SHADOW_IN);
+ gtk_container_add (GTK_CONTAINER (scrolled_win), fontsel->size_list);
+ gtk_widget_set_size_request (scrolled_win, -1, FONT_LIST_HEIGHT);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
- GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
- gtk_widget_show (fontsel->size_clist);
+ GTK_POLICY_NEVER, GTK_POLICY_ALWAYS);
+ gtk_widget_show (fontsel->size_list);
gtk_widget_show (scrolled_win);
gtk_table_attach (GTK_TABLE (table), scrolled_win, 2, 3, 2, 3,
- GTK_FILL, GTK_FILL, 0, 0);
-
- /* Insert the fonts. If there exist fonts with the same family but
- different foundries, then the foundry name is appended in brackets. */
- gtk_font_selection_show_available_fonts(fontsel);
-
- gtk_signal_connect (GTK_OBJECT (fontsel->font_clist), "select_row",
- GTK_SIGNAL_FUNC(gtk_font_selection_select_font),
- fontsel);
- GTK_WIDGET_SET_FLAGS (fontsel->font_clist, GTK_CAN_FOCUS);
- gtk_signal_connect (GTK_OBJECT (fontsel->font_clist), "key_press_event",
- GTK_SIGNAL_FUNC(gtk_font_selection_on_clist_key_press),
- fontsel);
- gtk_signal_connect_after (GTK_OBJECT (fontsel->font_clist), "expose_event",
- GTK_SIGNAL_FUNC(gtk_font_selection_expose_list),
- fontsel);
+ GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
+ focus_chain = g_list_append (focus_chain, scrolled_win);
+
+ gtk_container_set_focus_chain (GTK_CONTAINER (table), focus_chain);
+ g_list_free (focus_chain);
- gtk_font_selection_show_available_styles (fontsel);
+ /* Insert the fonts. */
+ g_signal_connect (gtk_tree_view_get_selection (GTK_TREE_VIEW (fontsel->family_list)), "changed",
+ G_CALLBACK (gtk_font_selection_select_font), fontsel);
+
+ g_signal_connect_after (fontsel->family_list, "map",
+ G_CALLBACK (gtk_font_selection_scroll_on_map),
+ fontsel);
- gtk_signal_connect (GTK_OBJECT (fontsel->font_style_clist), "select_row",
- GTK_SIGNAL_FUNC(gtk_font_selection_select_style),
- fontsel);
- GTK_WIDGET_SET_FLAGS (fontsel->font_style_clist, GTK_CAN_FOCUS);
- gtk_signal_connect (GTK_OBJECT (fontsel->font_style_clist),
- "key_press_event",
- GTK_SIGNAL_FUNC(gtk_font_selection_on_clist_key_press),
- fontsel);
-
- gtk_font_selection_show_available_sizes (fontsel);
-
- gtk_signal_connect (GTK_OBJECT (fontsel->size_clist), "select_row",
- GTK_SIGNAL_FUNC(gtk_font_selection_select_size),
- fontsel);
- GTK_WIDGET_SET_FLAGS (fontsel->size_clist, GTK_CAN_FOCUS);
- gtk_signal_connect (GTK_OBJECT (fontsel->size_clist), "key_press_event",
- GTK_SIGNAL_FUNC(gtk_font_selection_on_clist_key_press),
- fontsel);
+ g_signal_connect (gtk_tree_view_get_selection (GTK_TREE_VIEW (fontsel->face_list)), "changed",
+ G_CALLBACK (gtk_font_selection_select_style), fontsel);
+
+ g_signal_connect (gtk_tree_view_get_selection (GTK_TREE_VIEW (fontsel->size_list)), "changed",
+ G_CALLBACK (gtk_font_selection_select_size), fontsel);
+ atk_obj = gtk_widget_get_accessible (fontsel->size_list);
+ if (GTK_IS_ACCESSIBLE (atk_obj))
+ {
+ /* Accessibility support is enabled.
+ * Make the label ATK_RELATON_LABEL_FOR for the size list as well.
+ */
+ AtkObject *atk_label;
+ AtkRelationSet *relation_set;
+ AtkRelation *relation;
+ AtkObject *obj_array[1];
+
+ atk_label = gtk_widget_get_accessible (label);
+ relation_set = atk_object_ref_relation_set (atk_obj);
+ relation = atk_relation_set_get_relation_by_type (relation_set, ATK_RELATION_LABELLED_BY);
+ if (relation)
+ {
+ atk_relation_add_target (relation, atk_label);
+ }
+ else
+ {
+ obj_array[0] = atk_label;
+ relation = atk_relation_new (obj_array, 1, ATK_RELATION_LABELLED_BY);
+ atk_relation_set_add (relation_set, relation);
+ }
+ g_object_unref (relation_set);
+
+ relation_set = atk_object_ref_relation_set (atk_label);
+ relation = atk_relation_set_get_relation_by_type (relation_set, ATK_RELATION_LABEL_FOR);
+ if (relation)
+ {
+ atk_relation_add_target (relation, atk_obj);
+ }
+ else
+ {
+ obj_array[0] = atk_obj;
+ relation = atk_relation_new (obj_array, 1, ATK_RELATION_LABEL_FOR);
+ atk_relation_set_add (relation_set, relation);
+ }
+ g_object_unref (relation_set);
+ }
+
+
+ vbox = gtk_vbox_new (FALSE, 6);
+ gtk_widget_show (vbox);
+ gtk_box_pack_start (GTK_BOX (fontsel), vbox, FALSE, TRUE, 0);
/* create the text entry widget */
- text_frame = gtk_frame_new (_("Preview:"));
- gtk_widget_show (text_frame);
- gtk_frame_set_shadow_type(GTK_FRAME(text_frame), GTK_SHADOW_ETCHED_IN);
- gtk_box_pack_start (GTK_BOX (fontsel), text_frame,
- FALSE, TRUE, 0);
+ label = gtk_label_new_with_mnemonic (_("_Preview:"));
+ gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
+ gtk_widget_show (label);
+ gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, TRUE, 0);
- /* This is just used to get a 4-pixel space around the preview entry. */
text_box = gtk_hbox_new (FALSE, 0);
gtk_widget_show (text_box);
- gtk_container_add (GTK_CONTAINER (text_frame), text_box);
- gtk_container_set_border_width (GTK_CONTAINER (text_box), 4);
+ gtk_box_pack_start (GTK_BOX (vbox), text_box, FALSE, TRUE, 0);
fontsel->preview_entry = gtk_entry_new ();
+ gtk_label_set_mnemonic_widget (GTK_LABEL (label), fontsel->preview_entry);
+ gtk_entry_set_text (GTK_ENTRY (fontsel->preview_entry), _(PREVIEW_TEXT));
+
gtk_widget_show (fontsel->preview_entry);
- gtk_widget_set_usize (fontsel->preview_entry, -1, INITIAL_PREVIEW_HEIGHT);
+ g_signal_connect (fontsel->preview_entry, "changed",
+ G_CALLBACK (gtk_font_selection_preview_changed), fontsel);
+ gtk_widget_set_size_request (fontsel->preview_entry,
+ -1, INITIAL_PREVIEW_HEIGHT);
gtk_box_pack_start (GTK_BOX (text_box), fontsel->preview_entry,
TRUE, TRUE, 0);
- gtk_font_selection_update_preview (fontsel);
+ gtk_widget_pop_composite_child();
}
GtkWidget *
-gtk_font_selection_new()
+gtk_font_selection_new (void)
{
GtkFontSelection *fontsel;
- fontsel = gtk_type_new (GTK_TYPE_FONT_SELECTION);
+ fontsel = g_object_new (GTK_TYPE_FONT_SELECTION, NULL);
return GTK_WIDGET (fontsel);
}
{
GtkFontSelection *fontsel;
- g_return_if_fail (object != NULL);
g_return_if_fail (GTK_IS_FONT_SELECTION (object));
fontsel = GTK_FONT_SELECTION (object);
- pango_font_description_free (fontsel->font_desc);
-
if (fontsel->font)
gdk_font_unref (fontsel->font);
- if (G_OBJECT_CLASS (font_selection_parent_class)->finalize)
- (* G_OBJECT_CLASS (font_selection_parent_class)->finalize) (object);
+ (* G_OBJECT_CLASS (gtk_font_selection_parent_class)->finalize) (object);
+}
+
+static void
+gtk_font_selection_screen_changed (GtkWidget *widget,
+ GdkScreen *previous_screen)
+{
+ GtkFontSelection *fontsel = GTK_FONT_SELECTION (widget);
+
+ if (gtk_widget_has_screen (GTK_WIDGET (fontsel)))
+ {
+ gtk_font_selection_show_available_fonts (fontsel);
+ gtk_font_selection_show_available_sizes (fontsel, TRUE);
+ gtk_font_selection_show_available_styles (fontsel);
+ }
}
+static void
+gtk_font_selection_preview_changed (GtkWidget *entry,
+ GtkFontSelection *fontsel)
+{
+ g_object_notify (G_OBJECT (fontsel), "preview-text");
+}
-/* This is called when the clist is exposed. Here we scroll to the current
+static void
+scroll_to_selection (GtkTreeView *tree_view)
+{
+ GtkTreeSelection *selection = gtk_tree_view_get_selection (tree_view);
+ GtkTreeModel *model;
+ GtkTreeIter iter;
+
+ if (gtk_tree_selection_get_selected (selection, &model, &iter))
+ {
+ GtkTreePath *path = gtk_tree_model_get_path (model, &iter);
+ gtk_tree_view_scroll_to_cell (tree_view, path, NULL, TRUE, 0.5, 0.5);
+ gtk_tree_path_free (path);
+ }
+}
+
+static void
+set_cursor_to_iter (GtkTreeView *view,
+ GtkTreeIter *iter)
+{
+ GtkTreeModel *model = gtk_tree_view_get_model (view);
+ GtkTreePath *path = gtk_tree_model_get_path (model, iter);
+
+ gtk_tree_view_set_cursor (view, path, NULL, FALSE);
+
+ gtk_tree_path_free (path);
+}
+
+/* This is called when the list is mapped. Here we scroll to the current
font if necessary. */
static void
-gtk_font_selection_expose_list (GtkWidget *widget,
- GdkEventExpose *event,
- gpointer data)
+gtk_font_selection_scroll_on_map (GtkWidget *widget,
+ gpointer data)
{
GtkFontSelection *fontsel;
- GList *selection;
- gint index;
#ifdef FONTSEL_DEBUG
- g_message("In expose_list\n");
+ g_message ("In expose_list\n");
#endif
- fontsel = GTK_FONT_SELECTION(data);
+ fontsel = GTK_FONT_SELECTION (data);
- /* Try to scroll the font family clist to the selected item */
- selection = GTK_CLIST(fontsel->font_clist)->selection;
- if (selection)
- {
- index = GPOINTER_TO_INT (selection->data);
- if (gtk_clist_row_is_visible(GTK_CLIST(fontsel->font_clist), index)
- != GTK_VISIBILITY_FULL)
- gtk_clist_moveto(GTK_CLIST(fontsel->font_clist), index, -1, 0.5, 0);
- }
+ /* Try to scroll the font family list to the selected item */
+ scroll_to_selection (GTK_TREE_VIEW (fontsel->family_list));
- /* Try to scroll the font style clist to the selected item */
- selection = GTK_CLIST(fontsel->font_style_clist)->selection;
- if (selection)
- {
- index = GPOINTER_TO_INT (selection->data);
- if (gtk_clist_row_is_visible(GTK_CLIST(fontsel->font_style_clist), index)
- != GTK_VISIBILITY_FULL)
- gtk_clist_moveto(GTK_CLIST(fontsel->font_style_clist), index, -1,
- 0.5, 0);
- }
+ /* Try to scroll the font family list to the selected item */
+ scroll_to_selection (GTK_TREE_VIEW (fontsel->face_list));
- /* Try to scroll the font size clist to the selected item */
- selection = GTK_CLIST(fontsel->size_clist)->selection;
- if (selection)
- {
- index = GPOINTER_TO_INT (selection->data);
- if (gtk_clist_row_is_visible(GTK_CLIST(fontsel->size_clist), index)
- != GTK_VISIBILITY_FULL)
- gtk_clist_moveto(GTK_CLIST(fontsel->size_clist), index, -1, 0.5, 0);
- }
+ /* Try to scroll the font family list to the selected item */
+ scroll_to_selection (GTK_TREE_VIEW (fontsel->size_list));
}
/* This is called when a family is selected in the list. */
static void
-gtk_font_selection_select_font (GtkWidget *w,
- gint row,
- gint column,
- GdkEventButton *bevent,
- gpointer data)
+gtk_font_selection_select_font (GtkTreeSelection *selection,
+ gpointer data)
{
GtkFontSelection *fontsel;
- gchar *family_name;
- gint index;
-
+ GtkTreeModel *model;
+ GtkTreeIter iter;
+#ifdef INCLUDE_FONT_ENTRIES
+ const gchar *family_name;
+#endif
+
fontsel = GTK_FONT_SELECTION (data);
- if (GTK_CLIST (fontsel->font_clist)->selection)
+ if (gtk_tree_selection_get_selected (selection, &model, &iter))
{
- index = GPOINTER_TO_INT (GTK_CLIST (fontsel->font_clist)->selection->data);
-
- if (gtk_clist_get_text (GTK_CLIST (fontsel->font_clist), index, 0, &family_name) &&
- strcasecmp (fontsel->font_desc->family_name, family_name) != 0)
+ PangoFontFamily *family;
+
+ gtk_tree_model_get (model, &iter, FAMILY_COLUMN, &family, -1);
+ if (fontsel->family != family)
{
- g_free (fontsel->font_desc->family_name);
- fontsel->font_desc->family_name = g_strdup (family_name);
-
+ fontsel->family = family;
+
+#ifdef INCLUDE_FONT_ENTRIES
+ family_name = pango_font_family_get_name (fontsel->family);
gtk_entry_set_text (GTK_ENTRY (fontsel->font_entry), family_name);
+#endif
gtk_font_selection_show_available_styles (fontsel);
gtk_font_selection_select_best_style (fontsel, TRUE);
}
+
+ g_object_unref (family);
}
}
static int
-cmp_strings (const void *a, const void *b)
+cmp_families (const void *a, const void *b)
{
- return strcasecmp (*(const char **)a, *(const char **)b);
+ const char *a_name = pango_font_family_get_name (*(PangoFontFamily **)a);
+ const char *b_name = pango_font_family_get_name (*(PangoFontFamily **)b);
+
+ return g_utf8_collate (a_name, b_name);
}
static void
gtk_font_selection_show_available_fonts (GtkFontSelection *fontsel)
{
- gchar **families;
- int n_families, i;
-
+ GtkListStore *model;
+ PangoFontFamily **families;
+ PangoFontFamily *match_family = NULL;
+ gint n_families, i;
+ GtkTreeIter match_row;
+
+ model = GTK_LIST_STORE (gtk_tree_view_get_model (GTK_TREE_VIEW (fontsel->family_list)));
+
pango_context_list_families (gtk_widget_get_pango_context (GTK_WIDGET (fontsel)),
&families, &n_families);
- qsort (families, n_families, sizeof(char *), cmp_strings);
+ qsort (families, n_families, sizeof (PangoFontFamily *), cmp_families);
- gtk_clist_freeze (GTK_CLIST (fontsel->font_clist));
- gtk_clist_clear (GTK_CLIST (fontsel->font_clist));
+ gtk_list_store_clear (model);
for (i=0; i<n_families; i++)
{
- gtk_clist_append (GTK_CLIST (fontsel->font_clist), &families[i]);
-
- if (!strcasecmp (families[i], fontsel->font_desc->family_name))
+ const gchar *name = pango_font_family_get_name (families[i]);
+ GtkTreeIter iter;
+
+ gtk_list_store_append (model, &iter);
+ gtk_list_store_set (model, &iter,
+ FAMILY_COLUMN, families[i],
+ FAMILY_NAME_COLUMN, name,
+ -1);
+
+ if (i == 0 || !g_ascii_strcasecmp (name, "sans"))
{
- gtk_clist_select_row (GTK_CLIST(fontsel->font_clist), i, 0);
- gtk_entry_set_text(GTK_ENTRY(fontsel->font_entry), families[i]);
+ match_family = families[i];
+ match_row = iter;
}
}
-
- gtk_clist_thaw (GTK_CLIST(fontsel->font_clist));
-
- pango_font_map_free_families (families, n_families);
-}
-
-static gint
-gtk_font_selection_on_clist_key_press (GtkWidget *clist,
- GdkEventKey *event,
- GtkFontSelection *fontsel)
-{
-#ifdef FONTSEL_DEBUG
- g_message("In on_clist_key_press\n");
-#endif
- if (event->keyval == GDK_Up)
- return gtk_font_selection_select_next (fontsel, clist, -1);
- else if (event->keyval == GDK_Down)
- return gtk_font_selection_select_next (fontsel, clist, 1);
- else
- return FALSE;
-}
-
-
-static gboolean
-gtk_font_selection_select_next (GtkFontSelection *fontsel,
- GtkWidget *clist,
- gint step)
-{
- GList *selection;
- gint current_row, row;
-
- selection = GTK_CLIST(clist)->selection;
- if (!selection)
- return FALSE;
- current_row = GPOINTER_TO_INT (selection->data);
-
- /* Stop the normal clist key handler from being run. */
- gtk_signal_emit_stop_by_name (GTK_OBJECT (clist), "key_press_event");
- for (row = current_row + step;
- row >= 0 && row < GTK_CLIST(clist)->rows;
- row += step)
+ fontsel->family = match_family;
+ if (match_family)
{
- /* If this is the style clist, make sure that the item is not a charset
- entry. */
- if (clist == fontsel->font_style_clist)
- if (GPOINTER_TO_INT (gtk_clist_get_row_data(GTK_CLIST(clist), row)) == -1)
- continue;
-
- /* Now we've found the row to select. */
- if (gtk_clist_row_is_visible(GTK_CLIST(clist), row)
- != GTK_VISIBILITY_FULL)
- gtk_clist_moveto(GTK_CLIST(clist), row, -1, (step < 0) ? 0 : 1, 0);
- gtk_clist_select_row(GTK_CLIST(clist), row, 0);
- break;
+ set_cursor_to_iter (GTK_TREE_VIEW (fontsel->family_list), &match_row);
+#ifdef INCLUDE_FONT_ENTRIES
+ gtk_entry_set_text (GTK_ENTRY (fontsel->font_entry),
+ pango_font_family_get_name (match_family));
+#endif /* INCLUDE_FONT_ENTRIES */
}
- return TRUE;
+
+ g_free (families);
}
static int
compare_font_descriptions (const PangoFontDescription *a, const PangoFontDescription *b)
{
- int val = strcasecmp (a->family_name, b->family_name);
+ int val = strcmp (pango_font_description_get_family (a), pango_font_description_get_family (b));
if (val != 0)
return val;
- if (a->weight != b->weight)
- return a->weight - b->weight;
+ if (pango_font_description_get_weight (a) != pango_font_description_get_weight (b))
+ return pango_font_description_get_weight (a) - pango_font_description_get_weight (b);
- if (a->style != b->style)
- return a->style - b->style;
+ if (pango_font_description_get_style (a) != pango_font_description_get_style (b))
+ return pango_font_description_get_style (a) - pango_font_description_get_style (b);
- if (a->stretch != b->stretch)
- return a->stretch - b->stretch;
+ if (pango_font_description_get_stretch (a) != pango_font_description_get_stretch (b))
+ return pango_font_description_get_stretch (a) - pango_font_description_get_stretch (b);
- if (a->variant != b->variant)
- return a->variant - b->variant;
+ if (pango_font_description_get_variant (a) != pango_font_description_get_variant (b))
+ return pango_font_description_get_variant (a) - pango_font_description_get_variant (b);
return 0;
}
static int
-font_description_sort_func (const void *a, const void *b)
+faces_sort_func (const void *a, const void *b)
+{
+ PangoFontDescription *desc_a = pango_font_face_describe (*(PangoFontFace **)a);
+ PangoFontDescription *desc_b = pango_font_face_describe (*(PangoFontFace **)b);
+
+ int ord = compare_font_descriptions (desc_a, desc_b);
+
+ pango_font_description_free (desc_a);
+ pango_font_description_free (desc_b);
+
+ return ord;
+}
+
+static gboolean
+font_description_style_equal (const PangoFontDescription *a,
+ const PangoFontDescription *b)
{
- return compare_font_descriptions (*(PangoFontDescription **)a, *(PangoFontDescription **)b);
+ return (pango_font_description_get_weight (a) == pango_font_description_get_weight (b) &&
+ pango_font_description_get_style (a) == pango_font_description_get_style (b) &&
+ pango_font_description_get_stretch (a) == pango_font_description_get_stretch (b) &&
+ pango_font_description_get_variant (a) == pango_font_description_get_variant (b));
}
-/* This fills the font style clist with all the possible style combinations
+/* This fills the font style list with all the possible style combinations
for the current font family. */
static void
gtk_font_selection_show_available_styles (GtkFontSelection *fontsel)
{
- PangoFontDescription **descs;
- int n_descs, i;
- gint match_row = -1;
- gchar *str;
+ gint n_faces, i;
+ PangoFontFace **faces;
+ PangoFontDescription *old_desc;
+ GtkListStore *model;
+ GtkTreeIter match_row;
+ PangoFontFace *match_face = NULL;
+
+ model = GTK_LIST_STORE (gtk_tree_view_get_model (GTK_TREE_VIEW (fontsel->face_list)));
- pango_context_list_fonts (gtk_widget_get_pango_context (GTK_WIDGET (fontsel)),
- fontsel->font_desc->family_name, &descs, &n_descs);
- qsort (descs, n_descs, sizeof(PangoFontDescription *), font_description_sort_func);
+ if (fontsel->face)
+ old_desc = pango_font_face_describe (fontsel->face);
+ else
+ old_desc= NULL;
- gtk_clist_freeze (GTK_CLIST (fontsel->font_style_clist));
- gtk_clist_clear (GTK_CLIST (fontsel->font_style_clist));
+ pango_font_family_list_faces (fontsel->family, &faces, &n_faces);
+ qsort (faces, n_faces, sizeof (PangoFontFace *), faces_sort_func);
- for (i=0; i<n_descs; i++)
- {
- PangoFontDescription tmp_desc;
+ gtk_list_store_clear (model);
- tmp_desc = *descs[i];
- tmp_desc.family_name = NULL;
- tmp_desc.size = 0;
+ for (i=0; i < n_faces; i++)
+ {
+ GtkTreeIter iter;
+ const gchar *str = pango_font_face_get_face_name (faces[i]);
- str = pango_font_description_to_string (&tmp_desc);
- gtk_clist_append (GTK_CLIST (fontsel->font_style_clist), &str);
+ gtk_list_store_append (model, &iter);
+ gtk_list_store_set (model, &iter,
+ FACE_COLUMN, faces[i],
+ FACE_NAME_COLUMN, str,
+ -1);
- if (descs[i]->weight == fontsel->font_desc->weight &&
- descs[i]->style == fontsel->font_desc->style &&
- descs[i]->stretch == fontsel->font_desc->stretch &&
- descs[i]->variant == fontsel->font_desc->variant)
- match_row = i;
+ if (i == 0)
+ {
+ match_row = iter;
+ match_face = faces[i];
+ }
+ else if (old_desc)
+ {
+ PangoFontDescription *tmp_desc = pango_font_face_describe (faces[i]);
+
+ if (font_description_style_equal (tmp_desc, old_desc))
+ {
+ match_row = iter;
+ match_face = faces[i];
+ }
- g_free (str);
+ pango_font_description_free (tmp_desc);
+ }
}
- gtk_clist_select_row (GTK_CLIST (fontsel->font_style_clist), match_row, 0);
- if (match_row >= 0)
+ if (old_desc)
+ pango_font_description_free (old_desc);
+
+ fontsel->face = match_face;
+ if (match_face)
{
- gtk_clist_get_text (GTK_CLIST (fontsel->font_style_clist), match_row, 0, &str);
+#ifdef INCLUDE_FONT_ENTRIES
+ const gchar *str = pango_font_face_get_face_name (fontsel->face);
+
gtk_entry_set_text (GTK_ENTRY (fontsel->font_style_entry), str);
+#endif
+ set_cursor_to_iter (GTK_TREE_VIEW (fontsel->face_list), &match_row);
}
-
- gtk_clist_thaw (GTK_CLIST(fontsel->font_style_clist));
- pango_font_descriptions_free (descs, n_descs);
+ g_free (faces);
}
-
/* This selects a style when the user selects a font. It just uses the first
available style at present. I was thinking of trying to maintain the
selected style, e.g. bold italic, when the user selects different fonts.
However, the interface is so easy to use now I'm not sure it's worth it.
Note: This will load a font. */
static void
-gtk_font_selection_select_best_style(GtkFontSelection *fontsel,
- gboolean use_first)
+gtk_font_selection_select_best_style (GtkFontSelection *fontsel,
+ gboolean use_first)
{
- gint best_row = 0;
-
- gtk_clist_select_row(GTK_CLIST(fontsel->font_style_clist), best_row, 0);
- if (gtk_clist_row_is_visible(GTK_CLIST(fontsel->font_style_clist), best_row)
- != GTK_VISIBILITY_FULL)
- gtk_clist_moveto(GTK_CLIST(fontsel->font_style_clist), best_row, -1,
- 0.5, 0);
- gtk_font_selection_show_available_sizes (fontsel);
+ GtkTreeIter iter;
+ GtkTreeModel *model;
+
+ model = gtk_tree_view_get_model (GTK_TREE_VIEW (fontsel->face_list));
+
+ if (gtk_tree_model_get_iter_first (model, &iter))
+ {
+ set_cursor_to_iter (GTK_TREE_VIEW (fontsel->face_list), &iter);
+ scroll_to_selection (GTK_TREE_VIEW (fontsel->face_list));
+ }
+
+ gtk_font_selection_show_available_sizes (fontsel, FALSE);
gtk_font_selection_select_best_size (fontsel);
}
/* This is called when a style is selected in the list. */
static void
-gtk_font_selection_select_style (GtkWidget *w,
- gint row,
- gint column,
- GdkEventButton *bevent,
- gpointer data)
+gtk_font_selection_select_style (GtkTreeSelection *selection,
+ gpointer data)
{
GtkFontSelection *fontsel = GTK_FONT_SELECTION (data);
- PangoFontDescription *tmp_desc;
- gchar *text;
- gint index;
+ GtkTreeModel *model;
+ GtkTreeIter iter;
- if (bevent && !GTK_WIDGET_HAS_FOCUS (w))
- gtk_widget_grab_focus (w);
-
- if (GTK_CLIST (fontsel->font_style_clist)->selection)
+ if (gtk_tree_selection_get_selected (selection, &model, &iter))
{
- index = GPOINTER_TO_INT (GTK_CLIST (fontsel->font_style_clist)->selection->data);
+ PangoFontFace *face;
+
+ gtk_tree_model_get (model, &iter, FACE_COLUMN, &face, -1);
+ fontsel->face = face;
- if (gtk_clist_get_text (GTK_CLIST (fontsel->font_style_clist), index, 0, &text))
- {
- tmp_desc = pango_font_description_from_string (text);
-
- fontsel->font_desc->style = tmp_desc->style;
- fontsel->font_desc->variant = tmp_desc->variant;
- fontsel->font_desc->weight = tmp_desc->weight;
- fontsel->font_desc->stretch = tmp_desc->stretch;
-
- pango_font_description_free (tmp_desc);
- }
+ g_object_unref (face);
}
- gtk_font_selection_show_available_sizes (fontsel);
+ gtk_font_selection_show_available_sizes (fontsel, FALSE);
gtk_font_selection_select_best_size (fontsel);
}
static void
-gtk_font_selection_show_available_sizes (GtkFontSelection *fontsel)
+gtk_font_selection_show_available_sizes (GtkFontSelection *fontsel,
+ gboolean first_time)
{
gint i;
+ GtkListStore *model;
gchar buffer[128];
- gchar *size;
+ gchar *p;
+
+ model = GTK_LIST_STORE (gtk_tree_view_get_model (GTK_TREE_VIEW (fontsel->size_list)));
/* Insert the standard font sizes */
- gtk_clist_freeze (GTK_CLIST (fontsel->size_clist));
- gtk_clist_clear (GTK_CLIST (fontsel->size_clist));
+ if (first_time)
+ {
+ gtk_list_store_clear (model);
- for (i = 0; i < G_N_ELEMENTS (font_sizes); i++)
+ for (i = 0; i < G_N_ELEMENTS (font_sizes); i++)
+ {
+ GtkTreeIter iter;
+
+ gtk_list_store_append (model, &iter);
+ gtk_list_store_set (model, &iter, SIZE_COLUMN, font_sizes[i], -1);
+
+ if (font_sizes[i] * PANGO_SCALE == fontsel->size)
+ set_cursor_to_iter (GTK_TREE_VIEW (fontsel->size_list), &iter);
+ }
+ }
+ else
{
- sprintf(buffer, "%i", font_sizes[i]);
- size = buffer;
- gtk_clist_append (GTK_CLIST(fontsel->size_clist), &size);
- if (font_sizes[i] * PANGO_SCALE == fontsel->font_desc->size)
- gtk_clist_select_row(GTK_CLIST(fontsel->size_clist), i, 0);
+ GtkTreeIter iter;
+ gboolean found = FALSE;
+
+ gtk_tree_model_get_iter_first (GTK_TREE_MODEL (model), &iter);
+ for (i = 0; i < G_N_ELEMENTS (font_sizes) && !found; i++)
+ {
+ if (font_sizes[i] * PANGO_SCALE == fontsel->size)
+ {
+ set_cursor_to_iter (GTK_TREE_VIEW (fontsel->size_list), &iter);
+ found = TRUE;
+ }
+
+ gtk_tree_model_iter_next (GTK_TREE_MODEL (model), &iter);
+ }
+
+ if (!found)
+ {
+ GtkTreeSelection *selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (fontsel->size_list));
+ gtk_tree_selection_unselect_all (selection);
+ }
+ }
+
+ /* Set the entry to the new size, rounding to 1 digit,
+ * trimming of trailing 0's and a trailing period
+ */
+ g_snprintf (buffer, sizeof (buffer), "%.1f", fontsel->size / (1.0 * PANGO_SCALE));
+ if (strchr (buffer, '.'))
+ {
+ p = buffer + strlen (buffer) - 1;
+ while (*p == '0')
+ p--;
+ if (*p == '.')
+ p--;
+ p[1] = '\0';
}
- gtk_clist_thaw (GTK_CLIST(fontsel->size_clist));
- sprintf (buffer, "%i", fontsel->font_desc->size / PANGO_SCALE);
- gtk_entry_set_text (GTK_ENTRY(fontsel->size_entry), buffer);
+ /* Compare, to avoid moving the cursor unecessarily */
+ if (strcmp (gtk_entry_get_text (GTK_ENTRY (fontsel->size_entry)), buffer) != 0)
+ gtk_entry_set_text (GTK_ENTRY (fontsel->size_entry), buffer);
}
static void
gtk_font_selection_load_font (fontsel);
}
+static void
+gtk_font_selection_set_size (GtkFontSelection *fontsel,
+ gint new_size)
+{
+ if (fontsel->size != new_size)
+ {
+ fontsel->size = new_size;
+
+ gtk_font_selection_show_available_sizes (fontsel, FALSE);
+ gtk_font_selection_load_font (fontsel);
+ }
+}
+
/* If the user hits return in the font size entry, we change to the new font
size. */
-static gint
-gtk_font_selection_size_key_press (GtkWidget *w,
- GdkEventKey *event,
- gpointer data)
+static void
+gtk_font_selection_size_activate (GtkWidget *w,
+ gpointer data)
{
GtkFontSelection *fontsel;
gint new_size;
- gchar *text;
+ const gchar *text;
fontsel = GTK_FONT_SELECTION (data);
+
+ text = gtk_entry_get_text (GTK_ENTRY (fontsel->size_entry));
+ new_size = MAX (0.1, atof (text) * PANGO_SCALE + 0.5);
+
+ if (fontsel->size != new_size)
+ gtk_font_selection_set_size (fontsel, new_size);
+ else
+ list_row_activated (w);
+}
+
+static gboolean
+gtk_font_selection_size_focus_out (GtkWidget *w,
+ GdkEventFocus *event,
+ gpointer data)
+{
+ GtkFontSelection *fontsel;
+ gint new_size;
+ const gchar *text;
- if (event->keyval == GDK_Return)
- {
- text = gtk_entry_get_text (GTK_ENTRY (fontsel->size_entry));
- new_size = atoi (text) * PANGO_SCALE;
+ fontsel = GTK_FONT_SELECTION (data);
- if (fontsel->font_desc->size != new_size)
- {
- fontsel->font_desc->size = new_size;
- gtk_font_selection_load_font (fontsel);
- }
- return TRUE;
- }
+ text = gtk_entry_get_text (GTK_ENTRY (fontsel->size_entry));
+ new_size = MAX (0.1, atof (text) * PANGO_SCALE + 0.5);
+
+ gtk_font_selection_set_size (fontsel, new_size);
- return FALSE;
+ return TRUE;
}
/* This is called when a size is selected in the list. */
static void
-gtk_font_selection_select_size (GtkWidget *w,
- gint row,
- gint column,
- GdkEventButton *bevent,
- gpointer data)
+gtk_font_selection_select_size (GtkTreeSelection *selection,
+ gpointer data)
{
GtkFontSelection *fontsel;
+ GtkTreeModel *model;
+ GtkTreeIter iter;
gint new_size;
- gchar *text;
fontsel = GTK_FONT_SELECTION (data);
- if (bevent && !GTK_WIDGET_HAS_FOCUS (w))
- gtk_widget_grab_focus (w);
-
- gtk_clist_get_text(GTK_CLIST(fontsel->size_clist), row, 0, &text);
- new_size = atoi (text) * PANGO_SCALE;
-
- if (fontsel->font_desc->size != new_size)
+ if (gtk_tree_selection_get_selected (selection, &model, &iter))
{
- /* If the size was selected by the user we set the selected_size. */
- fontsel->font_desc->size = new_size;
-
- gtk_font_selection_load_font (fontsel);
+ gtk_tree_model_get (model, &iter, SIZE_COLUMN, &new_size, -1);
+ gtk_font_selection_set_size (fontsel, new_size * PANGO_SCALE);
}
}
gtk_font_selection_update_preview (fontsel);
}
+static PangoFontDescription *
+gtk_font_selection_get_font_description (GtkFontSelection *fontsel)
+{
+ PangoFontDescription *font_desc;
+
+ if (fontsel->face)
+ {
+ font_desc = pango_font_face_describe (fontsel->face);
+ pango_font_description_set_size (font_desc, fontsel->size);
+ }
+ else
+ font_desc = pango_font_description_from_string (DEFAULT_FONT_NAME);
+
+ return font_desc;
+}
+
/* This sets the font in the preview entry to the selected font, and tries to
make sure that the preview entry is a reasonable size, i.e. so that the
text can be seen with a bit of space to spare. But it tries to avoid
gint new_height;
GtkRequisition old_requisition;
GtkWidget *preview_entry = fontsel->preview_entry;
- gchar *text;
+ const gchar *text;
gtk_widget_get_child_requisition (preview_entry, &old_requisition);
rc_style = gtk_rc_style_new ();
- rc_style->font_desc = pango_font_description_copy (fontsel->font_desc);
+ rc_style->font_desc = gtk_font_selection_get_font_description (fontsel);
+
gtk_widget_modify_style (preview_entry, rc_style);
- gtk_rc_style_unref (rc_style);
+ g_object_unref (rc_style);
gtk_widget_size_request (preview_entry, NULL);
new_height = CLAMP (preview_entry->requisition.height, INITIAL_PREVIEW_HEIGHT, MAX_PREVIEW_HEIGHT);
if (new_height > old_requisition.height || new_height < old_requisition.height - 30)
- gtk_widget_set_usize(preview_entry, -1, new_height);
+ gtk_widget_set_size_request (preview_entry, -1, new_height);
/* This sets the preview text, if it hasn't been set already. */
- text = gtk_entry_get_text(GTK_ENTRY(preview_entry));
- if (strlen(text) == 0)
- gtk_entry_set_text(GTK_ENTRY(preview_entry), PREVIEW_TEXT);
- gtk_entry_set_position(GTK_ENTRY(preview_entry), 0);
+ text = gtk_entry_get_text (GTK_ENTRY (preview_entry));
+ if (strlen (text) == 0)
+ gtk_entry_set_text (GTK_ENTRY (preview_entry), _(PREVIEW_TEXT));
+ gtk_editable_set_position (GTK_EDITABLE (preview_entry), 0);
+}
+
+static GdkFont*
+gtk_font_selection_get_font_internal (GtkFontSelection *fontsel)
+{
+ if (!fontsel->font)
+ {
+ PangoFontDescription *font_desc = gtk_font_selection_get_font_description (fontsel);
+ fontsel->font = gdk_font_from_description_for_display (gtk_widget_get_display (GTK_WIDGET (fontsel)), font_desc);
+ pango_font_description_free (font_desc);
+ }
+
+ return fontsel->font;
}
+
/*****************************************************************************
* These functions are the main public interface for getting/setting the font.
*****************************************************************************/
-GdkFont*
-gtk_font_selection_get_font (GtkFontSelection *fontsel)
+/**
+ * gtk_font_selection_get_family_entry:
+ * @fontsel: a #GtkFontSelection
+ *
+ * This returns the #GtkEntry that allows the user to manually enter
+ * the font family they want to use.
+ *
+ * Return value: A #GtkWidget.
+ *
+ * Since: 2.14
+ **/
+GtkWidget *
+gtk_font_selection_get_family_entry (GtkFontSelection *fontsel)
{
- if (!fontsel->font)
- fontsel->font = gdk_font_from_description (fontsel->font_desc);
+ g_return_val_if_fail (GTK_IS_FONT_SELECTION (fontsel), NULL);
- return fontsel->font;
+ return fontsel->font_entry;
+}
+
+/**
+ * gtk_font_selection_get_family_list:
+ * @fontsel: a #GtkFontSelection
+ *
+ * This returns the #GtkTreeView that lists font families, for
+ * example, 'Sans', 'Serif', etc.
+ *
+ * Return value: A #GtkWidget.
+ *
+ * Since: 2.14
+ **/
+GtkWidget *
+gtk_font_selection_get_family_list (GtkFontSelection *fontsel)
+{
+ g_return_val_if_fail (GTK_IS_FONT_SELECTION (fontsel), NULL);
+
+ return fontsel->family_list;
+}
+
+/**
+ * gtk_font_selection_get_face_entry:
+ * @fontsel: a #GtkFontSelection
+ *
+ * This returns the #GtkEntry responsible for allowing manual
+ * configuration of the font style.
+ *
+ * Return value: A #GtkWidget.
+ *
+ * Since: 2.14
+ **/
+GtkWidget *
+gtk_font_selection_get_face_entry (GtkFontSelection *fontsel)
+{
+ g_return_val_if_fail (GTK_IS_FONT_SELECTION (fontsel), NULL);
+
+ return fontsel->font_style_entry;
}
+/**
+ * gtk_font_selection_get_face_list:
+ * @fontsel: a #GtkFontSelection
+ *
+ * This returns the #GtkTreeView which lists all styles available for
+ * the selected font. For example, 'Regular', 'Bold', etc.
+ *
+ * Return value: A #GtkWidget.
+ *
+ * Since: 2.14
+ **/
+GtkWidget *
+gtk_font_selection_get_face_list (GtkFontSelection *fontsel)
+{
+ g_return_val_if_fail (GTK_IS_FONT_SELECTION (fontsel), NULL);
+
+ return fontsel->face_list;
+}
+/**
+ * gtk_font_selection_get_size_entry:
+ * @fontsel: a #GtkFontSelection
+ *
+ * This returns the #GtkEntry used to allow the user to edit the font
+ * number manually instead of selecting it from the list of font sizes.
+ *
+ * Return value: A #GtkWidget.
+ *
+ * Since: 2.14
+ **/
+GtkWidget *
+gtk_font_selection_get_size_entry (GtkFontSelection *fontsel)
+{
+ g_return_val_if_fail (GTK_IS_FONT_SELECTION (fontsel), NULL);
+
+ return fontsel->size_entry;
+}
+
+/**
+ * gtk_font_selection_get_size_list:
+ * @fontsel: a #GtkFontSelection
+ *
+ * This returns the #GtkTreeeView used to list font sizes.
+ *
+ * Return value: A #GtkWidget.
+ *
+ * Since: 2.14
+ **/
+GtkWidget *
+gtk_font_selection_get_size_list (GtkFontSelection *fontsel)
+{
+ g_return_val_if_fail (GTK_IS_FONT_SELECTION (fontsel), NULL);
+
+ return fontsel->size_list;
+}
+
+/**
+ * gtk_font_selection_get_preview_entry:
+ * @fontsel: a #GtkFontSelection
+ *
+ * This returns the #GtkEntry used to display the font as a preview.
+ *
+ * Return value: A #GtkWidget.
+ *
+ * Since: 2.14
+ **/
+GtkWidget *
+gtk_font_selection_get_preview_entry (GtkFontSelection *fontsel)
+{
+ g_return_val_if_fail (GTK_IS_FONT_SELECTION (fontsel), NULL);
+
+ return fontsel->preview_entry;
+}
+
+/**
+ * gtk_font_selection_get_family:
+ * @fontsel: a #GtkFontSelection
+ *
+ * Gets the #PangoFontFamily representing the selected font family.
+ *
+ * Return value: A #PangoFontFamily representing the selected font
+ * family. Font families are a collection of font faces.
+ *
+ * Since: 2.14
+ **/
+PangoFontFamily *
+gtk_font_selection_get_family (GtkFontSelection *fontsel)
+{
+ g_return_val_if_fail (GTK_IS_FONT_SELECTION (fontsel), NULL);
+
+ return fontsel->family;
+}
+
+/**
+ * gtk_font_selection_get_face:
+ * @fontsel: a #GtkFontSelection
+ *
+ * Gets the #PangoFontFace representing the selected font group
+ * details (i.e. family, slant, weight, width, etc).
+ *
+ * Return value: A #PangoFontFace representing the selected font group
+ * details
+ *
+ * Since: 2.14
+ **/
+PangoFontFace *
+gtk_font_selection_get_face (GtkFontSelection *fontsel)
+{
+ g_return_val_if_fail (GTK_IS_FONT_SELECTION (fontsel), NULL);
+
+ return fontsel->face;
+}
+
+/**
+ * gtk_font_selection_get_size:
+ * @fontsel: a #GtkFontSelection
+ *
+ * The selected font size.
+ *
+ * Return value: A #gint representing the font size selected, or -1
+ * if not.
+ *
+ * Since: 2.14
+ **/
+gint
+gtk_font_selection_get_size (GtkFontSelection *fontsel)
+{
+ g_return_val_if_fail (GTK_IS_FONT_SELECTION (fontsel), -1);
+
+ return fontsel->size;
+}
+
+/**
+ * gtk_font_selection_get_font:
+ * @fontsel: a #GtkFontSelection
+ *
+ * Return value: A #GdkFont.
+ *
+ * Deprecated: 2.0: Use gtk_font_selection_get_font_name() instead.
+ **/
+GdkFont *
+gtk_font_selection_get_font (GtkFontSelection *fontsel)
+{
+ g_return_val_if_fail (GTK_IS_FONT_SELECTION (fontsel), NULL);
+
+ return gtk_font_selection_get_font_internal (fontsel);
+}
+
+/**
+ * gtk_font_selection_get_font_name:
+ * @fontsel: a #GtkFontSelection
+ *
+ * Gets the currently-selected font name. Note that this can be a different
+ * string than what you set with gtk_font_selection_set_font_name(), as
+ * the font selection widget may normalize font names and thus return a string
+ * with a different structure. For example, "Helvetica Italic Bold 12" could be
+ * normalized to "Helvetica Bold Italic 12". Use pango_font_description_equal()
+ * if you want to compare two font descriptions.
+ *
+ * Return value: A string with the name of the current font, or #NULL if no font
+ * is selected. You must free this string with g_free().
+ **/
gchar *
gtk_font_selection_get_font_name (GtkFontSelection *fontsel)
{
- return pango_font_description_to_string (fontsel->font_desc);
+ gchar *result;
+
+ PangoFontDescription *font_desc = gtk_font_selection_get_font_description (fontsel);
+ result = pango_font_description_to_string (font_desc);
+ pango_font_description_free (font_desc);
+
+ return result;
}
-/* This sets the current font, selecting the appropriate clist rows.
+/* This sets the current font, selecting the appropriate list rows.
First we check the fontname is valid and try to find the font family
- i.e. the name in the main list. If we can't find that, then just return.
Next we try to set each of the properties according to the fontname.
- Finally we select the font family & style in the clists. */
+ Finally we select the font family & style in the lists. */
+
+/**
+ * gtk_font_selection_set_font_name:
+ * @fontsel: a #GtkFontSelection
+ * @fontname: a font name like "Helvetica 12" or "Times Bold 18"
+ *
+ * Sets the currently-selected font. Note that the @fontsel needs to know the
+ * screen in which it will appear for this to work; this can be guaranteed by
+ * simply making sure that the @fontsel is inserted in a toplevel window before
+ * you call this function.
+ *
+ * Return value: #TRUE if the font could be set successfully; #FALSE if no such
+ * font exists or if the @fontsel doesn't belong to a particular screen yet.
+ **/
gboolean
gtk_font_selection_set_font_name (GtkFontSelection *fontsel,
const gchar *fontname)
{
+ PangoFontFamily *new_family = NULL;
+ PangoFontFace *new_face = NULL;
+ PangoFontFace *fallback_face = NULL;
PangoFontDescription *new_desc;
- PangoFontDescription **descs;
- int n_descs, i;
- gboolean found = FALSE;
-
- g_return_val_if_fail (fontsel != NULL, FALSE);
+ GtkTreeModel *model;
+ GtkTreeIter iter;
+ GtkTreeIter match_iter;
+ gboolean valid;
+ const gchar *new_family_name;
+
g_return_val_if_fail (GTK_IS_FONT_SELECTION (fontsel), FALSE);
+ g_return_val_if_fail (gtk_widget_has_screen (GTK_WIDGET (fontsel)), FALSE);
new_desc = pango_font_description_from_string (fontname);
+ new_family_name = pango_font_description_get_family (new_desc);
+
+ if (!new_family_name)
+ return FALSE;
+
+ /* Check to make sure that this is in the list of allowed fonts
+ */
+ model = gtk_tree_view_get_model (GTK_TREE_VIEW (fontsel->family_list));
+ for (valid = gtk_tree_model_get_iter_first (model, &iter);
+ valid;
+ valid = gtk_tree_model_iter_next (model, &iter))
+ {
+ PangoFontFamily *family;
+
+ gtk_tree_model_get (model, &iter, FAMILY_COLUMN, &family, -1);
+
+ if (g_ascii_strcasecmp (pango_font_family_get_name (family),
+ new_family_name) == 0)
+ new_family = family;
+
+ g_object_unref (family);
+
+ if (new_family)
+ break;
+ }
- /* Check to make sure that this is in the list of allowed fonts */
+ if (!new_family)
+ return FALSE;
- pango_context_list_fonts (gtk_widget_get_pango_context (GTK_WIDGET (fontsel)),
- new_desc->family_name, &descs, &n_descs);
+ fontsel->family = new_family;
+ set_cursor_to_iter (GTK_TREE_VIEW (fontsel->family_list), &iter);
+ gtk_font_selection_show_available_styles (fontsel);
- for (i=0; i<n_descs; i++)
+ model = gtk_tree_view_get_model (GTK_TREE_VIEW (fontsel->face_list));
+ for (valid = gtk_tree_model_get_iter_first (model, &iter);
+ valid;
+ valid = gtk_tree_model_iter_next (model, &iter))
{
- if (descs[i]->weight == new_desc->weight &&
- descs[i]->style == new_desc->style &&
- descs[i]->stretch == new_desc->stretch &&
- descs[i]->variant == new_desc->variant)
+ PangoFontFace *face;
+ PangoFontDescription *tmp_desc;
+
+ gtk_tree_model_get (model, &iter, FACE_COLUMN, &face, -1);
+ tmp_desc = pango_font_face_describe (face);
+
+ if (font_description_style_equal (tmp_desc, new_desc))
+ new_face = face;
+
+ if (!fallback_face)
{
- found = TRUE;
+ fallback_face = face;
+ match_iter = iter;
+ }
+
+ pango_font_description_free (tmp_desc);
+ g_object_unref (face);
+
+ if (new_face)
+ {
+ match_iter = iter;
break;
}
}
- pango_font_descriptions_free (descs, n_descs);
+ if (!new_face)
+ new_face = fallback_face;
- if (!found)
- return FALSE;
+ fontsel->face = new_face;
+ set_cursor_to_iter (GTK_TREE_VIEW (fontsel->face_list), &match_iter);
+
+ gtk_font_selection_set_size (fontsel, pango_font_description_get_size (new_desc));
+
+ g_object_freeze_notify (G_OBJECT (fontsel));
+ g_object_notify (G_OBJECT (fontsel), "font-name");
+ g_object_notify (G_OBJECT (fontsel), "font");
+ g_object_thaw_notify (G_OBJECT (fontsel));
- pango_font_description_free (fontsel->font_desc);
- fontsel->font_desc = new_desc;
+ pango_font_description_free (new_desc);
return TRUE;
}
-
-/* This returns the text in the preview entry. You should copy the returned
- text if you need it. */
-gchar*
-gtk_font_selection_get_preview_text (GtkFontSelection *fontsel)
+/**
+ * gtk_font_selection_get_preview_text:
+ * @fontsel: a #GtkFontSelection
+ *
+ * The text returned is the preview text used to show how the selected
+ * font looks.
+ *
+ * Return value: pointer to the preview text string. This string
+ * points to internally allocated storage in the widget and must not
+ * be freed, modified or stored.
+ **/
+G_CONST_RETURN gchar*
+gtk_font_selection_get_preview_text (GtkFontSelection *fontsel)
{
+ g_return_val_if_fail (GTK_IS_FONT_SELECTION (fontsel), NULL);
+
return gtk_entry_get_text (GTK_ENTRY (fontsel->preview_entry));
}
-/* This sets the text in the preview entry. */
+/**
+ * gtk_font_selection_set_preview_text:
+ * @fontsel: a #GtkFontSelection
+ * @text: a pointer to a string
+ *
+ * The @text is used to show how the selected font looks.
+ **/
void
gtk_font_selection_set_preview_text (GtkFontSelection *fontsel,
- const gchar *text)
+ const gchar *text)
{
+ g_return_if_fail (GTK_IS_FONT_SELECTION (fontsel));
+ g_return_if_fail (text != NULL);
+
gtk_entry_set_text (GTK_ENTRY (fontsel->preview_entry), text);
}
* GtkFontSelectionDialog
*****************************************************************************/
-GtkType
-gtk_font_selection_dialog_get_type (void)
-{
- static guint font_selection_dialog_type = 0;
-
- if (!font_selection_dialog_type)
- {
- GtkTypeInfo fontsel_diag_info =
- {
- "GtkFontSelectionDialog",
- sizeof (GtkFontSelectionDialog),
- sizeof (GtkFontSelectionDialogClass),
- (GtkClassInitFunc) gtk_font_selection_dialog_class_init,
- (GtkObjectInitFunc) gtk_font_selection_dialog_init,
- /* reserved_1 */ NULL,
- /* reserved_2 */ NULL,
- (GtkClassInitFunc) NULL,
- };
-
- font_selection_dialog_type = gtk_type_unique (GTK_TYPE_DIALOG,
- &fontsel_diag_info);
- }
-
- return font_selection_dialog_type;
-}
+static void gtk_font_selection_dialog_buildable_interface_init (GtkBuildableIface *iface);
+static GObject * gtk_font_selection_dialog_buildable_get_internal_child (GtkBuildable *buildable,
+ GtkBuilder *builder,
+ const gchar *childname);
+
+G_DEFINE_TYPE_WITH_CODE (GtkFontSelectionDialog, gtk_font_selection_dialog,
+ GTK_TYPE_DIALOG,
+ G_IMPLEMENT_INTERFACE (GTK_TYPE_BUILDABLE,
+ gtk_font_selection_dialog_buildable_interface_init))
+
+static GtkBuildableIface *parent_buildable_iface;
static void
gtk_font_selection_dialog_class_init (GtkFontSelectionDialogClass *klass)
{
- GtkObjectClass *object_class;
-
- object_class = (GtkObjectClass*) klass;
-
- font_selection_dialog_parent_class = gtk_type_class (GTK_TYPE_DIALOG);
}
static void
gtk_font_selection_dialog_init (GtkFontSelectionDialog *fontseldiag)
{
- GtkDialog *dialog;
-
- dialog = GTK_DIALOG (fontseldiag);
+ GtkDialog *dialog = GTK_DIALOG (fontseldiag);
- fontseldiag->dialog_width = -1;
- fontseldiag->auto_resize = TRUE;
-
- gtk_widget_set_events(GTK_WIDGET(fontseldiag), GDK_STRUCTURE_MASK);
- gtk_signal_connect (GTK_OBJECT (fontseldiag), "configure_event",
- (GtkSignalFunc) gtk_font_selection_dialog_on_configure,
- fontseldiag);
-
- gtk_container_set_border_width (GTK_CONTAINER (fontseldiag), 4);
- gtk_window_set_policy(GTK_WINDOW(fontseldiag), FALSE, TRUE, TRUE);
+ gtk_dialog_set_has_separator (dialog, FALSE);
+ gtk_container_set_border_width (GTK_CONTAINER (dialog), 5);
+ gtk_box_set_spacing (GTK_BOX (dialog->vbox), 2); /* 2 * 5 + 2 = 12 */
+ gtk_container_set_border_width (GTK_CONTAINER (dialog->action_area), 5);
+ gtk_box_set_spacing (GTK_BOX (dialog->action_area), 6);
+
+ gtk_widget_push_composite_child ();
+
+ gtk_window_set_resizable (GTK_WINDOW (fontseldiag), TRUE);
fontseldiag->main_vbox = dialog->vbox;
- fontseldiag->fontsel = gtk_font_selection_new();
- gtk_container_set_border_width (GTK_CONTAINER (fontseldiag->fontsel), 4);
+ fontseldiag->fontsel = gtk_font_selection_new ();
+ gtk_container_set_border_width (GTK_CONTAINER (fontseldiag->fontsel), 5);
gtk_widget_show (fontseldiag->fontsel);
gtk_box_pack_start (GTK_BOX (fontseldiag->main_vbox),
fontseldiag->fontsel, TRUE, TRUE, 0);
/* Create the action area */
fontseldiag->action_area = dialog->action_area;
-
- fontseldiag->ok_button = gtk_dialog_add_button (dialog,
- GTK_STOCK_BUTTON_OK,
- GTK_RESPONSE_OK);
- gtk_widget_grab_default (fontseldiag->ok_button);
-
+
+ fontseldiag->cancel_button = gtk_dialog_add_button (dialog,
+ GTK_STOCK_CANCEL,
+ GTK_RESPONSE_CANCEL);
+
fontseldiag->apply_button = gtk_dialog_add_button (dialog,
- GTK_STOCK_BUTTON_APPLY,
+ GTK_STOCK_APPLY,
GTK_RESPONSE_APPLY);
gtk_widget_hide (fontseldiag->apply_button);
+ fontseldiag->ok_button = gtk_dialog_add_button (dialog,
+ GTK_STOCK_OK,
+ GTK_RESPONSE_OK);
+ gtk_widget_grab_default (fontseldiag->ok_button);
- fontseldiag->cancel_button = gtk_dialog_add_button (dialog,
- GTK_STOCK_BUTTON_CANCEL,
- GTK_RESPONSE_CANCEL);
+ gtk_dialog_set_alternative_button_order (GTK_DIALOG (fontseldiag),
+ GTK_RESPONSE_OK,
+ GTK_RESPONSE_APPLY,
+ GTK_RESPONSE_CANCEL,
+ -1);
gtk_window_set_title (GTK_WINDOW (fontseldiag),
_("Font Selection"));
+ gtk_widget_pop_composite_child ();
+
+ _gtk_dialog_set_ignore_separator (dialog, TRUE);
}
+/**
+ * gtk_font_selection_dialog_new:
+ * @title: a pointer to a string
+ *
+ * The @title is used to set the title of the #GtkFontSelectionDialog
+ * returned. This #GtkDialog is specifically catered with widgets for
+ * selecting a font from those installed.
+ *
+ * Return value: a new #GtkFontSelectionDialog.
+ */
GtkWidget*
-gtk_font_selection_dialog_new (const gchar *title)
+gtk_font_selection_dialog_new (const gchar *title)
{
GtkFontSelectionDialog *fontseldiag;
- fontseldiag = gtk_type_new (GTK_TYPE_FONT_SELECTION_DIALOG);
+ fontseldiag = g_object_new (GTK_TYPE_FONT_SELECTION_DIALOG, NULL);
if (title)
gtk_window_set_title (GTK_WINDOW (fontseldiag), title);
return GTK_WIDGET (fontseldiag);
}
+/**
+ * gtk_font_selection_dialog_get_ok_button:
+ * @fsd: a #GtkFontSelectionDialog
+ *
+ * Gets the 'OK' button.
+ *
+ * Return value: the #GtkWidget used in the dialog for the 'OK' button.
+ *
+ * Since: 2.14
+ */
+GtkWidget *
+gtk_font_selection_dialog_get_ok_button (GtkFontSelectionDialog *fsd)
+{
+ g_return_val_if_fail (GTK_IS_FONT_SELECTION_DIALOG (fsd), NULL);
+
+ return fsd->ok_button;
+}
+
+/**
+ * gtk_font_selection_dialog_get_apply_button:
+ * @fsd: a #GtkFontSelectionDialog
+ *
+ * Gets the 'Apply' button.
+ *
+ * Return value: the #GtkWidget used in the dialog for the 'Apply' button.
+ *
+ * Since: 2.14
+ */
+GtkWidget *
+gtk_font_selection_dialog_get_apply_button (GtkFontSelectionDialog *fsd)
+{
+ g_return_val_if_fail (GTK_IS_FONT_SELECTION_DIALOG (fsd), NULL);
+
+ return fsd->apply_button;
+}
+
+/**
+ * gtk_font_selection_dialog_get_cancel_button:
+ * @fsd: a #GtkFontSelectionDialog
+ *
+ * Gets the 'Cancel' button.
+ *
+ * Return value: the #GtkWidget used in the dialog for the 'Cancel' button.
+ */
+GtkWidget *
+gtk_font_selection_dialog_get_cancel_button (GtkFontSelectionDialog *fsd)
+{
+ g_return_val_if_fail (GTK_IS_FONT_SELECTION_DIALOG (fsd), NULL);
+
+ return fsd->cancel_button;
+}
+
+static void
+gtk_font_selection_dialog_buildable_interface_init (GtkBuildableIface *iface)
+{
+ parent_buildable_iface = g_type_interface_peek_parent (iface);
+ iface->get_internal_child = gtk_font_selection_dialog_buildable_get_internal_child;
+}
+
+static GObject *
+gtk_font_selection_dialog_buildable_get_internal_child (GtkBuildable *buildable,
+ GtkBuilder *builder,
+ const gchar *childname)
+{
+ if (strcmp(childname, "ok_button") == 0)
+ return G_OBJECT (GTK_FONT_SELECTION_DIALOG(buildable)->ok_button);
+ else if (strcmp(childname, "cancel_button") == 0)
+ return G_OBJECT (GTK_FONT_SELECTION_DIALOG (buildable)->cancel_button);
+ else if (strcmp(childname, "apply_button") == 0)
+ return G_OBJECT (GTK_FONT_SELECTION_DIALOG(buildable)->apply_button);
+ else if (strcmp(childname, "font_selection") == 0)
+ return G_OBJECT (GTK_FONT_SELECTION_DIALOG(buildable)->fontsel);
+
+ return parent_buildable_iface->get_internal_child (buildable, builder, childname);
+}
+
+/**
+ * gtk_font_selection_dialog_get_font_name:
+ * @fsd: a #GtkFontSelectionDialog
+ *
+ * Gets the currently-selected font name. Note that this can be a different
+ * string than what you set with gtk_font_selection_dialog_set_font_name(), as
+ * the font selection widget may normalize font names and thus return a string
+ * with a different structure. For example, "Helvetica Italic Bold 12" could be
+ * normalized to "Helvetica Bold Italic 12". Use pango_font_description_equal()
+ * if you want to compare two font descriptions.
+ *
+ * Return value: A string with the name of the current font, or #NULL if no font
+ * is selected. You must free this string with g_free().
+ **/
gchar*
-gtk_font_selection_dialog_get_font_name (GtkFontSelectionDialog *fsd)
+gtk_font_selection_dialog_get_font_name (GtkFontSelectionDialog *fsd)
{
- return gtk_font_selection_get_font_name(GTK_FONT_SELECTION(fsd->fontsel));
+ g_return_val_if_fail (GTK_IS_FONT_SELECTION_DIALOG (fsd), NULL);
+
+ return gtk_font_selection_get_font_name (GTK_FONT_SELECTION (fsd->fontsel));
}
+/**
+ * gtk_font_selection_dialog_get_font:
+ * @fsd: a #GtkFontSelectionDialog
+ *
+ * Return value: the #GdkFont from the #GtkFontSelection for the
+ * currently selected font in the dialog.
+ *
+ * Deprecated: 2.0: Use gtk_font_selection_dialog_get_font_name() instead.
+ */
GdkFont*
-gtk_font_selection_dialog_get_font (GtkFontSelectionDialog *fsd)
+gtk_font_selection_dialog_get_font (GtkFontSelectionDialog *fsd)
{
- return gtk_font_selection_get_font(GTK_FONT_SELECTION(fsd->fontsel));
+ g_return_val_if_fail (GTK_IS_FONT_SELECTION_DIALOG (fsd), NULL);
+
+ return gtk_font_selection_get_font_internal (GTK_FONT_SELECTION (fsd->fontsel));
}
+/**
+ * gtk_font_selection_dialog_set_font_name:
+ * @fsd: a #GtkFontSelectionDialog
+ * @fontname: a pointer to a string
+ *
+ * Sets the currently selected font.
+ *
+ * Return value: %TRUE if the font selected in @fsd is now the
+ * @fontname specified. %FALSE otherwise.
+ */
gboolean
-gtk_font_selection_dialog_set_font_name (GtkFontSelectionDialog *fsd,
- const gchar *fontname)
+gtk_font_selection_dialog_set_font_name (GtkFontSelectionDialog *fsd,
+ const gchar *fontname)
{
- return gtk_font_selection_set_font_name(GTK_FONT_SELECTION(fsd->fontsel),
- fontname);
+ g_return_val_if_fail (GTK_IS_FONT_SELECTION_DIALOG (fsd), FALSE);
+ g_return_val_if_fail (fontname, FALSE);
+
+ return gtk_font_selection_set_font_name (GTK_FONT_SELECTION (fsd->fontsel), fontname);
}
-gchar*
+/**
+ * gtk_font_selection_dialog_get_preview_text:
+ * @fsd: a #GtkFontSelectionDialog
+ *
+ * The text returned is the preview text used to show how the selected
+ * font looks.
+ *
+ * Return value: pointer to the preview text string. This string
+ * points to internally allocated storage in the widget and must not
+ * be freed, modified or stored.
+ */
+G_CONST_RETURN gchar*
gtk_font_selection_dialog_get_preview_text (GtkFontSelectionDialog *fsd)
{
- return gtk_font_selection_get_preview_text(GTK_FONT_SELECTION(fsd->fontsel));
+ g_return_val_if_fail (GTK_IS_FONT_SELECTION_DIALOG (fsd), NULL);
+
+ return gtk_font_selection_get_preview_text (GTK_FONT_SELECTION (fsd->fontsel));
}
+/**
+ * gtk_font_selection_dialog_set_preview_text:
+ * @fsd: a #GtkFontSelectionDialog
+ * @text: a pointer to a string
+
+ * The @text is used to show how the selected font looks.
+ */
void
gtk_font_selection_dialog_set_preview_text (GtkFontSelectionDialog *fsd,
- const gchar *text)
+ const gchar *text)
{
- gtk_font_selection_set_preview_text(GTK_FONT_SELECTION(fsd->fontsel), text);
-}
-
+ g_return_if_fail (GTK_IS_FONT_SELECTION_DIALOG (fsd));
+ g_return_if_fail (text != NULL);
-/* This turns auto-shrink off if the user resizes the width of the dialog.
- It also turns it back on again if the user resizes it back to its normal
- width. */
-static gint
-gtk_font_selection_dialog_on_configure (GtkWidget *widget,
- GdkEventConfigure *event,
- GtkFontSelectionDialog *fsd)
-{
- /* This sets the initial width. */
- if (fsd->dialog_width == -1)
- fsd->dialog_width = event->width;
- else if (fsd->auto_resize && fsd->dialog_width != event->width)
- {
- fsd->auto_resize = FALSE;
- gtk_window_set_policy(GTK_WINDOW(fsd), FALSE, TRUE, FALSE);
- }
- else if (!fsd->auto_resize && fsd->dialog_width == event->width)
- {
- fsd->auto_resize = TRUE;
- gtk_window_set_policy(GTK_WINDOW(fsd), FALSE, TRUE, TRUE);
- }
-
- return FALSE;
+ gtk_font_selection_set_preview_text (GTK_FONT_SELECTION (fsd->fontsel), text);
}
+
+#define __GTK_FONTSEL_C__
+#include "gtkaliasdef.c"
projects / ~andy / gtk / blobdiff