* 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:
*
* 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 "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 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.
/* These are the names of the fields, used on the info & filter page. */
static const 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:",
+ 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,
(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,
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,
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;
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;
- const gchar *row_text[3];
+ 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->font = NULL;
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_set_border_width (GTK_CONTAINER (fontsel->main_vbox), 6);
- label = gtk_label_new("Font");
- gtk_widget_set_usize (label, 120, -1);
+ label = gtk_label_new(_("Font"));
gtk_notebook_append_page (GTK_NOTEBOOK (fontsel),
fontsel->main_vbox, label);
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,
/* Create the clists */
fontsel->font_clist = gtk_clist_new(1);
gtk_clist_column_titles_hide (GTK_CLIST(fontsel->font_clist));
- gtk_clist_set_column_width (GTK_CLIST(fontsel->font_clist), 0, 300);
- gtk_widget_set_usize (fontsel->font_clist, FONT_LIST_WIDTH,
- FONT_LIST_HEIGHT);
+ gtk_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);
fontsel->font_style_clist = gtk_clist_new(1);
gtk_clist_column_titles_hide (GTK_CLIST(fontsel->font_style_clist));
- gtk_clist_set_column_width (GTK_CLIST(fontsel->font_style_clist), 0, 300);
- gtk_widget_set_usize (fontsel->font_style_clist, FONT_STYLE_LIST_WIDTH, -1);
+ 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);
fontsel->size_clist = gtk_clist_new(1);
gtk_clist_column_titles_hide (GTK_CLIST(fontsel->size_clist));
- gtk_widget_set_usize (fontsel->size_clist, FONT_SIZE_LIST_WIDTH, -1);
+ 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);
"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));
gtk_widget_show (hbox);
gtk_box_pack_start (GTK_BOX (fontsel->main_vbox), hbox, FALSE, TRUE, 0);
- fontsel->filter_button = gtk_button_new_with_label(" Reset Filter ");
+ 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_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 == GTK_FONT_METRIC_POINTS)
- gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(fontsel->points_button),
+ 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 == GTK_FONT_METRIC_PIXELS)
- gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(fontsel->pixels_button),
+ gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(fontsel->pixels_button),
TRUE);
gtk_signal_connect(GTK_OBJECT(fontsel->points_button), "toggled",
/* 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,
fontsel->info_vbox = gtk_vbox_new (FALSE, 4);
gtk_widget_show (fontsel->info_vbox);
gtk_container_set_border_width (GTK_CONTAINER (fontsel->info_vbox), 2);
- label = gtk_label_new("Font Information");
- gtk_widget_set_usize (label, 120, -1);
+ label = gtk_label_new(_("Font Information"));
gtk_notebook_append_page (GTK_NOTEBOOK (fontsel),
fontsel->info_vbox, label);
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_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);
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_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);
fontsel->filter_vbox = gtk_vbox_new (FALSE, 4);
gtk_widget_show (fontsel->filter_vbox);
gtk_container_set_border_width (GTK_CONTAINER (fontsel->filter_vbox), 2);
- label = gtk_label_new("Filter");
- gtk_widget_set_usize (label, 120, -1);
+ label = gtk_label_new(_("Filter"));
gtk_notebook_append_page (GTK_NOTEBOOK (fontsel),
fontsel->filter_vbox, label);
gtk_widget_show (hbox);
gtk_container_add (GTK_CONTAINER (frame), hbox);
- label = gtk_label_new("Font Types:");
+ label = gtk_label_new(_("Font Types:"));
gtk_widget_show (label);
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 10);
gtk_widget_show (hbox2);
gtk_box_pack_start (GTK_BOX (hbox), hbox2, FALSE, TRUE, 0);
- fontsel->type_bitmaps_button = gtk_check_button_new_with_label ("Bitmap");
- gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (fontsel->type_bitmaps_button), TRUE);
+ 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_state (GTK_TOGGLE_BUTTON (fontsel->type_scalable_button), TRUE);
+ 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");
+ 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);
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_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_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_widget_show(alignment);
gtk_box_pack_start (GTK_BOX (vbox), alignment, FALSE, TRUE, 4);
- button = gtk_button_new_with_label("Reset 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",
/* 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)
property = gtk_font_selection_expand_spacing_code(property);
-
+
inserted = FALSE;
for (row = 1; row < GTK_CLIST(clist)->rows; row++)
{
}
+/* 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;
+
+#ifdef FONTSEL_DEBUG
+ g_message("In realize_list\n");
+#endif
+ fontsel = GTK_FONT_SELECTION (data);
+
+ /* 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)
+ {
+ 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);
+ }
+ }
+}
+
+
/* This is called when a family is selected in the list. */
static void
gtk_font_selection_select_font (GtkWidget *w,
&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++)
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;
{
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_message("In select_best_style\n");
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);
-
- fontsel->style = style;
-
+ g_return_if_fail (best_style != -1);
+ g_return_if_fail (best_row != -1);
+
+ 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);
}
FontInfo *font;
FontStyle *styles, *style;
const guint16 *standard_sizes;
- guint16 *bitmapped_sizes, bitmap_size;
+ 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;
while (nstandard_sizes || nbitmapped_sizes)
{
can_match = TRUE;
- if (fontsel->metric == GTK_FONT_METRIC_POINTS)
- {
- if (*bitmapped_sizes % 10 != 0)
- can_match = FALSE;
- bitmap_size = *bitmapped_sizes / 10;
- bitmap_size_float = *bitmapped_sizes / 10;
- }
- else
+
+ 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
{
GdkFont *font;
gchar *fontname, *label_text;
+ XFontStruct *xfs;
if (fontsel->font)
gdk_font_unref (fontsel->font);
#ifdef FONTSEL_DEBUG
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)
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_message("In update_preview\n");
#endif
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
}
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];
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;
}
if (default_filter)
{
gtk_widget_set_sensitive(fontsel->filter_button, FALSE);
- gtk_label_set(GTK_LABEL(fontsel->font_label), "Font:");
+ gtk_label_set_text(GTK_LABEL(fontsel->font_label), _("Font:"));
}
else
{
gtk_widget_set_sensitive(fontsel->filter_button, TRUE);
- gtk_label_set(GTK_LABEL(fontsel->font_label), "Font: (Filter Applied)");
+ gtk_label_set_text(GTK_LABEL(fontsel->font_label), _("Font: (Filter Applied)"));
}
gtk_font_selection_show_available_fonts(fontsel);
}
break;
}
}
+ if (!matched)
+ break;
}
}
base_font_type = fontsel->filters[GTK_FONT_FILTER_BASE].font_type;
if (base_font_type & GTK_FONT_BITMAP)
- gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (fontsel->type_bitmaps_button), TRUE);
+ gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (fontsel->type_bitmaps_button), TRUE);
if (base_font_type & GTK_FONT_SCALABLE)
- gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (fontsel->type_scalable_button), TRUE);
+ 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_state (GTK_TOGGLE_BUTTON (fontsel->type_scaled_bitmaps_button), FALSE);
+ 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);
/* Update the main notebook page. */
gtk_widget_set_sensitive(fontsel->filter_button, FALSE);
- gtk_label_set(GTK_LABEL(fontsel->font_label), "Font:");
+ gtk_label_set_text(GTK_LABEL(fontsel->font_label), _("Font:"));
gtk_font_selection_show_available_fonts(fontsel);
}
filter_string = filter_strings[prop][i];
for (j = 0; j < fontsel_info->nproperties[prop]; j++)
{
- property = fontsel_info->properties[prop][j];
+ property = _(fontsel_info->properties[prop][j]);
property_alt = NULL;
if (prop == SLANT)
property_alt = gtk_font_selection_expand_slant_code(property);
if (font_type & GTK_FONT_BITMAP)
{
gtk_widget_set_sensitive (fontsel->type_bitmaps_button, TRUE);
- gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (fontsel->type_bitmaps_button), user_font_type & GTK_FONT_BITMAP);
+ 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_state (GTK_TOGGLE_BUTTON (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_state (GTK_TOGGLE_BUTTON (fontsel->type_scalable_button), user_font_type & GTK_FONT_SCALABLE);
+ 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_state (GTK_TOGGLE_BUTTON (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_state (GTK_TOGGLE_BUTTON (fontsel->type_scaled_bitmaps_button), user_font_type & GTK_FONT_SCALABLE_BITMAP);
+ 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_state (GTK_TOGGLE_BUTTON (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_state (GTK_TOGGLE_BUTTON (fontsel->type_bitmaps_button), 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_state (GTK_TOGGLE_BUTTON (fontsel->type_scalable_button), 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_state (GTK_TOGGLE_BUTTON (fontsel->type_scaled_bitmaps_button), 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. */
}
+#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.);
+
+ if (res == -1)
+ res = logpixelsy;
+
+ /* 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);
+}
+
+int CALLBACK
+InnerEnumFontFamExProc (const LOGFONT *lfp,
+ const TEXTMETRIC *metrics,
+ DWORD fontType,
+ LPARAM lParam)
+{
+ int size;
+
+ if (fontType == TRUETYPE_FONTTYPE)
+ {
+ size = 0;
+ }
+ else
+ {
+ size = lfp->lfHeight;
+ }
+
+ 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;
+}
+
+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
* the data about all available fonts.
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;
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
unique entries there are. */
fontsel_info->nfonts = 0;
for (i = 0; i < num_fonts; i++)
{
-#ifdef FONTSEL_DEBUG
- g_message("%s\n", xfontnames[i]);
-#endif
if (gtk_font_selection_is_xlfd_font_name (xfontnames[i]))
gtk_font_selection_insert_font (fontnames, &fontsel_info->nfonts, xfontnames[i]);
- else
- {
-#ifdef FONTSEL_DEBUG
- g_warning("Skipping invalid font: %s", xfontnames[i]);
-#endif
- }
}
fontsel_info->point_sizes = g_realloc(fontsel_info->point_sizes,
sizeof(guint16) * npoint_sizes);
g_free(fontnames);
+
+#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. */
}
-/* This returns the style with the best match to the current fontsel setting,
- i.e. with the highest number of matching property values. */
-static gint
-gtk_font_selection_get_best_match(GtkFontSelection *fontsel)
-{
- FontInfo *font;
- FontStyle *styles;
- gint prop, style, best_style = 0, matched, best_matched = 0;
-
- font = &fontsel_info->font_info[fontsel->font_index];
- styles = &fontsel_info->font_styles[font->style_index];
-
- /* Find the style with the most matches. */
- for (style = 0; style < font->nstyles; style++)
- {
- matched = 0;
- for (prop = 0; prop < GTK_NUM_STYLE_PROPERTIES; prop++)
- {
- if (fontsel->property_values[prop] == styles[style].properties[prop])
- matched++;
- }
- if (matched > best_matched)
- {
- best_matched = matched;
- best_style = style;
- }
- }
-
- return best_style;
-}
-
-
/* 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.
size = 20;
fontsel->size = fontsel->selected_size = size;
fontsel->metric = GTK_FONT_METRIC_POINTS;
- gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(fontsel->points_button),
+ gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(fontsel->points_button),
TRUE);
if (size % 10 == 0)
sprintf (buffer, "%i", size / 10);
size = 2;
fontsel->size = fontsel->selected_size = size;
fontsel->metric = GTK_FONT_METRIC_PIXELS;
- gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(fontsel->pixels_button),
+ gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(fontsel->pixels_button),
TRUE);
sprintf (buffer, "%i", size);
}
{
FontInfo *font_info;
gint lower, upper, middle = -1, cmp, nfonts;
+ gint found_family = -1;
font_info = fontsel_info->font_info;
nfonts = fontsel_info->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;
}
{
const gchar *t1, *t2;
gint countdown, len, num_dashes;
+#ifdef GDK_WINDOWING_WIN32
+ gchar *p;
+#endif
if (!fontname)
return NULL;
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)");
{
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;
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
+GtkType
gtk_font_selection_dialog_get_type (void)
{
static guint font_selection_dialog_type = 0;
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 = 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);
}
projects / ~andy / gtk / blobdiff