* Boston, MA 02111-1307, USA.
*/
+/*
+ * Modified by the GTK+ Team and others 1997-1999. 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/.
+ */
+
/*
* Limits:
*
* Possible Improvements:
*
* Font Styles - could sort the styles into a reasonable order - regular
- * first, then bold, bold italic etc. Could also try to keep
- * a similar style as the user selects different fonts.
+ * 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
* Debugging: compile with -DFONTSEL_DEBUG for lots of debugging output.
*/
-
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <ctype.h>
-#include <X11/Xlib.h>
-#include "gdk/gdkx.h"
+#include "gdk/gdk.h"
+/* Protect against the CHARSET struct in Win32 */
+#ifdef GDK_WINDOWING_WIN32
+# define CHARSET CHARSETstruct
+#endif
+#include "gdkx.h"
+#ifdef GDK_WINDOWING_WIN32
+# undef CHARSET
+#endif
#include "gdk/gdkkeysyms.h"
#include "gtkbutton.h"
+#include "gtkcheckbutton.h"
#include "gtkclist.h"
#include "gtkentry.h"
#include "gtkfontsel.h"
#include "gtksignal.h"
#include "gtktable.h"
#include "gtkvbox.h"
+#include "gtkscrolledwindow.h"
+#include "gtkintl.h"
/* The maximum number of fontnames requested with XListFonts(). */
#define MAX_FONTS 32767
/* 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[] = {
+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
};
/* 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 POINTS_METRIC
+#define INITIAL_METRIC GTK_FONT_METRIC_POINTS
#define INITIAL_FONT_SIZE 140
/* This is the default text shown in the preview entry, though the user
/* These are the sizes of the font, style & size clists. */
#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
-/* Used for the flags field in FontStyle. Note that they can be combined,
- e.g. a style can have multiple bitmaps and a true scalable version.
- The displayed flag is used when displaying styles to remember which
- styles have already been displayed. */
-enum
-{
- BITMAP_FONT = 1 << 0,
- SCALABLE_FONT = 1 << 1,
- SCALABLE_BITMAP_FONT = 1 << 2,
- DISPLAYED = 1 << 3
-};
-
typedef struct _GtkFontSelInfo GtkFontSelInfo;
typedef struct _FontInfo FontInfo;
typedef struct _FontStyle FontStyle;
gint style_index;
guint16 nstyles;
};
+
/* 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. */
+ 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];
};
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];
-
- /* Whether any scalable bitmap fonts are available. If not, the 'Allow
- scaled bitmap fonts' toggle button is made insensitive. */
- gboolean scaled_bitmaps_available;
};
/* These are the field numbers in the X Logical Font Description fontnames,
} 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:",
+static const gchar* xlfd_field_names[GTK_XLFD_NUM_FIELDS] = {
+ N_("Foundry:"),
+ N_("Family:"),
+ N_("Weight:"),
+ N_("Slant:"),
+ N_("Set Width:"),
+ N_("Add Style:"),
+ N_("Pixel Size:"),
+ N_("Point Size:"),
+ N_("Resolution X:"),
+ N_("Resolution Y:"),
+ N_("Spacing:"),
+ N_("Average Width:"),
+ N_("Charset:"),
};
/* These are the array indices of the font properties used in several arrays,
/* 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] = {
+static const FontField xlfd_index[GTK_NUM_FONT_PROPERTIES] = {
XLFD_WEIGHT,
XLFD_SLANT,
XLFD_SET_WIDTH,
};
/* These are the positions of the properties in the filter table - x, y. */
-static gint filter_positions[GTK_NUM_FONT_PROPERTIES][2] = {
+static const gint filter_positions[GTK_NUM_FONT_PROPERTIES][2] = {
{ 1, 0 }, { 0, 2 }, { 1, 2 }, { 2, 2 }, { 2, 0 }, { 0, 0 }
};
-static gint filter_heights[GTK_NUM_FONT_PROPERTIES] = {
- 100, 80, 80, 50, 100, 100
+static const 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. */
GtkWidget *clist,
gint step);
static void gtk_font_selection_show_available_styles
- (GtkFontSelection *fs);
+(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,
GdkEventButton *bevent,
gpointer data);
static void gtk_font_selection_show_available_sizes
- (GtkFontSelection *fs);
+(GtkFontSelection *fs);
static gint gtk_font_selection_size_key_press (GtkWidget *w,
GdkEventKey *event,
gpointer data);
static void gtk_font_selection_expose_list (GtkWidget *w,
GdkEventExpose *event,
gpointer data);
+static void gtk_font_selection_realize_list (GtkWidget *widget,
+ gpointer data);
static void gtk_font_selection_switch_page (GtkWidget *w,
GtkNotebookPage *page,
gint row,
gint column,
GdkEventButton *bevent,
- gpointer data);
+ GtkFontSelection *fs);
static void gtk_font_selection_unselect_filter (GtkWidget *w,
gint row,
gint column,
GdkEventButton *bevent,
- gpointer data);
-static void gtk_font_selection_filter_fonts (GtkFontSelection *fs);
+ 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,
- gpointer data);
+ GtkFontSelection *fs);
static void gtk_font_selection_on_clear_filter (GtkWidget *w,
- gpointer data);
-static void gtk_font_selection_apply_filter (GtkFontSelection *fs);
+ 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_toggle_scaled_bitmaps
- (GtkWidget *w,
- gpointer data);
+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);
/* Misc. utility functions. */
-static void gtk_font_selection_insert_fonts (GtkFontSelection *fs);
static gboolean gtk_font_selection_load_font (GtkFontSelection *fs);
static void gtk_font_selection_update_preview (GtkFontSelection *fs);
GdkEventConfigure *event,
GtkFontSelectionDialog *fsd);
+#ifdef GDK_WINDOWING_WIN32
+static char *logfont_to_xlfd (const LOGFONT *lfp,
+ int size,
+ int res,
+ int avg_width);
+#endif
+
static GtkWindowClass *font_selection_parent_class = NULL;
static GtkNotebookClass *font_selection_dialog_parent_class = NULL;
-guint
+GtkType
gtk_font_selection_get_type()
{
- static guint font_selection_type = 0;
-
+ static GtkType font_selection_type = 0;
+
if(!font_selection_type)
{
- GtkTypeInfo fontsel_info =
+ static const GtkTypeInfo fontsel_type_info =
{
"GtkFontSelection",
- sizeof(GtkFontSelection),
- sizeof(GtkFontSelectionClass),
+ sizeof (GtkFontSelection),
+ sizeof (GtkFontSelectionClass),
(GtkClassInitFunc) gtk_font_selection_class_init,
(GtkObjectInitFunc) gtk_font_selection_init,
/* reserved_1 */ NULL,
/* reserved_2 */ NULL,
(GtkClassInitFunc) NULL,
};
-
- font_selection_type = gtk_type_unique (gtk_notebook_get_type(),
- &fontsel_info);
+
+ font_selection_type = gtk_type_unique (GTK_TYPE_NOTEBOOK,
+ &fontsel_type_info);
}
-
+
return font_selection_type;
}
gtk_font_selection_class_init(GtkFontSelectionClass *klass)
{
GtkObjectClass *object_class;
-
+
object_class = (GtkObjectClass *) klass;
-
- font_selection_parent_class = gtk_type_class (gtk_notebook_get_type ());
-
+
+ font_selection_parent_class = gtk_type_class (GTK_TYPE_NOTEBOOK);
+
object_class->destroy = gtk_font_selection_destroy;
-
+
gtk_font_selection_get_fonts ();
}
static void
gtk_font_selection_init(GtkFontSelection *fontsel)
{
+ GtkWidget *scrolled_win;
GtkWidget *text_frame;
- GtkWidget *text_box;
+ 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 *titles[] = { NULL, NULL, NULL };
gchar buffer[128];
gchar *size;
gint size_to_match;
gchar *row_text[3];
gchar *property, *text;
gboolean inserted;
+
+ /* Number of internationalized titles here must match number
+ of NULL initializers above */
+ titles[0] = _("Font Property");
+ titles[1] = _("Requested Value");
+ titles[2] = _("Actual Value");
/* Initialize the GtkFontSelection struct. We do this here in case any
callbacks are triggered while creating the interface. */
fontsel->metric = INITIAL_METRIC;
fontsel->size = INITIAL_FONT_SIZE;
fontsel->selected_size = INITIAL_FONT_SIZE;
- fontsel->scale_bitmapped_fonts = FALSE;
+ 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;
+
+
for (prop = 0; prop < GTK_NUM_FONT_PROPERTIES; prop++)
{
- fontsel->property_filters[prop] = NULL;
- fontsel->property_nfilters[prop] = 0;
+ 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;
-
- fontsel->scroll_on_expose = TRUE;
-
+ fontsel->property_values[prop] = 0;
+
/* Create the main notebook page. */
+ gtk_notebook_set_homogeneous_tabs (GTK_NOTEBOOK (fontsel), TRUE);
+ gtk_notebook_set_tab_hborder (GTK_NOTEBOOK (fontsel), 8);
fontsel->main_vbox = gtk_vbox_new (FALSE, 4);
gtk_widget_show (fontsel->main_vbox);
- gtk_container_border_width (GTK_CONTAINER (fontsel->main_vbox), 6);
- label = gtk_label_new("Font");
- gtk_widget_set_usize (label, 120, -1);
+ gtk_container_set_border_width (GTK_CONTAINER (fontsel->main_vbox), 6);
+ label = gtk_label_new(_("Font"));
gtk_notebook_append_page (GTK_NOTEBOOK (fontsel),
fontsel->main_vbox, label);
-
+
/* 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:");
+
+ 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:");
+ 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:");
+ 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_signal_connect (GTK_OBJECT (fontsel->size_entry), "key_press_event",
(GtkSignalFunc) gtk_font_selection_size_key_press,
fontsel);
-
+
/* 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_clist_set_policy(GTK_CLIST(fontsel->font_clist), GTK_POLICY_ALWAYS,
- GTK_POLICY_AUTOMATIC);
- gtk_widget_set_usize (fontsel->font_clist, FONT_LIST_WIDTH,
- FONT_LIST_HEIGHT);
+ gtk_clist_set_column_auto_resize (GTK_CLIST (fontsel->font_clist), 0, TRUE);
+ scrolled_win = gtk_scrolled_window_new (NULL, NULL);
+ gtk_widget_set_usize (scrolled_win, FONT_LIST_WIDTH, FONT_LIST_HEIGHT);
+ gtk_container_add (GTK_CONTAINER (scrolled_win), fontsel->font_clist);
+ gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
+ GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
gtk_widget_show(fontsel->font_clist);
- gtk_table_attach (GTK_TABLE (table), fontsel->font_clist, 0, 1, 2, 3,
+ gtk_widget_show(scrolled_win);
+
+ gtk_table_attach (GTK_TABLE (table), scrolled_win, 0, 1, 2, 3,
GTK_EXPAND | GTK_FILL,
GTK_EXPAND | GTK_FILL, 0, 0);
-
+
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_clist_set_policy(GTK_CLIST(fontsel->font_style_clist), GTK_POLICY_ALWAYS,
- GTK_POLICY_AUTOMATIC);
- gtk_widget_set_usize (fontsel->font_style_clist, FONT_STYLE_LIST_WIDTH, -1);
+ gtk_clist_set_column_auto_resize (GTK_CLIST (fontsel->font_style_clist),
+ 0, TRUE);
+ scrolled_win = gtk_scrolled_window_new (NULL, NULL);
+ gtk_widget_set_usize (scrolled_win, FONT_STYLE_LIST_WIDTH, -1);
+ gtk_container_add (GTK_CONTAINER (scrolled_win), fontsel->font_style_clist);
+ gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
+ GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
gtk_widget_show(fontsel->font_style_clist);
- gtk_table_attach (GTK_TABLE (table), fontsel->font_style_clist, 1, 2, 2, 3,
+ gtk_widget_show(scrolled_win);
+ gtk_table_attach (GTK_TABLE (table), scrolled_win, 1, 2, 2, 3,
GTK_EXPAND | GTK_FILL,
GTK_EXPAND | GTK_FILL, 0, 0);
-
+
fontsel->size_clist = gtk_clist_new(1);
gtk_clist_column_titles_hide (GTK_CLIST(fontsel->size_clist));
- gtk_clist_set_policy(GTK_CLIST(fontsel->size_clist), GTK_POLICY_ALWAYS,
- GTK_POLICY_AUTOMATIC);
- gtk_widget_set_usize (fontsel->size_clist, FONT_SIZE_LIST_WIDTH, -1);
+ gtk_clist_set_column_width (GTK_CLIST(fontsel->size_clist), 0, 20);
+ scrolled_win = gtk_scrolled_window_new (NULL, NULL);
+ gtk_widget_set_usize (scrolled_win, FONT_SIZE_LIST_WIDTH, -1);
+ gtk_container_add (GTK_CONTAINER (scrolled_win), fontsel->size_clist);
+ gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
+ GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
gtk_widget_show(fontsel->size_clist);
- gtk_table_attach (GTK_TABLE (table), fontsel->size_clist, 2, 3, 2, 3,
+ 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_insert_fonts(fontsel);
-
+ 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_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);
"key_press_event",
GTK_SIGNAL_FUNC(gtk_font_selection_on_clist_key_press),
fontsel);
-
+ gtk_signal_connect_after (GTK_OBJECT (fontsel->font_style_clist),
+ "realize",
+ GTK_SIGNAL_FUNC(gtk_font_selection_realize_list),
+ fontsel);
+
/* Insert the standard font sizes */
gtk_clist_freeze (GTK_CLIST(fontsel->size_clist));
size_to_match = INITIAL_FONT_SIZE;
- if (INITIAL_METRIC == POINTS_METRIC)
+ 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++)
{
}
}
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_signal_connect (GTK_OBJECT (fontsel->size_clist), "key_press_event",
GTK_SIGNAL_FUNC(gtk_font_selection_on_clist_key_press),
fontsel);
-
-
- /* create the Filter, Scale Bitmaps & Metric buttons */
+
+
+ /* 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(" Clear Filter ");
+
+ fontsel->filter_button = gtk_button_new_with_label(_("Reset Filter"));
+ gtk_misc_set_padding (GTK_MISC (GTK_BIN (fontsel->filter_button)->child),
+ 16, 0);
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);
-
- fontsel->scaled_bitmaps_button
- = gtk_check_button_new_with_label("Allow scaled bitmap fonts");
- gtk_widget_show(fontsel->scaled_bitmaps_button);
- gtk_box_pack_start (GTK_BOX (hbox), fontsel->scaled_bitmaps_button,
- FALSE, FALSE, 0);
- if (!fontsel_info->scaled_bitmaps_available)
- gtk_widget_set_sensitive (fontsel->scaled_bitmaps_button, FALSE);
- gtk_signal_connect (GTK_OBJECT (fontsel->scaled_bitmaps_button), "clicked",
- GTK_SIGNAL_FUNC(gtk_font_selection_toggle_scaled_bitmaps),
- fontsel);
-
-
+
hbox2 = gtk_hbox_new(FALSE, 0);
gtk_widget_show (hbox2);
gtk_box_pack_end (GTK_BOX (hbox), hbox2, FALSE, FALSE, 0);
- label = gtk_label_new("Metric:");
+ label = gtk_label_new(_("Metric:"));
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");
+
+ 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 == POINTS_METRIC)
- gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(fontsel->points_button),
+ if (INITIAL_METRIC == GTK_FONT_METRIC_POINTS)
+ gtk_toggle_button_set_active(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");
+
+ 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 == PIXELS_METRIC)
- gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(fontsel->pixels_button),
+ if (INITIAL_METRIC == GTK_FONT_METRIC_PIXELS)
+ gtk_toggle_button_set_active(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);
-
-
+
+
/* create the text entry widget */
- text_frame = gtk_frame_new ("Preview:");
+ 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,
FALSE, TRUE, 0);
-
+
/* This is just used to get a 4-pixel space around the preview entry. */
text_box = gtk_hbox_new (FALSE, 0);
gtk_widget_show (text_box);
gtk_container_add (GTK_CONTAINER (text_frame), text_box);
- gtk_container_border_width (GTK_CONTAINER (text_box), 4);
-
+ gtk_container_set_border_width (GTK_CONTAINER (text_box), 4);
+
fontsel->preview_entry = gtk_entry_new ();
gtk_widget_show (fontsel->preview_entry);
gtk_widget_set_usize (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_border_width (GTK_CONTAINER (fontsel->info_vbox), 2);
- label = gtk_label_new("Font Information");
- gtk_widget_set_usize (label, 120, -1);
+ gtk_container_set_border_width (GTK_CONTAINER (fontsel->info_vbox), 2);
+ label = gtk_label_new(_("Font Information"));
gtk_notebook_append_page (GTK_NOTEBOOK (fontsel),
fontsel->info_vbox, label);
-
- fontsel->info_clist = gtk_clist_new_with_titles(3, titles);
+
+ 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));
- gtk_clist_set_policy(GTK_CLIST(fontsel->info_clist), GTK_POLICY_AUTOMATIC,
- GTK_POLICY_AUTOMATIC);
+ 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_box_pack_start (GTK_BOX (fontsel->info_vbox), 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];
+ 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:");
+
+ 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:");
+
+ 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);
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.",
+
+ 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_border_width (GTK_CONTAINER (fontsel->filter_vbox), 2);
- label = gtk_label_new("Filter");
- gtk_widget_set_usize (label, 120, -1);
+ gtk_container_set_border_width (GTK_CONTAINER (fontsel->filter_vbox), 2);
+ label = gtk_label_new(_("Filter"));
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_active (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_active (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]]);
+
+ 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));
- gtk_clist_set_policy(GTK_CLIST(clist), GTK_POLICY_AUTOMATIC,
- GTK_POLICY_AUTOMATIC);
+ gtk_clist_set_column_auto_resize (GTK_CLIST (clist), 0, TRUE);
+ 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);
-
- /* For the bottom-right cell we add the 'Clear Filter' button. */
+ 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), clist, TRUE, TRUE, 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("Clear Filter");
+
+ 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",
fontsel);
}
else
- gtk_table_attach (GTK_TABLE (table), clist,
+ 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 = "*";
+ property = N_("*");
gtk_clist_append(GTK_CLIST(clist), &property);
-
+
for (i = 1; i < fontsel_info->nproperties[prop]; i++) {
- property = fontsel_info->properties[prop][i];
+ property = _(fontsel_info->properties[prop][i]);
if (prop == SLANT)
property = gtk_font_selection_expand_slant_code(property);
else if (prop == SPACING)
gtk_font_selection_new()
{
GtkFontSelection *fontsel;
-
- fontsel = gtk_type_new (gtk_font_selection_get_type ());
-
+
+ fontsel = gtk_type_new (GTK_TYPE_FONT_SELECTION);
+
return GTK_WIDGET (fontsel);
}
gtk_font_selection_destroy (GtkObject *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);
}
-/* This inserts all the fonts into the family clist. */
-static void
-gtk_font_selection_insert_fonts (GtkFontSelection *fontsel)
-{
- FontInfo *font_info, *font;
- gchar font_buffer[XLFD_MAX_FIELD_LEN * 2 + 4];
- gchar *font_item;
- gint nfonts, i, row;
-
- font_info = fontsel_info->font_info;
- nfonts = fontsel_info->nfonts;
-
- 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];
- 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));
- }
- gtk_clist_thaw (GTK_CLIST(fontsel->font_clist));
-}
-
-
/* This is called when the clist is exposed. Here we scroll to the current
font if necessary. */
static void
FontInfo *font_info;
GList *selection;
gint index;
-
+
#ifdef FONTSEL_DEBUG
- g_print("In expose_list\n");
+ g_message("In expose_list\n");
#endif
fontsel = GTK_FONT_SELECTION(data);
-
- if (fontsel->scroll_on_expose)
+
+ 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)
{
- fontsel->scroll_on_expose = FALSE;
+ 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 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 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);
+ }
+}
- 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);
- gtk_clist_moveto(GTK_CLIST(fontsel->font_clist), index, -1, 0.5, 0);
- }
+/* This is called when the style clist is realized. We need to set any
+ charset rows to insensitive colours. */
+static void
+gtk_font_selection_realize_list (GtkWidget *widget,
+ gpointer data)
+{
+ GtkFontSelection *fontsel;
+ gint row;
+ GdkColor *inactive_fg, *inactive_bg;
- /* 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);
- gtk_clist_moveto(GTK_CLIST(fontsel->font_style_clist), index, -1,
- 0.5, 0);
- }
+#ifdef FONTSEL_DEBUG
+ g_message("In realize_list\n");
+#endif
+ fontsel = GTK_FONT_SELECTION (data);
- /* Try to scroll the font size clist to the selected item */
- selection = GTK_CLIST(fontsel->size_clist)->selection;
- if (selection)
+ /* Set the colours for any charset rows to insensitive. */
+ inactive_fg = &fontsel->font_style_clist->style->fg[GTK_STATE_INSENSITIVE];
+ inactive_bg = &fontsel->font_style_clist->style->bg[GTK_STATE_INSENSITIVE];
+
+ for (row = 0; row < GTK_CLIST (fontsel->font_style_clist)->rows; row++)
+ {
+ if (GPOINTER_TO_INT (gtk_clist_get_row_data (GTK_CLIST (fontsel->font_style_clist), row)) == -1)
{
- index = GPOINTER_TO_INT (selection->data);
- gtk_clist_moveto(GTK_CLIST(fontsel->size_clist), index, -1, 0.5, 0);
+ 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);
}
}
}
GtkFontSelection *fontsel;
FontInfo *font_info;
FontInfo *font;
-
+
#ifdef FONTSEL_DEBUG
- g_print("In select_font\n");
+ g_message("In select_font\n");
#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);
GtkFontSelection *fontsel)
{
#ifdef FONTSEL_DEBUG
- g_print("In on_clist_key_press\n");
+ g_message("In on_clist_key_press\n");
#endif
if (event->keyval == GDK_Up)
return gtk_font_selection_select_next (fontsel, clist, -1);
{
GList *selection;
gint current_row, row;
-
+
selection = GTK_CLIST(clist)->selection;
if (!selection)
return FALSE;
current_row = GPOINTER_TO_INT (selection->data);
+
+ /* Stop the normal clist key handler from being run. */
+ gtk_signal_emit_stop_by_name (GTK_OBJECT (clist), "key_press_event");
for (row = current_row + step;
row >= 0 && row < GTK_CLIST(clist)->rows;
if (clist == fontsel->font_style_clist)
if (GPOINTER_TO_INT (gtk_clist_get_row_data(GTK_CLIST(clist), row)) == -1)
continue;
-
+
/* Now we've found the row to select. */
if (gtk_clist_row_is_visible(GTK_CLIST(clist), row)
!= GTK_VISIBILITY_FULL)
gtk_clist_moveto(GTK_CLIST(clist), row, -1, (step < 0) ? 0 : 1, 0);
gtk_clist_select_row(GTK_CLIST(clist), row, 0);
- return TRUE;
+ break;
}
- return FALSE;
+ return TRUE;
}
gchar buffer[XLFD_MAX_FIELD_LEN * 6 + 2];
GdkColor *inactive_fg, *inactive_bg;
gboolean show_charset;
-
+
#ifdef FONTSEL_DEBUG
- g_print("In show_available_styles\n");
+ 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. */
{
if (gtk_font_selection_style_visible(fontsel, font, style))
{
- styles[style].flags &= ~DISPLAYED;
-
+ 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 |= DISPLAYED;
+ 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 & DISPLAYED) continue;
-
+ if (styles[style].flags & GTK_FONT_DISPLAYED)
+ continue;
+
if (show_charset)
{
charset_index = styles[style].properties[CHARSET];
&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);
+ if (GTK_WIDGET_REALIZED (fontsel->font_style_clist))
+ {
+ 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 & DISPLAYED
+ if (styles[tmpstyle].flags & GTK_FONT_DISPLAYED
|| charset_index != styles[tmpstyle].properties[CHARSET])
continue;
-
- styles[tmpstyle].flags |= DISPLAYED;
-
+
+ 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];
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";
-
+ if (!g_strcasecmp(weight, N_("(nil)"))) weight = N_("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";
-
+ else if (!g_strcasecmp(slant, "i")) slant = N_("italic");
+ else if (!g_strcasecmp(slant, "o")) slant = N_("oblique");
+ else if (!g_strcasecmp(slant, "ri")) slant = N_("reverse italic");
+ else if (!g_strcasecmp(slant, "ro")) slant = N_("reverse oblique");
+ else if (!g_strcasecmp(slant, "ot")) slant = N_("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]";
-
+ else if (!g_strcasecmp(spacing, "m")) spacing = N_("[M]");
+ else if (!g_strcasecmp(spacing, "c")) spacing = N_("[C]");
+
/* Add the strings together, making sure there is 1 space between
them */
- strcpy(buffer, weight);
+ strcpy(buffer, _(weight));
if (slant)
{
strcat(buffer, " ");
- strcat(buffer, slant);
+ strcat(buffer, _(slant));
}
if (set_width)
{
strcat(buffer, " ");
- strcat(buffer, set_width);
+ strcat(buffer, _(set_width));
}
if (spacing)
{
strcat(buffer, " ");
- strcat(buffer, spacing);
+ strcat(buffer, _(spacing));
}
-
+
new_item = buffer;
row = gtk_clist_append(GTK_CLIST(fontsel->font_style_clist),
&new_item);
GINT_TO_POINTER (tmpstyle));
}
}
-
+
gtk_clist_thaw (GTK_CLIST(fontsel->font_style_clist));
}
{
FontInfo *font;
FontStyle *styles;
- gint row, prop, style = -1, style_to_find;
- gboolean found = FALSE;
-
+ gint row, prop, style, matched;
+ gint best_matched = -1, best_style = -1, best_row = -1;
+
#ifdef FONTSEL_DEBUG
- g_print("In select_best_style\n");
+ 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))
+ /* Skip charset rows. */
+ if (style == -1)
+ continue;
+
+ /* If we just want the first style, we've got it. */
+ if (use_first)
{
- found = TRUE;
+ best_style = style;
+ best_row = row;
break;
}
+
+ 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;
+ best_row = row;
+ }
}
- g_return_if_fail (found);
+ g_return_if_fail (best_style != -1);
+ g_return_if_fail (best_row != -1);
- fontsel->style = style;
+ fontsel->style = best_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_clist_select_row(GTK_CLIST(fontsel->font_style_clist), best_row, 0);
+ if (gtk_clist_row_is_visible(GTK_CLIST(fontsel->font_style_clist), best_row)
!= GTK_VISIBILITY_FULL)
- gtk_clist_moveto(GTK_CLIST(fontsel->font_style_clist), row, -1, 0.5, 0);
+ gtk_clist_moveto(GTK_CLIST(fontsel->font_style_clist), best_row, -1,
+ 0.5, 0);
gtk_font_selection_show_available_sizes (fontsel);
gtk_font_selection_select_best_size (fontsel);
}
FontStyle *styles;
gint style, prop;
gchar *text;
-
+
#ifdef FONTSEL_DEBUG
- g_print("In select_style\n");
+ 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);
}
-static void
-gtk_font_selection_toggle_scaled_bitmaps (GtkWidget *w,
- gpointer data)
-{
- GtkFontSelection *fontsel;
-
- fontsel = GTK_FONT_SELECTION(data);
-
- fontsel->scale_bitmapped_fonts
- = GTK_TOGGLE_BUTTON(w)->active ? TRUE : FALSE;
- if (fontsel->font_index != -1)
- {
- 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
{
FontInfo *font;
FontStyle *styles, *style;
- guint16 *standard_sizes, *bitmapped_sizes, bitmap_size;
+ const guint16 *standard_sizes;
+ guint16 *bitmapped_sizes;
gint nstandard_sizes, nbitmapped_sizes;
gchar buffer[16], *size;
- gfloat bitmap_size_float;
+ gfloat bitmap_size_float = 0.;
+ guint16 bitmap_size = 0;
gboolean can_match;
-
+ gint type_filter;
+
#ifdef FONTSEL_DEBUG
- g_print("In show_available_sizes\n");
+ 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 == POINTS_METRIC)
+ if (fontsel->metric == GTK_FONT_METRIC_POINTS)
{
bitmapped_sizes = &fontsel_info->point_sizes[style->point_sizes_index];
nbitmapped_sizes = style->npoint_sizes;
bitmapped_sizes = &fontsel_info->pixel_sizes[style->pixel_sizes_index];
nbitmapped_sizes = style->npixel_sizes;
}
-
- if (!(fontsel->scale_bitmapped_fonts && style->flags & SCALABLE_BITMAP_FONT)
- && !(style->flags & SCALABLE_FONT))
+
+ /* 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 == POINTS_METRIC)
- {
- if (*bitmapped_sizes % 10 != 0)
- can_match = FALSE;
- bitmap_size = *bitmapped_sizes / 10;
- bitmap_size_float = *bitmapped_sizes / 10;
- }
- else
+
+ if (nbitmapped_sizes)
{
- bitmap_size = *bitmapped_sizes;
- bitmap_size_float = *bitmapped_sizes;
+ 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)
{
}
else
{
- if (fontsel->metric == POINTS_METRIC)
+ if (fontsel->metric == GTK_FONT_METRIC_POINTS)
{
if (*bitmapped_sizes % 10 == 0)
sprintf(buffer, "%i *", *bitmapped_sizes / 10);
gint new_size;
gfloat new_size_float;
gchar *text;
-
+
#ifdef FONTSEL_DEBUG
- g_print("In size_key_press\n");
+ g_message("In size_key_press\n");
#endif
fontsel = GTK_FONT_SELECTION(data);
-
+
if (event->keyval == GDK_Return)
{
text = gtk_entry_get_text (GTK_ENTRY (fontsel->size_entry));
- if (fontsel->metric == PIXELS_METRIC)
+ if (fontsel->metric == GTK_FONT_METRIC_PIXELS)
{
new_size = atoi (text);
if (new_size < 2)
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;
}
-
+
return FALSE;
}
gboolean found = FALSE;
gchar buffer[32];
GList *selection;
-
+ gint type_filter;
+
#ifdef FONTSEL_DEBUG
- g_print("In select_best_size\n");
+ 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 == POINTS_METRIC)
+ if (fontsel->metric == GTK_FONT_METRIC_POINTS)
{
size *= 10;
if (nmatched == 2)
size += size_fraction;
}
-
+
if (size == fontsel->selected_size)
{
found = TRUE;
best_row = row;
}
}
-
+
/* If we aren't scaling bitmapped fonts and this is a bitmapped font, we
need to use the closest size found. */
- if (!(fontsel->scale_bitmapped_fonts && style->flags & SCALABLE_BITMAP_FONT)
- && !(style->flags & SCALABLE_FONT))
- found = TRUE;
+ 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_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 == PIXELS_METRIC)
+ if (fontsel->metric == GTK_FONT_METRIC_PIXELS)
sprintf(buffer, "%i", fontsel->size);
else
{
gchar *text;
gchar buffer[16];
gint i;
-
+
#ifdef FONTSEL_DEBUG
- g_print("In select_size\n");
+ 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);
}
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 == POINTS_METRIC)
+ 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);
}
gpointer data)
{
GtkFontSelection *fontsel = GTK_FONT_SELECTION(data);
-
+
#ifdef FONTSEL_DEBUG
- g_print("In metric_callback\n");
+ g_message("In metric_callback\n");
#endif
if (GTK_TOGGLE_BUTTON(fontsel->pixels_button)->active)
{
- if (fontsel->metric == PIXELS_METRIC)
+ if (fontsel->metric == GTK_FONT_METRIC_PIXELS)
return;
- fontsel->metric = PIXELS_METRIC;
+ fontsel->metric = GTK_FONT_METRIC_PIXELS;
fontsel->size = (fontsel->size + 5) / 10;
fontsel->selected_size = (fontsel->selected_size + 5) / 10;
}
else
{
- if (fontsel->metric == POINTS_METRIC)
+ if (fontsel->metric == GTK_FONT_METRIC_POINTS)
return;
- fontsel->metric = POINTS_METRIC;
+ fontsel->metric = GTK_FONT_METRIC_POINTS;
fontsel->size *= 10;
fontsel->selected_size *= 10;
}
gchar *field)
{
gint i;
-
+
for (i = 0; i < ntable; i++)
if (strcmp (field, table[i]) == 0)
return i;
-
+
return 0;
}
{
GdkFont *font;
gchar *fontname, *label_text;
-
+ XFontStruct *xfs;
+
if (fontsel->font)
gdk_font_unref (fontsel->font);
fontsel->font = NULL;
-
+
/* 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_print("Loading: %s\n", fontname);
+ g_message("Loading: %s\n", fontname);
#endif
+#ifndef GDK_WINDOWING_WIN32
font = gdk_font_load (fontname);
+ xfs = GDK_FONT_XFONT(font);
+ if (xfs->min_byte1 != 0 || xfs->max_byte1 != 0)
+ {
+ gchar *tmp_name;
+
+ gdk_font_unref (font);
+ tmp_name = g_strconcat (fontname, ",*", NULL);
+ font = gdk_fontset_load (tmp_name);
+ g_free(tmp_name);
+ }
+#else
+ /* Load as a fontset so that gtkentry uses wide chars for it */
+ font = gdk_fontset_load (fontname);
+#endif
g_free(fontname);
-
+
if (font)
{
fontsel->font = font;
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_label_set_text(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.");
+ gtk_label_set_text(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.");
+ gtk_label_set_text(GTK_LABEL(fontsel->message_label),
+ _("The selected font is not a valid font."));
}
-
+
return FALSE;
}
GtkStyle *style;
gint text_height, new_height;
gchar *text;
+#ifdef GDK_WINDOWING_X11
XFontStruct *xfs;
+#endif
#ifdef FONTSEL_DEBUG
- g_print("In update_preview\n");
+ 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 = 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);
-
+
+#ifdef GDK_WINDOWING_X11
/* 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.");
+ gtk_label_set_text(GTK_LABEL(fontsel->message_label),
+ _("This is a 2-byte font and may not be displayed correctly."));
+#endif
}
gpointer data)
{
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_filter_fonts(fontsel);
+ gtk_font_selection_update_filter(fontsel);
else if (page_num == 1)
gtk_font_selection_show_font_info(fontsel);
}
-
+
static void
gtk_font_selection_show_font_info (GtkFontSelection *fontsel)
{
+#ifdef GDK_WINDOWING_X11
Atom font_atom, atom;
Bool status;
+#endif
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++)
{
gtk_clist_set_text(GTK_CLIST(fontsel->info_clist), i, 1,
field ? field : "");
}
-
+#ifdef GDK_WINDOWING_X11
if (fontsel->font)
{
- font_atom = XInternAtom(GDK_DISPLAY(), "FONT", True);
- if (font_atom != None)
+ font_atom = gdk_atom_intern ("FONT", FALSE);
+
+ if (fontsel->font->type == GDK_FONT_FONTSET)
+ {
+ XFontStruct **font_structs;
+ gint num_fonts;
+ gchar **font_names;
+
+ num_fonts = XFontsOfFontSet (GDK_FONT_XFONT(fontsel->font),
+ &font_structs, &font_names);
+ status = XGetFontProperty(font_structs[0], font_atom, &atom);
+ }
+ else
{
status = XGetFontProperty(GDK_FONT_XFONT(fontsel->font), font_atom,
&atom);
- if (status == True)
+ }
+
+ if (status == True)
+ {
+ name = gdk_atom_name (atom);
+ gtk_entry_set_text (GTK_ENTRY (fontsel->actual_font_name), name);
+
+ for (i = 0; i < GTK_XLFD_NUM_FIELDS; i++)
{
- 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);
+ 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;
+ g_free (name);
+ }
+ }
+#elif defined (GDK_WINDOWING_WIN32)
+ if (fontsel->font)
+ {
+ LOGFONT logfont;
+
+ if (GetObject (GDK_FONT_XFONT (fontsel->font),
+ sizeof (LOGFONT), &logfont) > 0)
+ {
+ name = logfont_to_xlfd (&logfont, logfont.lfHeight, -1, 0);
+ 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;
+ g_free (name);
}
}
+
+#endif
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)" : "");
+ fontname ? _("(unknown)") : "");
}
}
gtk_clist_thaw (GTK_CLIST(fontsel->info_clist));
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");
+ 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");
+ 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.
+ * 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,
- gpointer data)
+ GtkFontSelection *fontsel)
{
- gint i;
+ gint i, prop, index;
if (row == 0)
- for (i = 1; i < GTK_CLIST(w)->rows; i++)
- gtk_clist_unselect_row(GTK_CLIST(w), i, 0);
+ {
+ for (i = 1; i < GTK_CLIST(w)->rows; i++)
+ gtk_clist_unselect_row(GTK_CLIST(w), i, 0);
+ }
else
- gtk_clist_unselect_row(GTK_CLIST(w), 0, 0);
+ {
+ /* 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);
+ }
}
gint row,
gint column,
GdkEventButton *bevent,
- gpointer data)
+ GtkFontSelection *fontsel)
{
- gint i;
+ gint i, prop, index;
+
if (!GTK_CLIST(w)->selection)
{
if (row == 0)
- for (i = 1; i < GTK_CLIST(w)->rows; i++)
- gtk_clist_select_row(GTK_CLIST(w), i, 0);
+ {
+ /* Find out which property this is. */
+ for (prop = 0; prop < GTK_NUM_FONT_PROPERTIES; prop++)
+ if (fontsel->filter_clists[prop] == w)
+ break;
+
+ 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_clist_select_row(GTK_CLIST(w), 0, 0);
+ {
+ gtk_clist_select_row(GTK_CLIST(w), 0, 0);
+ }
}
}
fonts shown. If an empty filter (all '*'s) is applied, then filtering is
turned off. */
static void
-gtk_font_selection_filter_fonts (GtkFontSelection *fontsel)
+gtk_font_selection_update_filter (GtkFontSelection *fontsel)
{
GtkWidget *clist;
GList *selection;
- gboolean empty_filter = TRUE, filter_changed = FALSE;
+ 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_print("In filter_fonts\n");
+ 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;
- /* Check if the filter has changed, and also if it is an empty filter,
- i.e. all '*'s are selected. */
for (prop = 0; prop < GTK_NUM_FONT_PROPERTIES; prop++)
{
clist = fontsel->filter_clists[prop];
nselected = g_list_length(selection);
if (nselected != 1 || GPOINTER_TO_INT (selection->data) != 0)
{
- empty_filter = FALSE;
-
- if (fontsel->property_nfilters[prop] != nselected)
+ default_filter = FALSE;
+
+ if (filter->property_nfilters[prop] != nselected)
filter_changed = TRUE;
else
{
{
row = GPOINTER_TO_INT (selection->data);
index = GPOINTER_TO_INT (gtk_clist_get_row_data (GTK_CLIST (clist), row));
- if (fontsel->property_filters[prop][i] != index)
+ if (filter->property_filters[prop][i] != index)
filter_changed = TRUE;
selection = selection->next;
}
}
else
{
- if (fontsel->property_nfilters[prop] != 0)
+ if (filter->property_nfilters[prop] != 0)
filter_changed = TRUE;
}
}
-
+
/* If the filter hasn't changed we just return. */
if (!filter_changed)
return;
-
-#ifdef FONTSEL_DEBUG
- g_print(" filter_fonts: filter has changed\n");
-#endif
-
- /* Setting the toggle buttons state will trigger the callbacks to clear
- or apply the filter, unless the font list is already filtered, in
- which case we have to call apply_filter here. */
- if (empty_filter)
- {
- gtk_widget_set_sensitive(fontsel->filter_button, FALSE);
- gtk_label_set(GTK_LABEL(fontsel->font_label), "Font:");
- gtk_font_selection_apply_filter(fontsel);
- }
- else
- {
- gtk_widget_set_sensitive(fontsel->filter_button, TRUE);
- gtk_label_set(GTK_LABEL(fontsel->font_label), "Font: [Filtered]");
- gtk_font_selection_apply_filter(fontsel);
- }
-}
-
-
-/* This clears the filter, showing all fonts and styles again. */
-static void
-gtk_font_selection_apply_filter (GtkFontSelection *fontsel)
-{
- FontInfo *font_info, *font;
- GtkWidget *clist;
- GList *selection;
- gint nfonts, prop, nselected, i, j, row, style, index;
- gchar font_buffer[XLFD_MAX_FIELD_LEN * 2 + 4];
- gchar *font_item;
- gboolean matched, matched_style;
-
+
#ifdef FONTSEL_DEBUG
- g_print("In apply_filter\n");
+ g_message(" update_fonts: filter has changed\n");
#endif
- font_info = fontsel_info->font_info;
- nfonts = fontsel_info->nfonts;
-
+
/* Free the old filter data and create the new arrays. */
for (prop = 0; prop < GTK_NUM_FONT_PROPERTIES; prop++)
{
- g_free(fontsel->property_filters[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)
{
- fontsel->property_filters[prop] = NULL;
- fontsel->property_nfilters[prop] = 0;
+ filter->property_filters[prop] = NULL;
+ filter->property_nfilters[prop] = 0;
}
else
{
- fontsel->property_filters[prop] = g_new(guint16, nselected);
- fontsel->property_nfilters[prop] = nselected;
+ 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));
- fontsel->property_filters[prop][i] = index;
+ filter->property_filters[prop][i] = index;
selection = selection->next;
}
}
}
+ /* 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)
+ {
+ gtk_widget_set_sensitive(fontsel->filter_button, FALSE);
+ gtk_label_set_text(GTK_LABEL(fontsel->font_label), _("Font:"));
+ }
+ else
+ {
+ gtk_widget_set_sensitive(fontsel->filter_button, TRUE);
+ gtk_label_set_text(GTK_LABEL(fontsel->font_label), _("Font: (Filter Applied)"));
+ }
+ gtk_font_selection_show_available_fonts(fontsel);
+}
+
+
+/* This shows all the available fonts in the font clist. */
+static void
+gtk_font_selection_show_available_fonts (GtkFontSelection *fontsel)
+{
+ 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 matches. */
- if (fontsel->property_nfilters[FOUNDRY] != 0)
+
+ /* Check if the foundry passes through all filters. */
+ matched = TRUE;
+ for (k = 0; k < GTK_NUM_FONT_FILTERS; k++)
{
- matched = FALSE;
- for (j = 0; j < fontsel->property_nfilters[FOUNDRY]; j++)
+ filter = &fontsel->filters[k];
+
+ if (filter->property_nfilters[FOUNDRY] != 0)
{
- if (font->foundry == fontsel->property_filters[FOUNDRY][j])
+ matched = FALSE;
+ for (j = 0; j < filter->property_nfilters[FOUNDRY]; j++)
{
- matched = TRUE;
- break;
+ if (font->foundry == filter->property_filters[FOUNDRY][j])
+ {
+ matched = TRUE;
+ break;
+ }
}
+ if (!matched)
+ break;
}
- if (!matched)
- continue;
}
+
+ if (!matched)
+ continue;
+
/* Now check if the other properties are matched in at least one style.*/
matched_style = FALSE;
}
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))
}
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;
+ }
- /* Clear the current font and the style clist. */
- 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), "");
+ 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);
+
+ gtk_font_selection_show_available_styles (fontsel);
+ gtk_font_selection_select_best_style (fontsel, FALSE);
}
static gboolean
gtk_font_selection_style_visible(GtkFontSelection *fontsel,
FontInfo *font,
- gint style)
+ gint style_index)
{
- FontStyle *styles;
+ FontStyle *styles, *style;
+ GtkFontFilter *filter;
guint16 value;
- gint prop, j;
+ 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++)
{
- value = styles[style].properties[prop];
-
- if (fontsel->property_nfilters[prop] != 0)
+ value = style->properties[prop];
+
+ /* Check each filter. */
+ for (i = 0; i < GTK_NUM_FONT_FILTERS; i++)
{
- matched = FALSE;
- for (j = 0; j < fontsel->property_nfilters[prop]; j++)
+ filter = &fontsel->filters[i];
+
+ if (filter->property_nfilters[prop] != 0)
{
- if (value == fontsel->property_filters[prop][j])
+ matched = FALSE;
+ for (j = 0; j < filter->property_nfilters[prop]; j++)
{
- matched = TRUE;
- break;
+ if (value == filter->property_filters[prop][j])
+ {
+ matched = TRUE;
+ break;
+ }
}
+ if (!matched)
+ return FALSE;
}
- if (!matched)
- return FALSE;
}
}
return TRUE;
}
-/* This resets all the filter clists to the wildcard '*' options. */
+/* 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,
- gpointer data)
+ GtkFontSelection *fontsel)
{
- GtkFontSelection *fontsel;
- gint prop;
-
- fontsel = GTK_FONT_SELECTION(data);
-
+ 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_active (GTK_TOGGLE_BUTTON (fontsel->type_bitmaps_button), TRUE);
+ if (base_font_type & GTK_FONT_SCALABLE)
+ gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (fontsel->type_scalable_button), TRUE);
+ if (base_font_type & GTK_FONT_SCALABLE_BITMAP)
+ gtk_toggle_button_set_active (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,
- gpointer data)
+ GtkFontSelection *fontsel)
{
- GtkFontSelection *fontsel;
-
- fontsel = GTK_FONT_SELECTION(data);
gtk_font_selection_clear_filter(fontsel);
}
-/* This clears the filter, showing all fonts and styles again. */
+/* 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. */
static void
gtk_font_selection_clear_filter (GtkFontSelection *fontsel)
{
- gboolean filtered = FALSE, found_style = FALSE;
- gint prop, row, style;
-
+ GtkFontFilter *filter;
+ gint prop;
+
#ifdef FONTSEL_DEBUG
- g_print("In clear_filter\n");
+ 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++)
{
- if (fontsel->property_filters[prop])
- filtered = TRUE;
- g_free(fontsel->property_filters[prop]);
- fontsel->property_filters[prop] = NULL;
- fontsel->property_nfilters[prop] = 0;
+ 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_text(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++)
+ {
+ g_free(filter->property_filters[prop]);
+ filter->property_filters[prop] = NULL;
+ filter->property_nfilters[prop] = 0;
+
+ 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;
+
+ /* 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;
+ }
+ }
+
+ /* 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_active (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_active (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_active (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_active (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_active (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_active (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_active (GTK_TOGGLE_BUTTON (fontsel->type_bitmaps_button), font_type & GTK_FONT_BITMAP);
+
+ if (base_font_type & GTK_FONT_SCALABLE)
+ gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (fontsel->type_scalable_button), font_type & GTK_FONT_SCALABLE);
+
+ if (base_font_type & GTK_FONT_SCALABLE_BITMAP)
+ gtk_toggle_button_set_active (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);
+}
+
+
+/* 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)
+{
+ 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;
+}
+
+
+#ifdef GDK_WINDOWING_WIN32
+
+static gint num_fonts;
+static gint font_names_size;
+static gchar **xfontnames;
+static HDC hdc;
+
+static char *
+logfont_to_xlfd (const LOGFONT *lfp,
+ int size,
+ int res,
+ int avg_width)
+{
+ const gchar *weight;
+ const gchar *registry, *encoding;
+ int point_size;
+ static int logpixelsy = 0;
+ gchar facename[LF_FACESIZE*3];
+ gchar *p;
+ const gchar *q;
+
+ if (logpixelsy == 0)
+ {
+ HDC hdc = GetDC (NULL);
+ logpixelsy = GetDeviceCaps (hdc, LOGPIXELSY);
+ ReleaseDC (NULL, hdc);
+ }
+
+ /* Don't use _() here, only N_(), the actual translation is done elsewhere */
+ if (lfp->lfWeight >= FW_HEAVY)
+ weight = N_("heavy");
+ else if (lfp->lfWeight >= FW_EXTRABOLD)
+ weight = N_("extrabold");
+ else if (lfp->lfWeight >= FW_BOLD)
+ weight = N_("bold");
+#ifdef FW_DEMIBOLD
+ else if (lfp->lfWeight >= FW_DEMIBOLD)
+ weight = N_("demibold");
+#endif
+ else if (lfp->lfWeight >= FW_MEDIUM)
+ weight = N_("medium");
+ else if (lfp->lfWeight >= FW_NORMAL)
+ weight = N_("normal");
+ else if (lfp->lfWeight >= FW_LIGHT)
+ weight = N_("light");
+ else if (lfp->lfWeight >= FW_EXTRALIGHT)
+ weight = N_("extralight");
+ else if (lfp->lfWeight >= FW_THIN)
+ weight = N_("thin");
+ else
+ weight = N_("regular");
+
+ if (lfp->lfCharSet == ANSI_CHARSET)
+ {
+ registry = "iso8859";
+ encoding = "1";
+ }
+ else
+ {
+ registry = "windows";
+ if (lfp->lfCharSet == DEFAULT_CHARSET)
+ encoding = "default";
+ else if (lfp->lfCharSet == SYMBOL_CHARSET)
+ encoding = "symbol";
+ else if (lfp->lfCharSet == SHIFTJIS_CHARSET)
+ encoding = "shiftjis";
+ else if (lfp->lfCharSet == GB2312_CHARSET)
+ encoding = "gb2312";
+ else if (lfp->lfCharSet == HANGEUL_CHARSET)
+ encoding = "hangeul";
+ else if (lfp->lfCharSet == CHINESEBIG5_CHARSET)
+ encoding = "chinesebig5";
+ else if (lfp->lfCharSet == OEM_CHARSET)
+ encoding = "oem";
+#ifdef JOHAB_CHARSET
+ else if (lfp->lfCharSet == JOHAB_CHARSET)
+ encoding = "johab";
+#endif
+ else if (lfp->lfCharSet == HEBREW_CHARSET)
+ encoding = "hebrew";
+ else if (lfp->lfCharSet == ARABIC_CHARSET)
+ encoding = "arabic";
+ else if (lfp->lfCharSet == GREEK_CHARSET)
+ encoding = "greek";
+ else if (lfp->lfCharSet == TURKISH_CHARSET)
+ encoding = "turkish";
+ else if (lfp->lfCharSet == THAI_CHARSET)
+ encoding = "thai";
+ else if (lfp->lfCharSet == EASTEUROPE_CHARSET)
+ encoding = "easteurope";
+ else if (lfp->lfCharSet == RUSSIAN_CHARSET)
+ encoding = "russian";
+ else if (lfp->lfCharSet == MAC_CHARSET)
+ encoding = "mac";
+ else if (lfp->lfCharSet == BALTIC_CHARSET)
+ encoding = "baltic";
+ else
+ encoding = "unknown";
+ }
+
+ point_size = (int) (((double) size/logpixelsy) * 720.);
- /* Update the main notebook page. */
- gtk_widget_set_sensitive(fontsel->filter_button, FALSE);
- gtk_label_set(GTK_LABEL(fontsel->font_label), "Font:");
+ if (res == -1)
+ res = logpixelsy;
- /* If there is no filter at present just return. */
- if (!filtered)
- return;
+ /* Replace illegal characters with hex escapes. */
+ p = facename;
+ q = lfp->lfFaceName;
+ while (*q)
+ {
+ if (*q == '-' || *q == '*' || *q == '?' || *q == '%')
+ p += sprintf (p, "%%%.02x", *q);
+ else
+ *p++ = *q;
+ q++;
+ }
+ *p = '\0';
+
+ return g_strdup_printf
+ ("-%s-%s-%s-%s-%s-%s-%d-%d-%d-%d-%s-%d-%s-%s",
+ "unknown",
+ facename,
+ weight,
+ (lfp->lfItalic ?
+ ((lfp->lfPitchAndFamily & 0xF0) == FF_ROMAN
+ || (lfp->lfPitchAndFamily & 0xF0) == FF_SCRIPT ?
+ "i" : "o") : "r"),
+ "normal",
+ "",
+ size,
+ point_size,
+ res,
+ res,
+ ((lfp->lfPitchAndFamily & 0x03) == FIXED_PITCH ? "m" : "p"),
+ avg_width,
+ registry, encoding);
+}
- gtk_font_selection_insert_fonts(fontsel);
+int CALLBACK
+InnerEnumFontFamExProc (const LOGFONT *lfp,
+ const TEXTMETRIC *metrics,
+ DWORD fontType,
+ LPARAM lParam)
+{
+ int size;
- /* Now find the current font & style and select them again. */
- if (fontsel->font_index != -1)
+ if (fontType == TRUETYPE_FONTTYPE)
+ {
+ size = 0;
+ }
+ else
{
- gtk_clist_select_row(GTK_CLIST(fontsel->font_clist),
- fontsel->font_index, 0);
- if (gtk_clist_row_is_visible(GTK_CLIST(fontsel->font_clist),
- fontsel->font_index) != GTK_VISIBILITY_FULL)
- gtk_clist_moveto(GTK_CLIST(fontsel->font_clist), fontsel->font_index,
- -1, 0.5, 0);
- gtk_font_selection_show_available_styles (fontsel);
+ size = lfp->lfHeight;
+ }
- 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 == fontsel->style)
- {
- found_style = TRUE;
- break;
- }
- }
+ num_fonts++;
+ if (num_fonts == font_names_size)
+ {
+ font_names_size *= 2;
+ xfontnames = g_realloc (xfontnames, font_names_size * sizeof (gchar *));
+ }
+ xfontnames[num_fonts-1] =
+ logfont_to_xlfd (lfp, size, 0, 0);
+ return 1;
+}
- if (found_style)
- {
- 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);
- }
+int CALLBACK
+EnumFontFamExProc (const LOGFONT *lfp,
+ const TEXTMETRIC *metrics,
+ DWORD fontType,
+ LPARAM lParam)
+{
+ if (fontType == TRUETYPE_FONTTYPE)
+ {
+ LOGFONT lf = *lfp;
+ lf.lfPitchAndFamily = 0;
+ EnumFontFamiliesEx (hdc, &lf, InnerEnumFontFamExProc, 0, 0);
}
+ else
+ InnerEnumFontFamExProc (lfp, metrics, fontType, lParam);
+ return 1;
}
+#endif
/*****************************************************************************
* These functions all deal with creating the main class arrays containing
static void
gtk_font_selection_get_fonts (void)
{
+#ifdef GDK_WINDOWING_X11
gchar **xfontnames;
+ gint num_fonts;
+#elif defined (GDK_WINDOWING_WIN32)
+ LOGFONT logfont;
+#else
+ gint num_fonts = 0;
+ gchar **xfontnames = NULL;
+#endif
GSList **fontnames;
gchar *fontname;
GSList * temp_list;
- gint num_fonts;
gint i, prop, style, size;
gint npixel_sizes = 0, npoint_sizes = 0;
FontInfo *font;
gchar *field;
guint8 flags;
guint16 *pixel_sizes, *point_sizes, *tmp_sizes;
-
+
fontsel_info = g_new (GtkFontSelInfo, 1);
+#ifdef GDK_WINDOWING_X11
/* 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.
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.");
+ g_warning(_("MAX_FONTS exceeded. Some fonts may be missing."));
+
+#elif defined (GDK_WINDOWING_WIN32)
+ num_fonts = 0;
+ hdc = GetDC (NULL);
+ font_names_size = 100;
+ xfontnames = g_new (gchar *, font_names_size);
+ logfont.lfCharSet = DEFAULT_CHARSET;
+ logfont.lfFaceName[0] = '\0';
+ logfont.lfPitchAndFamily = 0;
+ EnumFontFamiliesEx (hdc, &logfont, EnumFontFamExProc, 0, 0);
+ ReleaseDC (NULL, hdc);
+#endif
/* The maximum size of all these tables is the number of font names
returned. We realloc them later when we know exactly how many
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->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
fontsel_info->nfonts = 0;
for (i = 0; i < num_fonts; i++)
{
-#ifdef FONTSEL_DEBUG
- g_print("%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);
-
-
+ sizeof(FontInfo) * fontsel_info->nfonts);
+
+
/* Now we work out which choices of weight/slant etc. are valid for each
font. */
fontsel_info->nstyles = 0;
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. */
{
fontname = temp_list->data;
temp_list = temp_list->next;
-
+
for (prop = 0; prop < GTK_NUM_STYLE_PROPERTIES; prop++)
{
current_style->properties[prop]
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 = SCALABLE_FONT;
+ flags = GTK_FONT_SCALABLE;
else
- {
- flags = SCALABLE_BITMAP_FONT;
- fontsel_info->scaled_bitmaps_available = TRUE;
- }
+ flags = GTK_FONT_SCALABLE_BITMAP;
}
else
- flags = BITMAP_FONT;
-
+ flags = GTK_FONT_BITMAP;
+
/* 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;
break;
prev_style++;
}
-
+
/* 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
if (matched_style)
{
prev_style->flags |= flags;
- if (flags == BITMAP_FONT)
+ if (flags == GTK_FONT_BITMAP)
{
pixel_sizes = fontsel_info->pixel_sizes
+ prev_style->pixel_sizes_index;
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++;
}
}
-
+
point_sizes = fontsel_info->point_sizes
+ prev_style->point_sizes_index;
found_size = FALSE;
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)
{
else
{
current_style->flags = flags;
- if (flags == BITMAP_FONT)
+ if (flags == GTK_FONT_BITMAP)
{
fontsel_info->pixel_sizes[npixel_sizes++] = pixels;
current_style->npixel_sizes = 1;
}
}
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);
+ sizeof(FontStyle) * fontsel_info->nstyles);
fontsel_info->pixel_sizes = g_realloc(fontsel_info->pixel_sizes,
- sizeof(guint16) * npixel_sizes);
+ sizeof(guint16) * npixel_sizes);
fontsel_info->point_sizes = g_realloc(fontsel_info->point_sizes,
- sizeof(guint16) * npoint_sizes);
+ sizeof(guint16) * npoint_sizes);
g_free(fontnames);
- XFreeFontNames (xfontnames);
-
+#ifdef GDK_WINDOWING_X11
+ XFreeFontNames (xfontnames);
+#elif defined (GDK_WINDOWING_WIN32)
+ for (i = 0; i < num_fonts; i++)
+ g_free (xfontnames[i]);
+ g_free (xfontnames);
+#endif
+
/* Debugging Output */
/* This outputs all FontInfos. */
#ifdef FONTSEL_DEBUG
- g_print("\n\n Font Family Weight Slant Set Width Spacing Charset\n\n");
+ g_message("\n\n Font Family Weight Slant Set Width Spacing Charset\n\n");
for (i = 0; i < fontsel_info->nfonts; i++)
{
FontInfo *font = &fontsel_info->font_info[i];
FontStyle *styles = fontsel_info->font_styles + font->style_index;
for (style = 0; style < font->nstyles; style++)
{
- g_print("%5i %-16.16s ", i, font->family);
+ g_message("%5i %-16.16s ", i, font->family);
for (prop = 0; prop < GTK_NUM_STYLE_PROPERTIES; prop++)
- g_print("%-9.9s ",
- fontsel_info->properties[prop][styles->properties[prop]]);
- g_print("\n ");
-
- if (styles->flags & BITMAP_FONT)
- g_print("Bitmapped font ");
- if (styles->flags & SCALABLE_FONT)
- g_print("Scalable font ");
- if (styles->flags & SCALABLE_BITMAP_FONT)
- g_print("Scalable-Bitmapped font ");
- g_print("\n");
-
+ 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_print(" Pixel sizes: ");
+ g_message(" Pixel sizes: ");
tmp_sizes = fontsel_info->pixel_sizes + styles->pixel_sizes_index;
for (size = 0; size < styles->npixel_sizes; size++)
- g_print("%i ", *tmp_sizes++);
- g_print("\n");
+ g_message("%i ", *tmp_sizes++);
+ g_message("\n");
}
-
+
if (styles->npoint_sizes)
{
- g_print(" Point sizes: ");
+ g_message(" Point sizes: ");
tmp_sizes = fontsel_info->point_sizes + styles->point_sizes_index;
for (size = 0; size < styles->npoint_sizes; size++)
- g_print("%i ", *tmp_sizes++);
- g_print("\n");
+ g_message("%i ", *tmp_sizes++);
+ g_message("\n");
}
-
- g_print("\n");
+
+ g_message("\n");
styles++;
}
}
/* This outputs all available properties. */
for (prop = 0; prop < GTK_NUM_FONT_PROPERTIES; prop++)
{
- g_print("Property: %s\n", xlfd_field_names[xlfd_index[prop]]);
+ g_message("Property: %s\n", xlfd_field_names[xlfd_index[prop]]);
for (i = 0; i < fontsel_info->nproperties[prop]; i++)
- g_print(" %s\n", fontsel_info->properties[prop][i]);
+ g_message(" %s\n", fontsel_info->properties[prop][i]);
}
#endif
}
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)
{
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)
cmp = strcmp(fontsel_info->properties[FOUNDRY][foundry],
fontsel_info->properties[FOUNDRY][table[middle].foundry]);
}
-
+
if (cmp == 0)
{
fontnames[middle] = g_slist_prepend (fontnames[middle],
lower = middle+1;
}
}
-
+
/* 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);
-
+
(*ntable)++;
-
+
/* 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
gchar field_buffer[XLFD_MAX_FIELD_LEN];
gchar *field;
guint16 index;
-
+
field = gtk_font_selection_get_xlfd_field (fontname, xlfd_index[prop],
field_buffer);
if (!field)
return 0;
-
+
/* 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;
-
+
/* Make sure we have enough space to add the field. */
if (fontsel_info->nproperties[prop] == fontsel_info->space_allocated[prop])
{
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]);
+ sizeof(gchar*)
+ * fontsel_info->space_allocated[prop]);
}
-
+
/* Add the new field. */
index = fontsel_info->nproperties[prop];
fontsel_info->properties[prop][index] = g_strdup(field);
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];
-
+
for (prop = 0; prop < GTK_NUM_STYLE_PROPERTIES; prop++)
{
property_str[prop]
if (strcmp (property_str[prop], "(nil)") == 0)
property_str[prop] = "";
}
-
+
return gtk_font_selection_create_xlfd (fontsel->size,
fontsel->metric,
foundry_str,
}
-/* This returns the style with the best match to the current fontsel setting */
-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;
-}
-
-
/* This sets the current font, selecting the appropriate clist 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.
gchar family_buffer[XLFD_MAX_FIELD_LEN];
gchar field_buffer[XLFD_MAX_FIELD_LEN];
gchar buffer[16];
-
+
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);
+ 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);
fontsel->property_values[prop] = value;
}
-
+
field = gtk_font_selection_get_xlfd_field (fontname, XLFD_POINTS,
field_buffer);
size = atoi(field);
if (size < 20)
size = 20;
fontsel->size = fontsel->selected_size = size;
- fontsel->metric = POINTS_METRIC;
- gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(fontsel->points_button),
+ fontsel->metric = GTK_FONT_METRIC_POINTS;
+ gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(fontsel->points_button),
TRUE);
if (size % 10 == 0)
sprintf (buffer, "%i", size / 10);
if (size < 2)
size = 2;
fontsel->size = fontsel->selected_size = size;
- fontsel->metric = PIXELS_METRIC;
- gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(fontsel->pixels_button),
+ fontsel->metric = GTK_FONT_METRIC_PIXELS;
+ gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(fontsel->pixels_button),
TRUE);
sprintf (buffer, "%i", size);
}
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);
- else
- fontsel->scroll_on_expose = TRUE;
-
+
gtk_font_selection_show_available_styles (fontsel);
/* This will load the font. */
gtk_font_selection_select_best_style (fontsel, FALSE);
-
+
return TRUE;
}
{
FontInfo *font_info;
gint lower, upper, middle = -1, cmp, nfonts;
-
+ gint found_family = -1;
+
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;
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]);
+ {
+ found_family = middle;
+ cmp = strcmp(fontsel_info->properties[FOUNDRY][foundry],
+ fontsel_info->properties[FOUNDRY][font_info[middle].foundry]);
+ }
if (cmp == 0)
return middle;
else if (cmp > 0)
lower = middle+1;
}
-
- /* If we can't match family & foundry see if just the family matches */
- if (!strcmp (family, font_info[middle].family))
- return middle;
-
- return -1;
+
+ /* We couldn't find the family and foundry, but we may have just found the
+ family, so we return that. */
+ return found_family;
}
{
gint i = 0;
gint field_len = 0;
-
+
while (*fontname)
{
if (*fontname++ == '-')
else
field_len++;
}
-
+
return (i == 14) ? TRUE : FALSE;
}
{
const gchar *t1, *t2;
gint countdown, len, num_dashes;
-
+#ifdef GDK_WINDOWING_WIN32
+ gchar *p;
+#endif
+
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 */
return NULL;
strncpy (buffer, t1, len);
buffer[len] = 0;
+#ifdef GDK_WINDOWING_X11
+ /* Convert to lower case. */
+ g_strdown (buffer);
+#elif defined (GDK_WINDOWING_WIN32)
+ /* Check for hex escapes in font family */
+ if (field_num == XLFD_FAMILY)
+ {
+ p = buffer;
+ while (*p)
+ {
+ if (*p == '%' && isxdigit (p[1]) && isxdigit (p[2]))
+ {
+ guint c;
+ sscanf (p+1, "%2x", &c);
+ *p = c;
+ strcpy (p+1, p+3);
+ }
+ p++;
+ }
+ }
+#endif
}
else
strcpy(buffer, "(nil)");
-
+
return buffer;
}
{
gchar buffer[16];
gchar *pixel_size = "*", *point_size = "*", *fontname;
- gint length;
+ gchar *fam = family;
+#ifdef GDK_WINDOWING_WIN32
+ gchar *p, *q;
+#endif
if (size <= 0)
return NULL;
-
+
sprintf (buffer, "%d", (int) size);
- if (metric == PIXELS_METRIC)
+ 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);
+
+#ifdef GDK_WINDOWING_WIN32
+ fam = g_malloc (strlen (family) * 3 + 1);
+ p = fam;
+ q = family;
+ while (*q)
+ {
+ if (*q == '-' || *q == '*' || *q == '?' || *q == '%')
+ p += sprintf (p, "%%%.02x", *q);
+ else
+ *p++ = *q;
+ q++;
+ }
+ *p = '\0';
+#endif
+ fontname = g_strdup_printf ("-%s-%s-%s-%s-%s-*-%s-%s-*-*-%s-*-%s",
+ foundry, fam, weight, slant,
+ set_width, pixel_size, point_size,
+ spacing, charset);
+#ifdef GDK_WINDOWING_WIN32
+ g_free (fam);
+#endif
return fontname;
}
* GtkFontSelectionDialog
*****************************************************************************/
-guint
-gtk_font_selection_dialog_get_type (void)
+GtkType
+gtk_font_selection_dialog_get_type (void)
{
static guint font_selection_dialog_type = 0;
-
+
if (!font_selection_dialog_type)
{
GtkTypeInfo fontsel_diag_info =
/* reserved_2 */ NULL,
(GtkClassInitFunc) NULL,
};
-
- font_selection_dialog_type = gtk_type_unique (gtk_window_get_type (), &fontsel_diag_info);
+
+ font_selection_dialog_type = gtk_type_unique (GTK_TYPE_WINDOW, &fontsel_diag_info);
}
-
+
return font_selection_dialog_type;
}
gtk_font_selection_dialog_class_init (GtkFontSelectionDialogClass *klass)
{
GtkObjectClass *object_class;
-
+
object_class = (GtkObjectClass*) klass;
-
- font_selection_dialog_parent_class = gtk_type_class (gtk_window_get_type ());
+
+ font_selection_dialog_parent_class = gtk_type_class (GTK_TYPE_WINDOW);
}
static void
{
fontseldiag->dialog_width = -1;
fontseldiag->auto_resize = TRUE;
-
+
gtk_widget_set_events(GTK_WIDGET(fontseldiag), GDK_STRUCTURE_MASK);
gtk_signal_connect (GTK_OBJECT (fontseldiag), "configure_event",
(GtkSignalFunc) gtk_font_selection_dialog_on_configure,
fontseldiag);
-
- gtk_container_border_width (GTK_CONTAINER (fontseldiag), 4);
+
+ gtk_container_set_border_width (GTK_CONTAINER (fontseldiag), 4);
gtk_window_set_policy(GTK_WINDOW(fontseldiag), FALSE, TRUE, 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->fontsel = gtk_font_selection_new();
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_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");
+
+ 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);
gtk_widget_grab_default (fontseldiag->ok_button);
-
- fontseldiag->apply_button = gtk_button_new_with_label("Apply");
+
+ 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");
+
+ 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);
-
-
+
+
}
GtkWidget*
gtk_font_selection_dialog_new (const gchar *title)
{
GtkFontSelectionDialog *fontseldiag;
-
- fontseldiag = gtk_type_new (gtk_font_selection_dialog_get_type ());
+
+ fontseldiag = gtk_type_new (GTK_TYPE_FONT_SELECTION_DIALOG);
gtk_window_set_title (GTK_WINDOW (fontseldiag),
- title ? title : "Font Selection");
-
+ title ? title : _("Font Selection"));
+
return GTK_WIDGET (fontseldiag);
}
{
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);
}
gchar*
fsd->auto_resize = TRUE;
gtk_window_set_policy(GTK_WINDOW(fsd), FALSE, TRUE, TRUE);
}
-
+
return FALSE;
}
projects / ~andy / gtk / blobdiff