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;
+
+/* This struct represents one family of fonts (with one foundry), e.g. adobe
+ courier or sony fixed. It stores the family name, the index of the foundry
+ name, and the index of and number of available styles. */
+struct _FontInfo
+{
+ gchar *family;
+ guint16 foundry;
+ gint style_index;
+ guint16 nstyles;
+};
+/* 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. */
+struct _FontStyle
+{
+ guint16 properties[GTK_NUM_STYLE_PROPERTIES];
+ gint pixel_sizes_index;
+ guint16 npixel_sizes;
+ gint point_sizes_index;
+ guint16 npoint_sizes;
+ guint8 flags;
+};
+
+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 all possible weights/slants/set widths/spacings
+ and the amount of space allocated for each array. The extra array is
+ used for the foundries strings. */
+ 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. */
+ gboolean scaled_bitmaps_available;
+};
+
/* These are the field numbers in the X Logical Font Description fontnames,
e.g. -adobe-courier-bold-o-normal--25-180-100-100-m-150-iso8859-1 */
typedef enum
100, 80, 80, 50, 100, 100
};
+static GtkFontSelInfo *fontsel_info = NULL;
+
/* The initial size and increment of each of the arrays of property values. */
#define PROPERTY_ARRAY_INCREMENT 16
static void gtk_font_selection_destroy (GtkObject *object);
/* These are all used for class initialization - loading in the fonts etc. */
-static void gtk_font_selection_get_fonts (GtkFontSelectionClass *klass);
-static void gtk_font_selection_insert_font (GtkFontSelectionClass *klass,
- GSList *fontnames[],
+static void gtk_font_selection_get_fonts (void);
+static void gtk_font_selection_insert_font (GSList *fontnames[],
gint *ntable,
gchar *fontname);
-static gint gtk_font_selection_insert_field (GtkFontSelectionClass *klass,
- gchar *fontname,
+static gint gtk_font_selection_insert_field (gchar *fontname,
gint prop);
/* These are the callbacks & related functions. */
(GtkArgGetFunc) NULL,
};
- font_selection_type = gtk_type_unique(gtk_notebook_get_type(),
- &fontsel_info);
+ font_selection_type = gtk_type_unique (gtk_notebook_get_type(),
+ &fontsel_info);
}
return font_selection_type;
object_class->destroy = gtk_font_selection_destroy;
- gtk_font_selection_get_fonts(klass);
+ gtk_font_selection_get_fonts ();
}
static void
gtk_font_selection_init(GtkFontSelection *fontsel)
{
- GtkFontSelectionClass *klass;
GtkWidget *text_frame;
GtkWidget *text_box;
GtkWidget *table, *label, *hbox, *hbox2, *clist, *button, *vbox, *alignment;
gchar *property, *text;
gboolean inserted;
- klass = GTK_FONT_SELECTION_CLASS(GTK_OBJECT(fontsel)->klass);
-
/* Initialize the GtkFontSelection struct. We do this here in case any
callbacks are triggered while creating the interface. */
fontsel->font = NULL;
gtk_widget_show(fontsel->scaled_bitmaps_button);
gtk_box_pack_start (GTK_BOX (hbox), fontsel->scaled_bitmaps_button,
FALSE, FALSE, 0);
- if (!klass->scaled_bitmaps_available)
+ 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->actual_font_name, FALSE, TRUE, 0);
sprintf(buffer, "%i fonts available with a total of %i styles.",
- klass->nfonts, klass->nstyles);
+ 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);
property = "*";
gtk_clist_append(GTK_CLIST(clist), &property);
- for (i = 1; i < klass->nproperties[prop]; i++) {
- property = klass->properties[prop][i];
+ for (i = 1; i < fontsel_info->nproperties[prop]; i++) {
+ property = fontsel_info->properties[prop][i];
if (prop == SLANT)
property = gtk_font_selection_expand_slant_code(property);
else if (prop == SPACING)
static void
gtk_font_selection_insert_fonts (GtkFontSelection *fontsel)
{
- GtkFontSelectionClass *klass;
FontInfo *font_info, *font;
gchar font_buffer[XLFD_MAX_FIELD_LEN * 2 + 4];
gchar *font_item;
gint nfonts, i, row;
- klass = GTK_FONT_SELECTION_CLASS(GTK_OBJECT(fontsel)->klass);
- font_info = klass->font_info;
- nfonts = klass->nfonts;
+ 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));
|| (i < nfonts - 1 && font->family == font_info[i+1].family))
{
sprintf(font_buffer, "%s (%s)", font->family,
- klass->properties[FOUNDRY][font->foundry]);
+ fontsel_info->properties[FOUNDRY][font->foundry]);
font_item = font_buffer;
row = gtk_clist_append(GTK_CLIST(fontsel->font_clist), &font_item);
}
gpointer data)
{
GtkFontSelection *fontsel;
- GtkFontSelectionClass *klass;
FontInfo *font_info;
GList *selection;
gint index;
{
fontsel->scroll_on_expose = FALSE;
- klass = GTK_FONT_SELECTION_CLASS(GTK_OBJECT(fontsel)->klass);
- font_info = klass->font_info;
+ font_info = fontsel_info->font_info;
/* Try to scroll the font family clist to the selected item */
selection = GTK_CLIST(fontsel->font_clist)->selection;
gpointer data)
{
GtkFontSelection *fontsel;
- GtkFontSelectionClass *klass;
FontInfo *font_info;
FontInfo *font;
g_print("In select_font\n");
#endif
fontsel = GTK_FONT_SELECTION(data);
- klass = GTK_FONT_SELECTION_CLASS(GTK_OBJECT(fontsel)->klass);
- font_info = klass->font_info;
+ font_info = fontsel_info->font_info;
if (bevent && !GTK_WIDGET_HAS_FOCUS (w))
gtk_widget_grab_focus (w);
static void
gtk_font_selection_show_available_styles (GtkFontSelection *fontsel)
{
- GtkFontSelectionClass *klass;
FontInfo *font;
FontStyle *styles;
gint style, tmpstyle, row;
#ifdef FONTSEL_DEBUG
g_print("In show_available_styles\n");
#endif
- klass = GTK_FONT_SELECTION_CLASS(GTK_OBJECT(fontsel)->klass);
- font = &klass->font_info[fontsel->font_index];
- styles = &klass->font_styles[font->style_index];
+ 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));
if (show_charset)
{
charset_index = styles[style].properties[CHARSET];
- charset = klass->properties[CHARSET] [charset_index];
+ charset = fontsel_info->properties[CHARSET] [charset_index];
row = gtk_clist_append(GTK_CLIST(fontsel->font_style_clist),
&charset);
gtk_clist_set_row_data(GTK_CLIST(fontsel->font_style_clist), row,
slant_index = styles[tmpstyle].properties[SLANT];
set_width_index = styles[tmpstyle].properties[SET_WIDTH];
spacing_index = styles[tmpstyle].properties[SPACING];
- weight = klass->properties[WEIGHT] [weight_index];
- slant = klass->properties[SLANT] [slant_index];
- set_width = klass->properties[SET_WIDTH][set_width_index];
- spacing = klass->properties[SPACING] [spacing_index];
+ weight = fontsel_info->properties[WEIGHT] [weight_index];
+ slant = fontsel_info->properties[SLANT] [slant_index];
+ set_width = fontsel_info->properties[SET_WIDTH][set_width_index];
+ spacing = fontsel_info->properties[SPACING] [spacing_index];
/* Convert '(nil)' weights to 'regular', since it looks nicer. */
if (!g_strcasecmp(weight, "(nil)")) weight = "regular";
static void
gtk_font_selection_select_best_style(GtkFontSelection *fontsel)
{
- GtkFontSelectionClass *klass;
FontInfo *font;
FontStyle *styles;
gint row, prop, style;
#ifdef FONTSEL_DEBUG
g_print("In select_best_style\n");
#endif
- klass = GTK_FONT_SELECTION_CLASS(GTK_OBJECT(fontsel)->klass);
- font = &klass->font_info[fontsel->font_index];
- styles = &klass->font_styles[font->style_index];
+ font = &fontsel_info->font_info[fontsel->font_index];
+ styles = &fontsel_info->font_styles[font->style_index];
style = -1; /* Quite warning */
for (row = 0; row < GTK_CLIST(fontsel->font_style_clist)->rows; row++)
gpointer data)
{
GtkFontSelection *fontsel;
- GtkFontSelectionClass *klass;
FontInfo *font_info;
FontInfo *font;
FontStyle *styles;
g_print("In select_style\n");
#endif
fontsel = GTK_FONT_SELECTION(data);
- klass = GTK_FONT_SELECTION_CLASS(GTK_OBJECT(fontsel)->klass);
- font_info = klass->font_info;
+ font_info = fontsel_info->font_info;
font = &font_info[fontsel->font_index];
- styles = &klass->font_styles[font->style_index];
+ styles = &fontsel_info->font_styles[font->style_index];
if (bevent && !GTK_WIDGET_HAS_FOCUS (w))
gtk_widget_grab_focus (w);
static void
gtk_font_selection_show_available_sizes (GtkFontSelection *fontsel)
{
- GtkFontSelectionClass *klass;
FontInfo *font;
FontStyle *styles, *style;
guint16 *standard_sizes, *bitmapped_sizes, bitmap_size;
#ifdef FONTSEL_DEBUG
g_print("In show_available_sizes\n");
#endif
- klass = GTK_FONT_SELECTION_CLASS(GTK_OBJECT(fontsel)->klass);
- font = &klass->font_info[fontsel->font_index];
- styles = &klass->font_styles[font->style_index];
+ 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)
{
- bitmapped_sizes = &klass->point_sizes[style->point_sizes_index];
+ bitmapped_sizes = &fontsel_info->point_sizes[style->point_sizes_index];
nbitmapped_sizes = style->npoint_sizes;
}
else
{
- bitmapped_sizes = &klass->pixel_sizes[style->pixel_sizes_index];
+ bitmapped_sizes = &fontsel_info->pixel_sizes[style->pixel_sizes_index];
nbitmapped_sizes = style->npixel_sizes;
}
static void
gtk_font_selection_select_best_size(GtkFontSelection *fontsel)
{
- GtkFontSelectionClass *klass;
FontInfo *font;
FontStyle *styles, *style;
gchar *text;
#ifdef FONTSEL_DEBUG
g_print("In select_best_size\n");
#endif
- klass = GTK_FONT_SELECTION_CLASS(GTK_OBJECT(fontsel)->klass);
- font = &klass->font_info[fontsel->font_index];
- styles = &klass->font_styles[font->style_index];
+ 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
static void
gtk_font_selection_apply_filter (GtkFontSelection *fontsel)
{
- GtkFontSelectionClass *klass;
FontInfo *font_info, *font;
GtkWidget *clist;
GList *selection;
#ifdef FONTSEL_DEBUG
g_print("In apply_filter\n");
#endif
- klass = GTK_FONT_SELECTION_CLASS(GTK_OBJECT(fontsel)->klass);
- font_info = klass->font_info;
- nfonts = klass->nfonts;
+ 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++)
|| (i < nfonts - 1 && font->family == font_info[i+1].family))
{
sprintf(font_buffer, "%s (%s)", font->family,
- klass->properties[FOUNDRY][font->foundry]);
+ fontsel_info->properties[FOUNDRY][font->foundry]);
font_item = font_buffer;
row = gtk_clist_append(GTK_CLIST(fontsel->font_clist), &font_item);
}
FontInfo *font,
gint style)
{
- GtkFontSelectionClass *klass;
FontStyle *styles;
guint16 value;
gint prop, j;
gboolean matched;
- klass = GTK_FONT_SELECTION_CLASS(GTK_OBJECT(fontsel)->klass);
- styles = &klass->font_styles[font->style_index];
+ styles = &fontsel_info->font_styles[font->style_index];
for (prop = 0; prop < GTK_NUM_STYLE_PROPERTIES; prop++)
{
* the data about all available fonts.
*****************************************************************************/
static void
-gtk_font_selection_get_fonts (GtkFontSelectionClass *klass)
+gtk_font_selection_get_fonts (void)
{
gchar **xfontnames;
GSList **fontnames;
guint8 flags;
guint16 *pixel_sizes, *point_sizes, *tmp_sizes;
+ fontsel_info = g_new (GtkFontSelInfo, 1);
+
/* Get a maximum of MAX_FONTS fontnames from the X server.
Use "-*" as the pattern rather than "-*-*-*-*-*-*-*-*-*-*-*-*-*-*" since
the latter may result in fonts being returned which don't actually exist.
/* 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. */
- klass->font_info = g_new (FontInfo, num_fonts);
- klass->font_styles = g_new (FontStyle, num_fonts);
- klass->pixel_sizes = g_new (guint16, num_fonts);
- klass->point_sizes = g_new (guint16, num_fonts);
+ fontsel_info->font_info = g_new (FontInfo, num_fonts);
+ fontsel_info->font_styles = g_new (FontStyle, num_fonts);
+ fontsel_info->pixel_sizes = g_new (guint16, num_fonts);
+ fontsel_info->point_sizes = g_new (guint16, num_fonts);
fontnames = g_new (GSList*, num_fonts);
may be realloc'ed later. Put the wildcard '*' in the first elements. */
for (prop = 0; prop < GTK_NUM_FONT_PROPERTIES; prop++)
{
- klass->properties[prop] = g_new(gchar*, PROPERTY_ARRAY_INCREMENT);
- klass->space_allocated[prop] = PROPERTY_ARRAY_INCREMENT;
- klass->nproperties[prop] = 1;
- klass->properties[prop][0] = "*";
+ fontsel_info->properties[prop] = g_new(gchar*, PROPERTY_ARRAY_INCREMENT);
+ fontsel_info->space_allocated[prop] = PROPERTY_ARRAY_INCREMENT;
+ fontsel_info->nproperties[prop] = 1;
+ fontsel_info->properties[prop][0] = "*";
}
foundry (fonts with different foundries are placed in seaparate FontInfos.
All fontnames in each family + foundry are placed into the fontnames
array of lists. */
- klass->nfonts = 0;
+ 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 (klass, fontnames,
- &klass->nfonts, xfontnames[i]);
+ gtk_font_selection_insert_font (fontnames, &fontsel_info->nfonts, xfontnames[i]);
else
{
#ifdef FONTSEL_DEBUG
/* 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. */
- klass->font_info = g_realloc(klass->font_info,
- sizeof(FontInfo) * klass->nfonts);
+ fontsel_info->font_info = g_realloc(fontsel_info->font_info,
+ sizeof(FontInfo) * fontsel_info->nfonts);
/* Now we work out which choices of weight/slant etc. are valid for each
font. */
- klass->nstyles = 0;
- current_style = klass->font_styles;
- for (i = 0; i < klass->nfonts; i++)
+ fontsel_info->nstyles = 0;
+ current_style = fontsel_info->font_styles;
+ for (i = 0; i < fontsel_info->nfonts; i++)
{
- font = &klass->font_info[i];
+ font = &fontsel_info->font_info[i];
/* Use the next free position in the styles array. */
- font->style_index = klass->nstyles;
+ 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
for (prop = 0; prop < GTK_NUM_STYLE_PROPERTIES; prop++)
{
current_style->properties[prop]
- = gtk_font_selection_insert_field (klass, fontname, prop);
+ = gtk_font_selection_insert_field (fontname, prop);
}
current_style->pixel_sizes_index = npixel_sizes;
current_style->point_sizes_index = npoint_sizes;
else
{
flags = SCALABLE_BITMAP_FONT;
- klass->scaled_bitmaps_available = TRUE;
+ fontsel_info->scaled_bitmaps_available = TRUE;
}
else
flags = BITMAP_FONT;
/* Now we check to make sure that the style is unique. If it isn't
we forget it. */
- prev_style = klass->font_styles + font->style_index;
+ prev_style = fontsel_info->font_styles + font->style_index;
matched_style = FALSE;
while (prev_style < current_style)
{
prev_style->flags |= flags;
if (flags == BITMAP_FONT)
{
- pixel_sizes = klass->pixel_sizes
+ pixel_sizes = fontsel_info->pixel_sizes
+ prev_style->pixel_sizes_index;
found_size = FALSE;
for (size = 0; size < prev_style->npixel_sizes; size++)
update the indexes of any following styles. */
if (!found_size)
{
- for (tmp_sizes = klass->pixel_sizes + npixel_sizes;
+ for (tmp_sizes = fontsel_info->pixel_sizes + npixel_sizes;
tmp_sizes > pixel_sizes; tmp_sizes--)
*tmp_sizes = *(tmp_sizes - 1);
}
}
- point_sizes = klass->point_sizes
+ point_sizes = fontsel_info->point_sizes
+ prev_style->point_sizes_index;
found_size = FALSE;
for (size = 0; size < prev_style->npoint_sizes; size++)
update the indexes of any following styles. */
if (!found_size)
{
- for (tmp_sizes = klass->point_sizes + npoint_sizes;
+ for (tmp_sizes = fontsel_info->point_sizes + npoint_sizes;
tmp_sizes > point_sizes; tmp_sizes--)
*tmp_sizes = *(tmp_sizes - 1);
current_style->flags = flags;
if (flags == BITMAP_FONT)
{
- klass->pixel_sizes[npixel_sizes++] = pixels;
+ fontsel_info->pixel_sizes[npixel_sizes++] = pixels;
current_style->npixel_sizes = 1;
- klass->point_sizes[npoint_sizes++] = points;
+ fontsel_info->point_sizes[npoint_sizes++] = points;
current_style->npoint_sizes = 1;
}
style++;
- klass->nstyles++;
+ fontsel_info->nstyles++;
current_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. */
- klass->font_styles = g_realloc(klass->font_styles,
- sizeof(FontStyle) * klass->nstyles);
- klass->pixel_sizes = g_realloc(klass->pixel_sizes,
+ fontsel_info->font_styles = g_realloc(fontsel_info->font_styles,
+ sizeof(FontStyle) * fontsel_info->nstyles);
+ fontsel_info->pixel_sizes = g_realloc(fontsel_info->pixel_sizes,
sizeof(guint16) * npixel_sizes);
- klass->point_sizes = g_realloc(klass->point_sizes,
+ fontsel_info->point_sizes = g_realloc(fontsel_info->point_sizes,
sizeof(guint16) * npoint_sizes);
g_free(fontnames);
XFreeFontNames (xfontnames);
/* This outputs all FontInfos. */
#ifdef FONTSEL_DEBUG
g_print("\n\n Font Family Weight Slant Set Width Spacing Charset\n\n");
- for (i = 0; i < klass->nfonts; i++)
+ for (i = 0; i < fontsel_info->nfonts; i++)
{
- FontInfo *font = &klass->font_info[i];
- FontStyle *styles = klass->font_styles + font->style_index;
+ 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);
for (prop = 0; prop < GTK_NUM_STYLE_PROPERTIES; prop++)
g_print("%-9.9s ",
- klass->properties[prop][styles->properties[prop]]);
+ fontsel_info->properties[prop][styles->properties[prop]]);
g_print("\n ");
if (styles->flags & BITMAP_FONT)
if (styles->npixel_sizes)
{
g_print(" Pixel sizes: ");
- tmp_sizes = klass->pixel_sizes + styles->pixel_sizes_index;
+ 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");
if (styles->npoint_sizes)
{
g_print(" Point sizes: ");
- tmp_sizes = klass->point_sizes + styles->point_sizes_index;
+ 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");
for (prop = 0; prop < GTK_NUM_FONT_PROPERTIES; prop++)
{
g_print("Property: %s\n", xlfd_field_names[xlfd_index[prop]]);
- for (i = 0; i < klass->nproperties[prop]; i++)
- g_print(" %s\n", klass->properties[prop][i]);
+ for (i = 0; i < fontsel_info->nproperties[prop]; i++)
+ g_print(" %s\n", fontsel_info->properties[prop][i]);
}
#endif
}
fontname is added to the FontInfos list of fontnames, else a new FontInfo
is created and inserted in alphabetical order in the table. */
static void
-gtk_font_selection_insert_font (GtkFontSelectionClass *klass,
- GSList *fontnames[],
+gtk_font_selection_insert_font (GSList *fontnames[],
gint *ntable,
gchar *fontname)
{
gint middle, cmp;
gchar family_buffer[XLFD_MAX_FIELD_LEN];
- table = klass->font_info;
+ table = fontsel_info->font_info;
/* insert a fontname into a table */
family = gtk_font_selection_get_xlfd_field (fontname, XLFD_FAMILY,
if (!family)
return;
- foundry = gtk_font_selection_insert_field(klass, fontname, FOUNDRY);
+ foundry = gtk_font_selection_insert_field (fontname, FOUNDRY);
lower = 0;
if (*ntable > 0)
{
family_exists = TRUE;
family = table[middle].family;
- cmp = strcmp(klass->properties[FOUNDRY][foundry],
- klass->properties[FOUNDRY][table[middle].foundry]);
+ cmp = strcmp(fontsel_info->properties[FOUNDRY][foundry],
+ fontsel_info->properties[FOUNDRY][table[middle].foundry]);
}
if (cmp == 0)
appropriate properties array. If not it is added. Thus eventually we get
arrays of all possible weights/slants etc. It returns the array index. */
static gint
-gtk_font_selection_insert_field (GtkFontSelectionClass *klass,
- gchar *fontname,
+gtk_font_selection_insert_field (gchar *fontname,
gint prop)
{
gchar field_buffer[XLFD_MAX_FIELD_LEN];
return 0;
/* If the field is already in the array just return its index. */
- for (index = 0; index < klass->nproperties[prop]; index++)
- if (!strcmp(field, klass->properties[prop][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 (klass->nproperties[prop] == klass->space_allocated[prop])
+ if (fontsel_info->nproperties[prop] == fontsel_info->space_allocated[prop])
{
- klass->space_allocated[prop] += PROPERTY_ARRAY_INCREMENT;
- klass->properties[prop] = g_realloc(klass->properties[prop],
+ fontsel_info->space_allocated[prop] += PROPERTY_ARRAY_INCREMENT;
+ fontsel_info->properties[prop] = g_realloc(fontsel_info->properties[prop],
sizeof(gchar*)
- * klass->space_allocated[prop]);
+ * fontsel_info->space_allocated[prop]);
}
/* Add the new field. */
- index = klass->nproperties[prop];
- klass->properties[prop][index] = g_strdup(field);
- klass->nproperties[prop]++;
+ index = fontsel_info->nproperties[prop];
+ fontsel_info->properties[prop][index] = g_strdup(field);
+ fontsel_info->nproperties[prop]++;
return index;
}
gchar *
gtk_font_selection_get_font_name (GtkFontSelection *fontsel)
{
- GtkFontSelectionClass *klass;
FontInfo *font;
gchar *family_str, *foundry_str;
gchar *property_str[GTK_NUM_STYLE_PROPERTIES];
if (fontsel->font_index == -1)
return NULL;
- klass = GTK_FONT_SELECTION_CLASS(GTK_OBJECT(fontsel)->klass);
- font = &klass->font_info[fontsel->font_index];
+ font = &fontsel_info->font_info[fontsel->font_index];
family_str = font->family;
- foundry_str = klass->properties[FOUNDRY][font->foundry];
+ foundry_str = fontsel_info->properties[FOUNDRY][font->foundry];
for (prop = 0; prop < GTK_NUM_STYLE_PROPERTIES; prop++)
{
property_str[prop]
- = klass->properties[prop][fontsel->property_values[prop]];
+ = fontsel_info->properties[prop][fontsel->property_values[prop]];
if (strcmp (property_str[prop], "(nil)") == 0)
property_str[prop] = "";
}
static gint
gtk_font_selection_get_best_match(GtkFontSelection *fontsel)
{
- GtkFontSelectionClass *klass;
FontInfo *font;
FontStyle *styles;
gint prop, style, best_style = 0, matched, best_matched = 0;
- klass = GTK_FONT_SELECTION_CLASS(GTK_OBJECT(fontsel)->klass);
- font = &klass->font_info[fontsel->font_index];
- styles = &klass->font_styles[font->style_index];
+ 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++)
gtk_font_selection_set_font_name (GtkFontSelection *fontsel,
const gchar *fontname)
{
- GtkFontSelectionClass *klass;
gchar *family, *field;
gint index, prop, size;
guint16 foundry, value;
g_return_val_if_fail (GTK_IS_FONT_SELECTION (fontsel), FALSE);
g_return_val_if_fail (fontname != NULL, FALSE);
- klass = GTK_FONT_SELECTION_CLASS(GTK_OBJECT(fontsel)->klass);
-
/* Check it is a valid fontname. */
if (!gtk_font_selection_is_xlfd_font_name(fontname))
return FALSE;
field = gtk_font_selection_get_xlfd_field (fontname, XLFD_FOUNDRY,
field_buffer);
- foundry = gtk_font_selection_field_to_index (klass->properties[FOUNDRY],
- klass->nproperties[FOUNDRY],
+ 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);
{
field = gtk_font_selection_get_xlfd_field (fontname, xlfd_index[prop],
field_buffer);
- value = gtk_font_selection_field_to_index (klass->properties[prop],
- klass->nproperties[prop],
+ value = gtk_font_selection_field_to_index (fontsel_info->properties[prop],
+ fontsel_info->nproperties[prop],
field);
fontsel->property_values[prop] = value;
}
gchar *family,
guint16 foundry)
{
- GtkFontSelectionClass *klass;
FontInfo *font_info;
gint lower, upper, middle = -1, cmp, nfonts;
- klass = GTK_FONT_SELECTION_CLASS(GTK_OBJECT(fontsel)->klass);
- font_info = klass->font_info;
- nfonts = klass->nfonts;
+ font_info = fontsel_info->font_info;
+ nfonts = fontsel_info->nfonts;
if (nfonts == 0)
return -1;
cmp = strcmp (family, font_info[middle].family);
if (cmp == 0)
- cmp = strcmp(klass->properties[FOUNDRY][foundry],
- klass->properties[FOUNDRY][font_info[middle].foundry]);
+ cmp = strcmp(fontsel_info->properties[FOUNDRY][foundry],
+ fontsel_info->properties[FOUNDRY][font_info[middle].foundry]);
if (cmp == 0)
return middle;
projects / ~andy / gtk / commitdiff