X-Git-Url: http://pileus.org/git/?a=blobdiff_plain;f=gtk%2Fgtkfontsel.c;h=293d0bb03cbaba6ba6abba53dc4d61148e4c12ed;hb=8ba71578f2898d10641053cc089860b2b8d07266;hp=7deff314658f5f302d5421bfed519cc49cec5799;hpb=238ede333fb92750520071b71ebff7130b4c8803;p=~andy%2Fgtk diff --git a/gtk/gtkfontsel.c b/gtk/gtkfontsel.c index 7deff3146..293d0bb03 100644 --- a/gtk/gtkfontsel.c +++ b/gtk/gtkfontsel.c @@ -1,670 +1,480 @@ /* GTK - The GIMP Toolkit * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald * + * Massively updated for Pango by Owen Taylor, May 2000 * GtkFontSelection widget for Gtk+, by Damon Chaplin, May 1998. * Based on the GnomeFontSelector widget, by Elliot Lee, but major changes. * The GnomeFontSelector was derived from app/text_tool.c in the GIMP. * * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Library General Public + * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Library General Public License for more details. + * Lesser General Public License for more details. * - * You should have received a copy of the GNU Library General Public + * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the * Free Software Foundation, Inc., 59 Temple Place - Suite 330, * Boston, MA 02111-1307, USA. */ /* - * Limits: - * - * Fontnames - A maximum of MAX_FONTS (32767) fontnames will be retrieved - * from X Windows with XListFonts(). Any more are ignored. - * I think this limit may have been set because of a limit in - * GtkList. It could possibly be increased since we are using - * GtkClists now, but I'd be surprised if it was reached. - * Field length - XLFD_MAX_FIELD_LEN is the maximum length that any field of a - * fontname can be for it to be considered valid. Others are - * ignored. - * Properties - Maximum of 65535 choices for each font property - guint16's - * are used as indices, e.g. in the FontInfo struct. - * Combinations - Maximum of 65535 combinations of properties for each font - * family - a guint16 is used in the FontInfo struct. - * Font size - Minimum font size of 2 pixels/points, since trying to load - * some fonts with a size of 1 can cause X to hang. - * (e.g. the Misc Fixed fonts). - */ - -/* - * Possible Improvements: - * - * Font Styles - could sort the styles into a reasonable order - regular - * first, then bold, bold italic etc. - * - * I18N - the default preview text is not useful for international - * fonts. Maybe the first few characters of the font could be - * displayed instead. - * - fontsets? should these be handled by the font dialog? - */ - -/* - * Debugging: compile with -DFONTSEL_DEBUG for lots of debugging output. + * Modified by the GTK+ Team and others 1997-2000. See the AUTHORS + * file for a list of people on the GTK+ Team. See the ChangeLog + * files for a list of changes. These files are distributed with + * GTK+ at ftp://ftp.gtk.org/pub/gtk/. */ - #include -#include +#include #include -#include -#include -#include "gdk/gdkx.h" +#include "gdk/gdk.h" #include "gdk/gdkkeysyms.h" +#include "gtkfontsel.h" + #include "gtkbutton.h" -#include "gtkcheckbutton.h" -#include "gtkclist.h" +#include "gtkcellrenderertext.h" #include "gtkentry.h" -#include "gtkfontsel.h" #include "gtkframe.h" #include "gtkhbbox.h" #include "gtkhbox.h" #include "gtklabel.h" -#include "gtknotebook.h" -#include "gtkradiobutton.h" -#include "gtksignal.h" +#include "gtkliststore.h" +#include "gtkrc.h" +#include "gtkstock.h" #include "gtktable.h" +#include "gtktreeselection.h" +#include "gtktreeview.h" #include "gtkvbox.h" #include "gtkscrolledwindow.h" +#include "gtkintl.h" -/* The maximum number of fontnames requested with XListFonts(). */ -#define MAX_FONTS 32767 - -/* This is the largest field length we will accept. If a fontname has a field - larger than this we will skip it. */ -#define XLFD_MAX_FIELD_LEN 64 - -/* These are what we use as the standard font sizes, for the size clist. - Note that when using points we still show these integer point values but - we work internally in decipoints (and decipoint values can be typed in). */ -static guint16 font_sizes[] = { - 8, 9, 10, 11, 12, 13, 14, 16, 18, 20, 22, 24, 26, 28, - 32, 36, 40, 48, 56, 64, 72 -}; - -/* Initial font metric & size (Remember point sizes are in decipoints). - The font size should match one of those in the font_sizes array. */ -#define INITIAL_METRIC GTK_FONT_METRIC_POINTS -#define INITIAL_FONT_SIZE 140 +/* 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") /* 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 180 -#define FONT_STYLE_LIST_WIDTH 160 +#define FONT_LIST_WIDTH 190 +#define FONT_STYLE_LIST_WIDTH 170 #define FONT_SIZE_LIST_WIDTH 60 -/* This is the number of fields in an X Logical Font Description font name. - Note that we count the registry & encoding as 1. */ -#define GTK_XLFD_NUM_FIELDS 13 - -typedef struct _GtkFontSelInfo GtkFontSelInfo; -typedef struct _FontInfo FontInfo; -typedef struct _FontStyle FontStyle; - -/* This struct represents one family of fonts (with one foundry), e.g. adobe - courier or sony fixed. It stores the family name, the index of the foundry - name, and the index of and number of available styles. */ -struct _FontInfo -{ - gchar *family; - guint16 foundry; - gint style_index; - guint16 nstyles; +/* 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, + 32, 36, 40, 48, 56, 64, 72 }; -/* This represents one style, as displayed in the Font Style clist. It can - have a number of available pixel sizes and point sizes. The indexes point - into the two big fontsel_info->pixel_sizes & fontsel_info->point_sizes - arrays. The displayed flag is used when displaying styles to remember which - styles have already been displayed. Note that it is combined with the - GtkFontType in the flags field. */ -#define GTK_FONT_DISPLAYED (1 << 7) -struct _FontStyle -{ - guint16 properties[GTK_NUM_STYLE_PROPERTIES]; - gint pixel_sizes_index; - guint16 npixel_sizes; - gint point_sizes_index; - guint16 npoint_sizes; - guint8 flags; +enum { + PROP_0, + PROP_FONT_NAME, + PROP_FONT, + PROP_PREVIEW_TEXT }; -struct _GtkFontSelInfo { - - /* This is a table with each FontInfo representing one font family+foundry */ - FontInfo *font_info; - gint nfonts; - - /* This stores all the valid combinations of properties for every family. - Each FontInfo holds an index into its own space in this one big array. */ - FontStyle *font_styles; - gint nstyles; - - /* This stores all the font sizes available for every style. - Each style holds an index into these arrays. */ - guint16 *pixel_sizes; - guint16 *point_sizes; - - /* These are the arrays of strings of all possible weights, slants, - set widths, spacings, charsets & foundries, and the amount of space - allocated for each array. */ - gchar **properties[GTK_NUM_FONT_PROPERTIES]; - guint16 nproperties[GTK_NUM_FONT_PROPERTIES]; - guint16 space_allocated[GTK_NUM_FONT_PROPERTIES]; -}; -/* These are the field numbers in the X Logical Font Description fontnames, - e.g. -adobe-courier-bold-o-normal--25-180-100-100-m-150-iso8859-1 */ -typedef enum -{ - XLFD_FOUNDRY = 0, - XLFD_FAMILY = 1, - XLFD_WEIGHT = 2, - XLFD_SLANT = 3, - XLFD_SET_WIDTH = 4, - XLFD_ADD_STYLE = 5, - XLFD_PIXELS = 6, - XLFD_POINTS = 7, - XLFD_RESOLUTION_X = 8, - XLFD_RESOLUTION_Y = 9, - XLFD_SPACING = 10, - XLFD_AVERAGE_WIDTH = 11, - XLFD_CHARSET = 12 -} FontField; - -/* These are the names of the fields, used on the info & filter page. */ -static gchar* xlfd_field_names[GTK_XLFD_NUM_FIELDS] = { - "Foundry:", - "Family:", - "Weight:", - "Slant:", - "Set Width:", - "Add Style:", - "Pixel Size:", - "Point Size:", - "Resolution X:", - "Resolution Y:", - "Spacing:", - "Average Width:", - "Charset:", +enum { + FAMILY_COLUMN, + FAMILY_NAME_COLUMN }; -/* These are the array indices of the font properties used in several arrays, - and should match the xlfd_index array below. */ -typedef enum -{ - WEIGHT = 0, - SLANT = 1, - SET_WIDTH = 2, - SPACING = 3, - CHARSET = 4, - FOUNDRY = 5 -} PropertyIndexType; - -/* This is used to look up a field in a fontname given one of the above - property indices. */ -static FontField xlfd_index[GTK_NUM_FONT_PROPERTIES] = { - XLFD_WEIGHT, - XLFD_SLANT, - XLFD_SET_WIDTH, - XLFD_SPACING, - XLFD_CHARSET, - XLFD_FOUNDRY +enum { + FACE_COLUMN, + FACE_NAME_COLUMN }; -/* These are the positions of the properties in the filter table - x, y. */ -static gint filter_positions[GTK_NUM_FONT_PROPERTIES][2] = { - { 1, 0 }, { 0, 2 }, { 1, 2 }, { 2, 2 }, { 2, 0 }, { 0, 0 } +enum { + SIZE_COLUMN }; -static gint filter_heights[GTK_NUM_FONT_PROPERTIES] = { - 100, 70, 70, 40, 100, 100 -}; - -/* This is returned by gtk_font_selection_filter_state to describe if a - property value is filtered. e.g. if 'bold' has been selected on the filter - page, then that will return 'FILTERED' and 'black' will be 'NOT_FILTERED'. - If none of the weight values are selected, they all return 'NOT_SET'. */ -typedef enum -{ - FILTERED, - NOT_FILTERED, - NOT_SET -} GtkFontPropertyFilterState; - -static GtkFontSelInfo *fontsel_info = NULL; - -/* The initial size and increment of each of the arrays of property values. */ -#define PROPERTY_ARRAY_INCREMENT 16 static void gtk_font_selection_class_init (GtkFontSelectionClass *klass); -static void gtk_font_selection_init (GtkFontSelection *fontsel); -static void gtk_font_selection_destroy (GtkObject *object); - -/* These are all used for class initialization - loading in the fonts etc. */ -static void gtk_font_selection_get_fonts (void); -static void gtk_font_selection_insert_font (GSList *fontnames[], - gint *ntable, - gchar *fontname); -static gint gtk_font_selection_insert_field (gchar *fontname, - gint prop); +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_init (GtkFontSelection *fontsel); +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, - 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_styles -(GtkFontSelection *fs); -static void gtk_font_selection_select_best_style (GtkFontSelection *fs, - gboolean use_first); -static gint gtk_font_selection_get_best_match (GtkFontSelection *fs); - -static void gtk_font_selection_select_style (GtkWidget *w, - gint row, - gint column, - GdkEventButton *bevent, - gpointer data); -static void gtk_font_selection_show_available_sizes -(GtkFontSelection *fs); -static gint gtk_font_selection_size_key_press (GtkWidget *w, - GdkEventKey *event, - gpointer data); -static void gtk_font_selection_select_best_size (GtkFontSelection *fs); -static void gtk_font_selection_select_size (GtkWidget *w, - gint row, - gint column, - GdkEventButton *bevent, - gpointer data); - -static void gtk_font_selection_metric_callback (GtkWidget *w, - gpointer data); -static void gtk_font_selection_expose_list (GtkWidget *w, - GdkEventExpose *event, - gpointer data); - -static void gtk_font_selection_switch_page (GtkWidget *w, - GtkNotebookPage *page, - gint page_num, - gpointer data); -static void gtk_font_selection_show_font_info (GtkFontSelection *fs); - -static void gtk_font_selection_select_filter (GtkWidget *w, - gint row, - gint column, - GdkEventButton *bevent, - GtkFontSelection *fs); -static void gtk_font_selection_unselect_filter (GtkWidget *w, - gint row, - gint column, - GdkEventButton *bevent, - GtkFontSelection *fs); -static void gtk_font_selection_update_filter (GtkFontSelection *fs); -static gboolean gtk_font_selection_style_visible (GtkFontSelection *fs, - FontInfo *font, - gint style); -static void gtk_font_selection_reset_filter (GtkWidget *w, - GtkFontSelection *fs); -static void gtk_font_selection_on_clear_filter (GtkWidget *w, - GtkFontSelection *fs); -static void gtk_font_selection_show_available_fonts - (GtkFontSelection *fs); -static void gtk_font_selection_clear_filter (GtkFontSelection *fs); -static void gtk_font_selection_update_filter_lists(GtkFontSelection *fs); -static GtkFontPropertyFilterState gtk_font_selection_filter_state - (GtkFontSelection *fs, - GtkFontFilterType filter_type, - gint property, - gint index); +static void gtk_font_selection_select_font (GtkTreeSelection *selection, + gpointer data); +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 (GtkTreeSelection *selection, + gpointer data); + +static void gtk_font_selection_select_best_size (GtkFontSelection *fs); +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 (GtkTreeSelection *selection, + gpointer data); + +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 gboolean 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); -static gint gtk_font_selection_find_font (GtkFontSelection *fs, - gchar *family, - guint16 foundry); -static guint16 gtk_font_selection_field_to_index (gchar **table, - gint ntable, - gchar *field); - -static gchar* gtk_font_selection_expand_slant_code (gchar *slant); -static gchar* gtk_font_selection_expand_spacing_code(gchar *spacing); - -/* Functions for handling X Logical Font Description fontnames. */ -static gboolean gtk_font_selection_is_xlfd_font_name (const gchar *fontname); -static char* gtk_font_selection_get_xlfd_field (const gchar *fontname, - FontField field_num, - gchar *buffer); -static gchar * gtk_font_selection_create_xlfd (gint size, - GtkFontMetricType metric, - gchar *foundry, - gchar *family, - gchar *weight, - gchar *slant, - gchar *set_width, - gchar *spacing, - gchar *charset); - +static GdkFont* gtk_font_selection_get_font_internal (GtkFontSelection *fontsel); /* FontSelectionDialog */ static void gtk_font_selection_dialog_class_init (GtkFontSelectionDialogClass *klass); static void gtk_font_selection_dialog_init (GtkFontSelectionDialog *fontseldiag); -static gint gtk_font_selection_dialog_on_configure(GtkWidget *widget, - GdkEventConfigure *event, - GtkFontSelectionDialog *fsd); +static GtkVBoxClass *font_selection_parent_class = NULL; +static GtkWindowClass *font_selection_dialog_parent_class = NULL; -static GtkWindowClass *font_selection_parent_class = NULL; -static GtkNotebookClass *font_selection_dialog_parent_class = NULL; -GtkType -gtk_font_selection_get_type() +GType +gtk_font_selection_get_type (void) { - static GtkType font_selection_type = 0; + static GType font_selection_type = 0; - if(!font_selection_type) + if (!font_selection_type) { - GtkTypeInfo fontsel_type_info = + static const GTypeInfo 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, + NULL, /* base_init */ + NULL, /* base_finalize */ + (GClassInitFunc) gtk_font_selection_class_init, + NULL, /* class_finalize */ + NULL, /* class_data */ + sizeof (GtkFontSelection), + 0, /* n_preallocs */ + (GInstanceInitFunc) gtk_font_selection_init, }; - font_selection_type = gtk_type_unique (GTK_TYPE_NOTEBOOK, - &fontsel_type_info); + font_selection_type = + g_type_register_static (GTK_TYPE_VBOX, "GtkFontSelection", + &fontsel_type_info, 0); } return font_selection_type; } static void -gtk_font_selection_class_init(GtkFontSelectionClass *klass) +gtk_font_selection_class_init (GtkFontSelectionClass *klass) +{ + GObjectClass *gobject_class = G_OBJECT_CLASS (klass); + GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass); + + font_selection_parent_class = g_type_class_peek_parent (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", + _("Font name"), + _("The X string that represents this font"), + NULL, + G_PARAM_READWRITE)); + g_object_class_install_property (gobject_class, + PROP_FONT, + g_param_spec_boxed ("font", + _("Font"), + _("The GdkFont that is currently selected"), + GDK_TYPE_FONT, + G_PARAM_READABLE)); + g_object_class_install_property (gobject_class, + PROP_PREVIEW_TEXT, + g_param_spec_string ("preview_text", + _("Preview text"), + _("The text to display in order to demonstrate the selected font"), + PREVIEW_TEXT, + G_PARAM_READWRITE)); + gobject_class->finalize = gtk_font_selection_finalize; +} + +static void +gtk_font_selection_set_property (GObject *object, + guint prop_id, + const GValue *value, + GParamSpec *pspec) { - GtkObjectClass *object_class; - - object_class = (GtkObjectClass *) klass; - - font_selection_parent_class = gtk_type_class (GTK_TYPE_NOTEBOOK); - - object_class->destroy = gtk_font_selection_destroy; - - gtk_font_selection_get_fonts (); + GtkFontSelection *fontsel; + + fontsel = GTK_FONT_SELECTION (object); + + switch (prop_id) + { + 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; + } +} + +static void gtk_font_selection_get_property (GObject *object, + guint prop_id, + GValue *value, + GParamSpec *pspec) +{ + GtkFontSelection *fontsel; + + fontsel = GTK_FONT_SELECTION (object); + + switch (prop_id) + { + case PROP_FONT_NAME: + g_value_set_string (value, gtk_font_selection_get_font_name (fontsel)); + break; + case PROP_FONT: + g_value_set_object (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; + } } + static void -gtk_font_selection_init(GtkFontSelection *fontsel) +gtk_font_selection_init (GtkFontSelection *fontsel) { GtkWidget *scrolled_win; GtkWidget *text_frame; - GtkWidget *text_box, *frame; - GtkWidget *table, *label, *hbox, *hbox2, *clist, *button, *vbox, *alignment; - gint i, prop, row; - gchar *titles[] = { "Font Property", "Requested Value", "Actual Value" }; - gchar buffer[128]; - gchar *size; - gint size_to_match; - gchar *row_text[3]; - gchar *property, *text; - gboolean inserted; - - /* Initialize the GtkFontSelection struct. We do this here in case any - callbacks are triggered while creating the interface. */ - fontsel->font = NULL; - fontsel->font_index = -1; - fontsel->style = -1; - fontsel->metric = INITIAL_METRIC; - fontsel->size = INITIAL_FONT_SIZE; - fontsel->selected_size = INITIAL_FONT_SIZE; + GtkWidget *text_box; + GtkWidget *table, *label; + GtkWidget *font_label, *style_label; + GtkListStore *model; + GtkTreeViewColumn *column; + GList *focus_chain = NULL; - fontsel->filters[GTK_FONT_FILTER_BASE].font_type = GTK_FONT_ALL; - fontsel->filters[GTK_FONT_FILTER_USER].font_type = GTK_FONT_BITMAP - | GTK_FONT_SCALABLE; + gtk_widget_push_composite_child (); - - for (prop = 0; prop < GTK_NUM_FONT_PROPERTIES; prop++) - { - fontsel->filters[GTK_FONT_FILTER_BASE].property_filters[prop] = NULL; - fontsel->filters[GTK_FONT_FILTER_BASE].property_nfilters[prop] = 0; - fontsel->filters[GTK_FONT_FILTER_USER].property_filters[prop] = NULL; - fontsel->filters[GTK_FONT_FILTER_USER].property_nfilters[prop] = 0; - } - - for (prop = 0; prop < GTK_NUM_STYLE_PROPERTIES; prop++) - fontsel->property_values[prop] = 0; - - /* Create the main notebook page. */ - fontsel->main_vbox = gtk_vbox_new (FALSE, 4); - gtk_widget_show (fontsel->main_vbox); - gtk_container_set_border_width (GTK_CONTAINER (fontsel->main_vbox), 6); - label = gtk_label_new("Font"); - gtk_widget_set_usize (label, 120, -1); - gtk_notebook_append_page (GTK_NOTEBOOK (fontsel), - fontsel->main_vbox, label); + 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_box_pack_start (GTK_BOX (fontsel->main_vbox), table, TRUE, TRUE, 0); - - fontsel->font_label = gtk_label_new("Font:"); - 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, - GTK_FILL, 0, 0, 0); - label = gtk_label_new("Font Style:"); - 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, - GTK_FILL, 0, 0, 0); - label = gtk_label_new("Size:"); - gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); - gtk_widget_show (label); - gtk_table_attach (GTK_TABLE (table), label, 2, 3, 0, 1, - GTK_FILL, 0, 0, 0); - - 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_table_set_col_spacings (GTK_TABLE (table), 8); + gtk_box_pack_start (GTK_BOX (fontsel), table, TRUE, TRUE, 0); + +#ifdef INCLUDE_FONT_ENTRIES + fontsel->font_entry = gtk_entry_new (); + 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); + + fontsel->font_style_entry = gtk_entry_new (); + 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); - fontsel->size_entry = gtk_entry_new(); - gtk_widget_set_usize (fontsel->size_entry, 20, -1); +#endif /* INCLUDE_FONT_ENTRIES */ + + fontsel->size_entry = gtk_entry_new (); + 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); + 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); + + 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_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); + gtk_widget_show (label); + gtk_table_attach (GTK_TABLE (table), label, 2, 3, 0, 1, + GTK_FILL, 0, 0, 0); + + + /* 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); + + 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); - /* Create the clists */ - fontsel->font_clist = gtk_clist_new(1); - gtk_clist_column_titles_hide (GTK_CLIST(fontsel->font_clist)); - gtk_clist_set_column_width (GTK_CLIST(fontsel->font_clist), 0, 300); - gtk_widget_set_usize (fontsel->font_clist, FONT_LIST_WIDTH, - FONT_LIST_HEIGHT); + gtk_label_set_mnemonic_widget (GTK_LABEL (font_label), fontsel->family_list); + scrolled_win = gtk_scrolled_window_new (NULL, NULL); - 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); + + 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_width (GTK_CLIST(fontsel->font_style_clist), 0, 300); - gtk_widget_set_usize (fontsel->font_style_clist, FONT_STYLE_LIST_WIDTH, -1); scrolled_win = gtk_scrolled_window_new (NULL, NULL); - 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); + + 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_widget_set_usize (fontsel->size_clist, FONT_SIZE_LIST_WIDTH, -1); scrolled_win = gtk_scrolled_window_new (NULL, NULL); - 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_widget_show(scrolled_win); + 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_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); - - /* Insert the standard font sizes */ - gtk_clist_freeze (GTK_CLIST(fontsel->size_clist)); - size_to_match = INITIAL_FONT_SIZE; - if (INITIAL_METRIC == GTK_FONT_METRIC_POINTS) - size_to_match = size_to_match / 10; - for (i = 0; i < sizeof(font_sizes) / sizeof(font_sizes[0]); i++) - { - sprintf(buffer, "%i", font_sizes[i]); - size = buffer; - gtk_clist_append(GTK_CLIST(fontsel->size_clist), &size); - if (font_sizes[i] == size_to_match) - { - gtk_clist_select_row(GTK_CLIST(fontsel->size_clist), i, 0); - gtk_entry_set_text(GTK_ENTRY(fontsel->size_entry), buffer); - } - } - gtk_clist_thaw (GTK_CLIST(fontsel->size_clist)); - - 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); - - - /* create the Reset Filter & Metric buttons */ - hbox = gtk_hbox_new(FALSE, 8); - gtk_widget_show (hbox); - gtk_box_pack_start (GTK_BOX (fontsel->main_vbox), hbox, FALSE, TRUE, 0); - - fontsel->filter_button = gtk_button_new_with_label(" Reset Filter "); - gtk_widget_show(fontsel->filter_button); - gtk_box_pack_start (GTK_BOX (hbox), fontsel->filter_button, FALSE, FALSE, 0); - gtk_widget_set_sensitive (fontsel->filter_button, FALSE); - gtk_signal_connect (GTK_OBJECT (fontsel->filter_button), "clicked", - GTK_SIGNAL_FUNC(gtk_font_selection_on_clear_filter), - 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); - hbox2 = gtk_hbox_new(FALSE, 0); - gtk_widget_show (hbox2); - gtk_box_pack_end (GTK_BOX (hbox), hbox2, FALSE, FALSE, 0); + /* 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); - label = gtk_label_new("Metric:"); + 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); + + /* create the text entry widget */ + label = gtk_label_new_with_mnemonic (_("_Preview:")); gtk_widget_show (label); - gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, TRUE, 8); - - fontsel->points_button = gtk_radio_button_new_with_label(NULL, "Points"); - gtk_widget_show (fontsel->points_button); - gtk_box_pack_start (GTK_BOX (hbox2), fontsel->points_button, FALSE, TRUE, 0); - if (INITIAL_METRIC == GTK_FONT_METRIC_POINTS) - gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(fontsel->points_button), - TRUE); - - fontsel->pixels_button = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(fontsel->points_button), "Pixels"); - gtk_widget_show (fontsel->pixels_button); - gtk_box_pack_start (GTK_BOX (hbox2), fontsel->pixels_button, FALSE, TRUE, 0); - if (INITIAL_METRIC == GTK_FONT_METRIC_PIXELS) - gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(fontsel->pixels_button), - TRUE); - - gtk_signal_connect(GTK_OBJECT(fontsel->points_button), "toggled", - (GtkSignalFunc) gtk_font_selection_metric_callback, - fontsel); - gtk_signal_connect(GTK_OBJECT(fontsel->pixels_button), "toggled", - (GtkSignalFunc) gtk_font_selection_metric_callback, - fontsel); + text_frame = gtk_frame_new (NULL); + gtk_frame_set_label_widget (GTK_FRAME (text_frame), label); - /* 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->main_vbox), 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); /* This is just used to get a 4-pixel space around the preview entry. */ @@ -674,2312 +484,586 @@ gtk_font_selection_init(GtkFontSelection *fontsel) gtk_container_set_border_width (GTK_CONTAINER (text_box), 4); fontsel->preview_entry = gtk_entry_new (); + gtk_label_set_mnemonic_widget (GTK_LABEL (label), fontsel->preview_entry); + 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); - - /* Create the message area */ - fontsel->message_label = gtk_label_new(""); - gtk_widget_show (fontsel->message_label); - gtk_box_pack_start (GTK_BOX (fontsel->main_vbox), fontsel->message_label, - FALSE, FALSE, 0); - - - /* Create the font info page */ - fontsel->info_vbox = gtk_vbox_new (FALSE, 4); - gtk_widget_show (fontsel->info_vbox); - gtk_container_set_border_width (GTK_CONTAINER (fontsel->info_vbox), 2); - label = gtk_label_new("Font Information"); - gtk_widget_set_usize (label, 120, -1); - gtk_notebook_append_page (GTK_NOTEBOOK (fontsel), - fontsel->info_vbox, label); - - fontsel->info_clist = gtk_clist_new_with_titles (3, titles); - gtk_widget_set_usize (fontsel->info_clist, 390, 150); - gtk_clist_set_column_width(GTK_CLIST(fontsel->info_clist), 0, 130); - gtk_clist_set_column_width(GTK_CLIST(fontsel->info_clist), 1, 130); - gtk_clist_set_column_width(GTK_CLIST(fontsel->info_clist), 2, 130); - gtk_clist_column_titles_passive(GTK_CLIST(fontsel->info_clist)); - scrolled_win = gtk_scrolled_window_new (NULL, NULL); - gtk_container_add (GTK_CONTAINER (scrolled_win), fontsel->info_clist); - gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win), - GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); - gtk_widget_show(fontsel->info_clist); - gtk_widget_show(scrolled_win); - gtk_box_pack_start (GTK_BOX (fontsel->info_vbox), scrolled_win, - TRUE, TRUE, 0); - - /* Insert the property names */ - gtk_clist_freeze (GTK_CLIST(fontsel->info_clist)); - row_text[1] = ""; - row_text[2] = ""; - for (i = 0; i < GTK_XLFD_NUM_FIELDS; i++) - { - row_text[0] = xlfd_field_names[i]; - gtk_clist_append(GTK_CLIST(fontsel->info_clist), row_text); - gtk_clist_set_shift(GTK_CLIST(fontsel->info_clist), i, 0, 0, 4); - gtk_clist_set_shift(GTK_CLIST(fontsel->info_clist), i, 1, 0, 4); - gtk_clist_set_shift(GTK_CLIST(fontsel->info_clist), i, 2, 0, 4); - } - gtk_clist_thaw (GTK_CLIST(fontsel->info_clist)); - - label = gtk_label_new("Requested Font Name:"); - gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); - gtk_widget_show (label); - gtk_box_pack_start (GTK_BOX (fontsel->info_vbox), label, FALSE, TRUE, 0); - - fontsel->requested_font_name = gtk_entry_new(); - gtk_entry_set_editable(GTK_ENTRY(fontsel->requested_font_name), FALSE); - gtk_widget_show (fontsel->requested_font_name); - gtk_box_pack_start (GTK_BOX (fontsel->info_vbox), - fontsel->requested_font_name, FALSE, TRUE, 0); - - label = gtk_label_new("Actual Font Name:"); - gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); - gtk_widget_show (label); - gtk_box_pack_start (GTK_BOX (fontsel->info_vbox), label, FALSE, TRUE, 0); - - fontsel->actual_font_name = gtk_entry_new(); - gtk_entry_set_editable(GTK_ENTRY(fontsel->actual_font_name), FALSE); - gtk_widget_show (fontsel->actual_font_name); - gtk_box_pack_start (GTK_BOX (fontsel->info_vbox), - fontsel->actual_font_name, FALSE, TRUE, 0); - - sprintf(buffer, "%i fonts available with a total of %i styles.", - fontsel_info->nfonts, fontsel_info->nstyles); - label = gtk_label_new(buffer); - gtk_widget_show (label); - gtk_box_pack_start (GTK_BOX (fontsel->info_vbox), label, FALSE, FALSE, 0); - - gtk_signal_connect (GTK_OBJECT (fontsel), "switch_page", - GTK_SIGNAL_FUNC(gtk_font_selection_switch_page), - fontsel); - - - /* Create the Filter page. */ - fontsel->filter_vbox = gtk_vbox_new (FALSE, 4); - gtk_widget_show (fontsel->filter_vbox); - gtk_container_set_border_width (GTK_CONTAINER (fontsel->filter_vbox), 2); - label = gtk_label_new("Filter"); - gtk_widget_set_usize (label, 120, -1); - gtk_notebook_append_page (GTK_NOTEBOOK (fontsel), - fontsel->filter_vbox, label); - - /* Create the font type checkbuttons. */ - frame = gtk_frame_new (NULL); - gtk_widget_show (frame); - gtk_box_pack_start (GTK_BOX (fontsel->filter_vbox), frame, FALSE, TRUE, 0); - - hbox = gtk_hbox_new (FALSE, 20); - gtk_widget_show (hbox); - gtk_container_add (GTK_CONTAINER (frame), hbox); - - label = gtk_label_new("Font Types:"); - gtk_widget_show (label); - gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 10); - - hbox2 = gtk_hbox_new (TRUE, 0); - gtk_widget_show (hbox2); - gtk_box_pack_start (GTK_BOX (hbox), hbox2, FALSE, TRUE, 0); - - fontsel->type_bitmaps_button = gtk_check_button_new_with_label ("Bitmap"); - gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (fontsel->type_bitmaps_button), TRUE); - gtk_widget_show (fontsel->type_bitmaps_button); - gtk_box_pack_start (GTK_BOX (hbox2), fontsel->type_bitmaps_button, - FALSE, TRUE, 0); - - fontsel->type_scalable_button = gtk_check_button_new_with_label ("Scalable"); - gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (fontsel->type_scalable_button), TRUE); - gtk_widget_show (fontsel->type_scalable_button); - gtk_box_pack_start (GTK_BOX (hbox2), fontsel->type_scalable_button, - FALSE, TRUE, 0); - - fontsel->type_scaled_bitmaps_button = gtk_check_button_new_with_label ("Scaled Bitmap"); - gtk_widget_show (fontsel->type_scaled_bitmaps_button); - gtk_box_pack_start (GTK_BOX (hbox2), fontsel->type_scaled_bitmaps_button, - FALSE, TRUE, 0); - table = gtk_table_new (4, 3, FALSE); - gtk_table_set_col_spacings(GTK_TABLE(table), 2); - gtk_widget_show (table); - gtk_box_pack_start (GTK_BOX (fontsel->filter_vbox), table, TRUE, TRUE, 0); - - for (prop = 0; prop < GTK_NUM_FONT_PROPERTIES; prop++) - { - gint left = filter_positions[prop][0]; - gint top = filter_positions[prop][1]; - - label = gtk_label_new(xlfd_field_names[xlfd_index[prop]]); - gtk_misc_set_alignment (GTK_MISC (label), 0.0, 1.0); - gtk_misc_set_padding (GTK_MISC (label), 0, 2); - gtk_widget_show(label); - gtk_table_attach (GTK_TABLE (table), label, left, left + 1, - top, top + 1, GTK_FILL, GTK_FILL, 0, 0); - - clist = gtk_clist_new(1); - gtk_widget_set_usize (clist, 100, filter_heights[prop]); - gtk_clist_set_selection_mode(GTK_CLIST(clist), GTK_SELECTION_MULTIPLE); - gtk_clist_column_titles_hide(GTK_CLIST(clist)); - scrolled_win = gtk_scrolled_window_new (NULL, NULL); - gtk_container_add (GTK_CONTAINER (scrolled_win), clist); - gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win), - GTK_POLICY_AUTOMATIC, - GTK_POLICY_AUTOMATIC); - gtk_widget_show(clist); - gtk_widget_show(scrolled_win); - - /* For the bottom-right cell we add the 'Reset Filter' button. */ - if (top == 2 && left == 2) - { - vbox = gtk_vbox_new(FALSE, 0); - gtk_widget_show(vbox); - gtk_table_attach (GTK_TABLE (table), vbox, left, left + 1, - top + 1, top + 2, GTK_FILL, GTK_FILL, 0, 0); - - gtk_box_pack_start (GTK_BOX (vbox), scrolled_win, TRUE, TRUE, 0); - - alignment = gtk_alignment_new(0.5, 0.0, 0.8, 0.0); - gtk_widget_show(alignment); - gtk_box_pack_start (GTK_BOX (vbox), alignment, FALSE, TRUE, 4); - - button = gtk_button_new_with_label("Reset Filter"); - gtk_widget_show(button); - gtk_container_add(GTK_CONTAINER(alignment), button); - gtk_signal_connect (GTK_OBJECT (button), "clicked", - GTK_SIGNAL_FUNC(gtk_font_selection_reset_filter), - fontsel); - } - else - gtk_table_attach (GTK_TABLE (table), scrolled_win, - left, left + 1, top + 1, top + 2, - GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0); - - gtk_signal_connect (GTK_OBJECT (clist), "select_row", - GTK_SIGNAL_FUNC(gtk_font_selection_select_filter), - fontsel); - gtk_signal_connect (GTK_OBJECT (clist), "unselect_row", - GTK_SIGNAL_FUNC(gtk_font_selection_unselect_filter), - fontsel); - - /* Insert the property names, expanded, and in sorted order. - But we make sure that the wildcard '*' is first. */ - gtk_clist_freeze (GTK_CLIST(clist)); - property = "*"; - gtk_clist_append(GTK_CLIST(clist), &property); - - for (i = 1; i < fontsel_info->nproperties[prop]; i++) { - property = fontsel_info->properties[prop][i]; - if (prop == SLANT) - property = gtk_font_selection_expand_slant_code(property); - else if (prop == SPACING) - property = gtk_font_selection_expand_spacing_code(property); - - inserted = FALSE; - for (row = 1; row < GTK_CLIST(clist)->rows; row++) - { - gtk_clist_get_text(GTK_CLIST(clist), row, 0, &text); - if (strcmp(property, text) < 0) - { - inserted = TRUE; - gtk_clist_insert(GTK_CLIST(clist), row, &property); - break; - } - } - if (!inserted) - row = gtk_clist_append(GTK_CLIST(clist), &property); - gtk_clist_set_row_data(GTK_CLIST(clist), row, GINT_TO_POINTER (i)); - } - gtk_clist_select_row(GTK_CLIST(clist), 0, 0); - gtk_clist_thaw (GTK_CLIST(clist)); - fontsel->filter_clists[prop] = clist; - } + gtk_widget_pop_composite_child(); } GtkWidget * -gtk_font_selection_new() +gtk_font_selection_new () { GtkFontSelection *fontsel; - fontsel = gtk_type_new (GTK_TYPE_FONT_SELECTION); + fontsel = g_object_new (GTK_TYPE_FONT_SELECTION, NULL); return GTK_WIDGET (fontsel); } static void -gtk_font_selection_destroy (GtkObject *object) +gtk_font_selection_finalize (GObject *object) { GtkFontSelection *fontsel; - g_return_if_fail (object != NULL); g_return_if_fail (GTK_IS_FONT_SELECTION (object)); fontsel = GTK_FONT_SELECTION (object); - - /* All we have to do is unref the font, if we have one. */ + if (fontsel->font) gdk_font_unref (fontsel->font); - if (GTK_OBJECT_CLASS (font_selection_parent_class)->destroy) - (* GTK_OBJECT_CLASS (font_selection_parent_class)->destroy) (object); + if (G_OBJECT_CLASS (font_selection_parent_class)->finalize) + (* G_OBJECT_CLASS (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"); +} + +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, 0, FALSE); + + gtk_tree_path_free (path); +} -/* This is called when the clist is exposed. Here we scroll to the current +/* 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; - FontInfo *font_info; - 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); - font_info = fontsel_info->font_info; - - /* 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; - FontInfo *font_info; - FontInfo *font; + GtkTreeModel *model; + GtkTreeIter iter; + const gchar *family_name; -#ifdef FONTSEL_DEBUG - g_message("In select_font\n"); + fontsel = GTK_FONT_SELECTION (data); + + if (gtk_tree_selection_get_selected (selection, &model, &iter)) + { + PangoFontFamily *family; + + gtk_tree_model_get (model, &iter, FAMILY_COLUMN, &family, -1); + if (fontsel->family != family) + { + fontsel->family = family; + + family_name = pango_font_family_get_name (fontsel->family); + +#ifdef INCLUDE_FONT_ENTRIES + gtk_entry_set_text (GTK_ENTRY (fontsel->font_entry), family_name); #endif - fontsel = GTK_FONT_SELECTION(data); - font_info = fontsel_info->font_info; - - if (bevent && !GTK_WIDGET_HAS_FOCUS (w)) - gtk_widget_grab_focus (w); - - row = GPOINTER_TO_INT (gtk_clist_get_row_data (GTK_CLIST (fontsel->font_clist), row)); - font = &font_info[row]; - gtk_entry_set_text(GTK_ENTRY(fontsel->font_entry), font->family); - - /* If it is already the current font, just return. */ - if (fontsel->font_index == row) - return; - - fontsel->font_index = row; - gtk_font_selection_show_available_styles (fontsel); - gtk_font_selection_select_best_style (fontsel, TRUE); -} + + gtk_font_selection_show_available_styles (fontsel); + gtk_font_selection_select_best_style (fontsel, TRUE); + } + g_object_unref (family); + } +} -static gint -gtk_font_selection_on_clist_key_press (GtkWidget *clist, - GdkEventKey *event, - GtkFontSelection *fontsel) +static int +cmp_families (const void *a, const void *b) { -#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; + 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 gboolean -gtk_font_selection_select_next (GtkFontSelection *fontsel, - GtkWidget *clist, - gint step) +static void +gtk_font_selection_show_available_fonts (GtkFontSelection *fontsel) { - GList *selection; - gint current_row, row; + GtkListStore *model; + PangoFontFamily **families; + PangoFontFamily *match_family = NULL; + gint n_families, i; + GtkTreeIter match_row; - selection = GTK_CLIST(clist)->selection; - if (!selection) - return FALSE; - current_row = GPOINTER_TO_INT (selection->data); + model = GTK_LIST_STORE (gtk_tree_view_get_model (GTK_TREE_VIEW (fontsel->family_list))); - /* Stop the normal clist key handler from being run. */ - gtk_signal_emit_stop_by_name (GTK_OBJECT (clist), "key_press_event"); + pango_context_list_families (gtk_widget_get_pango_context (GTK_WIDGET (fontsel)), + &families, &n_families); + qsort (families, n_families, sizeof (PangoFontFamily *), cmp_families); - for (row = current_row + step; - row >= 0 && row < GTK_CLIST(clist)->rows; - row += step) + gtk_list_store_clear (model); + + for (i=0; ifont_style_clist) - if (GPOINTER_TO_INT (gtk_clist_get_row_data(GTK_CLIST(clist), row)) == -1) - continue; + 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); - /* 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; - } - return TRUE; -} - - -/* This fills the font style clist with all the possible style combinations - for the current font family. */ -static void -gtk_font_selection_show_available_styles (GtkFontSelection *fontsel) -{ - FontInfo *font; - FontStyle *styles; - gint style, tmpstyle, row; - gint weight_index, slant_index, set_width_index, spacing_index; - gint charset_index; - gchar *weight, *slant, *set_width, *spacing; - gchar *charset = NULL; - gchar *new_item; - gchar buffer[XLFD_MAX_FIELD_LEN * 6 + 2]; - GdkColor *inactive_fg, *inactive_bg; - gboolean show_charset; - -#ifdef FONTSEL_DEBUG - g_message("In show_available_styles\n"); -#endif - font = &fontsel_info->font_info[fontsel->font_index]; - styles = &fontsel_info->font_styles[font->style_index]; - - gtk_clist_freeze (GTK_CLIST(fontsel->font_style_clist)); - gtk_clist_clear (GTK_CLIST(fontsel->font_style_clist)); - - /* First we mark all visible styles as not having been displayed yet, - and check if every style has the same charset. If not then we will - display the charset in the list before the styles. */ - show_charset = FALSE; - charset_index = -1; - for (style = 0; style < font->nstyles; style++) - { - if (gtk_font_selection_style_visible(fontsel, font, style)) + if (i == 0 || !g_ascii_strcasecmp (name, "sans")) { - styles[style].flags &= ~GTK_FONT_DISPLAYED; - - if (charset_index == -1) - charset_index = styles[style].properties[CHARSET]; - else if (charset_index != styles[style].properties[CHARSET]) - show_charset = TRUE; - } - else - styles[style].flags |= GTK_FONT_DISPLAYED; - } - - /* Step through the undisplayed styles, finding the next charset which - hasn't been displayed yet. Then display the charset on one line, if - necessary, and the visible styles indented beneath it. */ - inactive_fg = &fontsel->font_style_clist->style->fg[GTK_STATE_INSENSITIVE]; - inactive_bg = &fontsel->font_style_clist->style->bg[GTK_STATE_INSENSITIVE]; - - for (style = 0; style < font->nstyles; style++) - { - if (styles[style].flags & GTK_FONT_DISPLAYED) - continue; - - if (show_charset) - { - charset_index = styles[style].properties[CHARSET]; - charset = fontsel_info->properties[CHARSET] [charset_index]; - row = gtk_clist_append(GTK_CLIST(fontsel->font_style_clist), - &charset); - gtk_clist_set_row_data(GTK_CLIST(fontsel->font_style_clist), row, - (gpointer) -1); - gtk_clist_set_foreground(GTK_CLIST(fontsel->font_style_clist), - row, inactive_fg); - gtk_clist_set_background(GTK_CLIST(fontsel->font_style_clist), - row, inactive_bg); - } - - for (tmpstyle = style; tmpstyle < font->nstyles; tmpstyle++) - { - if (styles[tmpstyle].flags & GTK_FONT_DISPLAYED - || charset_index != styles[tmpstyle].properties[CHARSET]) - continue; - - styles[tmpstyle].flags |= GTK_FONT_DISPLAYED; - - weight_index = styles[tmpstyle].properties[WEIGHT]; - slant_index = styles[tmpstyle].properties[SLANT]; - set_width_index = styles[tmpstyle].properties[SET_WIDTH]; - spacing_index = styles[tmpstyle].properties[SPACING]; - weight = fontsel_info->properties[WEIGHT] [weight_index]; - slant = fontsel_info->properties[SLANT] [slant_index]; - set_width = fontsel_info->properties[SET_WIDTH][set_width_index]; - spacing = fontsel_info->properties[SPACING] [spacing_index]; - - /* Convert '(nil)' weights to 'regular', since it looks nicer. */ - if (!g_strcasecmp(weight, "(nil)")) weight = "regular"; - - /* We don't show default values or (nil) in the other properties. */ - if (!g_strcasecmp(slant, "r")) slant = NULL; - else if (!g_strcasecmp(slant, "(nil)")) slant = NULL; - else if (!g_strcasecmp(slant, "i")) slant = "italic"; - else if (!g_strcasecmp(slant, "o")) slant = "oblique"; - else if (!g_strcasecmp(slant, "ri")) slant = "reverse italic"; - else if (!g_strcasecmp(slant, "ro")) slant = "reverse oblique"; - else if (!g_strcasecmp(slant, "ot")) slant = "other"; - - if (!g_strcasecmp(set_width, "normal")) set_width = NULL; - else if (!g_strcasecmp(set_width, "(nil)")) set_width = NULL; - - if (!g_strcasecmp(spacing, "p")) spacing = NULL; - else if (!g_strcasecmp(spacing, "(nil)")) spacing = NULL; - else if (!g_strcasecmp(spacing, "m")) spacing = "[M]"; - else if (!g_strcasecmp(spacing, "c")) spacing = "[C]"; - - /* Add the strings together, making sure there is 1 space between - them */ - strcpy(buffer, weight); - if (slant) - { - strcat(buffer, " "); - strcat(buffer, slant); - } - if (set_width) - { - strcat(buffer, " "); - strcat(buffer, set_width); - } - if (spacing) - { - strcat(buffer, " "); - strcat(buffer, spacing); - } - - new_item = buffer; - row = gtk_clist_append(GTK_CLIST(fontsel->font_style_clist), - &new_item); - if (show_charset) - gtk_clist_set_shift(GTK_CLIST(fontsel->font_style_clist), row, 0, - 0, 4); - gtk_clist_set_row_data(GTK_CLIST(fontsel->font_style_clist), row, - GINT_TO_POINTER (tmpstyle)); + match_family = families[i]; + match_row = iter; } } - - gtk_clist_thaw (GTK_CLIST(fontsel->font_style_clist)); -} - -/* 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) -{ - FontInfo *font; - FontStyle *styles; - gint row, prop, style = -1, style_to_find; - gboolean found = FALSE; - -#ifdef FONTSEL_DEBUG - g_message("In select_best_style\n"); -#endif - font = &fontsel_info->font_info[fontsel->font_index]; - styles = &fontsel_info->font_styles[font->style_index]; - - /* If use_first is set, we just find the first style in the list, not - including charset items. */ - style_to_find = use_first ? -1 : gtk_font_selection_get_best_match (fontsel); - - for (row = 0; row < GTK_CLIST(fontsel->font_style_clist)->rows; row++) - { - style = GPOINTER_TO_INT (gtk_clist_get_row_data (GTK_CLIST (fontsel->font_style_clist), row)); - if (style != -1 && (style_to_find == -1 || style_to_find == style)) - { - found = TRUE; - break; - } - } - g_return_if_fail (found); - - fontsel->style = style; - - for (prop = 0; prop < GTK_NUM_STYLE_PROPERTIES; prop++) - fontsel->property_values[prop] = styles[fontsel->style].properties[prop]; - - gtk_clist_select_row(GTK_CLIST(fontsel->font_style_clist), row, 0); - if (gtk_clist_row_is_visible(GTK_CLIST(fontsel->font_style_clist), row) - != GTK_VISIBILITY_FULL) - gtk_clist_moveto(GTK_CLIST(fontsel->font_style_clist), row, -1, 0.5, 0); - gtk_font_selection_show_available_sizes (fontsel); - 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) -{ - GtkFontSelection *fontsel; - FontInfo *font_info; - FontInfo *font; - FontStyle *styles; - gint style, prop; - gchar *text; - -#ifdef FONTSEL_DEBUG - g_message("In select_style\n"); -#endif - fontsel = GTK_FONT_SELECTION(data); - font_info = fontsel_info->font_info; - font = &font_info[fontsel->font_index]; - styles = &fontsel_info->font_styles[font->style_index]; - - if (bevent && !GTK_WIDGET_HAS_FOCUS (w)) - gtk_widget_grab_focus (w); - - /* The style index is stored in the row data, so we just need to copy - the style values into the fontsel and reload the font. */ - style = GPOINTER_TO_INT (gtk_clist_get_row_data(GTK_CLIST(fontsel->font_style_clist), row)); - - /* Don't allow selection of charset rows. */ - if (style == -1) - { - gtk_clist_unselect_row(GTK_CLIST(fontsel->font_style_clist), row, 0); - return; - } - - gtk_clist_get_text(GTK_CLIST(fontsel->font_style_clist), row, 0, &text); - gtk_entry_set_text(GTK_ENTRY(fontsel->font_style_entry), text); - - for (prop = 0; prop < GTK_NUM_STYLE_PROPERTIES; prop++) - fontsel->property_values[prop] = styles[style].properties[prop]; - - if (fontsel->style == style) - return; - - fontsel->style = style; - gtk_font_selection_show_available_sizes (fontsel); - gtk_font_selection_select_best_size (fontsel); -} - - -/* This shows all the available sizes in the size clist, according to the - current metric and the current font & style. */ -static void -gtk_font_selection_show_available_sizes (GtkFontSelection *fontsel) -{ - FontInfo *font; - FontStyle *styles, *style; - guint16 *standard_sizes, *bitmapped_sizes, bitmap_size; - gint nstandard_sizes, nbitmapped_sizes; - gchar buffer[16], *size; - gfloat bitmap_size_float; - gboolean can_match; - gint type_filter; - -#ifdef FONTSEL_DEBUG - g_message("In show_available_sizes\n"); -#endif - font = &fontsel_info->font_info[fontsel->font_index]; - styles = &fontsel_info->font_styles[font->style_index]; - style = &styles[fontsel->style]; - - standard_sizes = font_sizes; - nstandard_sizes = sizeof(font_sizes) / sizeof(font_sizes[0]); - if (fontsel->metric == GTK_FONT_METRIC_POINTS) - { - bitmapped_sizes = &fontsel_info->point_sizes[style->point_sizes_index]; - nbitmapped_sizes = style->npoint_sizes; - } - else - { - bitmapped_sizes = &fontsel_info->pixel_sizes[style->pixel_sizes_index]; - nbitmapped_sizes = style->npixel_sizes; - } - - /* Only show the standard sizes if a scalable font is available. */ - type_filter = fontsel->filters[GTK_FONT_FILTER_BASE].font_type - & fontsel->filters[GTK_FONT_FILTER_USER].font_type; - - if (!((style->flags & GTK_FONT_SCALABLE_BITMAP - && type_filter & GTK_FONT_SCALABLE_BITMAP) - || (style->flags & GTK_FONT_SCALABLE - && type_filter & GTK_FONT_SCALABLE))) - nstandard_sizes = 0; - - gtk_clist_freeze (GTK_CLIST(fontsel->size_clist)); - gtk_clist_clear (GTK_CLIST(fontsel->size_clist)); - - /* Interleave the standard sizes with the bitmapped sizes so we get a list - of ascending sizes. If the metric is points, we have to convert the - decipoints to points. */ - while (nstandard_sizes || nbitmapped_sizes) - { - can_match = TRUE; - if (fontsel->metric == GTK_FONT_METRIC_POINTS) - { - if (*bitmapped_sizes % 10 != 0) - can_match = FALSE; - bitmap_size = *bitmapped_sizes / 10; - bitmap_size_float = *bitmapped_sizes / 10; - } - else - { - bitmap_size = *bitmapped_sizes; - bitmap_size_float = *bitmapped_sizes; - } - - if (can_match && nstandard_sizes && nbitmapped_sizes - && *standard_sizes == bitmap_size) - { - sprintf(buffer, "%i *", *standard_sizes); - standard_sizes++; - nstandard_sizes--; - bitmapped_sizes++; - nbitmapped_sizes--; - } - else if (nstandard_sizes - && (!nbitmapped_sizes - || (gfloat)*standard_sizes < bitmap_size_float)) - { - sprintf(buffer, "%i", *standard_sizes); - standard_sizes++; - nstandard_sizes--; - } - else - { - if (fontsel->metric == GTK_FONT_METRIC_POINTS) - { - if (*bitmapped_sizes % 10 == 0) - sprintf(buffer, "%i *", *bitmapped_sizes / 10); - else - sprintf(buffer, "%i.%i *", *bitmapped_sizes / 10, - *bitmapped_sizes % 10); - } - else - { - sprintf(buffer, "%i *", *bitmapped_sizes); - } - bitmapped_sizes++; - nbitmapped_sizes--; - } - size = buffer; - gtk_clist_append(GTK_CLIST(fontsel->size_clist), &size); - } - gtk_clist_thaw (GTK_CLIST(fontsel->size_clist)); -} - - -/* 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) -{ - GtkFontSelection *fontsel; - gint new_size; - gfloat new_size_float; - gchar *text; - -#ifdef FONTSEL_DEBUG - g_message("In size_key_press\n"); -#endif - fontsel = GTK_FONT_SELECTION(data); - - if (event->keyval == GDK_Return) + fontsel->family = match_family; + if (match_family) { - text = gtk_entry_get_text (GTK_ENTRY (fontsel->size_entry)); - if (fontsel->metric == GTK_FONT_METRIC_PIXELS) - { - new_size = atoi (text); - if (new_size < 2) - new_size = 2; - } - else - { - new_size_float = atof (text) * 10; - new_size = (gint) new_size_float; - if (new_size < 20) - new_size = 20; - } - - /* Remember that this size was set explicitly. */ - fontsel->selected_size = new_size; - - /* Check if the font size has changed, and return if it hasn't. */ - if (fontsel->size == new_size) - return TRUE; - - fontsel->size = new_size; - gtk_font_selection_select_best_size (fontsel); - return TRUE; + 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 FALSE; -} - -/* This tries to select the closest size to the current size, though it - may have to change the size if only unscaled bitmaps are available. - Note: this will load a font. */ -static void -gtk_font_selection_select_best_size(GtkFontSelection *fontsel) -{ - FontInfo *font; - FontStyle *styles, *style; - gchar *text; - gint row, best_row = 0, size, size_fraction, best_size = 0, nmatched; - gboolean found = FALSE; - gchar buffer[32]; - GList *selection; - gint type_filter; - -#ifdef FONTSEL_DEBUG - g_message("In select_best_size\n"); -#endif - font = &fontsel_info->font_info[fontsel->font_index]; - styles = &fontsel_info->font_styles[font->style_index]; - style = &styles[fontsel->style]; - - /* Find the closest size available in the size clist. If the exact size is - in the list set found to TRUE. */ - for (row = 0; row < GTK_CLIST(fontsel->size_clist)->rows; row++) - { - gtk_clist_get_text(GTK_CLIST(fontsel->size_clist), row, 0, &text); - nmatched = sscanf(text, "%i.%i", &size, &size_fraction); - if (fontsel->metric == GTK_FONT_METRIC_POINTS) - { - size *= 10; - if (nmatched == 2) - size += size_fraction; - } - - if (size == fontsel->selected_size) - { - found = TRUE; - best_size = size; - best_row = row; - break; - } - else if (best_size == 0 - || abs(size - fontsel->selected_size) - < (abs(best_size - fontsel->selected_size))) - { - best_size = size; - best_row = row; - } - } - - /* If we aren't scaling bitmapped fonts and this is a bitmapped font, we - need to use the closest size found. */ - type_filter = fontsel->filters[GTK_FONT_FILTER_BASE].font_type - & fontsel->filters[GTK_FONT_FILTER_USER].font_type; - - if (!((style->flags & GTK_FONT_SCALABLE_BITMAP - && type_filter & GTK_FONT_SCALABLE_BITMAP) - || (style->flags & GTK_FONT_SCALABLE - && type_filter & GTK_FONT_SCALABLE))) - found = TRUE; - - if (found) - { - fontsel->size = best_size; - gtk_clist_moveto(GTK_CLIST(fontsel->size_clist), best_row, -1, 0.5, 0); - gtk_clist_select_row(GTK_CLIST(fontsel->size_clist), best_row, 0); - } - else - { - fontsel->size = fontsel->selected_size; - selection = GTK_CLIST(fontsel->size_clist)->selection; - if (selection) - gtk_clist_unselect_row(GTK_CLIST(fontsel->size_clist), - GPOINTER_TO_INT (selection->data), 0); - gtk_clist_moveto(GTK_CLIST(fontsel->size_clist), best_row, -1, 0.5, 0); - - /* Show the size in the size entry. */ - if (fontsel->metric == GTK_FONT_METRIC_PIXELS) - sprintf(buffer, "%i", fontsel->size); - else - { - if (fontsel->size % 10 == 0) - sprintf(buffer, "%i", fontsel->size / 10); - else - sprintf(buffer, "%i.%i", fontsel->size / 10, fontsel->size % 10); - } - gtk_entry_set_text (GTK_ENTRY (fontsel->size_entry), buffer); - } - gtk_font_selection_load_font (fontsel); + g_free (families); } - -/* 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) +static int +compare_font_descriptions (const PangoFontDescription *a, const PangoFontDescription *b) { - GtkFontSelection *fontsel; - gint new_size; - gchar *text; - gchar buffer[16]; - gint i; - -#ifdef FONTSEL_DEBUG - g_message("In select_size\n"); -#endif - fontsel = GTK_FONT_SELECTION(data); - - if (bevent && !GTK_WIDGET_HAS_FOCUS (w)) - gtk_widget_grab_focus (w); - - /* Copy the size from the clist to the size entry, but without the bitmapped - marker ('*'). */ - gtk_clist_get_text(GTK_CLIST(fontsel->size_clist), row, 0, &text); - i = 0; - while (i < 15 && (text[i] == '.' || (text[i] >= '0' && text[i] <= '9'))) - { - buffer[i] = text[i]; - i++; - } - buffer[i] = '\0'; - gtk_entry_set_text(GTK_ENTRY(fontsel->size_entry), buffer); - - /* Check if the font size has changed, and return if it hasn't. */ - new_size = atoi(text); - if (fontsel->metric == GTK_FONT_METRIC_POINTS) - new_size *= 10; - - if (fontsel->size == new_size) - return; - - /* If the size was selected by the user we set the selected_size. */ - fontsel->selected_size = new_size; - - fontsel->size = new_size; - gtk_font_selection_load_font (fontsel); -} + int val = strcmp (pango_font_description_get_family (a), pango_font_description_get_family (b)); + if (val != 0) + return val; + 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); -/* This is called when the pixels or points radio buttons are pressed. */ -static void -gtk_font_selection_metric_callback (GtkWidget *w, - gpointer data) -{ - GtkFontSelection *fontsel = GTK_FONT_SELECTION(data); + 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); -#ifdef FONTSEL_DEBUG - g_message("In metric_callback\n"); -#endif - if (GTK_TOGGLE_BUTTON(fontsel->pixels_button)->active) - { - if (fontsel->metric == GTK_FONT_METRIC_PIXELS) - return; - fontsel->metric = GTK_FONT_METRIC_PIXELS; - fontsel->size = (fontsel->size + 5) / 10; - fontsel->selected_size = (fontsel->selected_size + 5) / 10; - } - else - { - if (fontsel->metric == GTK_FONT_METRIC_POINTS) - return; - fontsel->metric = GTK_FONT_METRIC_POINTS; - fontsel->size *= 10; - fontsel->selected_size *= 10; - } - if (fontsel->font_index != -1) - { - gtk_font_selection_show_available_sizes (fontsel); - gtk_font_selection_select_best_size (fontsel); - } -} + 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 (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); -/* This searches the given property table and returns the index of the given - string, or 0, which is the wildcard '*' index, if it's not found. */ -static guint16 -gtk_font_selection_field_to_index (gchar **table, - gint ntable, - gchar *field) -{ - gint i; - - for (i = 0; i < ntable; i++) - if (strcmp (field, table[i]) == 0) - return i; - return 0; } - - -/* This attempts to load the current font, and returns TRUE if it succeeds. */ -static gboolean -gtk_font_selection_load_font (GtkFontSelection *fontsel) +static int +faces_sort_func (const void *a, const void *b) { - GdkFont *font; - gchar *fontname, *label_text; - - if (fontsel->font) - gdk_font_unref (fontsel->font); - fontsel->font = NULL; + PangoFontDescription *desc_a = pango_font_face_describe (*(PangoFontFace **)a); + PangoFontDescription *desc_b = pango_font_face_describe (*(PangoFontFace **)b); - /* If no family has been selected yet, just return FALSE. */ - if (fontsel->font_index == -1) - return FALSE; - - fontname = gtk_font_selection_get_font_name (fontsel); - if (fontname) - { -#ifdef FONTSEL_DEBUG - g_message("Loading: %s\n", fontname); -#endif - font = gdk_font_load (fontname); - g_free(fontname); - - if (font) - { - fontsel->font = font; - /* Make sure the message label is empty, but don't change it unless - it's necessary as it results in a resize of the whole window! */ - gtk_label_get(GTK_LABEL(fontsel->message_label), &label_text); - if (strcmp(label_text, "")) - gtk_label_set(GTK_LABEL(fontsel->message_label), ""); - gtk_font_selection_update_preview (fontsel); - return TRUE; - } - else - { - gtk_label_set(GTK_LABEL(fontsel->message_label), - "The selected font is not available."); - } - } - else - { - gtk_label_set(GTK_LABEL(fontsel->message_label), - "The selected font is not a valid font."); - } - - return FALSE; -} + int ord = compare_font_descriptions (desc_a, desc_b); + pango_font_description_free (desc_a); + pango_font_description_free (desc_b); -/* 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 - resizing the entry every time the font changes. - This also used to shrink the preview if the font size was decreased, but - that made it awkward if the user wanted to resize the window themself. */ -static void -gtk_font_selection_update_preview (GtkFontSelection *fontsel) -{ - GtkWidget *preview_entry; - GtkStyle *style; - gint text_height, new_height; - gchar *text; - XFontStruct *xfs; - -#ifdef FONTSEL_DEBUG - g_message("In update_preview\n"); -#endif - style = gtk_style_new (); - gdk_font_unref (style->font); - style->font = fontsel->font; - gdk_font_ref (style->font); - - preview_entry = fontsel->preview_entry; - gtk_widget_set_style (preview_entry, style); - gtk_style_unref(style); - - text_height = preview_entry->style->font->ascent - + preview_entry->style->font->descent; - /* We don't ever want to be over MAX_PREVIEW_HEIGHT pixels high. */ - new_height = text_height + 20; - if (new_height < INITIAL_PREVIEW_HEIGHT) - new_height = INITIAL_PREVIEW_HEIGHT; - if (new_height > MAX_PREVIEW_HEIGHT) - new_height = MAX_PREVIEW_HEIGHT; - - if ((preview_entry->requisition.height < text_height + 10) - || (preview_entry->requisition.height > text_height + 40)) - gtk_widget_set_usize(preview_entry, -1, new_height); - - /* This sets the preview text, if it hasn't been set already. */ - text = gtk_entry_get_text(GTK_ENTRY(fontsel->preview_entry)); - if (strlen(text) == 0) - gtk_entry_set_text(GTK_ENTRY(fontsel->preview_entry), PREVIEW_TEXT); - gtk_entry_set_position(GTK_ENTRY(fontsel->preview_entry), 0); - - /* If this is a 2-byte font display a message to say it may not be - displayed properly. */ - xfs = GDK_FONT_XFONT(fontsel->font); - if (xfs->min_byte1 != 0 || xfs->max_byte1 != 0) - gtk_label_set(GTK_LABEL(fontsel->message_label), - "This is a 2-byte font and may not be displayed correctly."); + return ord; } - -static void -gtk_font_selection_switch_page (GtkWidget *w, - GtkNotebookPage *page, - gint page_num, - gpointer data) +static gboolean +font_description_style_equal (const PangoFontDescription *a, + const PangoFontDescription *b) { - GtkFontSelection *fontsel = GTK_FONT_SELECTION(data); - - /* This function strangely gets called when the window is destroyed, - so we check here to see if the notebook is visible. */ - if (!GTK_WIDGET_VISIBLE(w)) - return; - - if (page_num == 0) - gtk_font_selection_update_filter(fontsel); - else if (page_num == 1) - gtk_font_selection_show_font_info(fontsel); + 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 list with all the possible style combinations + for the current font family. */ static void -gtk_font_selection_show_font_info (GtkFontSelection *fontsel) +gtk_font_selection_show_available_styles (GtkFontSelection *fontsel) { - Atom font_atom, atom; - Bool status; - char *name; - gchar *fontname; - gchar field_buffer[XLFD_MAX_FIELD_LEN]; - gchar *field; - gint i; - gboolean shown_actual_fields = FALSE; - - fontname = gtk_font_selection_get_font_name(fontsel); - gtk_entry_set_text(GTK_ENTRY(fontsel->requested_font_name), - fontname ? fontname : ""); - - gtk_clist_freeze (GTK_CLIST(fontsel->info_clist)); - for (i = 0; i < GTK_XLFD_NUM_FIELDS; i++) - { - if (fontname) - field = gtk_font_selection_get_xlfd_field (fontname, i, field_buffer); - else - field = NULL; - if (field) - { - if (i == XLFD_SLANT) - field = gtk_font_selection_expand_slant_code(field); - else if (i == XLFD_SPACING) - field = gtk_font_selection_expand_spacing_code(field); - } - gtk_clist_set_text(GTK_CLIST(fontsel->info_clist), i, 1, - field ? field : ""); - } + gint n_faces, i; + PangoFontFace **faces; + PangoFontDescription *old_desc; + GtkListStore *model; + GtkTreeIter match_row; + PangoFontFace *match_face = NULL; - if (fontsel->font) - { - font_atom = XInternAtom(GDK_DISPLAY(), "FONT", True); - if (font_atom != None) - { - status = XGetFontProperty(GDK_FONT_XFONT(fontsel->font), font_atom, - &atom); - if (status == True) - { - name = XGetAtomName(GDK_DISPLAY(), atom); - gtk_entry_set_text(GTK_ENTRY(fontsel->actual_font_name), name); - - for (i = 0; i < GTK_XLFD_NUM_FIELDS; i++) - { - field = gtk_font_selection_get_xlfd_field (name, i, - field_buffer); - if (i == XLFD_SLANT) - field = gtk_font_selection_expand_slant_code(field); - else if (i == XLFD_SPACING) - field = gtk_font_selection_expand_spacing_code(field); - gtk_clist_set_text(GTK_CLIST(fontsel->info_clist), i, 2, - field ? field : ""); - } - shown_actual_fields = TRUE; - XFree(name); - } - } - } - if (!shown_actual_fields) - { - gtk_entry_set_text(GTK_ENTRY(fontsel->actual_font_name), ""); - for (i = 0; i < GTK_XLFD_NUM_FIELDS; i++) - { - gtk_clist_set_text(GTK_CLIST(fontsel->info_clist), i, 2, - fontname ? "(unknown)" : ""); - } - } - gtk_clist_thaw (GTK_CLIST(fontsel->info_clist)); - g_free(fontname); -} - - -static gchar* -gtk_font_selection_expand_slant_code(gchar *slant) -{ - if (!g_strcasecmp(slant, "r")) return("roman"); - else if (!g_strcasecmp(slant, "i")) return("italic"); - else if (!g_strcasecmp(slant, "o")) return("oblique"); - else if (!g_strcasecmp(slant, "ri")) return("reverse italic"); - else if (!g_strcasecmp(slant, "ro")) return("reverse oblique"); - else if (!g_strcasecmp(slant, "ot")) return("other"); - return slant; -} - -static gchar* -gtk_font_selection_expand_spacing_code(gchar *spacing) -{ - if (!g_strcasecmp(spacing, "p")) return("proportional"); - else if (!g_strcasecmp(spacing, "m")) return("monospaced"); - else if (!g_strcasecmp(spacing, "c")) return("char cell"); - return spacing; -} - - -/***************************************************************************** - * These functions all deal with the Filter page and filtering the fonts. - *****************************************************************************/ - -/* This is called when an item is selected in one of the filter clists. - We make sure that the first row of the clist, i.e. the wildcard '*', is - selected if and only if none of the other items are selected. - Also doesn't allow selections of values filtered out by base filter. - We may need to be careful about triggering other signals. */ -static void -gtk_font_selection_select_filter (GtkWidget *w, - gint row, - gint column, - GdkEventButton *bevent, - GtkFontSelection *fontsel) -{ - gint i, prop, index; + model = GTK_LIST_STORE (gtk_tree_view_get_model (GTK_TREE_VIEW (fontsel->face_list))); - if (row == 0) - { - for (i = 1; i < GTK_CLIST(w)->rows; i++) - gtk_clist_unselect_row(GTK_CLIST(w), i, 0); - } + if (fontsel->face) + old_desc = pango_font_face_describe (fontsel->face); else - { - /* Find out which property this is. */ - for (prop = 0; prop < GTK_NUM_FONT_PROPERTIES; prop++) - if (fontsel->filter_clists[prop] == w) - break; - index = GPOINTER_TO_INT (gtk_clist_get_row_data(GTK_CLIST(w), row)); - if (gtk_font_selection_filter_state (fontsel, GTK_FONT_FILTER_BASE, - prop, index) == NOT_FILTERED) - gtk_clist_unselect_row(GTK_CLIST(w), row, 0); - else - gtk_clist_unselect_row(GTK_CLIST(w), 0, 0); - } -} + old_desc= NULL; + pango_font_family_list_faces (fontsel->family, &faces, &n_faces); + qsort (faces, n_faces, sizeof (PangoFontFace *), faces_sort_func); -/* Here a filter item is being deselected. If there are now no items selected - we select the first '*' item, unless that it is the item being deselected, - in which case we select all of the other items. This makes it easy to - select all items in the list except one or two. */ -static void -gtk_font_selection_unselect_filter (GtkWidget *w, - gint row, - gint column, - GdkEventButton *bevent, - GtkFontSelection *fontsel) -{ - gint i, prop, index; + gtk_list_store_clear (model); - if (!GTK_CLIST(w)->selection) + for (i=0; i < n_faces; i++) { - if (row == 0) - { - /* Find out which property this is. */ - for (prop = 0; prop < GTK_NUM_FONT_PROPERTIES; prop++) - if (fontsel->filter_clists[prop] == w) - break; + GtkTreeIter iter; + const gchar *str = pango_font_face_get_face_name (faces[i]); - for (i = 1; i < GTK_CLIST(w)->rows; i++) - { - index = GPOINTER_TO_INT (gtk_clist_get_row_data(GTK_CLIST(w), - i)); - if (gtk_font_selection_filter_state (fontsel, - GTK_FONT_FILTER_BASE, - prop, index) - != NOT_FILTERED) - gtk_clist_select_row(GTK_CLIST(w), i, 0); - } - } - else + gtk_list_store_append (model, &iter); + gtk_list_store_set (model, &iter, + FACE_COLUMN, faces[i], + FACE_NAME_COLUMN, str, + -1); + + if (i == 0) { - gtk_clist_select_row(GTK_CLIST(w), 0, 0); + match_row = iter; + match_face = faces[i]; } - } -} - - -/* This is called when the main notebook page is selected. It checks if the - filter has changed, an if so it creates the filter settings, and filters the - fonts shown. If an empty filter (all '*'s) is applied, then filtering is - turned off. */ -static void -gtk_font_selection_update_filter (GtkFontSelection *fontsel) -{ - GtkWidget *clist; - GList *selection; - gboolean default_filter = TRUE, filter_changed = FALSE; - gint prop, nselected, i, row, index; - GtkFontFilter *filter = &fontsel->filters[GTK_FONT_FILTER_USER]; - gint base_font_type, user_font_type, new_font_type; - -#ifdef FONTSEL_DEBUG - g_message("In update_filter\n"); -#endif - - /* Check if the user filter has changed, and also if it is the default - filter, i.e. bitmap & scalable fonts and all '*'s selected. - We only look at the bits which are not already filtered out by the base - filter, since that overrides the user filter. */ - base_font_type = fontsel->filters[GTK_FONT_FILTER_BASE].font_type - & GTK_FONT_ALL; - user_font_type = fontsel->filters[GTK_FONT_FILTER_USER].font_type - & GTK_FONT_ALL; - new_font_type = GTK_TOGGLE_BUTTON(fontsel->type_bitmaps_button)->active - ? GTK_FONT_BITMAP : 0; - new_font_type |= (GTK_TOGGLE_BUTTON(fontsel->type_scalable_button)->active - ? GTK_FONT_SCALABLE : 0); - new_font_type |= (GTK_TOGGLE_BUTTON(fontsel->type_scaled_bitmaps_button)->active ? GTK_FONT_SCALABLE_BITMAP : 0); - new_font_type &= base_font_type; - new_font_type |= (~base_font_type & user_font_type); - if (new_font_type != (GTK_FONT_BITMAP | GTK_FONT_SCALABLE)) - default_filter = FALSE; - - if (new_font_type != user_font_type) - filter_changed = TRUE; - fontsel->filters[GTK_FONT_FILTER_USER].font_type = new_font_type; - - for (prop = 0; prop < GTK_NUM_FONT_PROPERTIES; prop++) - { - clist = fontsel->filter_clists[prop]; - selection = GTK_CLIST(clist)->selection; - nselected = g_list_length(selection); - if (nselected != 1 || GPOINTER_TO_INT (selection->data) != 0) + else if (old_desc) { - default_filter = FALSE; + PangoFontDescription *tmp_desc = pango_font_face_describe (faces[i]); - if (filter->property_nfilters[prop] != nselected) - filter_changed = TRUE; - else + if (font_description_style_equal (tmp_desc, old_desc)) { - for (i = 0; i < nselected; i++) - { - row = GPOINTER_TO_INT (selection->data); - index = GPOINTER_TO_INT (gtk_clist_get_row_data (GTK_CLIST (clist), row)); - if (filter->property_filters[prop][i] != index) - filter_changed = TRUE; - selection = selection->next; - } + match_row = iter; + match_face = faces[i]; } - } - else - { - if (filter->property_nfilters[prop] != 0) - filter_changed = TRUE; + + pango_font_description_free (tmp_desc); } } - - /* If the filter hasn't changed we just return. */ - if (!filter_changed) - return; - -#ifdef FONTSEL_DEBUG - g_message(" update_fonts: filter has changed\n"); -#endif - - /* Free the old filter data and create the new arrays. */ - for (prop = 0; prop < GTK_NUM_FONT_PROPERTIES; prop++) - { - g_free(filter->property_filters[prop]); - clist = fontsel->filter_clists[prop]; - selection = GTK_CLIST(clist)->selection; - nselected = g_list_length(selection); - if (nselected == 1 && GPOINTER_TO_INT (selection->data) == 0) - { - filter->property_filters[prop] = NULL; - filter->property_nfilters[prop] = 0; - } - else - { - filter->property_filters[prop] = g_new(guint16, nselected); - filter->property_nfilters[prop] = nselected; - for (i = 0; i < nselected; i++) - { - row = GPOINTER_TO_INT (selection->data); - index = GPOINTER_TO_INT (gtk_clist_get_row_data (GTK_CLIST (clist), row)); - filter->property_filters[prop][i] = index; - selection = selection->next; - } - } - } + if (old_desc) + pango_font_description_free (old_desc); - /* Set the 'Reset Filter' button sensitive if a filter is in effect, and - also set the label above the font list to show this as well. */ - if (default_filter) + fontsel->face = match_face; + if (match_face) { - gtk_widget_set_sensitive(fontsel->filter_button, FALSE); - gtk_label_set(GTK_LABEL(fontsel->font_label), "Font:"); - } - else - { - gtk_widget_set_sensitive(fontsel->filter_button, TRUE); - gtk_label_set(GTK_LABEL(fontsel->font_label), "Font: (Filter Applied)"); +#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_font_selection_show_available_fonts(fontsel); -} + g_free (faces); +} -/* This shows all the available fonts in the font clist. */ +/* 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_show_available_fonts (GtkFontSelection *fontsel) +gtk_font_selection_select_best_style (GtkFontSelection *fontsel, + gboolean use_first) { - FontInfo *font_info, *font; - GtkFontFilter *filter; - gint nfonts, i, j, k, row, style, font_row = -1; - gchar font_buffer[XLFD_MAX_FIELD_LEN * 2 + 4]; - gchar *font_item; - gboolean matched, matched_style; - -#ifdef FONTSEL_DEBUG - g_message("In show_available_fonts\n"); -#endif - font_info = fontsel_info->font_info; - nfonts = fontsel_info->nfonts; - - /* Filter the list of fonts. */ - gtk_clist_freeze (GTK_CLIST(fontsel->font_clist)); - gtk_clist_clear (GTK_CLIST(fontsel->font_clist)); - for (i = 0; i < nfonts; i++) - { - font = &font_info[i]; - - /* Check if the foundry passes through all filters. */ - matched = TRUE; - for (k = 0; k < GTK_NUM_FONT_FILTERS; k++) - { - filter = &fontsel->filters[k]; - - if (filter->property_nfilters[FOUNDRY] != 0) - { - matched = FALSE; - for (j = 0; j < filter->property_nfilters[FOUNDRY]; j++) - { - if (font->foundry == filter->property_filters[FOUNDRY][j]) - { - matched = TRUE; - break; - } - } - } - } - - if (!matched) - continue; - - - /* Now check if the other properties are matched in at least one style.*/ - matched_style = FALSE; - for (style = 0; style < font->nstyles; style++) - { - if (gtk_font_selection_style_visible(fontsel, font, style)) - { - matched_style = TRUE; - break; - } - } - if (!matched_style) - continue; - - /* Insert the font in the clist. */ - if ((i > 0 && font->family == font_info[i-1].family) - || (i < nfonts - 1 && font->family == font_info[i+1].family)) - { - sprintf(font_buffer, "%s (%s)", font->family, - fontsel_info->properties[FOUNDRY][font->foundry]); - font_item = font_buffer; - row = gtk_clist_append(GTK_CLIST(fontsel->font_clist), &font_item); - } - else - { - row = gtk_clist_append(GTK_CLIST(fontsel->font_clist), - &font->family); - } - gtk_clist_set_row_data(GTK_CLIST(fontsel->font_clist), row, - GINT_TO_POINTER (i)); - if (fontsel->font_index == i) - font_row = row; - } - gtk_clist_thaw (GTK_CLIST(fontsel->font_clist)); - - /* If the currently-selected font isn't in the new list, reset the - selection. */ - if (font_row == -1) - { - fontsel->font_index = -1; - if (fontsel->font) - gdk_font_unref(fontsel->font); - fontsel->font = NULL; - gtk_entry_set_text(GTK_ENTRY(fontsel->font_entry), ""); - gtk_clist_clear (GTK_CLIST(fontsel->font_style_clist)); - gtk_entry_set_text(GTK_ENTRY(fontsel->font_style_entry), ""); - return; - } + GtkTreeIter iter; + GtkTreeModel *model; - gtk_clist_select_row(GTK_CLIST(fontsel->font_clist), font_row, 0); - if (gtk_clist_row_is_visible(GTK_CLIST(fontsel->font_clist), font_row) - != GTK_VISIBILITY_FULL) - gtk_clist_moveto(GTK_CLIST(fontsel->font_clist), font_row, -1, 0.5, 0); + model = gtk_tree_view_get_model (GTK_TREE_VIEW (fontsel->face_list)); - gtk_font_selection_show_available_styles (fontsel); - gtk_font_selection_select_best_style (fontsel, FALSE); -} - - -/* Returns TRUE if the style is not currently filtered out. */ -static gboolean -gtk_font_selection_style_visible(GtkFontSelection *fontsel, - FontInfo *font, - gint style_index) -{ - FontStyle *styles, *style; - GtkFontFilter *filter; - guint16 value; - gint prop, i, j; - gboolean matched; - gint type_filter; - - styles = &fontsel_info->font_styles[font->style_index]; - style = &styles[style_index]; - - /* Check if font_type of style is filtered. */ - type_filter = fontsel->filters[GTK_FONT_FILTER_BASE].font_type - & fontsel->filters[GTK_FONT_FILTER_USER].font_type; - if (!(style->flags & type_filter)) - return FALSE; - - for (prop = 0; prop < GTK_NUM_STYLE_PROPERTIES; prop++) + if (gtk_tree_model_get_iter_first (model, &iter)) { - value = style->properties[prop]; - - /* Check each filter. */ - for (i = 0; i < GTK_NUM_FONT_FILTERS; i++) - { - filter = &fontsel->filters[i]; - - if (filter->property_nfilters[prop] != 0) - { - matched = FALSE; - for (j = 0; j < filter->property_nfilters[prop]; j++) - { - if (value == filter->property_filters[prop][j]) - { - matched = TRUE; - break; - } - } - if (!matched) - return FALSE; - } - } + set_cursor_to_iter (GTK_TREE_VIEW (fontsel->face_list), &iter); + scroll_to_selection (GTK_TREE_VIEW (fontsel->face_list)); } - return TRUE; -} - - -/* This resets the font type to bitmap or scalable, and sets all the filter - clists to the wildcard '*' options. */ -static void -gtk_font_selection_reset_filter (GtkWidget *w, - GtkFontSelection *fontsel) -{ - gint prop, base_font_type; - - fontsel->filters[GTK_FONT_FILTER_USER].font_type = GTK_FONT_BITMAP - | GTK_FONT_SCALABLE; - - base_font_type = fontsel->filters[GTK_FONT_FILTER_BASE].font_type; - if (base_font_type & GTK_FONT_BITMAP) - gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (fontsel->type_bitmaps_button), TRUE); - if (base_font_type & GTK_FONT_SCALABLE) - gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (fontsel->type_scalable_button), TRUE); - if (base_font_type & GTK_FONT_SCALABLE_BITMAP) - gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (fontsel->type_scaled_bitmaps_button), FALSE); - - for (prop = 0; prop < GTK_NUM_FONT_PROPERTIES; prop++) - gtk_clist_select_row(GTK_CLIST(fontsel->filter_clists[prop]), 0, 0); -} - -/* This clears the filter, showing all fonts and styles again. */ -static void -gtk_font_selection_on_clear_filter (GtkWidget *w, - GtkFontSelection *fontsel) -{ - gtk_font_selection_clear_filter(fontsel); + gtk_font_selection_show_available_sizes (fontsel, FALSE); + gtk_font_selection_select_best_size (fontsel); } -/* This resets the user filter, showing all fonts and styles which pass the - base filter again. Note that the font type is set to bitmaps and scalable - fonts - scaled bitmaps are not shown. */ +/* This is called when a style is selected in the list. */ static void -gtk_font_selection_clear_filter (GtkFontSelection *fontsel) +gtk_font_selection_select_style (GtkTreeSelection *selection, + gpointer data) { - GtkFontFilter *filter; - gint prop; + GtkFontSelection *fontsel = GTK_FONT_SELECTION (data); + GtkTreeModel *model; + GtkTreeIter iter; -#ifdef FONTSEL_DEBUG - g_message("In clear_filter\n"); -#endif - /* Clear the filter data. */ - filter = &fontsel->filters[GTK_FONT_FILTER_USER]; - filter->font_type = GTK_FONT_BITMAP | GTK_FONT_SCALABLE; - for (prop = 0; prop < GTK_NUM_FONT_PROPERTIES; prop++) - { - g_free(filter->property_filters[prop]); - filter->property_filters[prop] = NULL; - filter->property_nfilters[prop] = 0; - } - - /* Select all the '*'s on the filter page. */ - gtk_font_selection_reset_filter(NULL, fontsel); - - /* Update the main notebook page. */ - gtk_widget_set_sensitive(fontsel->filter_button, FALSE); - gtk_label_set(GTK_LABEL(fontsel->font_label), "Font:"); - - gtk_font_selection_show_available_fonts(fontsel); -} - - -void -gtk_font_selection_set_filter (GtkFontSelection *fontsel, - GtkFontFilterType filter_type, - GtkFontType font_type, - gchar **foundries, - gchar **weights, - gchar **slants, - gchar **setwidths, - gchar **spacings, - gchar **charsets) -{ - GtkFontFilter *filter; - gchar **filter_strings [GTK_NUM_FONT_PROPERTIES]; - gchar *filter_string; - gchar *property, *property_alt; - gint prop, nfilters, i, j, num_found; - gint base_font_type, user_font_type; - gboolean filter_set; - - /* Put them into an array so we can use a simple loop. */ - filter_strings[FOUNDRY] = foundries; - filter_strings[WEIGHT] = weights; - filter_strings[SLANT] = slants; - filter_strings[SET_WIDTH] = setwidths; - filter_strings[SPACING] = spacings; - filter_strings[CHARSET] = charsets; - - filter = &fontsel->filters[filter_type]; - filter->font_type = font_type; - - /* Free the old filter data, and insert the new. */ - for (prop = 0; prop < GTK_NUM_FONT_PROPERTIES; prop++) + if (gtk_tree_selection_get_selected (selection, &model, &iter)) { - g_free(filter->property_filters[prop]); - filter->property_filters[prop] = NULL; - filter->property_nfilters[prop] = 0; + PangoFontFace *face; - if (filter_strings[prop]) - { - /* Count how many items in the new array. */ - nfilters = 0; - while (filter_strings[prop][nfilters]) - nfilters++; - - filter->property_filters[prop] = g_new(guint16, nfilters); - filter->property_nfilters[prop] = 0; + gtk_tree_model_get (model, &iter, FACE_COLUMN, &face, -1); + fontsel->face = face; - /* Now convert the strings to property indices. */ - num_found = 0; - for (i = 0; i < nfilters; i++) - { - filter_string = filter_strings[prop][i]; - for (j = 0; j < fontsel_info->nproperties[prop]; j++) - { - property = fontsel_info->properties[prop][j]; - property_alt = NULL; - if (prop == SLANT) - property_alt = gtk_font_selection_expand_slant_code(property); - else if (prop == SPACING) - property_alt = gtk_font_selection_expand_spacing_code(property); - if (!strcmp (filter_string, property) - || (property_alt && !strcmp (filter_string, property_alt))) - { - filter->property_filters[prop][num_found] = j; - num_found++; - break; - } - } - } - filter->property_nfilters[prop] = num_found; - } + g_object_unref (face); } - /* Now set the clists on the filter page according to the new filter. */ - gtk_font_selection_update_filter_lists (fontsel); - - if (filter_type == GTK_FONT_FILTER_BASE) - { - user_font_type = fontsel->filters[GTK_FONT_FILTER_USER].font_type; - if (font_type & GTK_FONT_BITMAP) - { - gtk_widget_set_sensitive (fontsel->type_bitmaps_button, TRUE); - gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (fontsel->type_bitmaps_button), user_font_type & GTK_FONT_BITMAP); - } - else - { - gtk_widget_set_sensitive (fontsel->type_bitmaps_button, FALSE); - gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (fontsel->type_bitmaps_button), FALSE); - } - - if (font_type & GTK_FONT_SCALABLE) - { - gtk_widget_set_sensitive (fontsel->type_scalable_button, TRUE); - gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (fontsel->type_scalable_button), user_font_type & GTK_FONT_SCALABLE); - } - else - { - gtk_widget_set_sensitive (fontsel->type_scalable_button, FALSE); - gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (fontsel->type_scalable_button), FALSE); - } - - if (font_type & GTK_FONT_SCALABLE_BITMAP) - { - gtk_widget_set_sensitive (fontsel->type_scaled_bitmaps_button, TRUE); - gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (fontsel->type_scaled_bitmaps_button), user_font_type & GTK_FONT_SCALABLE_BITMAP); - } - else - { - gtk_widget_set_sensitive (fontsel->type_scaled_bitmaps_button, FALSE); - gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (fontsel->type_scaled_bitmaps_button), FALSE); - } - } - else - { - base_font_type = fontsel->filters[GTK_FONT_FILTER_BASE].font_type; - if (base_font_type & GTK_FONT_BITMAP) - gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (fontsel->type_bitmaps_button), font_type & GTK_FONT_BITMAP); - - if (base_font_type & GTK_FONT_SCALABLE) - gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (fontsel->type_scalable_button), font_type & GTK_FONT_SCALABLE); - - if (base_font_type & GTK_FONT_SCALABLE_BITMAP) - gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (fontsel->type_scaled_bitmaps_button), font_type & GTK_FONT_SCALABLE_BITMAP); - - /* If the user filter is not the default, make the 'Reset Filter' button - sensitive. */ - filter_set = FALSE; - if (font_type != (GTK_FONT_BITMAP | GTK_FONT_SCALABLE)) - filter_set = TRUE; - for (prop = 0; prop < GTK_NUM_FONT_PROPERTIES; prop++) - { - if (filter->property_nfilters[prop] != 0) - filter_set = TRUE; - } - if (filter_set) - gtk_widget_set_sensitive (fontsel->filter_button, TRUE); - } - - gtk_font_selection_show_available_fonts (fontsel); + gtk_font_selection_show_available_sizes (fontsel, FALSE); + gtk_font_selection_select_best_size (fontsel); } - -/* This sets the colour of each property in the filter clists according to - the base filter. i.e. Filtered properties are shown as insensitive. */ static void -gtk_font_selection_update_filter_lists (GtkFontSelection *fontsel) -{ - GtkWidget *clist; - GdkColor *inactive_fg, *inactive_bg, *fg, *bg; - gint prop, row, index; - - /* We have to make sure the clist is realized to use the colours. */ - for (prop = 0; prop < GTK_NUM_FONT_PROPERTIES; prop++) - { - clist = fontsel->filter_clists[prop]; - gtk_widget_realize (clist); - inactive_fg = &clist->style->fg[GTK_STATE_INSENSITIVE]; - inactive_bg = &clist->style->bg[GTK_STATE_INSENSITIVE]; - for (row = 1; row < GTK_CLIST(clist)->rows; row++) - { - index = GPOINTER_TO_INT (gtk_clist_get_row_data(GTK_CLIST(clist), - row)); - /* Set the colour according to the base filter. */ - if (gtk_font_selection_filter_state (fontsel, GTK_FONT_FILTER_BASE, - prop, index) == NOT_FILTERED) - { - fg = inactive_fg; - bg = inactive_bg; - } - else - { - fg = NULL; - bg = NULL; - } - gtk_clist_set_foreground(GTK_CLIST(clist), row, fg); - gtk_clist_set_background(GTK_CLIST(clist), row, bg); - - /* Set the selection state according to the user filter. */ - if (gtk_font_selection_filter_state (fontsel, GTK_FONT_FILTER_USER, - prop, index) == FILTERED - && fg == NULL) - gtk_clist_select_row (GTK_CLIST (clist), row, 0); - else - gtk_clist_unselect_row (GTK_CLIST (clist), row, 0); - } - } -} - - -/* Returns whether a property value is in the filter or not, or if the - property has no filter set. */ -static GtkFontPropertyFilterState -gtk_font_selection_filter_state (GtkFontSelection *fontsel, - GtkFontFilterType filter_type, - gint property, - gint index) +gtk_font_selection_show_available_sizes (GtkFontSelection *fontsel, + gboolean first_time) { - GtkFontFilter *filter; gint i; - - filter = &fontsel->filters[filter_type]; - if (filter->property_nfilters[property] == 0) - return NOT_SET; - - for (i = 0; i < filter->property_nfilters[property]; i++) - { - if (filter->property_filters[property][i] == index) - return FILTERED; - } - return NOT_FILTERED; -} - - -/***************************************************************************** - * These functions all deal with creating the main class arrays containing - * the data about all available fonts. - *****************************************************************************/ -static void -gtk_font_selection_get_fonts (void) -{ - gchar **xfontnames; - GSList **fontnames; - gchar *fontname; - GSList * temp_list; - gint num_fonts; - gint i, prop, style, size; - gint npixel_sizes = 0, npoint_sizes = 0; - FontInfo *font; - FontStyle *current_style, *prev_style, *tmp_style; - gboolean matched_style, found_size; - gint pixels, points, res_x, res_y; - gchar field_buffer[XLFD_MAX_FIELD_LEN]; - gchar *field; - guint8 flags; - guint16 *pixel_sizes, *point_sizes, *tmp_sizes; - - fontsel_info = g_new (GtkFontSelInfo, 1); - - /* Get a maximum of MAX_FONTS fontnames from the X server. - Use "-*" as the pattern rather than "-*-*-*-*-*-*-*-*-*-*-*-*-*-*" since - the latter may result in fonts being returned which don't actually exist. - xlsfonts also uses "*" so I think it's OK. "-*" gets rid of aliases. */ - xfontnames = XListFonts (GDK_DISPLAY(), "-*", MAX_FONTS, &num_fonts); - /* Output a warning if we actually get MAX_FONTS fonts. */ - if (num_fonts == MAX_FONTS) - g_warning("MAX_FONTS exceeded. Some fonts may be missing."); - - /* The maximum size of all these tables is the number of font names - returned. We realloc them later when we know exactly how many - unique entries there are. */ - fontsel_info->font_info = g_new (FontInfo, num_fonts); - fontsel_info->font_styles = g_new (FontStyle, num_fonts); - fontsel_info->pixel_sizes = g_new (guint16, num_fonts); - fontsel_info->point_sizes = g_new (guint16, num_fonts); - - fontnames = g_new (GSList*, num_fonts); - - /* Create the initial arrays for the property value strings, though they - may be realloc'ed later. Put the wildcard '*' in the first elements. */ - for (prop = 0; prop < GTK_NUM_FONT_PROPERTIES; prop++) - { - fontsel_info->properties[prop] = g_new(gchar*, PROPERTY_ARRAY_INCREMENT); - fontsel_info->space_allocated[prop] = PROPERTY_ARRAY_INCREMENT; - fontsel_info->nproperties[prop] = 1; - fontsel_info->properties[prop][0] = "*"; - } - - - /* Insert the font families into the main table, sorted by family and - foundry (fonts with different foundries are placed in seaparate FontInfos. - All fontnames in each family + foundry are placed into the fontnames - array of lists. */ - fontsel_info->nfonts = 0; - for (i = 0; i < num_fonts; i++) - { -#ifdef FONTSEL_DEBUG - g_message("%s\n", xfontnames[i]); -#endif - if (gtk_font_selection_is_xlfd_font_name (xfontnames[i])) - gtk_font_selection_insert_font (fontnames, &fontsel_info->nfonts, xfontnames[i]); - else - { -#ifdef FONTSEL_DEBUG - g_warning("Skipping invalid font: %s", xfontnames[i]); -#endif - } - } - - - /* Since many font names will be in the same FontInfo not all of the - allocated FontInfo table will be used, so we will now reallocate it - with the real size. */ - fontsel_info->font_info = g_realloc(fontsel_info->font_info, - sizeof(FontInfo) * fontsel_info->nfonts); - - - /* Now we work out which choices of weight/slant etc. are valid for each - font. */ - fontsel_info->nstyles = 0; - current_style = fontsel_info->font_styles; - for (i = 0; i < fontsel_info->nfonts; i++) - { - font = &fontsel_info->font_info[i]; - - /* Use the next free position in the styles array. */ - font->style_index = fontsel_info->nstyles; - - /* Now step through each of the fontnames with this family, and create - a style for each fontname. Each style contains the index into the - weights/slants etc. arrays, and a number of pixel/point sizes. */ - style = 0; - temp_list = fontnames[i]; - while (temp_list) - { - fontname = temp_list->data; - temp_list = temp_list->next; - - for (prop = 0; prop < GTK_NUM_STYLE_PROPERTIES; prop++) - { - current_style->properties[prop] - = gtk_font_selection_insert_field (fontname, prop); - } - current_style->pixel_sizes_index = npixel_sizes; - current_style->npixel_sizes = 0; - current_style->point_sizes_index = npoint_sizes; - current_style->npoint_sizes = 0; - current_style->flags = 0; - - - field = gtk_font_selection_get_xlfd_field (fontname, XLFD_PIXELS, - field_buffer); - pixels = atoi(field); - - field = gtk_font_selection_get_xlfd_field (fontname, XLFD_POINTS, - field_buffer); - points = atoi(field); - - field = gtk_font_selection_get_xlfd_field (fontname, - XLFD_RESOLUTION_X, - field_buffer); - res_x = atoi(field); - - field = gtk_font_selection_get_xlfd_field (fontname, - XLFD_RESOLUTION_Y, - field_buffer); - res_y = atoi(field); - - if (pixels == 0 && points == 0) - { - if (res_x == 0 && res_y == 0) - flags = GTK_FONT_SCALABLE; - else - flags = GTK_FONT_SCALABLE_BITMAP; - } - else - flags = GTK_FONT_BITMAP; + GtkListStore *model; + GtkTreeSelection *selection; + gchar buffer[128]; + gchar *p; + + model = GTK_LIST_STORE (gtk_tree_view_get_model (GTK_TREE_VIEW (fontsel->size_list))); + selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (fontsel->size_list)); + + /* Insert the standard font sizes */ + if (first_time) + { + gtk_list_store_clear (model); + + for (i = 0; i < G_N_ELEMENTS (font_sizes); i++) + { + GtkTreeIter iter; - /* Now we check to make sure that the style is unique. If it isn't - we forget it. */ - prev_style = fontsel_info->font_styles + font->style_index; - matched_style = FALSE; - while (prev_style < current_style) - { - matched_style = TRUE; - for (prop = 0; prop < GTK_NUM_STYLE_PROPERTIES; prop++) - { - if (prev_style->properties[prop] - != current_style->properties[prop]) - { - matched_style = FALSE; - break; - } - } - if (matched_style) - break; - prev_style++; - } + gtk_list_store_append (model, &iter); + gtk_list_store_set (model, &iter, SIZE_COLUMN, font_sizes[i], -1); - /* If we matched an existing style, we need to add the pixels & - point sizes to the style. If not, we insert the pixel & point - sizes into our new style. Note that we don't add sizes for - scalable fonts. */ - if (matched_style) - { - prev_style->flags |= flags; - if (flags == GTK_FONT_BITMAP) - { - pixel_sizes = fontsel_info->pixel_sizes - + prev_style->pixel_sizes_index; - found_size = FALSE; - for (size = 0; size < prev_style->npixel_sizes; size++) - { - if (pixels == *pixel_sizes) - { - found_size = TRUE; - break; - } - else if (pixels < *pixel_sizes) - break; - pixel_sizes++; - } - /* We need to move all the following pixel sizes up, and also - update the indexes of any following styles. */ - if (!found_size) - { - for (tmp_sizes = fontsel_info->pixel_sizes + npixel_sizes; - tmp_sizes > pixel_sizes; tmp_sizes--) - *tmp_sizes = *(tmp_sizes - 1); - - *pixel_sizes = pixels; - npixel_sizes++; - prev_style->npixel_sizes++; - - tmp_style = prev_style + 1; - while (tmp_style < current_style) - { - tmp_style->pixel_sizes_index++; - tmp_style++; - } - } - - point_sizes = fontsel_info->point_sizes - + prev_style->point_sizes_index; - found_size = FALSE; - for (size = 0; size < prev_style->npoint_sizes; size++) - { - if (points == *point_sizes) - { - found_size = TRUE; - break; - } - else if (points < *point_sizes) - break; - point_sizes++; - } - /* We need to move all the following point sizes up, and also - update the indexes of any following styles. */ - if (!found_size) - { - for (tmp_sizes = fontsel_info->point_sizes + npoint_sizes; - tmp_sizes > point_sizes; tmp_sizes--) - *tmp_sizes = *(tmp_sizes - 1); - - *point_sizes = points; - npoint_sizes++; - prev_style->npoint_sizes++; - - tmp_style = prev_style + 1; - while (tmp_style < current_style) - { - tmp_style->point_sizes_index++; - tmp_style++; - } - } - } - } - else - { - current_style->flags = flags; - if (flags == GTK_FONT_BITMAP) - { - fontsel_info->pixel_sizes[npixel_sizes++] = pixels; - current_style->npixel_sizes = 1; - fontsel_info->point_sizes[npoint_sizes++] = points; - current_style->npoint_sizes = 1; - } - style++; - fontsel_info->nstyles++; - current_style++; - } + if (font_sizes[i] * PANGO_SCALE == fontsel->size) + set_cursor_to_iter (GTK_TREE_VIEW (fontsel->size_list), &iter); } - g_slist_free(fontnames[i]); - - /* Set nstyles to the real value, minus duplicated fontnames. - Note that we aren't using all the allocated memory if fontnames are - duplicated. */ - font->nstyles = style; } - - /* Since some repeated styles may be skipped we won't have used all the - allocated space, so we will now reallocate it with the real size. */ - fontsel_info->font_styles = g_realloc(fontsel_info->font_styles, - sizeof(FontStyle) * fontsel_info->nstyles); - fontsel_info->pixel_sizes = g_realloc(fontsel_info->pixel_sizes, - sizeof(guint16) * npixel_sizes); - fontsel_info->point_sizes = g_realloc(fontsel_info->point_sizes, - sizeof(guint16) * npoint_sizes); - g_free(fontnames); - XFreeFontNames (xfontnames); - - - /* Debugging Output */ - /* This outputs all FontInfos. */ -#ifdef FONTSEL_DEBUG - g_message("\n\n Font Family Weight Slant Set Width Spacing Charset\n\n"); - for (i = 0; i < fontsel_info->nfonts; i++) + else { - FontInfo *font = &fontsel_info->font_info[i]; - FontStyle *styles = fontsel_info->font_styles + font->style_index; - for (style = 0; style < font->nstyles; style++) + 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++) { - g_message("%5i %-16.16s ", i, font->family); - for (prop = 0; prop < GTK_NUM_STYLE_PROPERTIES; prop++) - g_message("%-9.9s ", - fontsel_info->properties[prop][styles->properties[prop]]); - g_message("\n "); - - if (styles->flags & GTK_FONT_BITMAP) - g_message("Bitmapped font "); - if (styles->flags & GTK_FONT_SCALABLE) - g_message("Scalable font "); - if (styles->flags & GTK_FONT_SCALABLE_BITMAP) - g_message("Scalable-Bitmapped font "); - g_message("\n"); - - if (styles->npixel_sizes) - { - g_message(" Pixel sizes: "); - tmp_sizes = fontsel_info->pixel_sizes + styles->pixel_sizes_index; - for (size = 0; size < styles->npixel_sizes; size++) - g_message("%i ", *tmp_sizes++); - g_message("\n"); - } - - if (styles->npoint_sizes) + if (font_sizes[i] * PANGO_SCALE == fontsel->size) { - g_message(" Point sizes: "); - tmp_sizes = fontsel_info->point_sizes + styles->point_sizes_index; - for (size = 0; size < styles->npoint_sizes; size++) - g_message("%i ", *tmp_sizes++); - g_message("\n"); + set_cursor_to_iter (GTK_TREE_VIEW (fontsel->size_list), &iter); + found = TRUE; } - - g_message("\n"); - styles++; + + 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); } } - /* This outputs all available properties. */ - for (prop = 0; prop < GTK_NUM_FONT_PROPERTIES; prop++) + + /* 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, '.')) { - g_message("Property: %s\n", xlfd_field_names[xlfd_index[prop]]); - for (i = 0; i < fontsel_info->nproperties[prop]; i++) - g_message(" %s\n", fontsel_info->properties[prop][i]); + p = buffer + strlen (buffer) - 1; + while (*p == '0') + p--; + if (*p == '.') + p--; + p[1] = '\0'; } -#endif + + /* 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); } -/* This inserts the given fontname into the FontInfo table. - If a FontInfo already exists with the same family and foundry, then the - fontname is added to the FontInfos list of fontnames, else a new FontInfo - is created and inserted in alphabetical order in the table. */ static void -gtk_font_selection_insert_font (GSList *fontnames[], - gint *ntable, - gchar *fontname) +gtk_font_selection_select_best_size (GtkFontSelection *fontsel) { - FontInfo *table; - FontInfo temp_info; - GSList *temp_fontname; - gchar *family; - gboolean family_exists = FALSE; - gint foundry; - gint lower, upper; - gint middle, cmp; - gchar family_buffer[XLFD_MAX_FIELD_LEN]; - - table = fontsel_info->font_info; - - /* insert a fontname into a table */ - family = gtk_font_selection_get_xlfd_field (fontname, XLFD_FAMILY, - family_buffer); - if (!family) - return; - - foundry = gtk_font_selection_insert_field (fontname, FOUNDRY); - - lower = 0; - if (*ntable > 0) + gtk_font_selection_load_font (fontsel); +} + +static void +gtk_font_selection_set_size (GtkFontSelection *fontsel, + gint new_size) +{ + if (fontsel->size != new_size) { - /* Do a binary search to determine if we have already encountered - * a font with this family & foundry. */ - upper = *ntable; - while (lower < upper) - { - middle = (lower + upper) >> 1; - - cmp = strcmp (family, table[middle].family); - /* If the family matches we sort by the foundry. */ - if (cmp == 0) - { - family_exists = TRUE; - family = table[middle].family; - cmp = strcmp(fontsel_info->properties[FOUNDRY][foundry], - fontsel_info->properties[FOUNDRY][table[middle].foundry]); - } - - if (cmp == 0) - { - fontnames[middle] = g_slist_prepend (fontnames[middle], - fontname); - return; - } - else if (cmp < 0) - upper = middle; - else - lower = middle+1; - } + 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 void +gtk_font_selection_size_activate (GtkWidget *w, + gpointer data) +{ + GtkFontSelection *fontsel; + gint new_size; + 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); + + gtk_font_selection_set_size (fontsel, new_size); +} + +static gboolean +gtk_font_selection_size_focus_out (GtkWidget *w, + GdkEventFocus *event, + gpointer data) +{ + gtk_font_selection_size_activate (w, data); - /* Add another entry to the table for this new font family */ - temp_info.family = family_exists ? family : g_strdup(family); - temp_info.foundry = foundry; - temp_fontname = g_slist_prepend (NULL, fontname); + return TRUE; +} + +/* This is called when a size is selected in the list. */ +static void +gtk_font_selection_select_size (GtkTreeSelection *selection, + gpointer data) +{ + GtkFontSelection *fontsel; + GtkTreeModel *model; + GtkTreeIter iter; + gint new_size; - (*ntable)++; + fontsel = GTK_FONT_SELECTION (data); - /* Quickly insert the entry into the table in sorted order - * using a modification of insertion sort and the knowledge - * that the entries proper position in the table was determined - * above in the binary search and is contained in the "lower" - * variable. */ - if (*ntable > 1) + if (gtk_tree_selection_get_selected (selection, &model, &iter)) { - upper = *ntable - 1; - while (lower != upper) - { - table[upper] = table[upper-1]; - fontnames[upper] = fontnames[upper-1]; - upper--; - } + gtk_tree_model_get (model, &iter, SIZE_COLUMN, &new_size, -1); + gtk_font_selection_set_size (fontsel, new_size * PANGO_SCALE); } - table[lower] = temp_info; - fontnames[lower] = temp_fontname; } +static void +gtk_font_selection_load_font (GtkFontSelection *fontsel) +{ + if (fontsel->font) + gdk_font_unref (fontsel->font); + fontsel->font = NULL; + + 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 ("Sans 10"); + + return font_desc; +} -/* This checks that the specified field of the given fontname is in the - appropriate properties array. If not it is added. Thus eventually we get - arrays of all possible weights/slants etc. It returns the array index. */ -static gint -gtk_font_selection_insert_field (gchar *fontname, - gint prop) +/* 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 + resizing the entry every time the font changes. + This also used to shrink the preview if the font size was decreased, but + that made it awkward if the user wanted to resize the window themself. */ +static void +gtk_font_selection_update_preview (GtkFontSelection *fontsel) { - gchar field_buffer[XLFD_MAX_FIELD_LEN]; - gchar *field; - guint16 index; + GtkRcStyle *rc_style; + gint new_height; + GtkRequisition old_requisition; + GtkWidget *preview_entry = fontsel->preview_entry; + const gchar *text; + + gtk_widget_get_child_requisition (preview_entry, &old_requisition); + + rc_style = gtk_rc_style_new (); + rc_style->font_desc = gtk_font_selection_get_font_description (fontsel); - field = gtk_font_selection_get_xlfd_field (fontname, xlfd_index[prop], - field_buffer); - if (!field) - return 0; + gtk_widget_modify_style (preview_entry, rc_style); + gtk_rc_style_unref (rc_style); + + gtk_widget_size_request (preview_entry, NULL); - /* If the field is already in the array just return its index. */ - for (index = 0; index < fontsel_info->nproperties[prop]; index++) - if (!strcmp(field, fontsel_info->properties[prop][index])) - return index; + /* We don't ever want to be over MAX_PREVIEW_HEIGHT pixels high. */ + 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_size_request (preview_entry, -1, new_height); - /* Make sure we have enough space to add the field. */ - if (fontsel_info->nproperties[prop] == fontsel_info->space_allocated[prop]) + /* 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_editable_set_position (GTK_EDITABLE (preview_entry), 0); +} + +GdkFont* +gtk_font_selection_get_font_internal (GtkFontSelection *fontsel) +{ + if (!fontsel->font) { - fontsel_info->space_allocated[prop] += PROPERTY_ARRAY_INCREMENT; - fontsel_info->properties[prop] = g_realloc(fontsel_info->properties[prop], - sizeof(gchar*) - * fontsel_info->space_allocated[prop]); + 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); } - /* Add the new field. */ - index = fontsel_info->nproperties[prop]; - fontsel_info->properties[prop][index] = g_strdup(field); - fontsel_info->nproperties[prop]++; - return index; + return fontsel->font; } @@ -2990,228 +1074,127 @@ gtk_font_selection_insert_field (gchar *fontname, GdkFont* gtk_font_selection_get_font (GtkFontSelection *fontsel) { - g_return_val_if_fail (fontsel != NULL, NULL); - return fontsel->font; + return gtk_font_selection_get_font_internal (fontsel); } - gchar * gtk_font_selection_get_font_name (GtkFontSelection *fontsel) { - FontInfo *font; - gchar *family_str, *foundry_str; - gchar *property_str[GTK_NUM_STYLE_PROPERTIES]; - gint prop; - - g_return_val_if_fail (fontsel != NULL, NULL); - g_return_val_if_fail (GTK_IS_FONT_SELECTION (fontsel), NULL); - - /* If no family has been selected return NULL. */ - if (fontsel->font_index == -1) - return NULL; - - font = &fontsel_info->font_info[fontsel->font_index]; - family_str = font->family; - foundry_str = fontsel_info->properties[FOUNDRY][font->foundry]; + gchar *result; - for (prop = 0; prop < GTK_NUM_STYLE_PROPERTIES; prop++) - { - property_str[prop] - = fontsel_info->properties[prop][fontsel->property_values[prop]]; - if (strcmp (property_str[prop], "(nil)") == 0) - property_str[prop] = ""; - } - - return gtk_font_selection_create_xlfd (fontsel->size, - fontsel->metric, - foundry_str, - family_str, - property_str[WEIGHT], - property_str[SLANT], - property_str[SET_WIDTH], - property_str[SPACING], - property_str[CHARSET]); -} + PangoFontDescription *font_desc = gtk_font_selection_get_font_description (fontsel); + result = pango_font_description_to_string (font_desc); + pango_font_description_free (font_desc); - -/* This returns the style with the best match to the current fontsel setting, - i.e. with the highest number of matching property values. */ -static gint -gtk_font_selection_get_best_match(GtkFontSelection *fontsel) -{ - FontInfo *font; - FontStyle *styles; - gint prop, style, best_style = 0, matched, best_matched = 0; - - font = &fontsel_info->font_info[fontsel->font_index]; - styles = &fontsel_info->font_styles[font->style_index]; - - /* Find the style with the most matches. */ - for (style = 0; style < font->nstyles; style++) - { - matched = 0; - for (prop = 0; prop < GTK_NUM_STYLE_PROPERTIES; prop++) - { - if (fontsel->property_values[prop] == styles[style].properties[prop]) - matched++; - } - if (matched > best_matched) - { - best_matched = matched; - best_style = style; - } - } - - return best_style; + 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. */ gboolean gtk_font_selection_set_font_name (GtkFontSelection *fontsel, const gchar *fontname) { - gchar *family, *field; - gint index, prop, size; - guint16 foundry, value; - gchar family_buffer[XLFD_MAX_FIELD_LEN]; - gchar field_buffer[XLFD_MAX_FIELD_LEN]; - gchar buffer[16]; + PangoFontFamily *new_family = NULL; + PangoFontFace *new_face = NULL; + PangoFontFace *fallback_face = NULL; + PangoFontDescription *new_desc; + GtkTreeModel *model; + GtkTreeIter iter; + GtkTreeIter match_iter; + gboolean valid; - g_return_val_if_fail (fontsel != NULL, FALSE); g_return_val_if_fail (GTK_IS_FONT_SELECTION (fontsel), FALSE); - g_return_val_if_fail (fontname != NULL, FALSE); - - /* Check it is a valid fontname. */ - if (!gtk_font_selection_is_xlfd_font_name(fontname)) - return FALSE; - - family = gtk_font_selection_get_xlfd_field (fontname, XLFD_FAMILY, - family_buffer); - if (!family) - return FALSE; - - field = gtk_font_selection_get_xlfd_field (fontname, XLFD_FOUNDRY, - field_buffer); - foundry = gtk_font_selection_field_to_index (fontsel_info->properties[FOUNDRY], - fontsel_info->nproperties[FOUNDRY], - field); - index = gtk_font_selection_find_font(fontsel, family, foundry); - if (index == -1) - return FALSE; - - /* Convert the property fields into indices and set them. */ - for (prop = 0; prop < GTK_NUM_STYLE_PROPERTIES; prop++) - { - field = gtk_font_selection_get_xlfd_field (fontname, xlfd_index[prop], - field_buffer); - value = gtk_font_selection_field_to_index (fontsel_info->properties[prop], - fontsel_info->nproperties[prop], - field); - fontsel->property_values[prop] = value; - } - - field = gtk_font_selection_get_xlfd_field (fontname, XLFD_POINTS, - field_buffer); - size = atoi(field); - if (size > 0) - { - if (size < 20) - size = 20; - fontsel->size = fontsel->selected_size = size; - fontsel->metric = GTK_FONT_METRIC_POINTS; - gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(fontsel->points_button), - TRUE); - if (size % 10 == 0) - sprintf (buffer, "%i", size / 10); - else - sprintf (buffer, "%i.%i", size / 10, size % 10); - } - else + new_desc = pango_font_description_from_string (fontname); + + /* 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)) { - field = gtk_font_selection_get_xlfd_field (fontname, XLFD_PIXELS, - field_buffer); - size = atoi(field); - if (size < 2) - size = 2; - fontsel->size = fontsel->selected_size = size; - fontsel->metric = GTK_FONT_METRIC_PIXELS; - gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(fontsel->pixels_button), - TRUE); - sprintf (buffer, "%i", size); + PangoFontFamily *family; + + gtk_tree_model_get (model, &iter, FAMILY_COLUMN, &family, -1); + + if (g_ascii_strcasecmp (pango_font_family_get_name (family), + pango_font_description_get_family (new_desc)) == 0) + new_family = family; + + g_object_unref (family); + + if (new_family) + break; } - gtk_entry_set_text (GTK_ENTRY (fontsel->size_entry), buffer); - - /* Clear any current filter. */ - gtk_font_selection_clear_filter(fontsel); - - /* Now find the best style match. */ - fontsel->font_index = index; - gtk_clist_select_row(GTK_CLIST(fontsel->font_clist), index, 0); - if (GTK_WIDGET_MAPPED (fontsel->font_clist)) - gtk_clist_moveto(GTK_CLIST(fontsel->font_clist), index, -1, 0.5, 0); - - gtk_font_selection_show_available_styles (fontsel); - /* This will load the font. */ - gtk_font_selection_select_best_style (fontsel, FALSE); - - return TRUE; -} + if (!new_family) + return FALSE; -/* Returns the index of the given family, or -1 if not found */ -static gint -gtk_font_selection_find_font (GtkFontSelection *fontsel, - gchar *family, - guint16 foundry) -{ - FontInfo *font_info; - gint lower, upper, middle = -1, cmp, nfonts; - - font_info = fontsel_info->font_info; - nfonts = fontsel_info->nfonts; - if (nfonts == 0) - return -1; - - /* Do a binary search to find the font family. */ - lower = 0; - upper = nfonts; - while (lower < upper) + fontsel->family = new_family; + set_cursor_to_iter (GTK_TREE_VIEW (fontsel->family_list), &iter); + gtk_font_selection_show_available_styles (fontsel); + + 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)) { - middle = (lower + upper) >> 1; + 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) + { + fallback_face = face; + match_iter = iter; + } - cmp = strcmp (family, font_info[middle].family); - if (cmp == 0) - cmp = strcmp(fontsel_info->properties[FOUNDRY][foundry], - fontsel_info->properties[FOUNDRY][font_info[middle].foundry]); + pango_font_description_free (tmp_desc); + g_object_unref (face); - if (cmp == 0) - return middle; - else if (cmp < 0) - upper = middle; - else if (cmp > 0) - lower = middle+1; + if (new_face) + { + match_iter = iter; + break; + } } + + if (!new_face) + new_face = fallback_face; + + 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)); - /* If we can't match family & foundry see if just the family matches */ - if (!strcmp (family, font_info[middle].family)) - return middle; - - return -1; + 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 (new_desc); + + return TRUE; } /* This returns the text in the preview entry. You should copy the returned text if you need it. */ -gchar* +G_CONST_RETURN gchar* gtk_font_selection_get_preview_text (GtkFontSelection *fontsel) { - return gtk_entry_get_text(GTK_ENTRY(fontsel->preview_entry)); + return gtk_entry_get_text (GTK_ENTRY (fontsel->preview_entry)); } @@ -3220,161 +1203,36 @@ void gtk_font_selection_set_preview_text (GtkFontSelection *fontsel, const gchar *text) { - gtk_entry_set_text(GTK_ENTRY(fontsel->preview_entry), text); -} - - -/***************************************************************************** - * These functions all deal with X Logical Font Description (XLFD) fontnames. - * See the freely available documentation about this. - *****************************************************************************/ - -/* - * Returns TRUE if the fontname is a valid XLFD. - * (It just checks if the number of dashes is 14, and that each - * field < XLFD_MAX_FIELD_LEN characters long - that's not in the XLFD but it - * makes it easier for me). - */ -static gboolean -gtk_font_selection_is_xlfd_font_name (const gchar *fontname) -{ - gint i = 0; - gint field_len = 0; - - while (*fontname) - { - if (*fontname++ == '-') - { - if (field_len > XLFD_MAX_FIELD_LEN) return FALSE; - field_len = 0; - i++; - } - else - field_len++; - } - - return (i == 14) ? TRUE : FALSE; -} - -/* - * This fills the buffer with the specified field from the X Logical Font - * Description name, and returns it. If fontname is NULL or the field is - * longer than XFLD_MAX_FIELD_LEN it returns NULL. - * Note: For the charset field, we also return the encoding, e.g. 'iso8859-1'. - */ -static gchar* -gtk_font_selection_get_xlfd_field (const gchar *fontname, - FontField field_num, - gchar *buffer) -{ - const gchar *t1, *t2; - gint countdown, len, num_dashes; - - if (!fontname) - return NULL; - - /* we assume this is a valid fontname...that is, it has 14 fields */ - - countdown = field_num; - t1 = fontname; - while (*t1 && (countdown >= 0)) - if (*t1++ == '-') - countdown--; - - num_dashes = (field_num == XLFD_CHARSET) ? 2 : 1; - for (t2 = t1; *t2; t2++) - { - if (*t2 == '-' && --num_dashes == 0) - break; - } - - if (t1 != t2) - { - /* Check we don't overflow the buffer */ - len = (long) t2 - (long) t1; - if (len > XLFD_MAX_FIELD_LEN - 1) - return NULL; - strncpy (buffer, t1, len); - buffer[len] = 0; - - /* Convert to lower case. */ - g_strdown (buffer); - } - else - strcpy(buffer, "(nil)"); - - return buffer; -} - -/* - * This returns a X Logical Font Description font name, given all the pieces. - * Note: this retval must be freed by the caller. - */ -static gchar * -gtk_font_selection_create_xlfd (gint size, - GtkFontMetricType metric, - gchar *foundry, - gchar *family, - gchar *weight, - gchar *slant, - gchar *set_width, - gchar *spacing, - gchar *charset) -{ - gchar buffer[16]; - gchar *pixel_size = "*", *point_size = "*", *fontname; - gint length; - - if (size <= 0) - return NULL; - - sprintf (buffer, "%d", (int) size); - if (metric == GTK_FONT_METRIC_PIXELS) - pixel_size = buffer; - else - point_size = buffer; - - /* Note: be careful here - don't overrun the allocated memory. */ - length = strlen(foundry) + strlen(family) + strlen(weight) + strlen(slant) - + strlen(set_width) + strlen(pixel_size) + strlen(point_size) - + strlen(spacing) + strlen(charset) - + 1 + 1 + 1 + 1 + 1 + 3 + 1 + 5 + 3 - + 1 /* for the terminating '\0'. */; - - fontname = g_new(gchar, length); - /* **NOTE**: If you change this string please change length above! */ - sprintf(fontname, "-%s-%s-%s-%s-%s-*-%s-%s-*-*-%s-*-%s", - foundry, family, weight, slant, set_width, pixel_size, - point_size, spacing, charset); - return fontname; + gtk_entry_set_text (GTK_ENTRY (fontsel->preview_entry), text); } - - /***************************************************************************** * GtkFontSelectionDialog *****************************************************************************/ -guint +GType gtk_font_selection_dialog_get_type (void) { - static guint font_selection_dialog_type = 0; + static GType font_selection_dialog_type = 0; if (!font_selection_dialog_type) { - GtkTypeInfo fontsel_diag_info = + static const GTypeInfo 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, + NULL, /* base_init */ + NULL, /* base_finalize */ + (GClassInitFunc) gtk_font_selection_dialog_class_init, + NULL, /* class_finalize */ + NULL, /* class_data */ + sizeof (GtkFontSelectionDialog), + 0, /* n_preallocs */ + (GInstanceInitFunc) gtk_font_selection_dialog_init, }; - font_selection_dialog_type = gtk_type_unique (GTK_TYPE_WINDOW, &fontsel_diag_info); + font_selection_dialog_type = + g_type_register_static (GTK_TYPE_DIALOG, "GtkFontSelectionDialog", + &fontsel_diag_info, 0); } return font_selection_dialog_type; @@ -3383,151 +1241,95 @@ gtk_font_selection_dialog_get_type (void) 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_WINDOW); + font_selection_dialog_parent_class = g_type_class_peek_parent (klass); } static void gtk_font_selection_dialog_init (GtkFontSelectionDialog *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); + GtkDialog *dialog; + + gtk_widget_push_composite_child (); + + dialog = GTK_DIALOG (fontseldiag); gtk_container_set_border_width (GTK_CONTAINER (fontseldiag), 4); - gtk_window_set_policy(GTK_WINDOW(fontseldiag), FALSE, TRUE, TRUE); + gtk_window_set_resizable (GTK_WINDOW (fontseldiag), TRUE); - fontseldiag->main_vbox = gtk_vbox_new (FALSE, 4); - gtk_widget_show (fontseldiag->main_vbox); - gtk_container_add (GTK_CONTAINER (fontseldiag), fontseldiag->main_vbox); + fontseldiag->main_vbox = dialog->vbox; - fontseldiag->fontsel = gtk_font_selection_new(); + fontseldiag->fontsel = gtk_font_selection_new (); + gtk_container_set_border_width (GTK_CONTAINER (fontseldiag->fontsel), 4); 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 = gtk_hbutton_box_new (); - gtk_button_box_set_layout(GTK_BUTTON_BOX(fontseldiag->action_area), - GTK_BUTTONBOX_END); - gtk_button_box_set_spacing(GTK_BUTTON_BOX(fontseldiag->action_area), 5); - gtk_box_pack_start (GTK_BOX (fontseldiag->main_vbox), - fontseldiag->action_area, FALSE, FALSE, 0); - gtk_widget_show (fontseldiag->action_area); - - fontseldiag->ok_button = gtk_button_new_with_label("OK"); - GTK_WIDGET_SET_FLAGS (fontseldiag->ok_button, GTK_CAN_DEFAULT); - gtk_widget_show(fontseldiag->ok_button); - gtk_box_pack_start (GTK_BOX (fontseldiag->action_area), - fontseldiag->ok_button, TRUE, TRUE, 0); + fontseldiag->action_area = dialog->action_area; + + fontseldiag->cancel_button = gtk_dialog_add_button (dialog, + GTK_STOCK_CANCEL, + GTK_RESPONSE_CANCEL); + + fontseldiag->apply_button = gtk_dialog_add_button (dialog, + 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->apply_button = gtk_button_new_with_label("Apply"); - GTK_WIDGET_SET_FLAGS (fontseldiag->apply_button, GTK_CAN_DEFAULT); - /*gtk_widget_show(fontseldiag->apply_button);*/ - gtk_box_pack_start (GTK_BOX(fontseldiag->action_area), - fontseldiag->apply_button, TRUE, TRUE, 0); - - fontseldiag->cancel_button = gtk_button_new_with_label("Cancel"); - GTK_WIDGET_SET_FLAGS (fontseldiag->cancel_button, GTK_CAN_DEFAULT); - gtk_widget_show(fontseldiag->cancel_button); - gtk_box_pack_start (GTK_BOX(fontseldiag->action_area), - fontseldiag->cancel_button, TRUE, TRUE, 0); - + gtk_window_set_title (GTK_WINDOW (fontseldiag), + _("Font Selection")); + + gtk_dialog_set_has_separator (GTK_DIALOG (dialog), FALSE); + gtk_widget_pop_composite_child (); } 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); - gtk_window_set_title (GTK_WINDOW (fontseldiag), - title ? title : "Font Selection"); + fontseldiag = g_object_new (GTK_TYPE_FONT_SELECTION_DIALOG, NULL); + + if (title) + gtk_window_set_title (GTK_WINDOW (fontseldiag), title); return GTK_WIDGET (fontseldiag); } 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)); + return gtk_font_selection_get_font_name (GTK_FONT_SELECTION (fsd->fontsel)); } 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)); + return gtk_font_selection_get_font (GTK_FONT_SELECTION (fsd->fontsel)); } gboolean -gtk_font_selection_dialog_set_font_name (GtkFontSelectionDialog *fsd, +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); -} - -void -gtk_font_selection_dialog_set_filter (GtkFontSelectionDialog *fsd, - GtkFontFilterType filter_type, - GtkFontType font_type, - gchar **foundries, - gchar **weights, - gchar **slants, - gchar **setwidths, - gchar **spacings, - gchar **charsets) -{ - gtk_font_selection_set_filter (GTK_FONT_SELECTION (fsd->fontsel), - filter_type, font_type, - foundries, weights, slants, setwidths, - spacings, charsets); + return gtk_font_selection_set_font_name (GTK_FONT_SELECTION (fsd->fontsel), fontname); } -gchar* +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)); + return gtk_font_selection_get_preview_text (GTK_FONT_SELECTION (fsd->fontsel)); } void gtk_font_selection_dialog_set_preview_text (GtkFontSelectionDialog *fsd, - const gchar *text) -{ - gtk_font_selection_set_preview_text(GTK_FONT_SELECTION(fsd->fontsel), text); -} - - -/* 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) + const gchar *text) { - /* 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); }